Rotating a 'quad' .. How to?

What funky maths do I need to successfully rotate a quad?
In the example below I'm using Sin/Cos to rotate 4 vertices by around 360 degrees.
As you press SPACE in the example you'll see the quad snap into a larger version then shrink and grow as it rotates.
How do I prevent this from happening?

For reference the quad is constructed/displayed like this:

-1 +1             +1 +1
       2--------3
       |        |
       |        |
       |        |
       0--------1
-1 -1             +1 -1

; Quad (rotating)

Graphics3D 640,480,0,2
SetBuffer BackBuffer()

HidePointer

cam=CreateCamera()
MoveEntity cam,0,0,-6.5
MoveMouse 320,240

; container for quads
quad=CreateMesh()
surf=CreateSurface(quad)
EntityFX quad,1+2+32

; texture for quads
;tex=LoadTexture("testimage.png")
;EntityTexture quad,tex

;For d=1 To 500
;  q=AddQuad(surf,Rnd(-10,10),Rnd(-10,10),Rnd(25))
;  QuadColor surf,q,Rand(255),Rand(255),Rand(255) , Rnd(1.0)
;Next

mainquad=AddQuad(surf,0,0)

; ==================================================

Repeat

	If KeyHit(17) ;[W]
		w=Not w
		WireFrame w
	EndIf

	If KeyDown(57) ; [SPACE]
		rotang#=rotang#+1.5
		RotateQuad surf,mainquad,rotang
	EndIf
	
	mx#=mx#+Float(MouseXSpeed())/16.0
	my#=my#-Float(MouseYSpeed())/16.0
	MoveMouse 320,240

	PositionQuad surf,mainquad,mx,my,0

	RenderWorld

	Color 100,100,100
	Text 20,40,"[MOUSE] = move main quad"
	Text 20,60,"[SPACE] = rotate main quad"
	Text 20,80,"[W] = Wireframe"
	Text 80,130,"Angle# = "+rotang

	; reference box	
	Color 200,0,0
	Rect 320,140,100,100,0
	Flip

Until KeyHit(1)

End

; ==================================================

