'Got Balls?' - little sprite tester...

I just made this little tester, inspired by MGE and our research to figure out what funky things happen on different machines. Only very little differences can screw up performances on "perfect" machines, while running perfect on "crappy" machines, while the other way around is even more shocking and I'm dealing with that for the past few weeks or rather months since I've started with Bmax.

However, I got a little carried away and wrote this, which I think is gonna be fun for all of you. It contains creation routines for 3d looking balls, pretending volume by 3d shading and procedural normal creation. (very cheap, but cute!)
I've added even a fake highlight, which is particularely cute, while naturally nowhere near perfect. However, it performs brilliantly on my machine and offers a few different toggle modes...(I keep writing toogle, too weird?!).

So, yeah, have fun with this one... hopefully it may even inspire a little bit?

I never know how good my programming is, so I'm always a little hesitant to impose with this stuff, but here's a list of things I find neat in there:

- procedural ball creation with soft edge antialiasing and lighting
- useful little vector type
- vector to degree conversion
- nice and simple framework (I think it's a great starting point!)
- neat trick I figured out to toggle ( toggle:~1 )
...there maybe a few more curious things in there, good and bad...

As for the testing, I'd be already just happy to read whether it ran smooth or not. I realized that fps reports are not always enough of a clue. Let me know, if vertical blank [on] is true to your desktop framerate (ordinarily 60 nowadays], please.

You may just change the amount_of_sprites in there and let me know at what point it stops performing fine?!

Thanks in advance and have fun with it! 8)

SuperStrict
Framework brl.GLMax2D
Import brl.StandardIO
'--------------------------------------------------------------'
'"Got Balls?"												   '
'A little benchmark routine for smoothness and consistency of  '
'frames per second (fps) on any system...	   (www.taron.de)  '
'--------------------------------------------------------------'
'(feel free to use my balls any time you like!)

'-------------------------------	set graphics
Graphics(800,600,0,60)
SetGraphicsDriver GLMax2DDriver()
AutoMidHandle(1)


'-------------------------------	create image of lit ball
Local size:Int =64
Local half:Int = size Shr 1
Global blob:TImage = CreateImage(size,size,1,FILTEREDIMAGE)
Local bpix:TPixmap = LockImage(blob,0)
Local normal:vec = vec.Create()
Local light:vec = vec.Create()
light.x = 0.0;light.y = 0.5;light.z = +0.4;light.normalize3d()
	
Local rgb:Int
For Local y:Byte = 0 Until size
	For Local x:Byte = 0 Until size
		normal.x = x-half
		normal.y = y-half
		Local alpha:Int = $ff-(Int(normal.x*normal.x+normal.y*normal.y)Shr 2)
		If alpha<0 Then alpha = 0 Else alpha:*8
		If alpha>255 Then alpha = 255

		normal.x :/half
		normal.y :/half
		normal.z = (1.0-(normal.x*normal.x+normal.y*normal.y))^0.5
		normal.normalize3d()
		rgb = normal.dot3d(light)*$ff
		If rgb <0 Then rgb = 0
		rgb = rgb | (rgb Shl 8) | (rgb Shl $10)
		WritePixel(bpix,x,y,(alpha Shl $18)|rgb)
	Next
Next
UnlockImage(blob,0)

'-------------------------------	create image of funny highlight
Global spec:TImage = CreateImage(16,16,1,FILTEREDIMAGE)
bpix = LockImage(spec,0)
For Local y:Byte = 0 Until 16
	For Local x:Byte = 0 Until 16
		normal.x = x-8
		normal.y = y-8
		Local alpha:Int = $ff-(Int(normal.x*normal.x+normal.y*normal.y)Shl 2)
		If alpha<0 Then alpha = 0 
		WritePixel(bpix,x,y,(alpha Shl $18)|$ffffff)
	Next
Next
UnlockImage(spec,0)

bpix = Null
GCCollect()

