drawing to pixmap is faster than drawing to screen

BlitzMax Forums/BlitzMax Programming/drawing to pixmap is faster than drawing to screen

Jesse

(Posted 2010) [#1]

?
I need some volunteers to test this. Please.
I was going to put this directly in the code archives but wanted wanted to know if it works good on everyones computer.
It basically illustrate that drawing to a pixmap is faster than using max2d commands to draw to the back buffer. The only draw back is that none of the advanced 3d functionality is available for pixmaps but for some dirty fast classic game design, I think it's great.


SuperStrict
Const SCR_WIDTH:Int =800
Const SCR_HEIGHT:Int = 600
Const SCR_SIZE:Int = SCR_WIDTH * SCR_HEIGHT * 4
Const SCR_MIDX:Int = (SCR_WIDTH  / 2)
Const SCR_MIDY:Int = (SCR_HEIGHT / 2)


Const LENS:Int = 256

Const TORNUMRINGS:Int = 80
Const TORNUMBANDS:Int = 80
Const TORRINGRADIUS:Int = 150
Const TORBANDRADIUS:Int = 55

Global canvas:TImage = CreateImage(SCR_WIDTH,SCR_HEIGHT)
Global pixmap:TPixmap
Global buffer:Int Ptr
Global directToScreen:Int = False


Type vector

	Field x:Float
	Field y:Float
	Field z:Float
End Type

Type point3d

	Field x:Float
	Field y:Float
	Field z:Float
	Field xr:Float
	Field yr:Float
	Field zr:Float
	Field sx:Int
	Field sy:Int
	Field color:Int
End Type

Type xpoly

	Field p1:Int
	Field p2:Int
	Field p3:Int
	Field color:Int
	Field idx:Int
End Type



  	Global mat:Float[4,4]
	Global tmat:Float[4,4]

  	Local max3dpoint:Int =  TORNUMRINGS * TORNUMBANDS 
     Global torus:point3d[] = New point3d[max3dpoint]
	If Not torus End

	Local maxpoly:Int = get_max_poly(TORNUMRINGS, TORNUMBANDS)
	Global torpoly:xpoly[] = New xpoly[maxpoly]
	'!!!!!!!! I want this To be inside the set_torus_faces funk)
	If Not torpoly End

	Local thetax:Int, thetay:Int, thetaz:Int


	load_torus (torus, TORNUMRINGS, TORNUMBANDS, TORRINGRADIUS, TORBANDRADIUS)
	set_torus_faces(torpoly, TORNUMRINGS, TORNUMBANDS)


	thetax = Rand(360)
	thetay = Rand(360)
	thetay = Rand(360)


   ' If (!ptc_open("MingW swirl",SCR_WIDTH,SCR_HEIGHT)) Return 1
     Graphics SCR_WIDTH,SCR_HEIGHT
	Global myfont:TBitmapFont = TBitmapFont.Create(GetEnv_("systemroot")+"\fonts\COURBaD.TTF",16)
	'SetBlend lightblend
	If Not directToScreen Then 
		pixmap = LockImage(canvas)
		buffer = Int Ptr(pixmap.pixels)
	EndIf
	Repeat
 		Cls()
		If directToScreen
		Else
			canvas.seqs[0] = 0
			canvas.frames[0] = Null
			MemClear(buffer,SCR_SIZE-1)
		EndIf
		thetax = (thetax + 1) Mod 360
		thetay = (thetay + 1) Mod 360
		thetaz = (thetaz + 1) Mod 360

		matrix_clear( mat)
		matrix_clear(tmat)

		matrix_set_identity( mat)


		matrix_rotate_x(tmat, thetax)
		matrix_mul_matrix(mat, tmat)

		matrix_rotate_y(tmat, thetay)
		matrix_mul_matrix(mat, tmat)

		matrix_rotate_z(tmat, thetaz)
		matrix_mul_matrix(mat, tmat)
		
		
		For Local i:Int = 0 Until max3dpoint
		
			Local x:Float, y:Float, z:Float, xr:Float, yr:Float, zr:Float

			x = torus[i].x
			y = torus[i].y
			z = torus[i].z

			xr = x * mat[0,0] + y * mat[0,1] + z * mat[0,2] +  mat[0,3]
			yr = x * mat[1,0] + y * mat[1,1] + z * mat[1,2] +  mat[1,3]
			zr = x * mat[2,0] + y * mat[2,1] + z * mat[2,2] +  mat[2,3]

			torus[i].xr= xr
			torus[i].yr= yr
			torus[i].zr= zr

			Local distance:Int = LENS - zr
			If (distance > 0)
			
				Local sx:Int = SCR_MIDX + Int(LENS * xr / distance)
				Local sy:Int = SCR_MIDY + Int(LENS * yr / distance)
				torus[i].sx = sx
				torus[i].sy = sy
			EndIf
		Next
				
		draw_torus(torus, max3dpoint, torpoly, maxpoly)
				
        If KeyHit(KEY_SPACE) 	directToScreen = Not directToScreen
        Flip(0)
	Until(KeyDown(key_escape))

'********************************************************************
'	color and pixel manipulation
'********************************************************************

Function rgb:Int(r:Int, g:Int, b:Int)
	Return  $ff000000 | (r) Shl 16 | (g) Shl 8 | (b)
End Function

Function changeColor(color:Int)
	SetColor (color Shr 16) & $ff,(color Shr 8)& $ff,color & $ff
End Function


'*********************************************************************
'		3d torus stuff
'*********************************************************************

Function draw_torus(model:point3d[], maxpoint:Int, tri:xpoly[], maxpoly:Int)

	Local i:Int,j:Int, x1:Int, y1:Int, x2:Int, y2:Int, x3:Int, y3:Int

	For i = 0 Until maxpoly
	
		j  = tri[i].idx
		x1 = model[tri[j].p1].sx
		y1 = model[tri[j].p1].sy
		x2 = model[tri[j].p2].sx
		y2 = model[tri[j].p2].sy
		x3 = model[tri[j].p3].sx
		y3 = model[tri[j].p3].sy
		If directToScreen
			changeColor(tri[j].color)
			DrawLine(x1, y1, x2, y2)
			DrawLine(x2, y2, x3, y3)
			DrawLine(x3, y3, x1, y1)
		Else
			Draw_Line_add(buffer,x1, y1, x2, y2,tri[j].color)
			Draw_Line_add(buffer,x2, y2, x3, y3,tri[j].color)
			Draw_Line_add(buffer,x3, y3, x1, y1,tri[j].color)
		EndIf
	Next
	SetColor 255,255,255

	If directToScreen
			SetColor 255,255,255 
			DrawText "using Max 2d command set slow",10,10
			DrawText "Press SPACE BAR to switch to Pixel Plotting",10,25
	Else
		myFont.Draw(pixmap,"pixelplotting to image's pixmap and displaying pixmap fast",10,10)
		myFont.Draw(pixmap,"Press SPACE BAR to switch to Max 2d Commands",10,25)
		DrawImage canvas,0,0
	EndIf

End Function
Function load_torus(model:point3d[], rings:Int, bands:Int, ringradius:Int, bandradius:Int)

	Local a1:Float = 360.0 / Float(rings)
	Local a2:Float = 360.0 / Float(bands)
	Local i:Int = 0
	For Local s2:Int = 0 Until bands
	
		For Local s1:Int = 0 Until rings
		
			Local x1:Float = Cos(s1 * a1) * ringradius
			Local y1:Float = Sin(s1 * a1) * ringradius
			model[i] = New point3d
			model[i].x = x1 + Cos(s1 * a1) * Cos(s2 * a2) * bandradius
			model[i].y = y1 + Sin(s1 * a1) * Cos(s2 * a2) * bandradius
			model[i].z = Sin(s2 * a2) * bandradius
			i:+1
		Next
	Next
End Function

Function get_max_poly:Int(rings:Int, bands:Int)

  Local i:Int = 0
  Local maxtri:Int = 0
  For Local s1:Int = (bands - 1) To 0 Step -1
  
	For Local s2:Int = (rings - 1) To 0 Step -1
	
		i:+1
		maxtri:+1
		i:+1
		maxtri:+1
	Next
  Next
  Return maxtri
End Function

Function set_torus_faces(tri:xpoly[], rings:Int, bands:Int)

	Local maxpoint:Int = rings * bands
	Local i:Int = 0

	Local r:Int = 64
	Local g:Int = 32
	Local b:Int = 16
	For Local s1:Int = (bands - 1) To 0 Step -1
	
		For Local s2:Int = (rings - 1) To 0 Step -1
			tri[i] = New xpoly
			tri[i].p3 = (s1 * rings + s2 + rings) Mod maxpoint
			tri[i].p2 = s1 * rings + (s2 + 1) Mod rings
			tri[i].p1 = s1 * rings + s2
			tri[i].color = rgb(r,g,b)
			tri[i].idx = i
			i:+1
			tri[i] = New xpoly
			tri[i].p3 = (s1 * rings + s2 + rings) Mod maxpoint
			tri[i].p2 = (s1 * rings + (s2 + 1) Mod rings + rings) Mod maxpoint
			tri[i].p1 = s1 * rings + (s2 + 1) Mod rings
			tri[i].color =rgb(r,g,b)
			tri[i].idx = i
			i:+1
		Next
	Next
End Function


'*********************************************************************
'		Matrix funks
'*********************************************************************
Function matrix_clear(m:Float[,])

	Local row:Int, col:Int

	For row = 0 Until 4
	
		For col = 0 Until 4
			m[row,col] = 0
		Next
	Next
End Function


Function matrix_set_identity(m:Float[,])

	matrix_clear(m)
	m[0,0] = 1
	m[1,1] = 1
	m[2,2] = 1
	m[3,3] = 1
End Function

Function matrix_set_scale(m:Float[,], sx:Float, sy:Float, sz:Float)

	m[0,0] = sx
	m[1,1] = sy
	m[2,2] = sz
End Function


Function matrix_set_translate(m:Float[,], tx:Float, ty:Float, tz:Float)

	m[0,3] = tx
	m[1,3] = ty
	m[2,3] = tz
End Function

Function matrix_rotate_x(m:Float[,], angle:Int)

	Local ang:Float = angle 
	Local sa:Float = Sin(ang)
	Local ca:Float = Cos(ang)

	matrix_set_identity(m)
	m[1,1] = ca
	m[1,2] = -sa
	m[2,1] = sa
	m[2,2] = ca
End Function


Function matrix_rotate_y(m:Float[,], angle:Int)

	Local ang:Float = angle 
	Local sa:Float = Sin(ang)
	Local ca:Float = Cos(ang)

	matrix_set_identity(m)
	m[0,0] = ca
	m[0,2] = sa
	m[2,0] = -sa
	m[2,2] = ca
End Function

Function matrix_rotate_z(m:Float[,], angle:Int)

	Local ang:Float = angle 
	Local sa:Float = Sin(ang)
	Local ca:Float = Cos(ang)

	matrix_set_identity(m)
	m[0,0] = ca
	m[0,1] = -sa
	m[1,0] = sa
	m[1,1] = ca
End Function

Function matrix_mul_matrix(m1:Float[,], m2:Float[,])

	Local i:Int, j:Int, k:Int
	Local mresult:Float[4,4]

	matrix_clear (mresult)
	For i = 0 Until 4
	
		For j = 0 Until 4
		
			mresult[i,j] = 0
			For k = 0 Until 4
			
				mresult[i,j] :+ ( m2[i,k] * m1[k,j] )
			Next
		Next
	Next
	'copy result back
	For i = 0 Until 4
	
		For j = 0 Until 4
			m1[i,j] = mresult[i,j]
		Next
	Next

End Function

Function matrix_mul_vector(m:Float[,],v_in:vector,v_out:vector)

	v_out.x = v_in.x * m[0,0] + v_in.y * m[0,1] + v_in.z * m[0,2] +  m[0,3]
	v_out.y = v_in.x * m[1,0] + v_in.y * m[1,1] + v_in.z * m[1,2] +  m[1,3]
	v_out.z = v_in.x * m[2,0] + v_in.y * m[2,1] + v_in.z * m[2,2] +  m[2,3]
End Function

'*****************************************************************************
'			pixmap drawing funciton
'*****************************************************************************

Function draw_line_add ( buffer:Int Ptr, x:Int, y:Int, x2:Int, y2:Int, color:Int)

	Local notclip:Int, temp:Int
	
	Const scrxmax:Int = SCR_WIDTH  - 1
	Const scrymax:Int = SCR_HEIGHT - 1
	
	Local i:Int = 0
	Local slope:Int =0
	Local eterm:Int = 0
	Local sx:Int = 0
	Local sy:Int = 0
	Local a:Int = (color Shr 24) & $FF 
	Local r:Int = (color Shr 16) & $FF
	Local g:Int = (color Shr 8) & $FF
	Local b:Int = (color Shr 0) & $FF
	Local color2:Int  = (a Shl 24) | (b Shl 16) | (g Shl 8) | (r Shl 0)
	
	If (x2 - x) > 0 sx = 1 Else sx = -1
	Local dx:Int = Abs(x2 - x)
	If (y2 - y) > 0 sy = 1 Else sy = -1
	Local dy:Int = Abs(y2 - y)
	If dy > dx
	        slope = 1
	        temp = x
	        x = y
	        y = temp
	
	        temp = dx
	        dx = dy
	        dy = temp
	
	        temp = sx
	        sx = sy
	        sy = temp
	EndIf
	
	eterm = 2 * dy - dx
		
	For i = 0 Until dx
	   If slope = 1
	     If ((y < 0) + (x < 0) + (y > scrxmax) + (x > scrymax)) = 0 Then buffer[x * SCR_WIDTH + y] = color2
	   Else
	     If ((y < 0) + (x < 0) + (x > scrxmax) + (y > scrymax)) = 0 Then buffer[y * SCR_WIDTH + x] = color2
	   EndIf
	   While eterm >= 0
	      y :+ sy 
	      eterm = eterm - 2 * dx
	   Wend
	   x :+ sx
	   eterm = eterm + 2 * dy
	Next
     If ((y2 < 0)+(x2 < 0)+(x2 > scrxmax)+(y2 > scrymax)) = 0 Then buffer[y2 * SCR_WIDTH + x2] = color2
 
End Function

'**********************************************************************
'*			draws bitmap fonts to a pixmap
'**********************************************************************


Type TBitMap
	Field gx			:Int
	Field gy			:Int
	Field gImg			:TImage
	Field advance		:Int
	Function Create:TBitMap(image:TImage,x:Float,y:Float,adv:Int)
		
		Local b:TbitMap = New TBitMap
		b.gImg = image
		b.gx = x
		b.gy = y
		b.advance = adv
		Return b
	End Function
	
	Method Draw(into:TPixmap,x:Float,y:Float)
		Local w:Int
		Local h:Int
		If gImg 
			DrawImage gImg,x,y
			Local from:TPixmap = gImg.lock(0,True,True)
			If into.width  >= from.width+x Then  w = from.width  Else w = inTo.width - x
			If into.height >= from.height+y Then h = from.height Else h = inTo.height- y
			For Local d:Int = 0 Until h
				For Local a:Int = 0  Until w
						Local n:Int = from.ReadPixel(a,d)
						If n Then inTo.WritePixel(a+x,d+y,n)
				Next
			Next
		EndIf
	End Method	
End Type		

Type TBitMapFont
	
	Field bitMap		:Tbitmap[96]
	Field gfx			:TMax2dGraphics
	
	Function Create:TBitmapFont(url:String,size:Int)
		Local oldFont:TImageFont = GetImageFont()
		Local imgFont:TImageFont=LoadImageFont(url,size)
		If imgFont = Null imgFont = GetImageFont()
		Local b:TbitMapFont = New TbitMapFont
		If imgfont=Null Return Null
		SetImageFont(imgfont)
		
		b.gfx = tmax2dgraphics.Current()
		
		For Local i:Int = 0 Until 96
			Local n:Int = imgFont.CharToGlyph(i+32)
			If n < 0 Continue
			Local glyph:TImageGlyph = imgFont.LoadGlyph(n)
			If glyph
				b.bitMap[i] = TBitMap.Create(glyph._image,glyph._x,glyph._y,glyph._advance)			
			Else
			 	b.bitmap[i] = New TBitMap
			EndIf
		Next
		SetImageFont(oldFont)
		Return b
	End Function
	
	
	Method draw(pixmap:TPixmap,text:String,x:Float,y:Float)
		For Local i:Int = 0 Until text.length
			Local bm:TBitMap = bitmap[text[i]-32]
			bm.Draw(pixmap,x+bm.gx,y+bm.gy)
			x :+ bm.advance
		Next
	End Method

End Type

Brucey

(Posted 2010) [#2]

DrawPixmap pixmap,0,0

DrawPixmap is notoriously slow... you are better using LoadImage(pixmap) and DrawImage.

GfK	(Posted 2010) [#3]

When drawing on pixmaps nothing is sent to the graphics card. But if you modify an image/pixmap then draw it, it will be uploaded each and every time so ultimately, its going to be slower.

N	(Posted 2010) [#4]

If you want to modify pixels and stuff by hand, you should probably use something like SDL.

Jesse

(Posted 2010) [#5]

yes I forgot that pixmaps don't work in Vista and Windows 7
pixmaps are faster on my HP dual core with intel graphics.

GfK	(Posted 2010) [#6]

yes I forgot that pixmaps don't work in Vista and Windows 7

Huh? Says who??

Jesse

(Posted 2010) [#7]

there where several complaints that they could not use drawpixmap to display pixmap on Windows 7 and Vista.

Just in case no one noticed I modified the source to display the pixmap as image.

Jesse

(Posted 2010) [#8]

it's funny on my laptop with mobile Intel 945 graphics with 256 MB mem it runs really fast with pixmaps but when I tried it on my desktop with GEForce 9500 with 512 MB memory it ran really slow, a lot slower than the Intel Graphics did. I can say that the intel graphics ran the pixmap version twice as fast as the GEForce did.
I am not even going to try to ask why because I won't be happy with any explanation.
I'll try it on a mac in a while.
And I don't think I'll be posting it in the Code Archives.

_JIM	(Posted 2010) [#9]

One possible explanation would be that the Intel version doesn't have to upload the pixmap to video memory because there isn't any video memory. It's shared from RAM. So maybe a memcpy is faster than RAM-to-VRAM.

jsp	(Posted 2010) [#10]

it's funny on my laptop with mobile Intel 945 graphics with 256 MB mem it runs really fast with pixmap

Was the same with my old Dell laptop with Intel graphics...

Jesse

(Posted 2010) [#11]

anybody else?
I gave up on the idea anyway.
too much inconsistency.