BGE Cleanup: Removing KX_ObjectProperties, KX_BoundBoxClass, KX_BoxBounds, and KX_CBounds

These were used in BL_CreatePhysicsObjectNew() in the converter. However, all
of the data put into KX_ObjectProperties was then copied again in
KX_ConvertBulletObject(). So, instead KX_ConvertBulletObject() now gathers the
information it needs itself, which avoid this odd double conversion step for
physics.

As a side-effect, the old code would result in static non-mesh objects with no bounds
set to still have triangle mesh bounds. This would result in no bounds for these objects.
If a bounds was set that required a mesh, non-mesh objects would become sphere bounds.
This is now true regardless of whether user bounds were set. In other words, static
non-mesh objects now use sphere bounds by default instead of mesh bounds. This might
slightly alter some games, but these objects should generally be set to No Collision
anyways.

1 files changed, 1 insertions, 330 deletions

diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index 041dde2918f..b5c9f7a9abe 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -1312,121 +1312,6 @@ static float my_boundbox_mesh(Mesh *me, float *loc, float *size)
 	return sqrtf_signed(radius_sq);
 }
 
-
-static void my_tex_space_mesh(Mesh *me)
-{
-	KeyBlock *kb;
-	float *fp, loc[3], size[3], min[3], max[3];
-	int a;
-
-	my_boundbox_mesh(me, loc, size);
-	
-	if (me->texflag & ME_AUTOSPACE) {
-		if (me->key) {
-			kb= me->key->refkey;
-			if (kb) {
-
-				INIT_MINMAX(min, max);
-
-				fp= (float *)kb->data;
-				for (a=0; a<kb->totelem; a++, fp += 3) {
-					minmax_v3v3_v3(min, max, fp);
-				}
-				if (kb->totelem) {
-					loc[0] = (min[0]+max[0])/2.0f; loc[1] = (min[1]+max[1])/2.0f; loc[2] = (min[2]+max[2])/2.0f;
-					size[0] = (max[0]-min[0])/2.0f; size[1] = (max[1]-min[1])/2.0f; size[2] = (max[2]-min[2])/2.0f;
-				}
-				else {
-					loc[0] = loc[1] = loc[2] = 0.0;
-					size[0] = size[1] = size[2] = 0.0;
-				}
-				
-			}
-		}
-
-		copy_v3_v3(me->loc, loc);
-		copy_v3_v3(me->size, size);
-		me->rot[0] = me->rot[1] = me->rot[2] = 0.0f;
-
-		if (me->size[0] == 0.0f) me->size[0] = 1.0f;
-		else if (me->size[0] > 0.0f && me->size[0]< 0.00001f) me->size[0] = 0.00001f;
-		else if (me->size[0] < 0.0f && me->size[0]> -0.00001f) me->size[0] = -0.00001f;
-
-		if (me->size[1] == 0.0f) me->size[1] = 1.0f;
-		else if (me->size[1] > 0.0f && me->size[1]< 0.00001f) me->size[1] = 0.00001f;
-		else if (me->size[1] < 0.0f && me->size[1]> -0.00001f) me->size[1] = -0.00001f;
-
-		if (me->size[2] == 0.0f) me->size[2] = 1.0f;
-		else if (me->size[2] > 0.0f && me->size[2]< 0.00001f) me->size[2] = 0.00001f;
-		else if (me->size[2] < 0.0f && me->size[2]> -0.00001f) me->size[2] = -0.00001f;
-	}
-	
-}
-
-static void my_get_local_bounds(Object *ob, DerivedMesh *dm, float *center, float *size)
-{
-	BoundBox *bb= NULL;
-	/* uses boundbox, function used by Ketsji */
-	switch (ob->type)
-	{
-		case OB_MESH:
-			if (dm)
-			{
-				float min_r[3], max_r[3];
-				INIT_MINMAX(min_r, max_r);
-				dm->getMinMax(dm, min_r, max_r);
-				size[0] = 0.5f * fabsf(max_r[0] - min_r[0]);
-				size[1] = 0.5f * fabsf(max_r[1] - min_r[1]);
-				size[2] = 0.5f * fabsf(max_r[2] - min_r[2]);
-					
-				center[0] = 0.5f * (max_r[0] + min_r[0]);
-				center[1] = 0.5f * (max_r[1] + min_r[1]);
-				center[2] = 0.5f * (max_r[2] + min_r[2]);
-				return;
-			} else
-			{
-				bb= ( (Mesh *)ob->data )->bb;
-				if (bb==0) 
-				{
-					my_tex_space_mesh((struct Mesh *)ob->data);
-					bb= ( (Mesh *)ob->data )->bb;
-				}
-			}
-			break;
-		case OB_CURVE:
-		case OB_SURF:
-			center[0] = center[1] = center[2] = 0.0;
-			size[0]  = size[1]=size[2]=0.0;
-			break;
-		case OB_FONT:
-			center[0] = center[1] = center[2] = 0.0;
-			size[0]  = size[1]=size[2]=1.0;
-			break;
-		case OB_MBALL:
-			bb= ob->bb;
-			break;
-	}
-	
-	if (bb==NULL) 
-	{
-		center[0] = center[1] = center[2] = 0.0;
-		size[0] = size[1] = size[2] = 1.0;
-	}
-	else 
-	{
-		size[0] = 0.5f * fabsf(bb->vec[0][0] - bb->vec[4][0]);
-		size[1] = 0.5f * fabsf(bb->vec[0][1] - bb->vec[2][1]);
-		size[2] = 0.5f * fabsf(bb->vec[0][2] - bb->vec[1][2]);
-
-		center[0] = 0.5f * (bb->vec[0][0] + bb->vec[4][0]);
-		center[1] = 0.5f * (bb->vec[0][1] + bb->vec[2][1]);
-		center[2] = 0.5f * (bb->vec[0][2] + bb->vec[1][2]);
-	}
-}
-	
-
-
-
 //////////////////////////////////////////////////////
 
 
