Coll.cpp

				Mesh& mesh = triObj->GetMesh();
				switch (bvType)
				{
				case bv_type_box:
					shape = makeProxyBoxShape(node, obj, mesh, tm);
					break;

				//case bv_type_sphere:
				//	shape = makeProxySphereShape(node, obj, mesh, tm);
				//	break;

				case bv_type_shapes:
					shape = makeProxyTriStripShape(node, obj, mesh, tm);
					break;

				case bv_type_packed:
					shape = makeProxyPackedTriStripShape(node, obj, mesh, tm);
					break;

				case bv_type_convex: 
					shape = makeProxyConvexShape(node, obj, mesh, tm);
					break;
				}
			}
		}
	}
	return shape;
}

bhkShapeRef	Exporter::makeProxyBoxShape(INode *node, Object *obj, Mesh& mesh, Matrix3& tm)
{
	enum { list_params, bv_mesh, };  // pblock2 ID
	enum { PB_MATERIAL, PB_MESHLIST, PB_BOUND_TYPE, PB_CENTER, };
	enum { bv_type_none, bv_type_box, bv_type_shapes, bv_type_packed, bv_type_convex, };  // pblock ID

	bhkShapeRef retval;
	if (IParamBlock2* pblock2 = obj->GetParamBlockByID(list_params))
	{
		Box3 box; box.Init();
		CalcAxisAlignedBox(mesh, box, NULL);

		int mtl = 0;
		float length = 0, width = 0, height = 0;
		pblock2->GetValue(PB_MATERIAL, 0, mtl, FOREVER, 0);

		bhkBoxShapeRef shape = new bhkBoxShape();
		Vector3 dim(box.Max().x-box.Min().x, box.Max().y-box.Min().y, box.Max().z-box.Min().z);
		dim /= (Exporter::bhkScaleFactor * 2);

		shape->SetMaterial(HavokMaterial(mtl));
		shape->SetDimensions(dim);

		Matrix3 ltm = /*GetLocalTM(node) * */TransMatrix(box.Center()) * tm;
		if (ltm.IsIdentity())
		{
			retval = StaticCast<bhkShape>(shape);
		}
		else
		{
			ltm.SetTrans(ltm.GetTrans() / Exporter::bhkScaleFactor);

			bhkTransformShapeRef transform = new bhkTransformShape();
			transform->SetTransform(TOMATRIX4(ltm).Transpose());
			transform->SetShape(shape);
			transform->SetMaterial(HavokMaterial(mtl));
			retval = StaticCast<bhkShape>(transform);
		}
	}
	return retval;
}

bhkShapeRef	Exporter::makeProxySphereShape(INode *node, Object *obj, Mesh& mesh, Matrix3& tm)
{
	enum { list_params, bv_mesh, };  // pblock2 ID
	enum { PB_MATERIAL, PB_MESHLIST, PB_BOUND_TYPE, PB_CENTER, };
	enum { bv_type_none, bv_type_box, bv_type_shapes, bv_type_packed, bv_type_convex, };  // pblock ID

	bhkShapeRef shape;
	if (IParamBlock2* pblock2 = obj->GetParamBlockByID(list_params))
	{
		//Matrix3 tm = GetLocalTM(node) * TransMatrix(box.Center());

	}
	return shape;
}

bhkShapeRef	Exporter::makeProxyConvexShape(INode *node, Object *obj, Mesh& mesh, Matrix3& tm)
{
	enum { list_params, bv_mesh, };  // pblock2 ID
	enum { PB_MATERIAL, PB_MESHLIST, PB_BOUND_TYPE, PB_CENTER, };
	enum { bv_type_none, bv_type_box, bv_type_shapes, bv_type_packed, bv_type_convex, };  // pblock ID

	bhkShapeRef shape;
	if (IParamBlock2* pblock2 = obj->GetParamBlockByID(list_params))
	{
		if (bhkConvexVerticesShapeRef convShape = makeConvexShape(mesh, tm))
		{
			int mtl = pblock2->GetInt(PB_MATERIAL, 0, 0);
			convShape->SetMaterial(HavokMaterial(mtl));
			shape = StaticCast<bhkShape>(convShape);
		}
	}
	return shape;
}

