Lights Fantastic (Source Included)

Cls()
Flip true
Cls()
Flip true

SetGraphicsDriver GLMax2DDriver(), 0 ' 0 is important. No GRAPHICS_BACKBUFFER.
Graphics 320,240
glDrawBuffer(GL_FRONT) ' Throw that in for good measure.

SetGraphicsDriver GLMax2DDriver(), 0 ' 0 is important. No GRAPHICS_BACKBUFFER.
Graphics 640,480
glDrawBuffer(GL_FRONT)
glflush
DrawOval 50,50,50,50
Flip ' this command or what is used to transfer the graphics ?
WaitKey

SetGraphicsDriver GLMax2DDriver(), 0 ' 0 is important. No GRAPHICS_BACKBUFFER.
Graphics 640,480
DrawOval 50,50,50,50
glFlush
WaitKey

SetGraphicsDriver GLMax2DDriver(), 0 ' 0 is important. No GRAPHICS_BACKBUFFER.
Graphics 640,480
Repeat
  Cls
  DrawOval i,50,50,50
  i:+1
  glFlush
  Delay 1
Until KeyDown(27)

'
' 60hz Smooth screen pixel access on 2010+ Mac's and PC's
'
' It does not use pixelshader nor PBO, but a simple memory-to-GPU transfer every frame. This practically saturates at about 4GB for an old 2010+ Mac' or PC.
' Meaning a full 1920 x 1080 are perfectly possible at 120hz (or two frames at 60hz if you want that for some reason) on most old machines. It only goes up from there. 
'
' You get 60 fps pixelaccess of your full screen (1920 x 1080 or similiar is very realistic).
' Full pixel access reading writing, and it's perfectly possible at 60hz without stuttering.

' This use no GPU whatsoever, it relies on the CPU, BUS and MEM to be fast. Luckily today it's not a major problem.
' The problem using this technique is instead the speed of the language itself and how it compiles. 
' Becuase the array that are manipulated is huge this means that instructions gets too expansive to neglect in these huge quantities (even by todays standard). So despite popular beliefs - we need do optimize here.
'
' You need optimization every bit you can and you'll notice that when you start doing more and more complex things, e.g. try some trigonometry or even standard random functions and see it quickly die off.
' With BlitzMax this goes with simple IF THEN aswell, so try to use simple primitive such as + shl or even explore things like Sgn And Abs (which seem strangely fast in BlitzMAX if thet are they makes them into good optization tools).
' But you do need To think about code speed when manipulating the array. The array behaves just a classic screenbuffer.
'
' Here's a reminder of what sizes we're playing with and why careful coding and optimization needs to be done in the inner loops;
' - A 320 x 240 resolution is about 70 KB (32 bit graphics).
' - A 1920 x 1080 is 2GB (32 bit graphics).'

' This kind of slowdowns means oldschool & general knowledge about assemblers and compilers applies very much what we need to think about iside the loops e.g. 
' use minimum of IF THEN, converting multiplications into shifts etc everything is valuable. 
' It also means that you may want to use your knowledge about memory alignments and common practice how to transverse BlitzMax arrays quickest possible.
 
' Load some suiting retro graphics
Global buffer:Int[128*128] ; Local myhex$ = "0123456789ABCDEF", w:Int, h:Int, line$
RestoreData tiles ; ReadData w ; ReadData h
For Local y:Int = 0 To h - 1
	ReadData line$
	For Local x:Int = 0 To w - 1
		Local word$ = Mid$( line$, x * 8 + 1, 8 ), pixel:Int = 0, shift:Int = 28
		For Local i:Int = 1 To 8 ; pixel :+ (Instr( myhex$, Mid$(word$, i, 1) ) - 1) Shl shift ; shift :- 4 ; Next
		buffer[x+y*w] = pixel
	Next
Next

' Graphics mode
Global xres:Int = 1920 ; yres:Int = 1080 ; Global pixels:Int[xres*yres]
GLGraphics(xres,yres,32,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER) ; HideMouse ' Fullscreen, for windowed use instead GLGraphics(xres,yres,0,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER)
glViewport(0,0,xres,yres) ;  glLoadIdentity() ; glMatrixMode(GL_PROJECTION) ; glPixelZoom(1,-1) ; glOrtho(0,xres,yres,0,0,1) ; glRasterPos2i(0,0)