@@ -1524,230 +1409,16 @@ static void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj,
 	
 	PHY_MaterialProps* smmaterial = 
 		CreateMaterialFromBlenderObject(blenderobject);
-					
-	KX_ObjectProperties objprop;
-	objprop.m_lockXaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_X_AXIS) !=0;
-	objprop.m_lockYaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_Y_AXIS) !=0;
-	objprop.m_lockZaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_Z_AXIS) !=0;
-	objprop.m_lockXRotaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_X_ROT_AXIS) !=0;
-	objprop.m_lockYRotaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_Y_ROT_AXIS) !=0;
-	objprop.m_lockZRotaxis = (blenderobject->gameflag2 & OB_LOCK_RIGID_BODY_Z_ROT_AXIS) !=0;
-
-	objprop.m_isCompoundChild = isCompoundChild;
-	objprop.m_hasCompoundChildren = hasCompoundChildren;
-	objprop.m_margin = blenderobject->margin;
-	
-	// ACTOR is now a separate feature
-	objprop.m_isactor = (blenderobject->gameflag & OB_ACTOR)!=0;
-	objprop.m_dyna = (blenderobject->gameflag & OB_DYNAMIC) != 0;
-	objprop.m_softbody = (blenderobject->gameflag & OB_SOFT_BODY) != 0;
-	objprop.m_angular_rigidbody = (blenderobject->gameflag & OB_RIGID_BODY) != 0;
-	objprop.m_character = (blenderobject->gameflag & OB_CHARACTER) != 0;
-	objprop.m_record_animation = (blenderobject->gameflag & OB_RECORD_ANIMATION) != 0;
-	
-	///contact processing threshold is only for rigid bodies and static geometry, not 'dynamic'
-	if (objprop.m_angular_rigidbody || !objprop.m_dyna )
-	{
-		objprop.m_contactProcessingThreshold = blenderobject->m_contactProcessingThreshold;
-	} else
-	{
-		objprop.m_contactProcessingThreshold = 0.f;
-	}
 
