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

Timestamp:

03/02/07 19:07:56 (18 years ago)

Author:

szirmay

Message:

 

Location:

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

Files:

• include/SceneSerializer.h (modified) (2 diffs)
• src/SceneSerializer.cpp (modified) (5 diffs)

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

@@ -19 +19 @@
         String meshName;
         Entity* entity;
+        String pathMapTextureName;
         SceneNode* sceneNode;
         std::map<String, String> meshFiles;     
+        std::map<String, unsigned int> pathMapResolutions;      
 };
 
@@ -50 +52 @@
         SceneSerializer(SceneManager* sm);
         void parseScript(DataStreamPtr& stream, const String& groupName);
+        void parseEntryPoints(String filename);
 
 };

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

@@ -1 +1 @@
 #include "SceneSerializer.h"
+#include "OgreIlluminationManager.h"
 
 void logParseError(const String& error, const SceneScriptContext& context)
@@ -27 +28 @@
         StringUtil::trim(params);
         String meshfilename = context.meshFiles[params];
+        context.meshName = params;
         context.entity = context.sceneManager->createEntity(context.entityName, meshfilename);
         SceneNode* root = context.sceneManager->getRootSceneNode();
@@ -32 +34 @@
         context.sceneNode->attachObject(context.entity);
 
+    return false;
+}
+
+bool parseClusters(String& params, SceneScriptContext& context)
+{
+        if(params == "")
+                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];
+        PathMapClusters clasters;
+        clasters.count = parameters.size() - 2;
+        clasters.clusters = new unsigned int[clasters.count];
+        for(int i = 2; i < parameters.size(); i++)
+                clasters.clusters[i-2] = StringConverter::parseUnsignedInt(parameters.at(i));
+        clasters.pathMapTextureFilename = context.pathMapTextureName + "_" + parameters[0]+ ".hdr";
+        clasters.pathMapResolution = context.pathMapResolutions[context.meshName];
+        OgreIlluminationManager::getSingleton().addPathMapClusters(subentityname, clasters);
+        
     return false;
 }
@@ -76 +98 @@
 }
 
+bool parsePMRes(String& params, SceneScriptContext& context)
+{
+        context.pathMapResolutions[context.meshName] = StringConverter::parseUnsignedInt(params);
+        return false;
+}
+
+bool parsePRMMapName(String& params, SceneScriptContext& context)
+{
+        context.pathMapTextureName = params;
+        return false;
+}
+
 SceneSerializer::SceneSerializer(SceneManager* sm)
 {
@@ -85 +119 @@
         
         mMeshAttribParsers.insert(AttribParserList::value_type("ogrefile", (SCENE_ATTRIBUTE_PARSER)parseMeshFileName));
+        mMeshAttribParsers.insert(AttribParserList::value_type("pathmapresolution", (SCENE_ATTRIBUTE_PARSER)parsePMRes));
 
         mEntityAttribParsers.insert(AttribParserList::value_type("mesh", (SCENE_ATTRIBUTE_PARSER)parseMeshName));
         mEntityAttribParsers.insert(AttribParserList::value_type("transformation", (SCENE_ATTRIBUTE_PARSER)parseTransform));
-
+        mEntityAttribParsers.insert(AttribParserList::value_type("subentity", (SCENE_ATTRIBUTE_PARSER)parseClusters));
+        mEntityAttribParsers.insert(AttribParserList::value_type("pathmapfile", (SCENE_ATTRIBUTE_PARSER)parsePRMMapName));
+
+}
+
+void SceneSerializer::parseEntryPoints(String filename)
+{
+        DataStreamPtr stream; 
+        stream = ResourceGroupManager::getSingleton().openResource(filename);
+
+        char buffer[500];
+    
+        stream->readLine(buffer, 500);
+        String line = buffer;
+
+        std::vector<String> tokens = StringUtil::split(line);
+        unsigned int entryPointCnt = StringConverter::parseUnsignedInt(tokens[1]);
+        for(int i= 0; i < entryPointCnt; i++)
+        {
+                stream->readLine(buffer, 500);
+                line = buffer;
+                tokens = StringUtil::split(line);
+                PathMapEntryPoint ep;
+                ep.position = Vector3(StringConverter::parseReal(tokens[1]),
+                                          StringConverter::parseReal(tokens[2]),
+                                                          StringConverter::parseReal(tokens[3]));
+
+                stream->readLine(buffer, 500);
+                line = buffer;
+                tokens = StringUtil::split(line);
+                ep.normal = Vector3(StringConverter::parseReal(tokens[1]),
+                                        StringConverter::parseReal(tokens[2]),
+                                                        StringConverter::parseReal(tokens[3]));
+
+                OgreIlluminationManager::getSingleton().addPathMapEntryPoint(ep);
+                stream->readLine(buffer, 500);
+        }
+        stream->readLine(buffer, 500);
+        line = buffer;
+        tokens = StringUtil::split(line);
+    unsigned int clusterCnt = StringConverter::parseUnsignedInt(tokens[1]);
+        for(int i= 0; i < clusterCnt; i++)
+        {
+                stream->readLine(buffer, 500);
+                unsigned int clusterlength = StringConverter::parseUnsignedInt(buffer);
+                OgreIlluminationManager::getSingleton().addPathMapClusterLength(clusterlength);         
+        }
 }