Function AddQuad%(s%,x#,y#,z#=0)
	Local o%,v%
	v=AddVertex(s,x-1,y-1,z ,0.0,1.0)
	AddVertex s,x+1,y-1,z , 1.0,1.0
	AddVertex s,x-1,y+1,z , 0.0,0.0
	AddVertex s,x+1,y+1,z , 1.0,0.0
	AddTriangle s,v+0,v+2,v+1
	AddTriangle s,v+1,v+2,v+3
	For o=0 To 3
		VertexNormal s,v+0,0,0,-1
	Next
	Return v
End Function

Function QuadColor(s%,i%,r%,g%,b%,a#=1.0)
	Local o%
	For o=0 To 3
		VertexColor s,i+o,r,g,b,a
	Next
End Function

Function PositionQuad(s%,i%,x#,y#,z#=0.0)
	Local dx#,dy#,dz# , o%
	dx=x-VertexX(s,i)
	dy=y-VertexY(s,i)
	dz=z-VertexZ(s,i)
	For o=0 To 3
		VertexCoords s,i+o,VertexX(s,i+o)+dx,VertexY(s,i+o)+dy,VertexZ(s,i+o)+dz
	Next
End Function

Function RotateQuad(s,i,ang#)
	x#=VertexX(s,i+0)+1 : y#=VertexY(s,i+0)+1
	VertexCoords s,i+0,(x-0.5)-Sin(ang+45),(y-0.5)-Cos(ang+45),VertexZ(s,i+0)
	VertexCoords s,i+1,(x+0.5)+Cos(ang+45),(y-0.5)-Sin(ang+45),VertexZ(s,i+1)
	VertexCoords s,i+2,(x-0.5)-Cos(ang+45),(y+0.5)+Sin(ang+45),VertexZ(s,i+2)
	VertexCoords s,i+3,(x+0.5)+Sin(ang+45),(y+0.5)+Cos(ang+45),VertexZ(s,i+3)
End Function

You need to take each dimension into account for each dimension you're rotating.

So in 2d, you need to take both X and Y into account for both rotations. (In other words, it's a 3d tform still, just applied on the Z-axis)

Something like,

Function rotate_x#(x#,y#,roll#)
	Return(Cos(roll)*x+Sin(roll)*y)
End Function

Function rotate_y#(x#,y#,roll#)
	Return(-Sin(roll)*x+Cos(roll)*y)
End Function

thanks guys, I was wondering how to deal withit myself.

Jim,

Where you able to apply Anthony's Functions?

Got it working. Thankyou kindly Antony

; Quad (rotating)

Graphics3D 640,480,0,2
SetBuffer BackBuffer()

HidePointer

cam=CreateCamera()
MoveEntity cam,0,0,-6.5
MoveMouse 320,240

; container for quads
quad=CreateMesh()
surf=CreateSurface(quad)
EntityFX quad,1+2+32

; texture for quads
;tex=LoadTexture("testimage.png")
;EntityTexture quad,tex

;For d=1 To 500
;  q=AddQuad(surf,Rnd(-10,10),Rnd(-10,10),Rnd(25))
;  QuadColor surf,q,Rand(255),Rand(255),Rand(255) , Rnd(1.0)
;Next

mainquad=AddQuad(surf,0,0)

; ==================================================

Repeat

	If KeyHit(17) ;[W]
		w=Not w
		WireFrame w
	EndIf

	If KeyDown(57) ; [SPACE]
		rotang#=rotang#+1.5
		RotateQuad surf,mainquad,rotang
	EndIf
	
	mx#=mx#+Float(MouseXSpeed())/16.0
	my#=my#-Float(MouseYSpeed())/16.0
	MoveMouse 320,240

	PositionQuad surf,mainquad,mx,my,0

	RenderWorld

	Color 100,100,100
	Text 20,40,"[MOUSE] = move main quad"
	Text 20,60,"[SPACE] = rotate main quad"
	Text 20,80,"[W] = Wireframe"
	Text 80,130,"Angle# = "+rotang

	; reference box	
	Color 200,0,0
	Rect 320,140,100,100,0
	Flip

Until KeyHit(1)

End

; ==================================================

Function AddQuad%(s%,x#,y#,z#=0)
	Local o%,v%
	v=AddVertex(s,x-1,y-1,z ,0.0,1.0)
	AddVertex s,x+1,y-1,z , 1.0,1.0
	AddVertex s,x-1,y+1,z , 0.0,0.0
	AddVertex s,x+1,y+1,z , 1.0,0.0
	AddTriangle s,v+0,v+2,v+1
	AddTriangle s,v+1,v+2,v+3
	For o=0 To 3
		VertexNormal s,v+0,0,0,-1
	Next
	Return v
End Function

Function QuadColor(s%,i%,r%,g%,b%,a#=1.0)
	Local o%
	For o=0 To 3
		VertexColor s,i+o,r,g,b,a
	Next
End Function

Function PositionQuad(s%,i%,x#,y#,z#=0.0)
	Local dx#,dy#,dz# , o%
	dx=x-VertexX(s,i)
	dy=y-VertexY(s,i)
	dz=z-VertexZ(s,i)
	For o=0 To 3
		VertexCoords s,i+o,VertexX(s,i+o)+dx,VertexY(s,i+o)+dy,VertexZ(s,i+o)+dz
	Next
End Function

Function RotateQuad(s,i,ang#)
	x#=VertexX(s,i+0)+1 : y#=VertexY(s,i+0)+1
	VertexCoords s,i+0,rotX(x-1.0,y-1.0,ang),rotY(x-1.0,y-1.0,ang),VertexZ(s,i+0)
	VertexCoords s,i+1,rotX(x+1.0,y-1.0,ang),rotY(x+1.0,y-1.0,ang),VertexZ(s,i+0)
	VertexCoords s,i+2,rotX(x-1.0,y+1.0,ang),rotY(x-1.0,y+1.0,ang),VertexZ(s,i+0)
	VertexCoords s,i+3,rotX(x+1.0,y+1.0,ang),rotY(x+1.0,y+1.0,ang),VertexZ(s,i+0)
End Function

Function rotX#(x#,y#,roll#)
	Return Cos(roll)*x+Sin(roll)*y
End Function

Function rotY#(x#,y#,roll#)
	Return -Sin(roll)*x+Cos(roll)*y
End Function

Stole some functions from here. Modified the functions to work with unspecified number of vertices. I deliberately altered the quad shape to demonstrate.

; Quad (rotating)

Graphics3D 640,480,0,2
SetBuffer BackBuffer()

HidePointer

cam=CreateCamera()
MoveEntity cam,0,0,-6.5
MoveMouse 320,240

; container for quads
quad=CreateMesh()
surf=CreateSurface(quad)
EntityFX quad,1+2+32

; texture for quads
;tex=LoadTexture("testimage.png")
;EntityTexture quad,tex

;For d=1 To 500
;  q=AddQuad(surf,Rnd(-10,10),Rnd(-10,10),Rnd(25))
;  QuadColor surf,q,Rand(255),Rand(255),Rand(255) , Rnd(1.0)
;Next

mainquad=AddQuad(surf,0,0)

; ==================================================

Repeat

	If KeyHit(17) ;[W]
		w=Not w
		WireFrame w
	EndIf

	If KeyDown(57) ; [SPACE]
		RotateQuad surf,mainquad,1.5
	EndIf
	
	mx#=mx#+Float(MouseXSpeed())/16.0
	my#=my#-Float(MouseYSpeed())/16.0
	MoveMouse 320,240

	PositionQuad surf,mainquad,mx,my,0

	RenderWorld

	Color 100,100,100
	Text 20,40,"[MOUSE] = move main quad"
	Text 20,60,"[SPACE] = rotate main quad"
	Text 20,80,"[W] = Wireframe"
	Text 80,130,"Angle# = "+rotang

	; reference box	
	Color 200,0,0
	Rect 320,140,100,100,0
	Flip

Until KeyHit(1)

End

; ==================================================

Function AddQuad%(s%,x#,y#,z#=0)
	Local o%,v%
	v=AddVertex(s,x-1,y-1,z ,0.0,1.0)
	AddVertex s,x+2,y-1,z , 1.0,1.0
	AddVertex s,x-1,y+1,z , 0.0,0.0
	AddVertex s,x+1,y+1,z , 1.0,0.0
	AddTriangle s,v+0,v+2,v+1
	AddTriangle s,v+1,v+2,v+3
	For o=0 To 3
		VertexNormal s,v+0,0,0,-1
	Next
	Return v
End Function

Function QuadColor(s%,i%,r%,g%,b%,a#=1.0)
	Local o%
	For o=0 To 3
		VertexColor s,i+o,r,g,b,a
	Next
End Function

Function PositionQuad(s%,i%,x#,y#,z#=0.0)
	Local dx#,dy#,dz# , o%
	dx=x-VertexX(s,i)
	dy=y-VertexY(s,i)
	dz=z-VertexZ(s,i)
	For o=0 To 3
		VertexCoords s,i+o,VertexX(s,i+o)+dx,VertexY(s,i+o)+dy,VertexZ(s,i+o)+dz
	Next
End Function

Function RotateQuad(s,i,ang#)
	For v% = i To i+3
		RotateZ(s,v,ang#)
	Next
End Function

Function RotateZ(s,v,ang#) 
	VertexCoords s,v,(Cos (ang#) * VertexX(s,v)) - (Sin (ang#) * VertexY(s,v%)),(Sin (ang#) * VertexX(s,v)) + (Cos (ang#) * VertexY(s,v%)),VertexZ(s,v%) 
End Function 

Function RotateY(s,v,ang#)
	VertexCoords s,v,(Cos (ang#) * VertexX(s,v)) + (Sin (ang#) * VertexZ(s,v%)),VertexY(s,v%),-(Sin (ang#) * VertexX(s,v)) + (Cos (ang#) * VertexZ(s,v%)) 
End Function

Function RotateX(s,v,ang#)
	VertexCoords s,v,VertexX(s,v%),(Cos (ang#) * VertexY(s,v%)) - (Sin (ang#) * VertexZ(s,v%)) ,(Sin (ang#) * VertexY(s,v%)) + (Cos (ang#) * VertexZ(s,v%))
End Function

Nice. That's a little faster too.
Plus, as you demonstrate, the quad can be warped and still rotate correctly.

Use TFormPoint, it makes for much simpler code.

Or copy the quad's verts into a separate, pre-made quad mesh, RotateMesh, then copy the verts back. This has the benefit of doing hardware accelorated rotations instead of doing it in software with those slow cos/sin calls. Of course, there's still going to be some overhead having to do the vertex copying, but I'm pretty sure it'll still be faster.

I doubt that making a new mesh to rotate four vertices will be faster.

Also even if the mesh has a thousand vertices I doubt it will be faster.

In fact, I doubt that rotatemesh uses hardware transformations at all. :-)

You dont make a new 4-vert mesh, use it then destroy it every time; you just make the mesh at the start and re-use it.

I used this technique for the exploding mesh demo I did and found it was pretty fast.


Why wouldn't it? If it doesn't, what commands do?

due to compatibility behavior of Blitz3D:

don't think any others than cubemapping, dot3 and blendmode 5 ...

Making a quad and using it for rotations is definitely slower than using good math ( optimized with sin/cos arrays ) on vertices.
Tform commands are also ( some of them much ) slower than plain math coded for particular case.
Believe me, I have spent a LOT of hours on finding fastest ways for dealing with single surface/quad systems.

"Why wouldn't it? If it doesn't, what commands do?"

The data needs to be available in ram for fast access, so even if it is calculated on the card it still needs to be downloaded to main ram.

As for what commands use hardware transformation... I don't know if any do. But if any do, then I'd guess that the bone animations commands do, and that is why you don't have access to the modified vertex locations... Because downloading those from the card as they are changed by the hardware would slow down animation so much that it's not worth it. That would explain why that data is not available to us, but normal mesh rotations and vertex location changes are.

"Tform commands are also ( some of them much ) slower than plain math coded for particular case."

Yes but I don't think that the speed difference would actually affect the speed of your average game, and the code is a lot easier to understand and make changes to than a bunch of sin/cos commands, which is why I suggested that method.

Trix, I'm still not 100% convinced, tbh. I'm sure I tried my demo using Birdie's TurnTriangle function and found it to be slower. Although, I don't think Birdie's function used sin/cos lookup tables but LUTs seem to be of limited use with modern CPUs.

Got any demo code that'll convince me? :)

Which is faster accessing vertex data using Blitz Commands EntityX(e), VertexX(s,i), etc -OR- Storing and accessing data in variables (ie MyEntityX#). It seems like a waste of additional memory to use variables when the data can be accessed from the entity itself. However, I dont mind using variables if there is a speed advantage.

I agree, but if you are using them 500 times in a frame it may be well worth to replace them with plain math. My particle system gained at least 20% more FPS by eliminating Tform commands.
@big10p : Soon...