-	objprop.m_sensor = (blenderobject->gameflag & OB_SENSOR) != 0;
-	
-	if (objprop.m_softbody)
-	{
-		///for game soft bodies
-		if (blenderobject->bsoft)
-		{
-			objprop.m_gamesoftFlag = blenderobject->bsoft->flag;
-					///////////////////
-			objprop.m_soft_linStiff = blenderobject->bsoft->linStiff;
-			objprop.m_soft_angStiff = blenderobject->bsoft->angStiff;		/* angular stiffness 0..1 */
-			objprop.m_soft_volume= blenderobject->bsoft->volume;			/* volume preservation 0..1 */
-
-			objprop.m_soft_viterations= blenderobject->bsoft->viterations;		/* Velocities solver iterations */
-			objprop.m_soft_piterations= blenderobject->bsoft->piterations;		/* Positions solver iterations */
-			objprop.m_soft_diterations= blenderobject->bsoft->diterations;		/* Drift solver iterations */
-			objprop.m_soft_citerations= blenderobject->bsoft->citerations;		/* Cluster solver iterations */
-
-			objprop.m_soft_kSRHR_CL= blenderobject->bsoft->kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
-			objprop.m_soft_kSKHR_CL= blenderobject->bsoft->kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
-			objprop.m_soft_kSSHR_CL= blenderobject->bsoft->kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
-			objprop.m_soft_kSR_SPLT_CL= blenderobject->bsoft->kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
-
-			objprop.m_soft_kSK_SPLT_CL= blenderobject->bsoft->kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
-			objprop.m_soft_kSS_SPLT_CL= blenderobject->bsoft->kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
-			objprop.m_soft_kVCF= blenderobject->bsoft->kVCF;			/* Velocities correction factor (Baumgarte) */
-			objprop.m_soft_kDP= blenderobject->bsoft->kDP;			/* Damping coefficient [0,1] */
-
-			objprop.m_soft_kDG= blenderobject->bsoft->kDG;			/* Drag coefficient [0,+inf] */
-			objprop.m_soft_kLF= blenderobject->bsoft->kLF;			/* Lift coefficient [0,+inf] */
-			objprop.m_soft_kPR= blenderobject->bsoft->kPR;			/* Pressure coefficient [-inf,+inf] */
-			objprop.m_soft_kVC= blenderobject->bsoft->kVC;			/* Volume conversation coefficient [0,+inf] */
-
-			objprop.m_soft_kDF= blenderobject->bsoft->kDF;			/* Dynamic friction coefficient [0,1] */
-			objprop.m_soft_kMT= blenderobject->bsoft->kMT;			/* Pose matching coefficient [0,1] */
-			objprop.m_soft_kCHR= blenderobject->bsoft->kCHR;			/* Rigid contacts hardness [0,1] */
-			objprop.m_soft_kKHR= blenderobject->bsoft->kKHR;			/* Kinetic contacts hardness [0,1] */
-
-			objprop.m_soft_kSHR= blenderobject->bsoft->kSHR;			/* Soft contacts hardness [0,1] */
-			objprop.m_soft_kAHR= blenderobject->bsoft->kAHR;			/* Anchors hardness [0,1] */
-			objprop.m_soft_collisionflags= blenderobject->bsoft->collisionflags;	/* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
-			objprop.m_soft_numclusteriterations= blenderobject->bsoft->numclusteriterations;	/* number of iterations to refine collision clusters*/
-			//objprop.m_soft_welding = blenderobject->bsoft->welding;		/* welding */
-			/* disable welding: it doesn't bring any additional stability and it breaks the relation between soft body collision shape and graphic mesh */
-			objprop.m_soft_welding = 0.f;
-			objprop.m_margin = blenderobject->bsoft->margin;
-			objprop.m_contactProcessingThreshold = 0.f;
-		} else
-		{
-			objprop.m_gamesoftFlag = OB_BSB_BENDING_CONSTRAINTS | OB_BSB_SHAPE_MATCHING | OB_BSB_AERO_VPOINT;
-			
-			objprop.m_soft_linStiff = 0.5;
-			objprop.m_soft_angStiff = 1.f;		/* angular stiffness 0..1 */
-			objprop.m_soft_volume= 1.f;			/* volume preservation 0..1 */
-
-
-			objprop.m_soft_viterations= 0;
-			objprop.m_soft_piterations= 1;
-			objprop.m_soft_diterations= 0;
-			objprop.m_soft_citerations= 4;
-
-			objprop.m_soft_kSRHR_CL= 0.1f;
-			objprop.m_soft_kSKHR_CL= 1.f;
-			objprop.m_soft_kSSHR_CL= 0.5;
-			objprop.m_soft_kSR_SPLT_CL= 0.5f;
-
-			objprop.m_soft_kSK_SPLT_CL= 0.5f;
-			objprop.m_soft_kSS_SPLT_CL= 0.5f;
-			objprop.m_soft_kVCF=  1;
-			objprop.m_soft_kDP= 0;
-
-			objprop.m_soft_kDG= 0;
-			objprop.m_soft_kLF= 0;
-			objprop.m_soft_kPR= 0;
-			objprop.m_soft_kVC= 0;
-
-			objprop.m_soft_kDF= 0.2f;
-			objprop.m_soft_kMT= 0.05f;
-			objprop.m_soft_kCHR= 1.0f;
-			objprop.m_soft_kKHR= 0.1f;
-
-			objprop.m_soft_kSHR= 1.f;
-			objprop.m_soft_kAHR= 0.7f;
-			objprop.m_soft_collisionflags= OB_BSB_COL_SDF_RS + OB_BSB_COL_VF_SS;
-			objprop.m_soft_numclusteriterations= 16;
-			objprop.m_soft_welding = 0.f;
-			objprop.m_margin = 0.f;
-			objprop.m_contactProcessingThreshold = 0.f;
-		}
-	}
-
-	objprop.m_ghost = (blenderobject->gameflag & (OB_GHOST | OB_SENSOR | OB_CHARACTER)) != 0;
-	objprop.m_disableSleeping = (blenderobject->gameflag & OB_COLLISION_RESPONSE) != 0;//abuse the OB_COLLISION_RESPONSE flag
-	//mmm, for now, taks this for the size of the dynamicobject
-	// Blender uses inertia for radius of dynamic object
-	objprop.m_radius = blenderobject->inertia;
-	objprop.m_in_active_layer = (blenderobject->lay & activeLayerBitInfo) != 0;
-	objprop.m_dynamic_parent=NULL;
-	objprop.m_isdeformable = ((blenderobject->gameflag2 & 2)) != 0;
-	objprop.m_boundclass = objprop.m_dyna?KX_BOUNDSPHERE:KX_BOUNDMESH;
-	
-	if ((blenderobject->gameflag & OB_SOFT_BODY) && !(blenderobject->gameflag & OB_BOUNDS))
-	{
-		objprop.m_boundclass = KX_BOUNDMESH;
-	}
-
-	if ((blenderobject->gameflag & OB_CHARACTER) && !(blenderobject->gameflag & OB_BOUNDS))
-	{
-		objprop.m_boundclass = KX_BOUNDSPHERE;
-	}
-
-	KX_BoxBounds bb;
 	DerivedMesh* dm = NULL;
 	if (gameobj->GetDeformer())
 		dm = gameobj->GetDeformer()->GetPhysicsMesh();
