Changeset 2388 for GTP/trunk/App/Demos/Illum/Ogre/src/Common

Timestamp:

05/21/07 12:35:33 (18 years ago)

Author:

szirmay

Message:

 

Location:

GTP/trunk/App/Demos/Illum/Ogre/src/Common

Files:

• include/SceneSerializer.h (modified) (3 diffs)
• src/SceneSerializer.cpp (modified) (7 diffs)

GTP/trunk/App/Demos/Illum/Ogre/src/Common/include/SceneSerializer.h

@@ -1 +1 @@
 #include "Ogre.h"
+
+#ifdef NXOGRE
+#include "NXOgre.h"
+using namespace NxOgre;
+#endif
 
 using namespace Ogre;
@@ -22 +27 @@
         SceneNode* sceneNode;
         std::map<String, String> meshFiles;     
-        std::map<String, unsigned int> pathMapResolutions;      
+        std::map<String, unsigned int> pathMapResolutions;
+        
+#ifdef NXOGRE
+        std::map<String, String> meshPhysXShapes;
+        std::map<String, String> meshPhysXShapeParams;
+        //float physXMass;
+        //float physXDensity;
+        //bool physXKinematic;
+        //bool physXStatic;
+        Scene* scene;
+        World* world;
+        Body* physXBody;
+#endif
 };
 
@@ -54 +71 @@
         void parseEntryPoints(String filename);
 
+        #ifdef NXOGRE
+                public:
+                        void setScene(Scene* scene){mScriptContext.scene = scene;}
+                        void setWorld(World* world){mScriptContext.world = world;}
+                
+        #endif
+
 };

GTP/trunk/App/Demos/Illum/Ogre/src/Common/src/SceneSerializer.cpp

@@ +1 @@
+#include "OgreIlluminationManager.h"
 #include "SceneSerializer.h"
-#include "OgreIlluminationManager.h"
 
 void logParseError(const String& error, const SceneScriptContext& context)
@@ -20 +20 @@
 }
 
+#ifdef NXOGRE
+ShapeDescription* createShape(String params)
+{
+        std::vector<String> parameters = StringUtil::split(params);
+        
+        ShapeDescription* s = 0;
+        if(parameters[0] == "cube")
+                s = new CubeShape(StringConverter::parseReal(parameters[1]),//width
+                                                        StringConverter::parseReal(parameters[2]),//height
+                                                        StringConverter::parseReal(parameters[3]));//depth
+        else if(parameters[0] == "sphere")
+                s = new SphereShape(StringConverter::parseReal(parameters[1]));//radius
+        else if(parameters[0] == "capsule")
+                s = new CapsuleShape(StringConverter::parseReal(parameters[1]),//radius
+                                                                StringConverter::parseReal(parameters[2]));//height
+        else if(parameters[0] == "convex_mesh")
+                s = new ConvexShape(parameters[1]);//mesh name
+        else if(parameters[0] == "free_mesh")
+                s = new MeshShape(parameters[1]);//mesh name
+
+        return s;
+}
+#endif
+
 bool parseMeshName(String& params, SceneScriptContext& context)
 {
@@ -27 +51 @@
         //create the Entity with the given mesh, attach to a scene node
         StringUtil::trim(params);
-        String meshfilename = context.meshFiles[params];
+        String meshfilename = "";
+        if(context.meshFiles.count(params) != 0)
+                meshfilename = context.meshFiles[params];
         context.meshName = params;
+
+#ifdef NXOGRE   
+        if(context.meshPhysXShapes.count(context.meshName) != 0)
+        {
+                ShapeDescription *newShape = createShape(context.meshPhysXShapes[context.meshName]);
+                //LogManager::getSingleton().logMessage("meshname: " + meshfilename);
+                context.physXBody = context.scene->createBody(context.entityName, meshfilename, newShape, Vector3(0,0,0), context.meshPhysXShapeParams[context.meshName]); 
+                context.entity = context.physXBody->getEntity();
+                context.sceneNode = context.physXBody->getNode();
+        }
+        else
+        {
+                context.entity = context.sceneManager->createEntity(context.entityName, meshfilename);
+                SceneNode* root = context.sceneManager->getRootSceneNode();
+                context.sceneNode = root->createChildSceneNode(context.entityName);
+                context.sceneNode->attachObject(context.entity);        
+        }
+#else
         context.entity = context.sceneManager->createEntity(context.entityName, meshfilename);
         SceneNode* root = context.sceneManager->getRootSceneNode();
         context.sceneNode = root->createChildSceneNode(context.entityName);
-        context.sceneNode->attachObject(context.entity);
-        context.entity->setCastShadows(true);
+        context.sceneNode->attachObject(context.entity);        
+#endif  
     return false;
 }
@@ -42 +86 @@
                 logParseError("No clusters given!", context);
 
-        //create the Entity with the given mesh, attach to a scene node
         std::vector<String> parameters = StringUtil::split(params);
         String subentityname = context.entityName + "_SE_" + parameters[0];