'-------------------------------  LITTLE (2d/3d) VECTOR TYPE
Type vec	
	Field x:Float
	Field y:Float
	Field z:Float
	Field length:Float
	Field dot:Float
	Method dot2d:Float(v:vec)
			dot = x*v.x + y*v.y
			Return dot
	End Method
	Method dot3d:Float(v:vec)
			dot = x*v.x+ y*v.y + z*v.z
			Return dot 
	End Method
	Method normalize2d:Float()
		length = x*x+y*y
		If length
			length = Sqr(length)
			x:/length
			y:/length
		End If
		Return length
	End Method
	Method normalize3d()
		length = x*x+y*y+z*z
		If length
			length = Sqr(length)
			x:/length
			y:/length
			z:/length
		End If
	End Method
	Function Create:vec()
		Return New vec
	End Function
End Type

'-------------------------------  SPRITE TYPE
Type sprite		
	Global splist:TList = CreateList()
	Field pos:vec
	Field loc:vec
	Field col:vec
	Field rot:Float
	
	Method draw()
		pos.x:+ loc.x
		pos.y:+loc.y
		Local dir:vec = vec.Create()
		dir.x = center.x-pos.x
		dir.y = center.y-pos.y
		
		Local dist:Float = dir.normalize2d()
				
		rot = ACos(dir.y)
		If dir.x>0 Then rot = ACos(-dir.y)+180
		SetRotation rot
		
		dir.length= $ff - dir.length/8 
		Local fade:Float = dir.length/$ff
		SetColor col.x*dir.length,col.y*dir.length*fade,col.z*dir.length*fade^2
		SetBlend ALPHABLEND
		DrawImage(blob,0.5*pos.x,0.5*pos.y,0)

		SetColor $ff,$ff,$ff		
		SetBlend LIGHTBLEND
		SetAlpha 0.4*dir.length/$ff
		SetScale 1.0,1.0-(dist/800)
		DrawImage(spec,0.5*pos.x+dir.x*dist*0.025,0.5*pos.y+dir.y*dist*0.025,0)
		SetScale 1,1
		SetAlpha 1.0
	End Method
	
	Function Create:sprite(l:vec)
		Local s:sprite = New sprite
			s.pos = vec.Create()
			s.loc = vec.Create()
			s.loc.x = l.x
			s.loc.y = l.y
			s.rot = 0
			s.col = vec.Create()
			s.col.x = (l.x *0.3) Mod 1
			s.col.y = (l.y *0.733) Mod 1
			s.col.z = (l.y+l.x *1.33) Mod 1
			
		ListAddLast splist,s
		Return s
	EndFunction
EndType

'-------------------------------	create & distribute sprites
Const amount_of_sprites:Int = 500

Local rep:Int = Sqr(amount_of_sprites)

Local location:vec = vec.Create()
For Local y:Int = 0 Until rep
	For Local x:Int = 0 Until rep
		location.x=32+x*32
		location.y=32+y*32
		sprite.Create(location)
	Next
Next

'-------------------------------	main loop
Local onoff:String[]=["off","on"]
Global center:vec = vec.Create()
Local sp:sprite
Local fs:Byte = 0
Local vb:Byte = 1
Local fps:Int = 0
Local frames:Int = 0
Local dt:Int = 0
Local t:Int = MilliSecs()
Local acc:Int = 0
Repeat
	dt:+ MilliSecs()-t
	t = MilliSecs()
	
	frames:+1
	If dt>1000 
		fps = frames
		frames = 0
		dt = 0
	End If
	
	SetBlend ALPHABLEND
	SetAlpha 0.5
	SetColor 0,0,0
	DrawRect (0,0,800,600)
	SetAlpha 1.0
	
	center.x=400+Sin(acc)*200
	center.y=300+Cos(acc)*200
	Local i:Int = 0
	For sp = EachIn sp.splist
		sp.pos.x:*Sin(acc+i*13)*Cos(i) 
		sp.pos.y:*Cos(acc+i*13)*Sin(acc) 
		sp.draw()	
		i:+1
	Next
	acc:+2
	
	SetColor $ff,$ff,$ff
	SetRotation 0
	DrawText "FPS: "+fps,530,500
	SetAlpha 0.2
	DrawText "'v' toggles vertical blank ["+onoff[vb]+"]",530,520
	DrawText "'f' toggles fullscreen",530,540
	
	If KeyHit(KEY_V) Then vb:~1
	If KeyHit(KEY_F)
		 fs:~1
	 	 If fs Then Graphics(800,600,32,60) Else Graphics(800,600,0,60)
	EndIf
	Flip vb
Until KeyHit(KEY_ESCAPE)
EndGraphics()                       
End   