bhkShapeRef	Exporter::makeProxyTriStripShape(INode *node, Object *obj, Mesh& mesh, Matrix3& tm)
{
	enum { list_params, bv_mesh, };  // pblock2 ID
	enum { PB_MATERIAL, PB_MESHLIST, PB_BOUND_TYPE, PB_CENTER, };
	enum { bv_type_none, bv_type_box, bv_type_shapes, bv_type_packed, bv_type_convex, };  // pblock ID

	bhkShapeRef shape;
	if (IParamBlock2* pblock2 = obj->GetParamBlockByID(list_params))
	{
		int mtl = pblock2->GetInt(PB_MATERIAL, 0, 0);

		// Transform location
		Mesh localmesh(mesh);
		MNMesh tmpMesh(localmesh);
		tmpMesh.Transform(tm);
		tmpMesh.buildNormals();
		tmpMesh.OutToTri(localmesh);
		localmesh.buildNormals();

		Matrix3 ident(true);
		bhkNiTriStripsShapeRef trishape = makeTriStripsShape(localmesh, ident);
		trishape->SetMaterial(HavokMaterial(mtl));

		shape = StaticCast<bhkShape>(trishape);
	}
	return shape;
}

bhkShapeRef	Exporter::makeProxyPackedTriStripShape(INode *node, Object *obj, Mesh& mesh, Matrix3& tm)
{
	enum { list_params, bv_mesh, };  // pblock2 ID
	enum { PB_MATERIAL, PB_MESHLIST, PB_BOUND_TYPE, PB_CENTER, };
	enum { bv_type_none, bv_type_box, bv_type_shapes, bv_type_packed, bv_type_convex, };  // pblock ID

	bhkShapeRef shape;
	if (IParamBlock2* pblock2 = obj->GetParamBlockByID(list_params))
	{
		int mtl = pblock2->GetInt(PB_MATERIAL, 0, 0);

		// Transform location
		Mesh localmesh(mesh);
		MNMesh tmpMesh(localmesh);
		tmpMesh.Transform(tm);
		tmpMesh.buildNormals();
		tmpMesh.OutToTri(localmesh);
		localmesh.buildNormals();

		Matrix3 ident(true);
		bhkPackedNiTriStripsShapeRef trishape = makePackedTriStripsShape(localmesh, ident);
		if ( TheHavokCode.Initialize() )
			shape = StaticCast<bhkShape>( makeTreeShape(trishape) );
		else
			shape = StaticCast<bhkShape>(trishape);
	}
	return shape;
}

bhkShapeRef	Exporter::makeModifierShape(INode *node, Object* obj, Modifier* mod, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID

	bhkShapeRef shape;

	const Mesh* mesh = NULL;
	int material = NP_DEFAULT_HVK_MATERIAL;
	int type = bv_type_none;

	node->EvalWorldState(0);
	if (bhkHelperInterface* bhkHelp = (bhkHelperInterface*)mod->GetInterface(BHKHELPERINTERFACE_DESC))
	{
		mesh = bhkHelp->GetMesh();
	}
	else
	{
		if (TriObject *tri = (TriObject *)obj->ConvertToType(0, Class_ID(TRIOBJ_CLASS_ID, 0)))
		{
			mesh = &tri->GetMesh();
		}
	}
	if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
	{
		pblock2->GetValue(PB_BOUND_TYPE, 0, type, FOREVER, 0);
		pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
	}
	switch (type)
	{
	default:
	case bv_type_none:
		break;

	case bv_type_box:
		shape = makeModBoxShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;

	case bv_type_sphere:
		shape = makeModSphereShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;

	case bv_type_capsule:
		shape = makeModCapsuleShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;

	case bv_type_shapes:
		shape = makeModTriStripShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;

	case bv_type_convex:
		shape = makeModConvexShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;

	case bv_type_packed:
		shape = makeModPackedTriStripShape(node, mod, const_cast<Mesh&>(*mesh), tm);
		break;
	}
	return shape;
}

bhkShapeRef	Exporter::makeModBoxShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
	{
		pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
	}

	bhkShapeRef retval;
	if (bhkBoxShapeRef shape = new bhkBoxShape())
	{
		Box3 box; box.Init();
		CalcAxisAlignedBox(mesh, box, NULL);

		Vector3 dim(box.Max().x-box.Min().x, box.Max().y-box.Min().y, box.Max().z-box.Min().z);
		dim /= (Exporter::bhkScaleFactor * 2);
		shape->SetDimensions(dim);
		shape->SetMaterial(HavokMaterial(material));

		Matrix3 ltm = TransMatrix(box.Center()) * node->GetNodeTM(0) * tm;
		if (ltm.IsIdentity())
		{
			retval = StaticCast<bhkShape>(shape);
		}
		else
		{
			ltm.SetTrans(ltm.GetTrans() / Exporter::bhkScaleFactor);

			bhkTransformShapeRef transform = new bhkTransformShape();
			transform->SetTransform(TOMATRIX4(ltm).Transpose());
			transform->SetShape(shape);
			transform->SetMaterial(HavokMaterial(material));
			retval = StaticCast<bhkShape>(transform);
		}
	}
	return retval;
}