' Main loop
Repeat

	' Demo a CLS, example how to clear the array (non-optimized yet)
	For y=0 To yres-1 Step 1 ; For x=0 To xres-1 Step 1 ; pixels[(y*xres+x)] = 0 ; Next ; Next ' stepping is not needed if you only use 1
	
	' Demo 128 sprites
	' The only reason that we do this is to show that the fullscreen buffer is very much alive and up and working, ready to be used.
	' Itīs there so you should be able to decide that there's a smooth 60hz movement happening or not. Remember itīs not about the sprites or few pixels that they are made of. 
	' We shuffle the whole buffer each frame either way if we use all the pixels or not. If it is smooth. You can go wild with your new pixelaccess fullscreen.
	
	xsprite=xsprite+2 ; ysprite=ysprite+2 ; xsprite = xsprite Mod (1920-512) ; ysprite = ysprite Mod (1080-512) ; temp2=temp2+1
	For temp=1 To 128
		ysprite = temp*2
		' Draw one sprite (coordinates are xprite & ysprite) (same goes here, partly un-optimized code)
		base = ysprite*xres+xsprite+(temp*32) ' Sprite coordinates are xsprite And ysprite
		tempy=0 ; For y=0 To 127 Step 1 ; For x=0 To 127 Step 1 ; pixels[base+x+x+X+X+tempy] = buffer[x+(y Shl 7)] ;	Next ;	tempy=tempy+xres+xres+XRES+XRES ; Next
	Next
	
	' This writes the array to the GPU, amazingly this is not the major bottleneck even on weak machines.
	glDrawPixels(xres,yres,GL_BGRA,GL_UNSIGNED_BYTE,Varptr(Pixels[0]))
	Delay 1 ; Flip 1

Until MouseDown(2)
End

Global xres:Int = 1024 ; yres:Int = 768 ; Global pixels:Int[xres*yres]

tempy=0 ; For y=0 To 127 Step 1 ; For x=0 To 127 Step 1 ; pixels[base+x+x+X+X+tempy] = buffer[x+(y Shl 7)] ;	Next ;	tempy=tempy+xres+xres+XRES+XRES ; Next

Function DrawCube(xScrnPos:Float,yScrnPos:Float,xWidth:Float,yHeight:Float,xPos:Float,yPos:Float,zPos:Float)

ClearArray Cards()

FillArray Flags(),1

xres=DesktopWidth() ; yres=DesktopHeight()

SetColor Red,Green,Blue
SetAlpha Solid#
SetRotation Rot#
SetScale X#,Y#

'Rem	
	'Here we rotate the pallet entries by one. :-)
	Local Temp:Int = Pallet[0]
	For Local i:Int = 0 To 14 ; Pallet[i] = Pallet[i+1] ; Next
	Pallet[15] = temp	
'End Rem

Strict
Local i,j
Graphics 1024,768
SetVirtualResolution 800,620 ' note it's 20+ compensates for taskbar
DrawRect 0,0,800,600 ' yet we can draw to full 800x600 with no problem
SetColor 0,0,0
DrawRect 1,1,798,598 ' hollow out rectangle to show it really fits
SetColor 0,0,255
DrawLine 50,50,200,200 ' simple line
SetColor 255,0,0
DrawOval 400,200,50,50 ' simple circle
Flip
WaitKey

'        50 SHADES of Red
'
' A simple introduction To shaders
'
'

' SET GRAPHICS MODE
Local xres:Int = 1920, yres:Int = 1080 ; GLGraphics xres,yres,32,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER ; glewInit ; HideMouse
glMatrixMode GL_PROJECTION ; glLoadIdentity ; glOrtho 0,xres,yres,0,-1,1 ; glMatrixMode GL_MODELVIEW ; glLoadIdentity ; glViewport 0,0,xres,yres ; glPixelZoom 1,-1 ; glRasterPos2i 0,0

' CREATE SHADER
Local VC:String = VERTEX ; PC:String = PIXEL ; PO = glCreateProgramObjectARB() ; VS = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB) ; PS = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)
Local SC:Byte Ptr = VC.ToCString(),SL = VC.Length ; glShaderSourceARB VS,1,Varptr SC,Varptr SL ; MemFree SC ; glCompileShaderARB VS
SC = PC.ToCString() ; SL = PC.Length ; glShaderSourceARB PS,1,Varptr SC,Varptr SL ; MemFree SC
glCompileShaderARB PS ; glAttachObjectARB PO,VS ; glAttachObjectARB PO,PS ; glDeleteObjectARB VS ; glDeleteObjectARB PS ; glLinkProgramARB PO