Nice, 400fps as well.

Thanks, Smiler, that was quick! I just did a tiny change to make sure you know if vertical blank is on or off when you read the fps.

If you'd like it a bit more interactive and prettier...

SuperStrict
Framework brl.GLMax2D
Import brl.StandardIO
'--------------------------------------------------------------'
'"Got Balls?"												   '
'A little benchmark routine for smoothness and consistency of  '
'frames per second (fps) on any system...	   (www.taron.de)  '
'--------------------------------------------------------------'
'(feel free to use my balls any time you like!)

'-------------------------------	set graphics
Graphics(800,600,0,60)
SetGraphicsDriver GLMax2DDriver()
AutoMidHandle(1)


'-------------------------------	create image of lit ball
Local size:Int =64
Local half:Int = size Shr 1
Global blob:TImage = CreateImage(size,size,1,FILTEREDIMAGE)
Local bpix:TPixmap = LockImage(blob,0)
Local normal:vec = vec.Create()
Local light:vec = vec.Create()
light.x = 0.0;light.y = 0.5;light.z = +0.4;light.normalize3d()
	
Local rgb:Int
For Local y:Byte = 0 Until size
	For Local x:Byte = 0 Until size
		normal.x = x-half
		normal.y = y-half
		Local alpha:Int = $ff-(Int(normal.x*normal.x+normal.y*normal.y)Shr 2)
		If alpha<0 Then alpha = 0 Else alpha:*8
		If alpha>255 Then alpha = 255

		normal.x :/half
		normal.y :/half
		normal.z = (1.0-(normal.x*normal.x+normal.y*normal.y))^0.5
		normal.normalize3d()
		rgb = normal.dot3d(light)*$ff
		If rgb <0 Then rgb = 0
		rgb = rgb | (rgb Shl 8) | (rgb Shl $10)
		WritePixel(bpix,x,y,(alpha Shl $18)|rgb)
	Next
Next
UnlockImage(blob,0)

'-------------------------------	create image of funny highlight
Global spec:TImage = CreateImage(16,16,1,FILTEREDIMAGE)
bpix = LockImage(spec,0)
For Local y:Byte = 0 Until 16
	For Local x:Byte = 0 Until 16
		normal.x = x-8
		normal.y = y-8
		Local alpha:Int = $ff-(Int(normal.x*normal.x+normal.y*normal.y)Shl 2)
		If alpha<0 Then alpha = 0 
		WritePixel(bpix,x,y,(alpha Shl $18)|$ffffff)
	Next
Next
UnlockImage(spec,0)

bpix = Null
GCCollect()

'-------------------------------  LITTLE (2d/3d) VECTOR TYPE
Type vec	
	Field x:Float
	Field y:Float
	Field z:Float
	Field length:Float
	Field dot:Float
	Method dot2d:Float(v:vec)
			dot = x*v.x + y*v.y
			Return dot
	End Method
	Method dot3d:Float(v:vec)
			dot = x*v.x+ y*v.y + z*v.z
			Return dot 
	End Method
	Method normalize2d:Float()
		length = x*x+y*y
		If length
			length = Sqr(length)
			x:/length
			y:/length
		End If
		Return length
	End Method
	Method normalize3d()
		length = x*x+y*y+z*z
		If length
			length = Sqr(length)
			x:/length
			y:/length
			z:/length
		End If
	End Method
	Function Create:vec()
		Return New vec
	End Function
End Type