-	my_get_local_bounds(blenderobject,dm,objprop.m_boundobject.box.m_center,bb.m_extends);
-	if (blenderobject->gameflag & OB_BOUNDS)
-	{
-		switch (blenderobject->collision_boundtype)
-		{
-			case OB_BOUND_BOX:
-				objprop.m_boundclass = KX_BOUNDBOX;
-				//mmm, has to be divided by 2 to be proper extends
-				objprop.m_boundobject.box.m_extends[0]=2.f*bb.m_extends[0];
-				objprop.m_boundobject.box.m_extends[1]=2.f*bb.m_extends[1];
-				objprop.m_boundobject.box.m_extends[2]=2.f*bb.m_extends[2];
-				break;
-			case OB_BOUND_CONVEX_HULL:
-				if (blenderobject->type == OB_MESH)
-				{
-					objprop.m_boundclass = KX_BOUNDPOLYTOPE;
-					break;
-				}
-				// Object is not a mesh... fall through OB_BOUND_TRIANGLE_MESH to
-				// OB_BOUND_SPHERE
-			case OB_BOUND_TRIANGLE_MESH:
-				if (blenderobject->type == OB_MESH)
-				{
-					objprop.m_boundclass = KX_BOUNDMESH;
-					break;
-				}
-				// Object is not a mesh... can't use polyhedron.
-				// Fall through and become a sphere.
-			case OB_BOUND_SPHERE:
-			{
-				objprop.m_boundclass = KX_BOUNDSPHERE;
-				objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], MT_max(bb.m_extends[1], bb.m_extends[2]));
-				break;
-			}
-			case OB_BOUND_CYLINDER:
-			{
-				objprop.m_boundclass = KX_BOUNDCYLINDER;
-				objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], bb.m_extends[1]);
-				objprop.m_boundobject.c.m_height = 2.f*bb.m_extends[2];
-				break;
-			}
-			case OB_BOUND_CONE:
-			{
-				objprop.m_boundclass = KX_BOUNDCONE;
-				objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], bb.m_extends[1]);
-				objprop.m_boundobject.c.m_height = 2.f*bb.m_extends[2];
-				break;
-			}
-			case OB_BOUND_CAPSULE:
-			{
-				objprop.m_boundclass = KX_BOUNDCAPSULE;
-				objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], bb.m_extends[1]);
-				objprop.m_boundobject.c.m_height = 2.f*(bb.m_extends[2]-objprop.m_boundobject.c.m_radius);
-				if (objprop.m_boundobject.c.m_height < 0.f)
-					objprop.m_boundobject.c.m_height = 0.f;
-				break;
-			}
-		}
-	}
-
-	
-	if (parent/* && (parent->gameflag & OB_DYNAMIC)*/) {
-		// parented object cannot be dynamic
-		KX_GameObject *parentgameobject = converter->FindGameObject(parent);
-		objprop.m_dynamic_parent = parentgameobject;
-		//cannot be dynamic:
-		objprop.m_dyna = false;
-		objprop.m_softbody = false;
-		shapeprops->m_mass = 0.f;
-	}
-
-	
-	objprop.m_concave = (blenderobject->collision_boundtype == OB_BOUND_TRIANGLE_MESH);
 	
 	switch (physics_engine)
 	{
 #ifdef WITH_BULLET
 		case UseBullet:
-			KX_ConvertBulletObject(gameobj, meshobj, dm, kxscene, shapeprops, smmaterial, &objprop);
+			KX_ConvertBulletObject(gameobj, meshobj, dm, kxscene, shapeprops, smmaterial, activeLayerBitInfo, isCompoundChild, hasCompoundChildren);
 			break;
 
 #endif