Removed string interface

CamelotRenderer/CamelotRenderer.vcxproj

@@ -167,7 +167,6 @@
     <ClInclude Include="OgreStdHeaders.h" />
     <ClInclude Include="OgreString.h" />
     <ClInclude Include="OgreStringConverter.h" />
-    <ClInclude Include="OgreStringInterface.h" />
     <ClInclude Include="OgreTexture.h" />
     <ClInclude Include="OgreTextureManager.h" />
     <ClInclude Include="OgreTextureUnitState.h" />
@@ -297,7 +296,6 @@
     <ClCompile Include="OgreRenderWindow.cpp" />
     <ClCompile Include="OgreString.cpp" />
     <ClCompile Include="OgreStringConverter.cpp" />
-    <ClCompile Include="OgreStringInterface.cpp" />
     <ClCompile Include="OgreTexture.cpp" />
     <ClCompile Include="OgreTextureManager.cpp" />
     <ClCompile Include="OgreTextureUnitState.cpp" />

CamelotRenderer/CamelotRenderer.vcxproj.filters

@@ -307,9 +307,6 @@
     <ClInclude Include="OgrePixelFormat.h">
       <Filter>Header Files\Utility</Filter>
     </ClInclude>
-    <ClInclude Include="OgreStringInterface.h">
-      <Filter>Header Files\Utility</Filter>
-    </ClInclude>
     <ClInclude Include="OgreWindowEventUtilities.h">
       <Filter>Header Files\Utility</Filter>
     </ClInclude>
@@ -693,9 +690,6 @@
     <ClCompile Include="OgrePixelFormat.cpp">
       <Filter>Source Files\Utility</Filter>
     </ClCompile>
-    <ClCompile Include="OgreStringInterface.cpp">
-      <Filter>Source Files\Utility</Filter>
-    </ClCompile>
     <ClCompile Include="OgreWindowEventUtilities.cpp">
       <Filter>Source Files\Utility</Filter>
     </ClCompile>

CamelotRenderer/OgreD3D9GpuProgram.cpp