' PROGRAM BEGINS
Repeat
	glClear GL_COLOR_BUFFER_BIT ; glUseProgramObjectARB PO ; glBegin GL_QUADS ' Custom attributes instead, glVertexAttrib2f or VA/VBO glEnableVertexAttribArray/glVertexAttribPointer.
    glTexCoord2f(0,0) ; glVertex2f(0,0) ; glTexCoord2f(1,0) ; glVertex2f(xres,0) ; glTexCoord2f(1,1) ; glVertex2f(xres,yres) ; glTexCoord2f(0,1) ; glVertex2f(0,yres) 
	glEnd ; glUseProgramObjectARB 0
	Delay 1 ; Flip 1
Until KeyHit(KEY_ESCAPE)
End

' SHADERS
Const VERTEX:String = "void main(void) { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex ; gl_TexCoord[0] = gl_MultiTexCoord0 ; }"

Const PIXEL:String = ..
"void main(void) { vec4 coord = gl_TexCoord[0] ; vec4 coord2 = coord ;                                  ~n" + ..
"int temp = 0 ; while (temp++ < 512) { coord2.w = coord.w + coord.y ; coord2.y = coord.y + coord.x ; } ~n" + ..
"float p = coord2.x ; gl_FragColor = vec4(p,0.0,0.0,1.0) ; }"

Rem VERTEX SHADER
void main(void) {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex
gl_TexCoord[0] = gl_MultiTexCoord0 
}
EndRem

Rem PIXEL SHADER
void main(void) {
vec4 coord = gl_TexCoord[0]
vec4 coord2 = coord
int temp = 0
while (temp++ < 512) {
coord2.w = coord.w + coord.y
coord2.y = coord.y + coord.x
}
float p = coord2.x
gl_FragColor = vec4(p,0.0,0.0,1.0)
}
EndRem

"int temp = 0 ; while (temp++ < 512) { coord2.w = coord.w + coord.y ; coord2.y = coord.y + coord.x ; } ~n" + ..

'        50 SHADES of Red
'
' A simple introduction To shaders
'

' SET GRAPHICS MODE
Local xres:Int = DesktopWidth(), yres:Int = DesktopHeight() ; GLGraphics xres,yres,32,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER ; glewInit ; HideMouse
glMatrixMode GL_PROJECTION ; glLoadIdentity ; glOrtho 0,xres,yres,0,-1,1 ; glMatrixMode GL_MODELVIEW ; glLoadIdentity ; glViewport 0,0,xres,yres ; glPixelZoom 1,-1 ; glRasterPos2i 0,0

' CREATE SHADER
Local VC:String = VERTEX ; PC:String = PIXEL ; PO = glCreateProgramObjectARB() ; VS = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB) ; PS = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)
Local SC:Byte Ptr = VC.ToCString(),SL = VC.Length ; glShaderSourceARB VS,1,Varptr SC,Varptr SL ; MemFree SC ; glCompileShaderARB VS
SC = PC.ToCString() ; SL = PC.Length ; glShaderSourceARB PS,1,Varptr SC,Varptr SL ; MemFree SC
glCompileShaderARB PS ; glAttachObjectARB PO,VS ; glAttachObjectARB PO,PS ; glDeleteObjectARB VS ; glDeleteObjectARB PS ; glLinkProgramARB PO

' INIT VARIABLES
Local CString:Byte Ptr = "timer".ToCSTring(), TimerObject:Int = glGetUniformLocationARB(PO,CString), timer:Float = 0 ' TIMER
 
' PROGRAM BEGINS
Repeat
glClear GL_COLOR_BUFFER_BIT ; glUseProgramObjectARB PO

' FUN
If MouseDown(1) Then timer = MouseX()/1024.0 ' allow interactivity when mousdown

glUniform1fARB(TimerObject,timer) ; timer :+ 0.05 ; timer = timer Mod 360 ' TIMER
glBegin GL_QUADS ; glTexCoord2f(0,0) ; glVertex2f(0,0) ; glTexCoord2f(1,0) ; glVertex2f(xres/2,0) ; glTexCoord2f(1,1) ; glVertex2f(xres/2,yres) ; glTexCoord2f(0,1) ; glVertex2f(0,yres)
glTexCoord2f(1,0) ; glVertex2f(xres/2,0) ; glTexCoord2f(0,0) ; glVertex2f(xres,0) ; glTexCoord2f(0,1) ; glVertex2f(xres,yres) ; glTexCoord2f(1,1) ; glVertex2f(xres/2,yres) 
glEnd ; glUseProgramObjectARB 0 ' Custom attributes instead, glVertexAttrib2f or VA/VBO glEnableVertexAttribArray/glVertexAttribPointer.
Delay 1 ; Flip 1
Until KeyHit(KEY_ESCAPE)
End

' ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

' SHADERS
Const VERTEX:String = "void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex ; gl_TexCoord[0] = gl_MultiTexCoord0 ; }"

Const PIXEL:String = ..
"vec2 O = vec2(0.0,1.0) ;        ~n" + ..
"float wrap(float x) {return abs(mod(x,2.0)-1.0) ; }                                                                                    ~n" + ..
"float wave(vec2 p,float angle) {vec2 direction = vec2(cos(angle),sin(angle)) ; return cos(dot(p,direction)) ; }                        ~n" + ..
"float rand (in vec2 uv) {return fract(sin(dot(uv,vec2(12.4124,48.4124)))*48512.41241) ; }                                              ~n" + ..
"float noise (in vec2 uv) {vec2 b = floor(uv) ; return mix(mix(rand(b),rand(b+O.yx),0.5),mix(rand(b+O),rand(b+O.yy),0.5),0.5) ; }       ~n" + ..
"varying vec2 position ; uniform sampler2D tex0 ; uniform vec2 resolution ; uniform float timer ;                                       ~n" + ..
"void main() { vec4 coord = gl_TexCoord[0] ; vec2 uv = coord.xy / resolution.xy ;                                                       ~n" + ..
"vec2 p = (coord.xy - 0.5) * 50.0 ; float brightness = 0.0 ; for (float i = 1.0 ; i <= 11.0 ; i++) {brightness += wave(p,timer/i) ; }   ~n" + ..
"brightness = wrap(brightness) ;  gl_FragColor = vec4(brightness,0.0,0.0,1.0) ; gl_FragColor.a = 1.0 ; }                                ~n"

' ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Rem Unrolled Pixelshader
vec2 O = vec2(0.0,1.0)
float wrap(float x) {return abs(mod(x,2.0)-1.0) ; }
float wave(vec2 p,float angle) {vec2 direction = vec2(cos(angle),sin(angle)) ; return cos(dot(p,direction)) ; }
float rand (in vec2 uv) {return fract(sin(dot(uv,vec2(12.4124,48.4124)))*48512.41241) ; }
float noise (in vec2 uv) {vec2 b = floor(uv) ; return mix(mix(rand(b),rand(b+O.yx),0.5),mix(rand(b+O),rand(b+O.yy),0.5),0.5) ; }

varying vec2 position ; uniform sampler2D tex0 ; uniform vec2 resolution ; uniform float timer 

void main() {
	vec4 coord = gl_TexCoord[0]
	vec2 uv = coord.xy / resolution.xy
	vec2 p = (coord.xy - 0.5) * 50.0
	float brightness = 0.0
	for (float i = 1.0 ; i <= 11.0 ; i++) {
		brightness += wave(p,timer/i)
	}
brightness = wrap(brightness)
gl_FragColor = vec4(brightness,0.0,0.0,1.0)
gl_FragColor.a = 1.0 
}
EndRem

Global xres:Int = 1920 ; yres:Int = 1080 ; Global pixels:Int[xres*yres] ; Global pixels2:Int[xres*yres]
GLGraphics(xres,yres,32,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER) ; HideMouse ' Fullscreen 
glViewport(0,0,xres,yres) ;  glLoadIdentity() ; glMatrixMode(GL_PROJECTION) ; glPixelZoom(1,-1) ; glOrtho(0,xres,yres,0,0,1) ; glRasterPos2i(0,0)

' C64 managed 2KB per frame just barely, To be able to do this was "elite" (120 KB / sec) (Triple buffering was pretty much invented here just to get things going)

' 1920 x 1080 32bit is 8MB per frame (0.5G Byte per 12 msec) (This example shows that One read of the screen + One write of the screen is possible under 12msec (60hz).

' A full read (0.5 GByte) and a full write (0.5 GB), makes a 1 Gbyte transfer happens between CPU and GPU per second.

' If you use any other resolution here's the numbers per frame it takes, just to get the feeling when you upsize pixels to something else.
' 1920*1080 takes 8MB, 0.5 GB per sec
' 1280*800 takes 4MB, 0.25GB per sec
' 1280*720 takes 3.5MB, 0.21 GB per sec
' 1024*768 takes 3MB, 0.18 GB per sec
' 800*600 takes 1.8MB, 0.1 GB  per sec
' 640*480 takes 1.2MB, 120 MB per sec
' 320*240 takes 0.3MB, 18 MB per sec