bhkShapeRef	Exporter::makeModSphereShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
	{
		pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
	}

	bhkShapeRef retval;

	Point3 center = Point3::Origin;
	float radius = 0.0f;
	CalcCenteredSphere(mesh, center, radius);

	if (bhkSphereShapeRef shape = new bhkSphereShape())
	{
		shape->SetRadius(radius / Exporter::bhkScaleFactor);
		shape->SetMaterial(HavokMaterial(material));

		Matrix3 ltm = TransMatrix(center) * node->GetObjTMAfterWSM(0) * tm;
		if (ltm.IsIdentity())
		{
			retval = StaticCast<bhkShape>(shape);
		}
		else
		{
			ltm.SetTrans(ltm.GetTrans() / Exporter::bhkScaleFactor);

			bhkTransformShapeRef transform = new bhkTransformShape();
			transform->SetTransform(TOMATRIX4(ltm).Transpose());
			transform->SetShape(shape);
			transform->SetMaterial(HavokMaterial(material));
			retval = StaticCast<bhkShape>(transform);
		}
	}
	return retval;
}

bhkShapeRef	Exporter::makeModCapsuleShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	node->EvalWorldState(0);
	if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
	{
		pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
	}

	bhkShapeRef retval;

	Point3 center = Point3::Origin;
	float radius = 0.0f;
	CalcCenteredSphere(mesh, center, radius);

	if (bhkCapsuleShapeRef shape = new bhkCapsuleShape())
	{
		shape->SetRadius(radius / Exporter::bhkScaleFactor);
		shape->SetRadius1(radius / Exporter::bhkScaleFactor);
		shape->SetRadius2(radius / Exporter::bhkScaleFactor);
		shape->SetFirstPoint(TOVECTOR3(center/Exporter::bhkScaleFactor));
		shape->SetSecondPoint(TOVECTOR3(center/Exporter::bhkScaleFactor));
		shape->SetMaterial(HavokMaterial(material));

		Matrix3 ltm = TransMatrix(center) * node->GetObjTMAfterWSM(0) * tm;
		if (ltm.IsIdentity())
		{
			retval = StaticCast<bhkShape>(shape);
		}
		else
		{
			ltm.SetTrans(ltm.GetTrans() / Exporter::bhkScaleFactor);

			bhkTransformShapeRef transform = new bhkTransformShape();
			transform->SetTransform(TOMATRIX4(ltm).Transpose());
			transform->SetShape(shape);
			transform->SetMaterial(HavokMaterial(material));
			retval = StaticCast<bhkShape>(transform);
		}
	}
	return retval;
}

bhkShapeRef	Exporter::makeModConvexShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	Matrix3 ltm = node->GetObjTMAfterWSM(0) * tm;

	bhkShapeRef shape;
	if (bhkConvexVerticesShapeRef convShape = makeConvexShape(mesh, ltm))
	{
		if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
		{
			pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
		}
		convShape->SetMaterial(HavokMaterial(material));
		shape = StaticCast<bhkShape>(convShape);
	}
	return shape;
}

bhkShapeRef	Exporter::makeModTriStripShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	Matrix3 ltm = node->GetObjTMAfterWSM(0) * tm;

	bhkShapeRef shape;
	if (bhkNiTriStripsShapeRef trishape = makeTriStripsShape(mesh, ltm))
	{
		trishape->SetMaterial(HavokMaterial(material));
		if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
		{
			pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
		}
		shape = StaticCast<bhkShape>(trishape);
	}
	return shape;
}

bhkShapeRef	Exporter::makeModPackedTriStripShape(INode *node, Modifier* mod, Mesh& mesh, Matrix3& tm)
{
	enum { havok_params };
	enum { PB_BOUND_TYPE, PB_MATERIAL, };
	enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_shapes, bv_type_convex, bv_type_packed, };  // pblock ID
	int material = NP_DEFAULT_HVK_MATERIAL;

	Matrix3 ltm = node->GetObjTMAfterWSM(0) * tm;

	bhkShapeRef shape;
	if (bhkPackedNiTriStripsShapeRef trishape = makePackedTriStripsShape(mesh, ltm))
	{
		//trishape->SetMaterial(HavokMaterial(material));
		if (IParamBlock2* pblock2 = mod->GetParamBlockByID(havok_params))
		{
			pblock2->GetValue(PB_MATERIAL, 0, material, FOREVER, 0);
		}

		if ( TheHavokCode.Initialize() )
			shape = StaticCast<bhkShape>( makeTreeShape(trishape) );
		else
			shape = StaticCast<bhkShape>(trishape);
	}
	return shape;
}