'-------------------------------  SPRITE TYPE
Type sprite		
	Global splist:TList = CreateList()
	Field pos:vec
	Field loc:vec
	Field col:vec
	Field rot:Float
	
	Method draw()
		pos.x:+ loc.x
		pos.y:+loc.y
		Local dir:vec = vec.Create()
		dir.x = center.x-pos.x
		dir.y = center.y-pos.y
		
		Local dist:Float = dir.normalize2d()
				
		rot = ACos(dir.y)
		If dir.x>0 Then rot = ACos(-dir.y)+180
		SetRotation rot
		
		dir.length= $ff - dir.length/8 
		Local fade:Float = dir.length/$ff
		SetColor col.x*dir.length,col.y*dir.length*fade,col.z*dir.length*fade^2
		SetBlend ALPHABLEND
		SetScale fade,fade
		DrawImage(blob,0.5*pos.x,0.5*pos.y,0)

		SetColor $ff,$ff,$ff		
		SetBlend LIGHTBLEND
		SetAlpha 0.4*dir.length/$ff
		SetScale fade,fade*(1.0-(dist/800))
		DrawImage(spec,0.5*pos.x+dir.x*dist*0.025*fade,0.5*pos.y+dir.y*dist*0.025*fade,0)
		SetScale 1,1
		SetAlpha 1.0
	End Method
	
	Function Create:sprite(l:vec)
		Local s:sprite = New sprite
			s.pos = vec.Create()
			s.loc = vec.Create()
			s.loc.x = l.x
			s.loc.y = l.y
			s.rot = 0
			s.col = vec.Create()
			s.col.x = (l.x *0.93) Mod 1
			s.col.y = (l.y *0.92) Mod 1
			s.col.z = (l.y+l.x *0.91) Mod 1
			
		ListAddLast splist,s
		Return s
	EndFunction
EndType

'-------------------------------	create & distribute sprites
Const amount_of_sprites:Int = 500

Local rep:Int = Sqr(amount_of_sprites)

Local location:vec = vec.Create()
For Local y:Int = 0 Until rep
	For Local x:Int = 0 Until rep
		location.x=32+x*32
		location.y=32+y*32
		sprite.Create(location)
	Next
Next

'-------------------------------	main loop
Local onoff:String[]=["off","on"]
Global center:vec = vec.Create()
Local sp:sprite
Local fs:Byte = 0
Local vb:Byte = 1
Local fps:Int = 0
Local frames:Int = 0
Local dt:Int = 0
Local t:Int = MilliSecs()
Local acc:Int = 0
Repeat
	dt:+ MilliSecs()-t
	t = MilliSecs()
	
	frames:+1
	If dt>1000 
		fps = frames
		frames = 0
		dt = 0
	End If
	
	SetBlend ALPHABLEND
	SetAlpha 0.5
	SetColor 0,0,0
	DrawRect (0,0,800,600)
	SetAlpha 1.0
	
	center.x=MouseX()*2
	center.y=MouseY()*2
	Local i:Int = 0
	For sp = EachIn sp.splist
		sp.pos.x:*Sin(acc+i*13)*Cos(i) 
		sp.pos.y:*Cos(acc+i*13)*Sin(acc) 
		sp.draw()	
		i:+1
	Next
	acc:+2
	
	SetColor $ff,$ff,$ff
	SetRotation 0
	DrawText "FPS: "+fps,530,500
	SetAlpha 0.2
	DrawText "'v' toggles vertical blank ["+onoff[vb]+"]",530,520
	DrawText "'f' toggles fullscreen",530,540
	
	If KeyHit(KEY_V) Then vb:~1
	If KeyHit(KEY_F)
		 fs:~1
	 	 If fs Then Graphics(800,600,32,60) Else Graphics(800,600,0,60)
	EndIf
	Flip vb
Until KeyHit(KEY_ESCAPE)
EndGraphics()                       
End   

Windowed: 61 FPS with vertical blank on, and 100-104 FPS with it off.
Fullscreen is the exact same.

Taron - See how this works under DirectX on your box: Just change the top lines to:

SuperStrict
' Framework brl.GLMax2D
' Import brl.StandardIO
'--------------------------------------------------------------'
'"Got Balls?"												   '
'A little benchmark routine for smoothness and consistency of  '
'frames per second (fps) on any system...	   (www.taron.de)  '
'--------------------------------------------------------------'
'(feel free to use my balls any time you like!)

'-------------------------------	set graphics
Graphics(800,600,0,60)
' SetGraphicsDriver GLMax2DDriver()
SetGraphicsDriver D3D7Max2DDriver()
AutoMidHandle(1)

You probably already know this, but for little projects, you don't need to use framework, import, etc. Sure it makes the exe bigger, but you can just write and go. ;)

SuperStrict
Framework brl.d3d7Max2D
Import brl.StandardIO
'--------------------------------------------------------------'
'"Got Balls?"												   '
'A little benchmark routine for smoothness and consistency of  '
'frames per second (fps) on any system...	   (www.taron.de)  '
'--------------------------------------------------------------'
'(feel free to use my balls any time you like!)