' Main
Repeat

	' Demo a CLS, example how to clear the array (non-optimized)
	For y=0 To yres-1 Step 1 ; For x=0 To xres-1 Step 1 ; pixels[(y*xres+x)] = 0 ; Next ; Next ' stepping is not needed if you only use 1
	
	' Demo a PLOT, example how to draw a pixel x,y,color (non-optimized and non-clipping)
	x=400 ; y = 300 ; c = 65535 ; 	pixels[x + y*xres] = c

        ' Demo
	a = a + 1 ; b = 64 * Sqr(a)*Cos(a) ; 	For y=0 Until yres Step 1 ; For x=0 Until xres Step 1 ; 	c = x + b * b Shr 8 * x+yy ; 	pixels[x + y*xres] = c ; 	Next ; Next
	
	' This reads an array from the GPU, make a dummy read of the entire screen before each frame and it just about manages to fetch an entire HD screen once and write it all once. 
        ' Living on the edge but it's a simple apporach. No slowdown on e.g. 2010 Mac's.
	 glReadPixels 0,0,xres,yres,GL_BGRA,GL_UNSIGNED_BYTE,Varptr(Pixels2[0]) ' Reads into an invisible array as a test.
	
	' This writes the array to the GPU, amazingly this is not the major bottleneck even on weak machines.
         glDrawPixels(xres,yres,GL_BGRA,GL_UNSIGNED_BYTE,Varptr(Pixels[0]))

Delay 1 ; Flip 1

Until MouseDown(2)
End

Global xres:Int = 1920 ; yres:Int = 1080 ; Global pixels:Int[xres*yres] ; Global pixels2:Int[xres*yres]
GLGraphics(xres,yres,32,60,GRAPHICS_BACKBUFFER + GRAPHICS_DEPTHBUFFER) ; HideMouse ' Fullscreen 
glViewport(0,0,xres,yres) ;  glLoadIdentity() ; glMatrixMode(GL_PROJECTION) ; glPixelZoom(1,-1) ; glOrtho(0,xres,yres,0,0,1) ; glRasterPos2i(0,0)

' C64 managed 2KB per frame just barely, To be able to do this was "elite" (120 KB / sec) (Triple buffering was pretty much invented here just to get things going)

' 1920 x 1080 32bit is 8MB per frame (0.5G Byte per 12 msec) (This example shows that One read of the screen + One write of the screen is possible under 12msec (60hz).

' A full read (0.5 GByte) and a full write (0.5 GB), makes a 1 Gbyte transfer happens between CPU and GPU per second.

' If you use any other resolution here's the numbers per frame it takes, just to get the feeling when you upsize pixels to something else.
' 1920*1080 takes 8MB, 0.5 GB per sec
' 1280*800 takes 4MB, 0.25GB per sec
' 1280*720 takes 3.5MB, 0.21 GB per sec
' 1024*768 takes 3MB, 0.18 GB per sec
' 800*600 takes 1.8MB, 0.1 GB  per sec
' 640*480 takes 1.2MB, 120 MB per sec
' 320*240 takes 0.3MB, 18 MB per sec

' Main
Repeat

	' Demo a CLS, example how to clear the array (non-optimized)
	For y=0 To yres-1 Step 1 ; For x=0 To xres-1 Step 1 ; pixels[(y*xres+x)] = 0 ; Next ; Next ' stepping is not needed if you only use 1
	
	' Demo a PLOT, example how to draw a pixel x,y,color (non-optimized and non-clipping)
	x=400 ; y = 300 ; c = 65535 ; 	pixels[x + y*xres] = c

        ' Demo
	a = a + 1 ; b = 64 * Sqr(a)*Cos(a) ; 	For y=0 Until yres Step 1 ; For x=0 Until xres Step 1 ; 	c = x + b * b Shr 8 * x+yy ; 	pixels[x + y*xres] = c ; 	Next ; Next
	
	' This reads an array from the GPU, make a dummy read of the entire screen before each frame and it just about manages to fetch an entire HD screen once and write it all once. 
        ' Living on the edge but it's a simple apporach. No slowdown on e.g. 2010 Mac's.
	 glReadPixels 0,0,xres,yres,GL_BGRA,GL_UNSIGNED_BYTE,Varptr(Pixels2[0]) ' Reads into an invisible array as a test.
	
	' This writes the array to the GPU, amazingly this is not the major bottleneck even on weak machines.
         glDrawPixels(xres,yres,GL_BGRA,GL_UNSIGNED_BYTE,Varptr(Pixels[0]))

Delay 1 ; Flip 1

Until MouseDown(2)
End