@@ -32,51 +32,10 @@ THE SOFTWARE.
 #include "OgreD3D9RenderSystem.h"
 
 namespace Ogre {
-
-    D3D9GpuProgram::CmdColumnMajorMatrices D3D9GpuProgram::msCmdColumnMajorMatrices;
-	D3D9GpuProgram::CmdExternalMicrocode D3D9GpuProgram::msCmdExternalMicrocode;
-
-   //-----------------------------------------------------------------------
-    String D3D9GpuProgram::CmdColumnMajorMatrices::doGet(const void *target) const
-    {
-        return StringConverter::toString(static_cast<const D3D9GpuProgram*>(target)->getColumnMajorMatrices());
-    }
-    void D3D9GpuProgram::CmdColumnMajorMatrices::doSet(void *target, const String& val)
-    {
-        static_cast<D3D9GpuProgram*>(target)->setColumnMajorMatrices(StringConverter::parseBool(val));
-    }
-    //-----------------------------------------------------------------------
-    String D3D9GpuProgram::CmdExternalMicrocode::doGet(const void *target) const
-    {
-		//D3D9GpuProgram* program=const_cast<D3D9GpuProgram*>(static_cast<const D3D9GpuProgram*>(target));
-		//LPD3DXBUFFER ptr=program->getExternalMicrocode();
-		//nothing to do
-		return String();
-    }
-    void D3D9GpuProgram::CmdExternalMicrocode::doSet(void *target, const String& val)
-    {
-		D3D9GpuProgram* program = const_cast<D3D9GpuProgram*>(static_cast<const D3D9GpuProgram*>(target));
-		const void* buffer = val.data();
-		program->setExternalMicrocode(buffer, val.size());
-    }
-
     //-----------------------------------------------------------------------------
     D3D9GpuProgram::D3D9GpuProgram() 
         : GpuProgram(), mpExternalMicrocode(NULL), mColumnMajorMatrices(false)
     {
-		// TODO PORT - Not using these param dictionaries but I'm not sure what that breaks
-   //     if (createParamDictionary("D3D9GpuProgram"))
-   //     {
-   //         setupBaseParamDictionary();
-
-   //         ParamDictionary* dict = getParamDictionary();
-   //         dict->addParameter(ParameterDef("column_major_matrices", 
-   //             "Whether matrix packing in column-major order.",
-   //             PT_BOOL),&msCmdColumnMajorMatrices);
-			//dict->addParameter(ParameterDef("external_micro_code", 
-			//	"the cached external micro code data.",
-			//	PT_STRING),&msCmdExternalMicrocode);
-   //     }
     }
 
 	//-----------------------------------------------------------------------------

CamelotRenderer/OgreD3D9GpuProgram.h

@@ -38,24 +38,6 @@ namespace Ogre {
     /** Direct3D implementation of a few things common to low-level vertex & fragment programs. */
     class _OgreD3D9Export D3D9GpuProgram : public GpuProgram, public D3D9Resource
     {   
-	public:
-        /// Command object for setting matrix packing in column-major order
-        class CmdColumnMajorMatrices : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& val);
-        };
-		/// Command object for getting/setting external micro code (void*)
-		class CmdExternalMicrocode : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-	protected:
-		static CmdColumnMajorMatrices msCmdColumnMajorMatrices;
-		static CmdExternalMicrocode msCmdExternalMicrocode;
     public:
         D3D9GpuProgram();
         ~D3D9GpuProgram();

CamelotRenderer/OgreD3D9HLSLProgram.cpp

@@ -34,15 +34,6 @@ THE SOFTWARE.
 #include "CmRenderSystemManager.h"
 
 namespace Ogre {
-    //-----------------------------------------------------------------------
-    D3D9HLSLProgram::CmdEntryPoint D3D9HLSLProgram::msCmdEntryPoint;
-    D3D9HLSLProgram::CmdTarget D3D9HLSLProgram::msCmdTarget;
-    D3D9HLSLProgram::CmdPreprocessorDefines D3D9HLSLProgram::msCmdPreprocessorDefines;
-    D3D9HLSLProgram::CmdColumnMajorMatrices D3D9HLSLProgram::msCmdColumnMajorMatrices;
-	D3D9HLSLProgram::CmdOptimisation D3D9HLSLProgram::msCmdOptimisation;
-	D3D9HLSLProgram::CmdMicrocode D3D9HLSLProgram::msCmdMicrocode;
-	D3D9HLSLProgram::CmdAssemblerCode D3D9HLSLProgram::msCmdAssemblerCode;
-
 	class _OgreD3D9Export HLSLIncludeHandler : public ID3DXInclude
 	{
 	public:
@@ -550,35 +541,6 @@ namespace Ogre {
         , mpMicroCode(NULL), mpConstTable(NULL)
 		, mOptimisationLevel(OPT_DEFAULT)
 	{
-		// TODO PORT - I'm not sure if this is needed but I won't be doing things this way
-   //     if (createParamDictionary("D3D9HLSLProgram"))
-   //     {
-   //         setupBaseParamDictionary();
-   //         ParamDictionary* dict = getParamDictionary();
-
-   //         dict->addParameter(ParameterDef("entry_point", 
-   //             "The entry point for the HLSL program.",
-   //             PT_STRING),&msCmdEntryPoint);
-   //         dict->addParameter(ParameterDef("target", 
-   //             "Name of the assembler target to compile down to.",
-   //             PT_STRING),&msCmdTarget);
-   //         dict->addParameter(ParameterDef("preprocessor_defines", 
-   //             "Preprocessor defines use to compile the program.",
-   //             PT_STRING),&msCmdPreprocessorDefines);
-   //         dict->addParameter(ParameterDef("column_major_matrices", 
-   //             "Whether matrix packing in column-major order.",
-   //             PT_BOOL),&msCmdColumnMajorMatrices);
-			//dict->addParameter(ParameterDef("optimisation_level", 
-			//	"The optimisation level to use.",
-			//	PT_STRING),&msCmdOptimisation);
-			//dict->addParameter(ParameterDef("micro_code", 
-			//	"the micro code.",
-			//	PT_STRING),&msCmdMicrocode);
-			//dict->addParameter(ParameterDef("assemble_code", 
-			//	"the assemble code.",
-			//	PT_STRING),&msCmdAssemblerCode);
-   //     }
-        
     }
     //-----------------------------------------------------------------------
     D3D9HLSLProgram::~D3D9HLSLProgram()
@@ -620,132 +582,4 @@ namespace Ogre {
 
         return language;
     }
-
-    //-----------------------------------------------------------------------
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdEntryPoint::doGet(const void *target) const
-    {
-        return static_cast<const D3D9HLSLProgram*>(target)->getEntryPoint();
-    }
-    void D3D9HLSLProgram::CmdEntryPoint::doSet(void *target, const String& val)
-    {
-        static_cast<D3D9HLSLProgram*>(target)->setEntryPoint(val);
-    }
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdTarget::doGet(const void *target) const
-    {
-        return static_cast<const D3D9HLSLProgram*>(target)->getTarget();
-    }
-    void D3D9HLSLProgram::CmdTarget::doSet(void *target, const String& val)
-    {
-        static_cast<D3D9HLSLProgram*>(target)->setTarget(val);
-    }
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdPreprocessorDefines::doGet(const void *target) const
-    {
-        return static_cast<const D3D9HLSLProgram*>(target)->getPreprocessorDefines();
-    }
-    void D3D9HLSLProgram::CmdPreprocessorDefines::doSet(void *target, const String& val)
-    {
-        static_cast<D3D9HLSLProgram*>(target)->setPreprocessorDefines(val);
-    }
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdColumnMajorMatrices::doGet(const void *target) const
-    {
-        return StringConverter::toString(static_cast<const D3D9HLSLProgram*>(target)->getColumnMajorMatrices());
-    }
-    void D3D9HLSLProgram::CmdColumnMajorMatrices::doSet(void *target, const String& val)
-    {
-        static_cast<D3D9HLSLProgram*>(target)->setColumnMajorMatrices(StringConverter::parseBool(val));
-    }
-	//-----------------------------------------------------------------------
-	String D3D9HLSLProgram::CmdOptimisation::doGet(const void *target) const
-	{
-		switch(static_cast<const D3D9HLSLProgram*>(target)->getOptimisationLevel())
-		{
-		default:
-		case OPT_DEFAULT:
-			return "default";
-		case OPT_NONE:
-			return "none";
-		case OPT_0:
-			return "0";
-		case OPT_1:
-			return "1";
-		case OPT_2:
-			return "2";
-		case OPT_3:
-			return "3";
-		}
-	}
-	void D3D9HLSLProgram::CmdOptimisation::doSet(void *target, const String& val)
-	{
-		if (StringUtil::startsWith(val, "default", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_DEFAULT);
-		else if (StringUtil::startsWith(val, "none", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_NONE);
-		else if (StringUtil::startsWith(val, "0", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_0);
-		else if (StringUtil::startsWith(val, "1", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_1);
-		else if (StringUtil::startsWith(val, "2", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_2);
-		else if (StringUtil::startsWith(val, "3", true))
-			static_cast<D3D9HLSLProgram*>(target)->setOptimisationLevel(OPT_3);
-	}
-
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdMicrocode::doGet(const void *target) const
-    {
-		D3D9HLSLProgram* program=const_cast<D3D9HLSLProgram*>(static_cast<const D3D9HLSLProgram*>(target));
-		LPD3DXBUFFER buffer=program->getMicroCode();
-		if(buffer)
-		{
-			char* str  =static_cast<Ogre::String::value_type*>(buffer->GetBufferPointer());
-			size_t size=static_cast<size_t>(buffer->GetBufferSize());
-			Ogre::String code;
-			code.assign(str,size);
-			return code;
-		}
-		else
-		{
-			return String();
-		}
-    }
-    void D3D9HLSLProgram::CmdMicrocode::doSet(void *target, const String& val)
-    {
-		//nothing to do 
-		//static_cast<D3D9HLSLProgram*>(target)->setColumnMajorMatrices(StringConverter::parseBool(val));
-    }
-    //-----------------------------------------------------------------------
-    String D3D9HLSLProgram::CmdAssemblerCode::doGet(const void *target) const
-    {
-		D3D9HLSLProgram* program=const_cast<D3D9HLSLProgram*>(static_cast<const D3D9HLSLProgram*>(target));
-		LPD3DXBUFFER buffer=program->getMicroCode();
-		if(buffer)
-		{
-			CONST DWORD* code =static_cast<CONST DWORD*>(buffer->GetBufferPointer());
-			LPD3DXBUFFER pDisassembly=0;
-			HRESULT hr=D3DXDisassembleShader(code,FALSE,"// assemble code from D3D9HLSLProgram\n",&pDisassembly);
-			if(pDisassembly)
-			{
-				char* str  =static_cast<Ogre::String::value_type*>(pDisassembly->GetBufferPointer());
-				size_t size=static_cast<size_t>(pDisassembly->GetBufferSize());
-				Ogre::String assemble_code;
-				assemble_code.assign(str,size);
-				pDisassembly->Release();
-				return assemble_code;
-			}
-			return String();
-		}
-		else
-		{
-			return String();
-		}
-    }
-    void D3D9HLSLProgram::CmdAssemblerCode::doSet(void *target, const String& val)
-    {
-		//nothing to do 
-		//static_cast<D3D9HLSLProgram*>(target)->setColumnMajorMatrices(StringConverter::parseBool(val));
-    }
 }

CamelotRenderer/OgreD3D9HLSLProgram.h

@@ -42,68 +42,7 @@ namespace Ogre {
     */
     class _OgreD3D9Export D3D9HLSLProgram : public HighLevelGpuProgram
     {
-    public:
-        /// Command object for setting entry point
-        class CmdEntryPoint : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& val);
-        };
-        /// Command object for setting target assembler
-        class CmdTarget : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& val);
-        };
-        /// Command object for setting macro defines
-        class CmdPreprocessorDefines : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& val);
-        };
-        /// Command object for setting matrix packing in column-major order
-        class CmdColumnMajorMatrices : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& val);
-        };
-		/// Command object for setting optimisation level
-		class CmdOptimisation : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-
-		/// Command object for getting/setting micro code
-		class CmdMicrocode : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-
-		/// Command object for getting/setting assembler code
-		class CmdAssemblerCode : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
     protected:
-
-        static CmdEntryPoint msCmdEntryPoint;
-        static CmdTarget msCmdTarget;
-        static CmdPreprocessorDefines msCmdPreprocessorDefines;
-        static CmdColumnMajorMatrices msCmdColumnMajorMatrices;
-		static CmdOptimisation msCmdOptimisation;
-		static CmdMicrocode msCmdMicrocode;
-		static CmdAssemblerCode msCmdAssemblerCode;
-
         /** Internal load implementation, must be implemented by subclasses.
         */
         void loadFromSource(void);

CamelotRenderer/OgreGpuProgram.cpp

@@ -37,17 +37,6 @@ THE SOFTWARE.
 
 namespace Ogre
 {
-    //-----------------------------------------------------------------------------
-    GpuProgram::CmdType GpuProgram::msTypeCmd;
-    GpuProgram::CmdSyntax GpuProgram::msSyntaxCmd;
-    GpuProgram::CmdSkeletal GpuProgram::msSkeletalCmd;
-	GpuProgram::CmdMorph GpuProgram::msMorphCmd;
-	GpuProgram::CmdPose GpuProgram::msPoseCmd;
-	GpuProgram::CmdVTF GpuProgram::msVTFCmd;
-	GpuProgram::CmdManualNamedConstsFile GpuProgram::msManNamedConstsFileCmd;
-	GpuProgram::CmdAdjacency GpuProgram::msAdjacencyCmd;
-	
-
     //-----------------------------------------------------------------------------
     GpuProgram::GpuProgram() 
         :mType(GPT_VERTEX_PROGRAM), mLoadFromFile(true), mSkeletalAnimation(false),
@@ -234,38 +223,6 @@ namespace Ogre
     //-----------------------------------------------------------------------------
     void GpuProgram::setupBaseParamDictionary(void)
     {
-		// TODO PORT - I'm not really sure what this will do and will it be needed in my port, but its calling a method from Resource, and we don't inherit from it
-  //      ParamDictionary* dict = getParamDictionary();
-
-  //      dict->addParameter(
-  //          ParameterDef("type", "'vertex_program', 'geometry_program' or 'fragment_program'",
-  //              PT_STRING), &msTypeCmd);
-  //      dict->addParameter(
-  //          ParameterDef("syntax", "Syntax code, e.g. vs_1_1", PT_STRING), &msSyntaxCmd);
-  //      dict->addParameter(
-  //          ParameterDef("includes_skeletal_animation", 
-  //          "Whether this vertex program includes skeletal animation", PT_BOOL), 
-  //          &msSkeletalCmd);
-		//dict->addParameter(
-		//	ParameterDef("includes_morph_animation", 
-		//	"Whether this vertex program includes morph animation", PT_BOOL), 
-		//	&msMorphCmd);
-		//dict->addParameter(
-		//	ParameterDef("includes_pose_animation", 
-		//	"The number of poses this vertex program supports for pose animation", PT_INT), 
-		//	&msPoseCmd);
-		//dict->addParameter(
-		//	ParameterDef("uses_vertex_texture_fetch", 
-		//	"Whether this vertex program requires vertex texture fetch support.", PT_BOOL), 
-		//	&msVTFCmd);
-		//dict->addParameter(
-		//	ParameterDef("manual_named_constants", 
-		//	"File containing named parameter mappings for low-level programs.", PT_BOOL), 
-		//	&msManNamedConstsFileCmd);
-		//dict->addParameter(
-		//	ParameterDef("uses_adjacency_information",
-		//	"Whether this geometry program requires adjacency information from the input primitives.", PT_BOOL),
-		//	&msAdjacencyCmd);
     }
 
     //-----------------------------------------------------------------------
@@ -275,116 +232,5 @@ namespace Ogre
 
         return language;
     }
-    //-----------------------------------------------------------------------
-    //-----------------------------------------------------------------------
-    String GpuProgram::CmdType::doGet(const void* target) const
-    {
-        const GpuProgram* t = static_cast<const GpuProgram*>(target);
-        if (t->getType() == GPT_VERTEX_PROGRAM)
-        {
-            return "vertex_program";
-        }
-		else if (t->getType() == GPT_GEOMETRY_PROGRAM)
-		{
-			return "geometry_program";
-		}
-		else
-        {
-            return "fragment_program";
-        }
-    }
-    void GpuProgram::CmdType::doSet(void* target, const String& val)
-    {
-        GpuProgram* t = static_cast<GpuProgram*>(target);
-        if (val == "vertex_program")
-        {
-            t->setType(GPT_VERTEX_PROGRAM);
-        }
-        else if (val == "geometry_program")
-		{
-			t->setType(GPT_GEOMETRY_PROGRAM);
-		}
-		else
-        {
-            t->setType(GPT_FRAGMENT_PROGRAM);
-        }
-    }
-    //-----------------------------------------------------------------------
-    String GpuProgram::CmdSyntax::doGet(const void* target) const
-    {
-        const GpuProgram* t = static_cast<const GpuProgram*>(target);
-        return t->getSyntaxCode();
-    }
-    void GpuProgram::CmdSyntax::doSet(void* target, const String& val)
-    {
-        GpuProgram* t = static_cast<GpuProgram*>(target);
-        t->setSyntaxCode(val);
-    }
-    //-----------------------------------------------------------------------
-    String GpuProgram::CmdSkeletal::doGet(const void* target) const
-    {
-        const GpuProgram* t = static_cast<const GpuProgram*>(target);
-        return StringConverter::toString(t->isSkeletalAnimationIncluded());
-    }
-    void GpuProgram::CmdSkeletal::doSet(void* target, const String& val)
-    {
-        GpuProgram* t = static_cast<GpuProgram*>(target);
-        t->setSkeletalAnimationIncluded(StringConverter::parseBool(val));
-    }
-	//-----------------------------------------------------------------------
-	String GpuProgram::CmdMorph::doGet(const void* target) const
-	{
-		const GpuProgram* t = static_cast<const GpuProgram*>(target);
-		return StringConverter::toString(t->isMorphAnimationIncluded());
-	}
-	void GpuProgram::CmdMorph::doSet(void* target, const String& val)
-	{
-		GpuProgram* t = static_cast<GpuProgram*>(target);
-		t->setMorphAnimationIncluded(StringConverter::parseBool(val));
-	}
-	//-----------------------------------------------------------------------
-	String GpuProgram::CmdPose::doGet(const void* target) const
-	{
-		const GpuProgram* t = static_cast<const GpuProgram*>(target);
-		return StringConverter::toString(t->getNumberOfPosesIncluded());
-	}
-	void GpuProgram::CmdPose::doSet(void* target, const String& val)
-	{
-		GpuProgram* t = static_cast<GpuProgram*>(target);
-		t->setPoseAnimationIncluded((ushort)StringConverter::parseUnsignedInt(val));
-	}
-	//-----------------------------------------------------------------------
-	String GpuProgram::CmdVTF::doGet(const void* target) const
-	{
-		const GpuProgram* t = static_cast<const GpuProgram*>(target);
-		return StringConverter::toString(t->isVertexTextureFetchRequired());
-	}
-	void GpuProgram::CmdVTF::doSet(void* target, const String& val)
-	{
-		GpuProgram* t = static_cast<GpuProgram*>(target);
-		t->setVertexTextureFetchRequired(StringConverter::parseBool(val));
-	}
-	//-----------------------------------------------------------------------
-	String GpuProgram::CmdManualNamedConstsFile::doGet(const void* target) const
-	{
-		const GpuProgram* t = static_cast<const GpuProgram*>(target);
-		return t->getManualNamedConstantsFile();
-	}
-	void GpuProgram::CmdManualNamedConstsFile::doSet(void* target, const String& val)
-	{
-		GpuProgram* t = static_cast<GpuProgram*>(target);
-		t->setManualNamedConstantsFile(val);
-	}
-    //-----------------------------------------------------------------------
-	String GpuProgram::CmdAdjacency::doGet(const void* target) const
-	{
-		const GpuProgram* t = static_cast<const GpuProgram*>(target);
-		return StringConverter::toString(t->isAdjacencyInfoRequired());
-	}
-	void GpuProgram::CmdAdjacency::doSet(void* target, const String& val)
-	{
-		GpuProgram* t = static_cast<GpuProgram*>(target);
-		t->setAdjacencyInfoRequired(StringConverter::parseBool(val));
-	}
 }
 

CamelotRenderer/OgreGpuProgram.h

@@ -31,7 +31,6 @@ THE SOFTWARE.
 // Precompiler options
 #include "OgrePrerequisites.h"
 #include "OgreRenderOperation.h"
-#include "OgreStringInterface.h"
 #include "OgreGpuProgramParams.h"
 
 namespace Ogre {
@@ -79,64 +78,6 @@ namespace Ogre {
 	class _OgreExport GpuProgram
 	{
 	protected:
-		/// Command object - see ParamCommand 
-		class _OgreExport CmdType : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdSyntax : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdSkeletal : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdMorph : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdPose : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdVTF : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdManualNamedConstsFile : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		class _OgreExport CmdAdjacency : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		// Command object for setting / getting parameters
-		static CmdType msTypeCmd;
-		static CmdSyntax msSyntaxCmd;
-		static CmdSkeletal msSkeletalCmd;
-		static CmdMorph msMorphCmd;
-		static CmdPose msPoseCmd;
-		static CmdVTF msVTFCmd;
-		static CmdManualNamedConstsFile msManNamedConstsFileCmd;
-		static CmdAdjacency msAdjacencyCmd;
 		/// The type of the program
 		GpuProgramType mType;
 		/// Name of the shader entry method

CamelotRenderer/OgreStringInterface.cpp

@@ -1,83 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2011 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#include "OgreStringInterface.h"
-
-namespace Ogre {
-	OGRE_STATIC_MUTEX_INSTANCE( StringInterface::msDictionaryMutex )
-    ParamDictionaryMap StringInterface::msDictionary;
-
-
-    const ParameterList& StringInterface::getParameters(void) const
-    {
-        static ParameterList emptyList;
-
-        const ParamDictionary* dict = getParamDictionary();
-        if (dict)
-            return dict->getParameters();
-        else
-            return emptyList;
-
-    }
-
-    bool StringInterface::setParameter(const String& name, const String& value)
-    {
-        // Get dictionary
-        ParamDictionary* dict = getParamDictionary();
-
-        if (dict)
-        {
-            // Look up command object
-            ParamCommand* cmd = dict->getParamCommand(name);
-            if (cmd)
-            {
-                cmd->doSet(this, value);
-                return true;
-            }
-        }
-        // Fallback
-        return false;
-    }
-	//-----------------------------------------------------------------------
-	void StringInterface::setParameterList(const NameValuePairList& paramList)
-	{
-		NameValuePairList::const_iterator i, iend;
-		iend = paramList.end();
-		for (i = paramList.begin(); i != iend; ++i)
-		{
-			setParameter(i->first, i->second);
-		}
-	}
-    //-----------------------------------------------------------------------
-	void StringInterface::cleanupDictionary ()
-	{
-		OGRE_LOCK_MUTEX( msDictionaryMutex )
-
-		msDictionary.clear();
-	}
-}

CamelotRenderer/OgreStringInterface.h

@@ -1,335 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2011 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __StringInterface_H__
-#define __StringInterface_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreString.h"
-#include "OgreCommon.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-
-    /// List of parameter types available
-    enum ParameterType
-    {
-        PT_BOOL,
-        PT_REAL,
-        PT_INT,
-        PT_UNSIGNED_INT,
-        PT_SHORT,
-        PT_UNSIGNED_SHORT,
-        PT_LONG,
-        PT_UNSIGNED_LONG,
-        PT_STRING,
-        PT_VECTOR3,
-        PT_MATRIX3,
-        PT_MATRIX4,
-        PT_QUATERNION,
-        PT_COLOURVALUE
-    };
-
-    /// Definition of a parameter supported by a StringInterface class, for introspection
-    class _OgreExport ParameterDef
-    {
-    public:
-        String name;
-        String description;
-        ParameterType paramType;
-        ParameterDef(const String& newName, const String& newDescription, ParameterType newType)
-            : name(newName), description(newDescription), paramType(newType) {}
-    };
-    typedef vector<ParameterDef>::type ParameterList;
-
-    /** Abstract class which is command object which gets/sets parameters.*/
-    class _OgreExport ParamCommand
-    {
-    public:
-        virtual String doGet(const void* target) const = 0;
-        virtual void doSet(void* target, const String& val) = 0;
-
-        virtual ~ParamCommand() { }
-    };
-    typedef map<String, ParamCommand* >::type ParamCommandMap;
-
-    /** Class to hold a dictionary of parameters for a single class. */
-    class _OgreExport ParamDictionary
-    {
-        friend class StringInterface;
-    protected:
-        /// Definitions of parameters
-        ParameterList mParamDefs;
-
-        /// Command objects to get/set
-        ParamCommandMap mParamCommands;
-
-        /** Retrieves the parameter command object for a named parameter. */
-        ParamCommand* getParamCommand(const String& name)
-        {
-            ParamCommandMap::iterator i = mParamCommands.find(name);
-            if (i != mParamCommands.end())
-            {
-                return i->second;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-
-		const ParamCommand* getParamCommand(const String& name) const
-        {
-            ParamCommandMap::const_iterator i = mParamCommands.find(name);
-            if (i != mParamCommands.end())
-            {
-                return i->second;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-    public:
-        ParamDictionary()  {}
-        /** Method for adding a parameter definition for this class. 
-        @param paramDef A ParameterDef object defining the parameter
-        @param paramCmd Pointer to a ParamCommand subclass to handle the getting / setting of this parameter.
-            NB this class will not destroy this on shutdown, please ensure you do
-
-        */
-        void addParameter(const ParameterDef& paramDef, ParamCommand* paramCmd)
-        {
-            mParamDefs.push_back(paramDef);
-            mParamCommands[paramDef.name] = paramCmd;
-        }
-        /** Retrieves a list of parameters valid for this object. 
-        @returns
-            A reference to a static list of ParameterDef objects.
-
-        */
-        const ParameterList& getParameters(void) const
-        {
-            return mParamDefs;
-        }
-
-
-
-    };
-    typedef map<String, ParamDictionary>::type ParamDictionaryMap;
-    
-    /** Class defining the common interface which classes can use to 
-        present a reflection-style, self-defining parameter set to callers.
-    @remarks
-        This class also holds a static map of class name to parameter dictionaries
-        for each subclass to use. See ParamDictionary for details. 
-    @remarks
-        In order to use this class, each subclass must call createParamDictionary in their constructors
-        which will create a parameter dictionary for the class if it does not exist yet.
-    */
-    class _OgreExport StringInterface 
-    {
-    private:
-		OGRE_STATIC_MUTEX( msDictionaryMutex )
-
-        /// Dictionary of parameters
-        static ParamDictionaryMap msDictionary;
-
-        /// Class name for this instance to be used as a lookup (must be initialised by subclasses)
-        String mParamDictName;
-		ParamDictionary* mParamDict;
-
-	protected:
-        /** Internal method for creating a parameter dictionary for the class, if it does not already exist.
-        @remarks
-            This method will check to see if a parameter dictionary exist for this class yet,
-            and if not will create one. NB you must supply the name of the class (RTTI is not 
-            used or performance).
-        @param
-            className the name of the class using the dictionary
-        @returns
-            true if a new dictionary was created, false if it was already there
-        */
-        bool createParamDictionary(const String& className)
-        {
-			OGRE_LOCK_MUTEX( msDictionaryMutex )
-
-			ParamDictionaryMap::iterator it = msDictionary.find(className);
-
-			if ( it == msDictionary.end() )
-			{
-				mParamDict = &msDictionary.insert( std::make_pair( className, ParamDictionary() ) ).first->second;
-				mParamDictName = className;
-				return true;
-			}
-			else
-			{
-				mParamDict = &it->second;
-				mParamDictName = className;
-				return false;
-			}
-        }
-
-    public:
-		StringInterface() : mParamDict(NULL) { }
-
-        /** Virtual destructor, see Effective C++ */
-        virtual ~StringInterface() {}
-
-        /** Retrieves the parameter dictionary for this class. 
-        @remarks
-            Only valid to call this after createParamDictionary.
-        @returns
-            Pointer to ParamDictionary shared by all instances of this class
-            which you can add parameters to, retrieve parameters etc.
-        */
-        ParamDictionary* getParamDictionary(void)
-        {
-			return mParamDict;
-        }
-
-		const ParamDictionary* getParamDictionary(void) const
-        {
-			return mParamDict;
-        }
-
-        /** Retrieves a list of parameters valid for this object. 
-        @returns
-            A reference to a static list of ParameterDef objects.
-
-        */
-        const ParameterList& getParameters(void) const;
-
-        /** Generic parameter setting method.
-        @remarks
-            Call this method with the name of a parameter and a string version of the value
-            to set. The implementor will convert the string to a native type internally.
-            If in doubt, check the parameter definition in the list returned from 
-            StringInterface::getParameters.
-        @param
-            name The name of the parameter to set
-        @param
-            value String value. Must be in the right format for the type specified in the parameter definition.
-            See the StringConverter class for more information.
-        @returns
-            true if set was successful, false otherwise (NB no exceptions thrown - tolerant method)
-        */
-        virtual bool setParameter(const String& name, const String& value);
-        /** Generic multiple parameter setting method.
-        @remarks
-            Call this method with a list of name / value pairs
-            to set. The implementor will convert the string to a native type internally.
-            If in doubt, check the parameter definition in the list returned from 
-            StringInterface::getParameters.
-        @param
-            paramList Name/value pair list
-        */
-        virtual void setParameterList(const NameValuePairList& paramList);
-        /** Generic parameter retrieval method.
-        @remarks
-            Call this method with the name of a parameter to retrieve a string-format value of
-            the parameter in question. If in doubt, check the parameter definition in the
-            list returned from getParameters for the type of this parameter. If you
-            like you can use StringConverter to convert this string back into a native type.
-        @param
-            name The name of the parameter to get
-        @returns
-            String value of parameter, blank if not found
-        */
-        virtual String getParameter(const String& name) const
-        {
-            // Get dictionary
-            const ParamDictionary* dict = getParamDictionary();
-
-            if (dict)
-            {
-                // Look up command object
-                const ParamCommand* cmd = dict->getParamCommand(name);
-
-                if (cmd)
-                {
-                    return cmd->doGet(this);
-                }
-            }
-
-            // Fallback
-            return "";
-        }
-        /** Method for copying this object's parameters to another object.
-        @remarks
-            This method takes the values of all the object's parameters and tries to set the
-            same values on the destination object. This provides a completely type independent
-            way to copy parameters to other objects. Note that because of the String manipulation 
-            involved, this should not be regarded as an efficient process and should be saved for
-            times outside of the rendering loop.
-        @par
-            Any unrecognised parameters will be ignored as with setParameter method.
-        @param dest Pointer to object to have it's parameters set the same as this object.
-
-        */
-        virtual void copyParametersTo(StringInterface* dest) const
-        {
-            // Get dictionary
-            const ParamDictionary* dict = getParamDictionary();
-
-            if (dict)
-            {
-                // Iterate through own parameters
-                ParameterList::const_iterator i;
-            
-                for (i = dict->mParamDefs.begin(); 
-                i != dict->mParamDefs.end(); ++i)
-                {
-                    dest->setParameter(i->name, getParameter(i->name));
-                }
-            }
-
-
-        }
-
-        /** Cleans up the static 'msDictionary' required to reset Ogre,
-        otherwise the containers are left with invalid pointers, which will lead to a crash
-        as soon as one of the ResourceManager implementers (e.g. MaterialManager) initializes.*/
-        static void cleanupDictionary () ;
-
-    };
-
-	/** @} */
-	/** @} */
-
-
-}
-
-#endif
-

CamelotRenderer/RenderSystemGL/Source/GLSL/include/OgreGLSLProgram.h

@@ -56,14 +56,6 @@ namespace Ogre {
     class _OgreGLExport GLSLProgram : public HighLevelGpuProgram
     {
     public:
-        /// Command object for attaching another GLSL Program 
-        class CmdAttach : public ParamCommand
-        {
-        public:
-            String doGet(const void* target) const;
-            void doSet(void* target, const String& shaderNames);
-        };
-
         GLSLProgram();
 		~GLSLProgram();
 
@@ -115,40 +107,7 @@ namespace Ogre {
 		virtual void setMaxOutputVertices(int maxOutputVertices) 
 		{ mMaxOutputVertices = maxOutputVertices; }
 
-		/// Command object for setting macro defines
-		class CmdPreprocessorDefines : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		/// Command object for setting the input operation type (geometry shader only)
-		class _OgreGLExport CmdInputOperationType : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		/// Command object for setting the output operation type (geometry shader only)
-		class _OgreGLExport CmdOutputOperationType : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-		/// Command object for setting the maximum output vertices (geometry shader only)
-		class _OgreGLExport CmdMaxOutputVertices : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
 	protected:
-		static CmdPreprocessorDefines msCmdPreprocessorDefines;
-        static CmdAttach msCmdAttach;
-		static CmdInputOperationType msInputOperationTypeCmd;
-		static CmdOutputOperationType msOutputOperationTypeCmd;
-		static CmdMaxOutputVertices msMaxOutputVerticesCmd;
 
         /** Internal load implementation, must be implemented by subclasses.
         */

CamelotRenderer/RenderSystemGL/Source/GLSL/src/OgreGLSLProgram.cpp

@@ -40,15 +40,6 @@ THE SOFTWARE.
 #include "OgreGLSLPreprocessor.h"
 
 namespace Ogre {
-
-    //-----------------------------------------------------------------------
-	GLSLProgram::CmdPreprocessorDefines GLSLProgram::msCmdPreprocessorDefines;
-    GLSLProgram::CmdAttach GLSLProgram::msCmdAttach;
-	GLSLProgram::CmdInputOperationType GLSLProgram::msInputOperationTypeCmd;
-	GLSLProgram::CmdOutputOperationType GLSLProgram::msOutputOperationTypeCmd;
-	GLSLProgram::CmdMaxOutputVertices GLSLProgram::msMaxOutputVerticesCmd;
-
-    //-----------------------------------------------------------------------
     //---------------------------------------------------------------------------
     GLSLProgram::~GLSLProgram()
     {
@@ -246,35 +237,6 @@ namespace Ogre {
             mInputOperationType(RenderOperation::OT_TRIANGLE_LIST),
             mOutputOperationType(RenderOperation::OT_TRIANGLE_LIST), mMaxOutputVertices(3)
     {
-		// add parameter command "attach" to the material serializer dictionary
-   //     if (createParamDictionary("GLSLProgram"))
-   //     {
-   //         setupBaseParamDictionary();
-   //         ParamDictionary* dict = getParamDictionary();
-
-			//dict->addParameter(ParameterDef("preprocessor_defines", 
-			//	"Preprocessor defines use to compile the program.",
-			//	PT_STRING),&msCmdPreprocessorDefines);
-   //         dict->addParameter(ParameterDef("attach", 
-   //             "name of another GLSL program needed by this program",
-   //             PT_STRING),&msCmdAttach);
-			//dict->addParameter(
-			//	ParameterDef("input_operation_type",
-			//	"The input operation type for this geometry program. \
-			//	Can be 'point_list', 'line_list', 'line_strip', 'triangle_list', \
-			//	'triangle_strip' or 'triangle_fan'", PT_STRING),
-			//	&msInputOperationTypeCmd);
-			//dict->addParameter(
-			//	ParameterDef("output_operation_type",
-			//	"The input operation type for this geometry program. \
-			//	Can be 'point_list', 'line_strip' or 'triangle_strip'",
-			//	 PT_STRING),
-			//	 &msOutputOperationTypeCmd);
-			//dict->addParameter(
-			//	ParameterDef("max_output_vertices", 
-			//	"The maximum number of vertices a single run of this geometry program can output",
-			//	PT_INT),&msMaxOutputVerticesCmd);
-   //     }
         // Manually assign language now since we use it immediately
         mSyntaxCode = "glsl";
         
@@ -291,32 +253,6 @@ namespace Ogre {
 		// scenemanager should pass on transform state to the rendersystem
 		return true;
 	}
-	//-----------------------------------------------------------------------
-    String GLSLProgram::CmdAttach::doGet(const void *target) const
-    {
-        return (static_cast<const GLSLProgram*>(target))->getAttachedShaderNames();
-    }
-	//-----------------------------------------------------------------------
-    void GLSLProgram::CmdAttach::doSet(void *target, const String& shaderNames)
-    {
-		//get all the shader program names: there could be more than one
-		std::vector<Ogre::String> vecShaderNames = StringUtil::split(shaderNames, " \t", 0);
-
-		size_t programNameCount = vecShaderNames.size();
-		for ( size_t i = 0; i < programNameCount; ++i )
-		{
-	        static_cast<GLSLProgram*>(target)->attachChildShader(vecShaderNames[i]);
-		}
-    }
-	//-----------------------------------------------------------------------
-	String GLSLProgram::CmdPreprocessorDefines::doGet(const void *target) const
-	{
-		return static_cast<const GLSLProgram*>(target)->getPreprocessorDefines();
-	}
-	void GLSLProgram::CmdPreprocessorDefines::doSet(void *target, const String& val)
-	{
-		static_cast<GLSLProgram*>(target)->setPreprocessorDefines(val);
-	}
 
 	//-----------------------------------------------------------------------
     void GLSLProgram::attachChildShader(const String& name)
@@ -453,39 +389,4 @@ namespace Ogre {
 			break;
 		}
 	}
-	//-----------------------------------------------------------------------
-    String GLSLProgram::CmdInputOperationType::doGet(const void* target) const
-    {
-        const GLSLProgram* t = static_cast<const GLSLProgram*>(target);
-		return operationTypeToString(t->getInputOperationType());
-    }
-    void GLSLProgram::CmdInputOperationType::doSet(void* target, const String& val)
-    {
-        GLSLProgram* t = static_cast<GLSLProgram*>(target);
-		t->setInputOperationType(parseOperationType(val));
-    }
-	//-----------------------------------------------------------------------
-	String GLSLProgram::CmdOutputOperationType::doGet(const void* target) const
-    {
-        const GLSLProgram* t = static_cast<const GLSLProgram*>(target);
-		return operationTypeToString(t->getOutputOperationType());
-    }
-    void GLSLProgram::CmdOutputOperationType::doSet(void* target, const String& val)
-    {
-        GLSLProgram* t = static_cast<GLSLProgram*>(target);
-		t->setOutputOperationType(parseOperationType(val));
-    }
-	//-----------------------------------------------------------------------
-	String GLSLProgram::CmdMaxOutputVertices::doGet(const void* target) const
-	{
-		const GLSLProgram* t = static_cast<const GLSLProgram*>(target);
-		return StringConverter::toString(t->getMaxOutputVertices());
-	}
-	void GLSLProgram::CmdMaxOutputVertices::doSet(void* target, const String& val)
-	{
-		GLSLProgram* t = static_cast<GLSLProgram*>(target);
-		t->setMaxOutputVertices(StringConverter::parseInt(val));
-	}
-
-  
 }

CamelotRenderer/TODO.txt

@@ -82,8 +82,8 @@ Viewport - MERGE WITH CAMERA
 
 TODO:
  - Make sure to parse D3D9 implementations of above classes and see what needs removing there as well
+ - OpenGL too
 
-IMPORTANT: After I set up a test case and remove irrelevant Ogre stuff, make sure to port OpenGL, before renaming anything or removing major files
 IMPORTANT: I think I should strive to make the renderer one unique CmRenderSystem.dll (Log manager, exceptions, math can go in a separate CmUtility library?)
    - Later separate out OpenGL and D3D9 dlls as well, since I want to support D3D11. And I want to keep the framework separate from implementation
      - AND because I need to have it separated since I can't expect DirectX to compile on OSX or Linux
@@ -91,14 +91,16 @@ IMPORTANT: I think I should strive to make the renderer one unique CmRenderSyste
 Other notes:
  - Make sure to remove all ogre memory allocators and memory category bullshit (Possibly replace with Camelot versions?)
  - Remove Ogre::String and Ogre::Real (Possibly replace with Camelot versions?)
- - Because HardwareBufferManager is quite useful I will probably need to reintroduce GpuProgramManager as well - Probably not until I add OpenGL
-   - As well as TextureManager
  - Ogre::ColourValue -> CamelotEngine::Color (Other struct names are okay for the most part)
  - Port all math methods to Camelot
  - Rename all macros and other OGRE references to CM
  - How am I notified on device reset? (When I need to reload my resources)
  - If possible, make sure GLSL uses EntryPoint and Profile fields I have added to GpuProgram
  
+ At one point rebuild everything and make sure all warnings are gone
+Figure out how to ignore those warnings in NVparse
+String stuff should go to a single StringUtil file
+
 After everything is polished:
  - Make sure the renderer can run on a separate thread
  - Get 64bit version working