@@ -57 +100 @@
 }
 
+bool parseCastShadows(String& params, SceneScriptContext& context)
+{
+        context.entity->setCastShadows(StringConverter::parseBool(params));
+
+        return false;
+}
+
+#ifdef NXOGRE
+bool parsePhysXShape(String& params, SceneScriptContext& context)
+{
+        context.meshPhysXShapes[context.meshName] = params;
+
+        return false;
+}
+
+bool parsePhysXMass(String& params, SceneScriptContext& context)
+{
+        if(context.meshPhysXShapeParams.count(context.meshName) == 0)
+                context.meshPhysXShapeParams[context.meshName] = "";
+
+        context.meshPhysXShapeParams[context.meshName] += "mass: " + params + ",";
+
+        return false;
+}
+
+bool parsePhysXDensity(String& params, SceneScriptContext& context)
+{
+        if(context.meshPhysXShapeParams.count(context.meshName) == 0)
+                context.meshPhysXShapeParams[context.meshName] = "";
+
+        context.meshPhysXShapeParams[context.meshName] += "density: " + params + ",";
+        
+        return false;
+}
+
+bool parsePhysXKinematic(String& params, SceneScriptContext& context)
+{
+        if(context.meshPhysXShapeParams.count(context.meshName) == 0)
+                context.meshPhysXShapeParams[context.meshName] = "";
+
+        context.meshPhysXShapeParams[context.meshName] += "kinematic: " + params + ",";
+        
+        return false;
+}
+
+bool parsePhysXStatic(String& params, SceneScriptContext& context)
+{
+        if(context.meshPhysXShapeParams.count(context.meshName) == 0)
+                context.meshPhysXShapeParams[context.meshName] = "";
+
+        context.meshPhysXShapeParams[context.meshName] += "static: " + params + ",";
+        
+        return false;
+}
+
+#endif
+
 bool parseTransform(String& params, SceneScriptContext& context)
 {
         Matrix4 transformMatrix = StringConverter::parseMatrix4(params);
-        context.sceneNode->setOrientation(transformMatrix.extractQuaternion());
         
         Vector4 x(1,0,0,0);
@@ -68 +167 @@
         Vector4 z(0,0,1,0);
         z = transformMatrix * z;
+
+#ifdef NXOGRE
+        if(context.meshPhysXShapes.count(context.meshName) != 0)
+        {
+                context.sceneNode->scale((Vector3(x.x,x.y,x.z)).length(),
+                                                                (Vector3(y.x,y.y,y.z)).length(),
+                                                                (Vector3(z.x,z.y,z.z)).length());
+                context.physXBody->setGlobalOrientation(transformMatrix.extractQuaternion());
+                context.physXBody->setGlobalPosition(transformMatrix.getTrans());       
+        }
+        else
+        {
+                context.sceneNode->setOrientation(transformMatrix.extractQuaternion());
+                context.sceneNode->scale((Vector3(x.x,x.y,x.z)).length(),
+                                                                (Vector3(y.x,y.y,y.z)).length(),
+                                                                (Vector3(z.x,z.y,z.z)).length());
+                context.sceneNode->translate(transformMatrix.getTrans());
+        }
+#else
+        context.sceneNode->setOrientation(transformMatrix.extractQuaternion());
         context.sceneNode->scale((Vector3(x.x,x.y,x.z)).length(),
                                                                 (Vector3(y.x,y.y,y.z)).length(),
                                                                 (Vector3(z.x,z.y,z.z)).length());
         context.sceneNode->translate(transformMatrix.getTrans());
+#endif
         
         return false;
@@ -125 +245 @@
         mEntityAttribParsers.insert(AttribParserList::value_type("subentity", (SCENE_ATTRIBUTE_PARSER)parseClusters));
         mEntityAttribParsers.insert(AttribParserList::value_type("pathmapfile", (SCENE_ATTRIBUTE_PARSER)parsePRMMapName));
-
+        mEntityAttribParsers.insert(AttribParserList::value_type("castShadows", (SCENE_ATTRIBUTE_PARSER)parseCastShadows));
+
+        #ifdef NXOGRE
+        mMeshAttribParsers.insert(AttribParserList::value_type("physXShape", (SCENE_ATTRIBUTE_PARSER)parsePhysXShape));
+        mMeshAttribParsers.insert(AttribParserList::value_type("physXMass", (SCENE_ATTRIBUTE_PARSER)parsePhysXMass));
+        mMeshAttribParsers.insert(AttribParserList::value_type("physXDensity", (SCENE_ATTRIBUTE_PARSER)parsePhysXDensity));
+        mMeshAttribParsers.insert(AttribParserList::value_type("physXKinematic", (SCENE_ATTRIBUTE_PARSER)parsePhysXKinematic));
+        mMeshAttribParsers.insert(AttribParserList::value_type("physXStatic", (SCENE_ATTRIBUTE_PARSER)parsePhysXStatic));
+        #endif
 }