'-------------------------------	set graphics
Graphics(800,600,0,60)
SetGraphicsDriver D3D7Max2DDriver()
AutoMidHandle(1)

Framework has to be changed, too!
Runs fine, but at fullscreen it appears VB is always on and flip args are ignored?!?

Overall, I'd say it's a little more consistent with d3d7.

SuperStrict isn't super if you don't use Framework, imo.

I've developed a liking for it, too! It's easy and feels percise, not to mention that it trains a good habit! :)

For the tiniest quickies I also didn't care about frameworks, but I think by now it already becomes second nature to me.

"Framework has to be changed, too!"

Really? Are you saying it wouldn't compile without it?

"Runs fine, but at fullscreen it appears VB is always on and flip args are ignored?!?"

More evidence that something is very XFile like on that 8Core mystery machine you use. :) lol..

oh yes... totally Xfile... check out the space thread to see another testimony for wackiness, when it runs on some machines. It seems to ignore the VB altogether and go completely nutz fast!

BAAAAAAAAAAAAAD Revelations!

- timer and millisecs are entertaining but bad functions in BlitzMax!

Nowadays a majority of machines run monitors that have a 60Hz refresh rate.
NOW, 60Hz means within 1000 milliseconds it refreshes the screen 60 times. Per frame that means it take 16.6666666~ millisecs. But Blitzmax can't handle floating point delays and the timer acts on the same principle as the delays (i'm sure!). Meaning that there is no way to actually let anything wait for 16.666666~ millisecs and we have to rely on vertical blancs in order to get a solid cycle rhythm of 60Hz. If for what ever absurd reason the GFX board doesn't send any understandable vertical blank trigger... ...we're screwed! Maybe, and I have no idea how, it's possible to figure out actual clock-cycles for certain commands and then pick the right one to come up with our own time measuring?! This would have to prerun on every machine and spit back out the usuable command for creating delay cycles.
However, I'm pretty underwhelmed right now... in other words: WTF, hahaha! Sorry for the hard shorthand <lol>.

Speak to me! :}

Oh my god I have an idea!!! Oh dear...hopefully that works! I'll report back when I got it running!

Well, I did have a funny idea and it may be interesting at some point, but it would almost require to take care of all the cycles in the loop. I measured (approximately) the amount of increments that would happen inside of one millisecond. Then I took that number by how ever many fractional millisecs I want to wait and somehow needed to take it times 2, but ended up incredibly close to what I wanted. This precision then showed the trouble of having to take in account what else would happen within the loops in terms of operations. I think that's a little on the insane side and frankly believe it's something BlitzMakers should consider "fixing". There must be a better alternative to get a finer timer for such fractional millisecs. Or much rather, is there no way to forcefully aquire vertical blank triggers of GFX boards?

For more accurate timing see here.

EDIT: Also see here, apparently the newer/unusual processors get a bit cocky with hires timers.

Ok, so I found out what the VB problem was and it's openGL related! Using directX prevents that from happening, while I believe to notice that it's perfectly erratic whether it runs faster or slower on than dx on different machine setups... absolutely wild!

HOWEVER, I'll continue posting on my space thread, because there's an update...

More timer reading! Hi-res timing on multi-processor systems is tricky:
http://msdn.microsoft.com/en-us/library/bb173458(VS.85).aspx

This article is worth going through to find out what a minefield it really is! It does come to the conclusion that the functions in the above article are the most reliable, but apparently some older CPUs don't support them, and of course they're not cross-platform:

http://www.geisswerks.com/ryan/FAQS/timing.html

EDIT: Cygnus has done the tricky bit:
High Resolution Timers


This might be down to driver settings possibly -- you can force apps to observe or ignore global settings in most drivers. (Eg. In the current Nvidia Control Panel it's under 3D Settings -> Manage 3D Settings -> Global Settings -> Vertical Sync.)

I was going to suggest high res timers too, but unfortuantely they are not supported on every cpu in exactly the same way. It might be more stable now and in the future, but in 2006 when I used them in my Visual Basic game engine, there were alot of machines that didn't support high res timers.

400 - 440 FPS with 'v' off
60 - 63 FPS with 'v' on

AH, very interesting! Thanks for the link to the highres timer... I'll play around with it a little bit...