Cube to Polygon collision

BlitzMax Forums/MiniB3D Module/Cube to Polygon collision

Hezkore

(Posted 2016) [#1]

Many years ago I asked the same question.
I'm hoping that this time there will be a solution.
Does anyone know how to get Cube to Plygon collision?
Or even just a cube shaped LinePick?

angros47

(Posted 2016) [#2]

You could do it using 8 pivots with sphere-to-polygon collision on cube vertices, and using constraints. There are some examples on how to implement it in Blitz3D by using Verlet formula, but in OpenB3D constraints are now part of the library

markcw

(Posted 2016) [#3]

Ok! Here is an example of what Angros described, adapted from the Minib3d balls_collision.bmx example. I made it rotate the cubes parallel to the camera so they're not always at 0,0,0 rotation.

At the moment it crashes after a while but hopefully that can be fixed [EDIT: sometimes I get the error "double free or corruption" EDIT2: fixed the crashes it was due to freeing entities attached to constraints without also using FreeConstraint - example updated]. I still need to add FreeConstraint and other free functions to the wrapper yet. Collisions aren't perfect but they're not too bad.

I made 8 pivots for each cube corner and constraints applied to all edges and then to the cube itself so it is held in position while collisions occur for each pivot.

' boxes_collision.bmx

Strict

Framework Openb3d.B3dglgraphics
Import Brl.Random

Local width%=800,height%=600,depth%=0,Mode%=2,hertz%=60

Graphics3D width,height,depth,Mode,hertz


' bullet type
Type TBullet

	Global list:TList=CreateList()
	Global no% ' no of bullets
	Field ent:TMesh
	Field x#,y#,z#
	Field vx#,vy#,vz#
	Field life% ' life counter
	Field piv:TPivot[8]
	
	' create bullet
	Function Shoot(x#,y#,z#,nx#,ny#,nz#,rx#,ry#,rz#)
	
		Local bull:TBullet=New TBullet
		no=no+1
		bull.ent=CreateCube()
		EntityColor bull.ent,64+Rand(191),64+Rand(191),64+Rand(191)
		bull.x=x
		bull.y=y
		bull.z=z
		bull.vx=nx
		bull.vy=ny
		bull.vz=nz
		PositionEntity bull.ent,x,y,z,True
		RotateMesh bull.ent,rx,ry,rz
		
		Local surf:TSurface=GetSurface(bull.ent,1)
		bull.piv[0]=CreatePivot()
		PositionEntity bull.piv[0],x+VertexX(surf,0),y+VertexY(surf,0),z+VertexZ(surf,0),True
		bull.piv[1]=CreatePivot()
		PositionEntity bull.piv[1],x+VertexX(surf,1),y+VertexY(surf,1),z+VertexZ(surf,1),True
		bull.piv[2]=CreatePivot()
		PositionEntity bull.piv[2],x+VertexX(surf,2),y+VertexY(surf,2),z+VertexZ(surf,2),True
		bull.piv[3]=CreatePivot()
		PositionEntity bull.piv[3],x+VertexX(surf,3),y+VertexY(surf,3),z+VertexZ(surf,3),True
		bull.piv[4]=CreatePivot()
		PositionEntity bull.piv[4],x+VertexX(surf,4),y+VertexY(surf,4),z+VertexZ(surf,4),True
		bull.piv[5]=CreatePivot()
		PositionEntity bull.piv[5],x+VertexX(surf,5),y+VertexY(surf,5),z+VertexZ(surf,5),True
		bull.piv[6]=CreatePivot()
		PositionEntity bull.piv[6],x+VertexX(surf,6),y+VertexY(surf,6),z+VertexZ(surf,6),True
		bull.piv[7]=CreatePivot()
		PositionEntity bull.piv[7],x+VertexX(surf,7),y+VertexY(surf,7),z+VertexZ(surf,7),True
		
		For Local id%=0 To 7
			EntityType bull.piv[id],1
			EntityRadius bull.piv[id],1
			ResetEntity bull.piv[id]
		Next
		
		' cube center
		Local cc1:TConstraint=CreateConstraint(bull.ent,bull.piv[0],EntityDistance(bull.ent,bull.piv[0]))
		Local cc2:TConstraint=CreateConstraint(bull.ent,bull.piv[1],EntityDistance(bull.ent,bull.piv[1]))
		Local cc3:TConstraint=CreateConstraint(bull.ent,bull.piv[2],EntityDistance(bull.ent,bull.piv[2]))
		Local cc4:TConstraint=CreateConstraint(bull.ent,bull.piv[3],EntityDistance(bull.ent,bull.piv[3]))
		Local cc5:TConstraint=CreateConstraint(bull.ent,bull.piv[4],EntityDistance(bull.ent,bull.piv[4]))
		Local cc6:TConstraint=CreateConstraint(bull.ent,bull.piv[5],EntityDistance(bull.ent,bull.piv[5]))
		Local cc7:TConstraint=CreateConstraint(bull.ent,bull.piv[6],EntityDistance(bull.ent,bull.piv[6]))
		Local cc8:TConstraint=CreateConstraint(bull.ent,bull.piv[7],EntityDistance(bull.ent,bull.piv[7]))
		
		' cube edges
		Local ce1:TConstraint=CreateConstraint(bull.piv[0],bull.piv[1],EntityDistance(bull.piv[0],bull.piv[1]))
		Local ce2:TConstraint=CreateConstraint(bull.piv[1],bull.piv[2],EntityDistance(bull.piv[1],bull.piv[2]))
		Local ce3:TConstraint=CreateConstraint(bull.piv[2],bull.piv[3],EntityDistance(bull.piv[2],bull.piv[3]))
		Local ce4:TConstraint=CreateConstraint(bull.piv[3],bull.piv[0],EntityDistance(bull.piv[3],bull.piv[0]))
		Local ce5:TConstraint=CreateConstraint(bull.piv[4],bull.piv[5],EntityDistance(bull.piv[4],bull.piv[5]))
		Local ce6:TConstraint=CreateConstraint(bull.piv[5],bull.piv[6],EntityDistance(bull.piv[5],bull.piv[6]))
		Local ce7:TConstraint=CreateConstraint(bull.piv[6],bull.piv[7],EntityDistance(bull.piv[6],bull.piv[7]))
		Local ce8:TConstraint=CreateConstraint(bull.piv[7],bull.piv[4],EntityDistance(bull.piv[7],bull.piv[4]))
		Local ce9:TConstraint=CreateConstraint(bull.piv[0],bull.piv[4],EntityDistance(bull.piv[0],bull.piv[4]))
		Local ce10:TConstraint=CreateConstraint(bull.piv[1],bull.piv[5],EntityDistance(bull.piv[1],bull.piv[5]))
		Local ce11:TConstraint=CreateConstraint(bull.piv[2],bull.piv[6],EntityDistance(bull.piv[2],bull.piv[6]))
		Local ce12:TConstraint=CreateConstraint(bull.piv[3],bull.piv[7],EntityDistance(bull.piv[3],bull.piv[7]))
		
		ListAddLast(list,bull)
		
	End Function
	
	' update bullet
	Method Update()
	 
		' life counter is over 600, so bullet hasn't collided with anything for a long time - free it
		If life>600
			ListRemove list,Self
			'FreeEntity ent
			For Local id%=0 To 7
				'FreeEntity piv[id]
			Next
			no=no-1
			Return
		EndIf
		
		life=life+1 ' increase bullet life counter
		
		' apply gravity
		Local GRAVITY#=0.01
		vy=vy-GRAVITY
		
		For Local id%=0 To 7
		
			x=EntityX(piv[id])
			y=EntityY(piv[id])
			z=EntityZ(piv[id])
			
			' check to see if the entity collided with the level
			Local entity_hit% = CountCollisions(piv[id])
			
			' if the entity collided with the level, make it bounce
			If entity_hit
			
				' bullet has collided with level - reset life counter
				life=0
				
				' get the normal of the surface which the entity collided with
				Local nx# = CollisionNX(piv[id],1)
				Local ny# = CollisionNY(piv[id],1)
				Local nz# = CollisionNZ(piv[id],1)
				
				' compute the dot product of the entity's motion vector and the normal of the surface collided with
				Local vdotn# = vx*nx + vy*ny + vz*nz
				
				' calculate the normal force
				Local nfx# = -2.0 * nx * vdotn
				Local nfy# = -2.0 * ny * vdotn 
				Local nfz# = -2.0 * nz * vdotn
				
				' add the normal force to the direction vector.
				vx = vx + nfx
				vy = vy + nfy
				vz = vz + nfz
			EndIf
			
			' update position values
			x=x+vx
			y=y+vy
			z=z+vz
		
			PositionEntity piv[id],x,y,z,True
		Next
		
	End Method
	
End Type


' init
Local cam:TCamera=CreateCamera()
PositionEntity cam,0,10,-10
CameraRange cam,.5,500

Local light:TLight=CreateLight(1)
RotateEntity light,90,0,0

Local mesh:TMesh=LoadMesh("../media/test.b3d")

ScaleMesh mesh,10,10,10

' set collision radius and types
EntityRadius cam,1,1
EntityType cam,1
EntityType mesh,2

' enable collisions
Collisions 1,2,2,2

' used by fps code
Local old_ms%=MilliSecs()
Local renders%, fps%


While Not KeyDown(KEY_ESCAPE)		

	' control camera
	MoveEntity cam,KeyDown(KEY_D)-KeyDown(KEY_A),0,KeyDown(KEY_W)-KeyDown(KEY_S)
	TurnEntity cam,KeyDown(KEY_DOWN)-KeyDown(KEY_UP),KeyDown(KEY_LEFT)-KeyDown(KEY_RIGHT),0
	
	' shoot bullet
	If KeyHit(KEY_SPACE)
		TFormNormal 0,0,0.05,cam,Null
		
		Local px#=EntityX(cam,True), py#=EntityY(cam,True), pz#=EntityZ(cam,True)
		Local nx#=TFormedX(), ny#=TFormedY(), nz#=TFormedZ()
		Local rx#=EntityPitch(cam,True), ry#=EntityYaw(cam,True), rz#=EntityRoll(cam,True)
		
		TBullet.Shoot(px,py,pz,nx,ny,nz,rx,ry,rz)
	EndIf
	
	' update bullets
	For Local bull:TBullet=EachIn TBullet.list
		bull.Update()
	Next
	
	UpdateWorld ' update physics
	RenderWorld
	
	' calculate fps
	renders=renders+1
	If MilliSecs()-old_ms>=1000
		old_ms=MilliSecs()
		fps=renders
		renders=0
	EndIf
	
	Text 0,0,"FPS: "+fps
	Text 0,20,"Press space to shoot a bullet"
	Text 0,40,"No. of bullets: "+TBullet.no
	
	Flip
	
Wend
End

Kryzon

(Posted 2016) [#4]

The cube is made of triangles, and so is your polygon.
The solution becomes doing a triangle-triangle collision test, which is fast. I think this is called doing it "analytically".

angros47

(Posted 2016) [#5]

The command MeshesIntersect can do that test, but is slow, and does not provide a "response " (slide, stop...)

Hezkore

(Posted 2016) [#6]

I've been using LinePicks to get my collisions the way I want, but LinePick uses a radius and is round.
A square LinePick with width and height would be awesome.

Kryzon

(Posted 2016) [#7]

If you have a cuboid (a box) in space, you can simply test if it contains any of the three vertices of a triangle.

If you describe that box with a pivot for its position, rotation and size (treating its scale as a size in 3D units), a simple intersection test would be to transform each vertex of the triangle to the space of the pivot and see if the coordinates of the vertex, in that space, are less than 1.0. You use TFormPoint for that.

In the local space of the box its width, height and depth are always 1.0, but in world space it can be any size that you ScaleEntity it to.

Hezkore

(Posted 2016) [#8]

@munch the cubes are very wobbly and twitchy for some reason.