Removed a ton of unused stuff from GpuProgram

CamelotRenderer/OgreGpuProgram.cpp

@@ -39,10 +39,8 @@ namespace Ogre
 {
     //-----------------------------------------------------------------------------
     GpuProgram::GpuProgram() 
-        :mType(GPT_VERTEX_PROGRAM), mLoadFromFile(true), mSkeletalAnimation(false),
-		mMorphAnimation(false), mPoseAnimation(0),
-        mVertexTextureFetch(false), mNeedsAdjacencyInfo(false),
-		mCompileError(false), mLoadedManualNamedConstants(false), mProfile(GPP_NONE)
+        :mType(GPT_VERTEX_PROGRAM),
+		mCompileError(false), mProfile(GPP_NONE)
     {
 		createParameterMappingStructures();
     }
@@ -57,19 +55,9 @@ namespace Ogre
         mSyntaxCode = syntax;
     }
     //-----------------------------------------------------------------------------
-    void GpuProgram::setSourceFile(const String& filename)
-    {
-        mFilename = filename;
-        mSource.clear();
-        mLoadFromFile = true;
-		mCompileError = false;
-    }
-    //-----------------------------------------------------------------------------
     void GpuProgram::setSource(const String& source)
     {
         mSource = source;
-        mFilename.clear();
-        mLoadFromFile = false;
 		mCompileError = false;
     }
 		
@@ -96,31 +84,6 @@ namespace Ogre
 			mCompileError = true;
 		}
 
-    }
-    //-----------------------------------------------------------------------------
-    bool GpuProgram::isRequiredCapabilitiesSupported(void) const
-    {
-		// TODO PORT- I dont think I'll be using these capabilities
-		return true;
-
-		//const RenderSystemCapabilities* caps = 
-		//	Root::getSingleton().getRenderSystem()->getCapabilities();
-
-  //      // If skeletal animation is being done, we need support for UBYTE4
-  //      if (isSkeletalAnimationIncluded() && 
-  //          !caps->hasCapability(RSC_VERTEX_FORMAT_UBYTE4))
-  //      {
-  //          return false;
-  //      }
-
-		//// Vertex texture fetch required?
-		//if (isVertexTextureFetchRequired() && 
-		//	!caps->hasCapability(RSC_VERTEX_TEXTURE_FETCH))
-		//{
-		//	return false;
-		//}
-
-  //      return true;
     }
     //-----------------------------------------------------------------------------
     bool GpuProgram::isSupported(void) const
@@ -131,6 +94,11 @@ namespace Ogre
 		RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
 		return rs->getCapabilities()->isShaderProfileSupported(mSyntaxCode);
     }
+	//-----------------------------------------------------------------------------
+	bool GpuProgram::isRequiredCapabilitiesSupported(void) const
+	{
+		return true;
+	}
 	//---------------------------------------------------------------------
 	void GpuProgram::createParameterMappingStructures(bool recreateIfExists) const
 	{
@@ -151,46 +119,6 @@ namespace Ogre
 		if (recreateIfExists || (mConstantDefs == nullptr))
 			mConstantDefs = GpuNamedConstantsPtr(OGRE_NEW GpuNamedConstants());
 	}
-	//---------------------------------------------------------------------
-	void GpuProgram::setManualNamedConstantsFile(const String& paramDefFile)
-	{
-		mManualNamedConstantsFile = paramDefFile;
-		mLoadedManualNamedConstants = false;
-	}
-	//---------------------------------------------------------------------
-	void GpuProgram::setManualNamedConstants(const GpuNamedConstants& namedConstants)
-	{
-		createParameterMappingStructures();
-		*mConstantDefs.get() = namedConstants;
-
-		mFloatLogicalToPhysical->bufferSize = mConstantDefs->floatBufferSize;
-		mIntLogicalToPhysical->bufferSize = mConstantDefs->intBufferSize;
-		mFloatLogicalToPhysical->map.clear();
-		mIntLogicalToPhysical->map.clear();
-		// need to set up logical mappings too for some rendersystems
-		for (GpuConstantDefinitionMap::const_iterator i = mConstantDefs->map.begin();
-			i != mConstantDefs->map.end(); ++i)
-		{
-			const String& name = i->first;
-			const GpuConstantDefinition& def = i->second;
-			// only consider non-array entries
-			if (name.find("[") == String::npos)
-			{
-				GpuLogicalIndexUseMap::value_type val(def.logicalIndex, 
-					GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, def.variability));
-				if (def.isFloat())
-				{
-					mFloatLogicalToPhysical->map.insert(val);
-				}
-				else
-				{
-					mIntLogicalToPhysical->map.insert(val);
-				}
-			}
-		}
-
-
-	}
     //-----------------------------------------------------------------------------
     GpuProgramParametersSharedPtr GpuProgram::createParameters(void)
     {
@@ -220,10 +148,6 @@ namespace Ogre
         }
         return mDefaultParams;
     }
-    //-----------------------------------------------------------------------------
-    void GpuProgram::setupBaseParamDictionary(void)
-    {
-    }
 
     //-----------------------------------------------------------------------
     const String& GpuProgram::getLanguage(void) const

CamelotRenderer/OgreGpuProgram.h

@@ -80,28 +80,16 @@ namespace Ogre {
 	protected:
 		/// The type of the program
 		GpuProgramType mType;
+		/// Does this (geometry) program require adjacency information?
+		bool mNeedsAdjacencyInfo;
 		/// Name of the shader entry method
 		String mEntryPoint;
 		/// Shader profiler that we are targeting (e.g. vs_1_1, etc.). Make sure profile matches the type.
 		GpuProgramProfile mProfile;
-		/// The name of the file to load source from (may be blank)
-		String mFilename;
         /// The assembler source of the program (may be blank until file loaded)
         String mSource;
-        /// Whether we need to load source from file or not
-        bool mLoadFromFile;
         /// Syntax code e.g. arbvp1, vs_2_0 etc
         String mSyntaxCode;
-        /// Does this (vertex) program include skeletal animation?
-        bool mSkeletalAnimation;
-		/// Does this (vertex) program include morph animation?
-		bool mMorphAnimation;
-		/// Does this (vertex) program include pose animation (count of number of poses supported)
-		ushort mPoseAnimation;
-		/// Does this (vertex) program require support for vertex texture fetch?
-		bool mVertexTextureFetch;
-		/// Does this (geometry) program require adjacency information?
-		bool mNeedsAdjacencyInfo;
 		/// The default parameters for use with this object
 		GpuProgramParametersSharedPtr mDefaultParams;
 		/// Did we encounter a compilation error?
@@ -121,20 +109,6 @@ namespace Ogre {
 		change, this definition will alter, but previous params may reference the old def.
 		*/
 		mutable GpuNamedConstantsPtr mConstantDefs;
-		/// File from which to load named constants manually
-		String mManualNamedConstantsFile;
-		bool mLoadedManualNamedConstants;
-
-
-		/** Internal method for setting up the basic parameter definitions for a subclass. 
-		@remarks
-		Because StringInterface holds a dictionary of parameters per class, subclasses need to
-		call this to ask the base class to add it's parameters to their dictionary as well.
-		Can't do this in the constructor because that runs in a non-virtual context.
-		@par
-		The subclass must have called it's own createParamDictionary before calling this method.
-		*/
-		void setupBaseParamDictionary(void);
 
         /** Internal method returns whether required capabilities for this program is supported.
         */
@@ -159,12 +133,6 @@ namespace Ogre {
 		virtual void load(void);
 		virtual void unload() {}
 
-        /** Sets the filename of the source assembly for this program.
-        @remarks
-            Setting this will have no effect until you (re)load the program.
-        */
-        virtual void setSourceFile(const String& filename);
-
 		/** Sets the source assembly for this program from an in-memory string.
         @remarks
             Setting this will have no effect until you (re)load the program.
@@ -177,8 +145,6 @@ namespace Ogre {
 		/** Sets the syntax code for this program e.g. arbvp1, fp20, vs_1_1 etc */
 		virtual void setSyntaxCode(const String& syntax);
 
-		/** Gets the name of the file used as source for this program. */
-		virtual const String& getSourceFile(void) const { return mFilename; }
         /** Gets the assembler source for this program. */
         virtual const String& getSource(void) const { return mSource; }
 		/// Set the program type (only valid before load)
@@ -201,79 +167,6 @@ namespace Ogre {
         /** Returns whether this program can be supported on the current renderer and hardware. */
         virtual bool isSupported(void) const;
 
-        /** Creates a new parameters object compatible with this program definition. 
-        @remarks
-            It is recommended that you use this method of creating parameters objects
-            rather than going direct to GpuProgramManager, because this method will
-            populate any implementation-specific extras (like named parameters) where
-            they are appropriate.
-        */
-        virtual GpuProgramParametersSharedPtr createParameters(void);
-
-        /** Sets whether a vertex program includes the required instructions
-        to perform skeletal animation. 
-        @remarks
-        If this is set to true, OGRE will not blend the geometry according to 
-        skeletal animation, it will expect the vertex program to do it.
-        */
-        virtual void setSkeletalAnimationIncluded(bool included) 
-        { mSkeletalAnimation = included; }
-
-        /** Returns whether a vertex program includes the required instructions
-            to perform skeletal animation. 
-        @remarks
-            If this returns true, OGRE will not blend the geometry according to 
-            skeletal animation, it will expect the vertex program to do it.
-        */
-        virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; }
-
-        /** Sets whether a vertex program includes the required instructions
-        to perform morph animation. 
-        @remarks
-        If this is set to true, OGRE will not blend the geometry according to 
-        morph animation, it will expect the vertex program to do it.
-        */
-        virtual void setMorphAnimationIncluded(bool included) 
-		{ mMorphAnimation = included; }
-
-        /** Sets whether a vertex program includes the required instructions
-        to perform pose animation. 
-        @remarks
-        If this is set to true, OGRE will not blend the geometry according to 
-        pose animation, it will expect the vertex program to do it.
-		@param poseCount The number of simultaneous poses the program can blend
-        */
-        virtual void setPoseAnimationIncluded(ushort poseCount) 
-		{ mPoseAnimation = poseCount; }
-
-		/** Returns whether a vertex program includes the required instructions
-            to perform morph animation. 
-        @remarks
-            If this returns true, OGRE will not blend the geometry according to 
-            morph animation, it will expect the vertex program to do it.
-        */
-        virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; }
-
-		/** Returns whether a vertex program includes the required instructions
-            to perform pose animation. 
-        @remarks
-            If this returns true, OGRE will not blend the geometry according to 
-            pose animation, it will expect the vertex program to do it.
-        */
-        virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; }
-		/** Returns the number of simultaneous poses the vertex program can 
-			blend, for use in pose animation.
-        */
-        virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; }
-		/** Sets whether this vertex program requires support for vertex 
-			texture fetch from the hardware.
-		*/
-		virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; }
-		/** Returns whether this vertex program requires support for vertex 
-			texture fetch from the hardware.
-		*/
-		virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; }
-
 		/** Sets whether this geometry program requires adjacency information
 			from the input primitives.
 		*/
@@ -282,6 +175,15 @@ namespace Ogre {
 			from the input primitives.
 		*/
 		virtual bool isAdjacencyInfoRequired(void) const { return mNeedsAdjacencyInfo; }
+
+        /** Creates a new parameters object compatible with this program definition. 
+        @remarks
+            It is recommended that you use this method of creating parameters objects
+            rather than going direct to GpuProgramManager, because this method will
+            populate any implementation-specific extras (like named parameters) where
+            they are appropriate.
+        */
+        virtual GpuProgramParametersSharedPtr createParameters(void);
 		
 		/** Get a reference to the default parameters which are to be used for all
 			uses of this program.
@@ -299,32 +201,6 @@ namespace Ogre {
         */
         virtual bool hasDefaultParameters(void) const { return mDefaultParams != nullptr; }
 
-		/** Returns whether a vertex program wants light and material states to be passed
-		through fixed pipeline low level API rendering calls (default false, subclasses can override)
-		@remarks
-			Most vertex programs do not need this material information, however GLSL
-			shaders can refer to this material and lighting state so enable this option
-		*/
-		virtual bool getPassSurfaceAndLightStates(void) const { return false; }
-
-		/** Returns whether a fragment program wants fog state to be passed
-		through fixed pipeline low level API rendering calls (default true, subclasses can override)
-		@remarks
-		On DirectX, shader model 2 and earlier continues to have fixed-function fog
-		applied to it, so fog state is still passed (you should disable fog on the
-		pass if you want to perform fog in the shader). In OpenGL it is also
-		common to be able to access the fixed-function fog state inside the shader. 
-		*/
-		virtual bool getPassFogStates(void) const { return true; }
-
-		/** Returns whether a vertex program wants transform state to be passed
-		through fixed pipeline low level API rendering calls
-		@remarks
-		Most vertex programs do not need fixed-function transform information, however GLSL
-		shaders can refer to this state so enable this option
-		*/
-		virtual bool getPassTransformStates(void) const { return false; }
-
 		/** Returns a string that specifies the language of the gpu programs as specified
         in a material script. ie: asm, cg, hlsl, glsl
         */
@@ -338,35 +214,9 @@ namespace Ogre {
 		*/
 		virtual void resetCompileError(void) { mCompileError = false; }
 
-		/** Allows you to manually provide a set of named parameter mappings
-			to a program which would not be able to derive named parameters itself.
-		@remarks
-			You may wish to use this if you have assembler programs that were compiled
-			from a high-level source, and want the convenience of still being able
-			to use the named parameters from the original high-level source.
-		@see setManualNamedConstantsFile
-		*/
-		virtual void setManualNamedConstants(const GpuNamedConstants& namedConstants);
-
 		/// Get a read-only reference to the named constants registered for this program (manually or automatically)
 		virtual const GpuNamedConstants& getNamedConstants() const { return *mConstantDefs.get(); }
 
-		/** Specifies the name of a file from which to load named parameters mapping
-			for a program which would not be able to derive named parameters itself.
-		@remarks
-			You may wish to use this if you have assembler programs that were compiled
-			from a high-level source, and want the convenience of still being able
-			to use the named parameters from the original high-level source. This
-			method will make a low-level program search in the resource group of the
-			program for the named file from which to load parameter names from. 
-			The file must be in the format produced by GpuNamedConstants::save.
-		*/
-		virtual void setManualNamedConstantsFile(const String& paramDefFile);
-
-		/** Gets the name of a file from which to load named parameters mapping
-			for a program which would not be able to derive named parameters itself.
-		*/
-		virtual const String& getManualNamedConstantsFile() const { return mManualNamedConstantsFile; }
 		/** Get the full list of named constants.
 		@note
 		Only available if this parameters object has named parameters, which means either

CamelotRenderer/OgreHighLevelGpuProgram.cpp

@@ -133,16 +133,6 @@ namespace Ogre
     //---------------------------------------------------------------------------
     void HighLevelGpuProgram::loadHighLevelImpl(void)
     {
-        if (mLoadFromFile)
-        {
-            //// find & load source code
-            //DataStreamPtr stream = 
-            //    ResourceGroupManager::getSingleton().openResource(
-            //        mFilename, mGroup, true, this);
-
-            //mSource = stream->getAsString();
-        }
-
         loadFromSource();
 
 

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

@@ -57,12 +57,6 @@ namespace Ogre {
 		{
 			mProgramID = ++mGeometryShaderCount;
 		}
-
-        // transfer skeletal animation status from parent
-        mSkeletalAnimation = mGLSLProgram->isSkeletalAnimationIncluded();
-		// there is nothing to load
-		mLoadFromFile = false;
-
     }
     //-----------------------------------------------------------------------
     GLSLGpuProgram::~GLSLGpuProgram()

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

@@ -126,7 +126,6 @@ namespace Ogre {
 			if (mVertexProgram)
 			{
 				mVertexProgram->getGLSLProgram()->attachToProgramObject(mGLHandle);
-				setSkeletalAnimationIncluded(mVertexProgram->isSkeletalAnimationIncluded());
 			}
 			if (mGeometryProgram)
 			{

CamelotRenderer/TODO.txt

@@ -1,8 +1,16 @@
-1. Search for all "TODO PORT" comments and fix them
-  - First I should create a render system singleton other classes can easily access
-2. Try to reproduce minimal functionality by rendering a cube (Similar like OgreToCamelotPort project does)
-3. Start stripping down the classes and see what I really need
-4. Port OpenGL render system as well
+PARSED FILES:
+
+GpuProgram - PARSED!
+TextureState - PARSED!
+ - This is just an utility class representing texture state
+VertexIndexData - Just data structures
+ - VertexCacheProfiler is a weird one, but I think I don't have to remove it as it might come in handy
+RenderTexture - Everything OK
+RenderWindow - Everything OK
+HardwareIndexBuffer - Everything OK
+RenderSystemCapabilities - I think I need all of that
+
+TODO FILES:
 
 Camera:
  - Remove auto tracking
@@ -21,13 +29,6 @@ Frustum
  - Remove orientation stuff because it's iPhone only
  - World space methods need to be updated. I still need them but they need to get their data from Transform
 
-GpuProgram - Most low level shader program. Single pixel/vertex/geometry shader.
- - keeps a lot of data specific to skeletal anim, morphing and similar. It should be more generic
- - has code that points to the source file, that should be at a higher level
- - also has code for loading directly from source file, but it should be loaded from string
- - has fixed pipeline code like surface and light states, fog states and transform states
- - ParamCommand and specific parameters that inherit from it should also be removed. Together with StringInterface.h
-
 GpuProgramParams - Holds all parameters used in a shader program and allows us to set them by index or name
  - Explore if we can remove GpuSharedParameters. I'm not exactly sure what they're used for
 
@@ -37,8 +38,6 @@ HardwareBuffer - Base class for all buffers
 HardwareBufferManager - Abstracts whether I'm creating D3D9 or OpenGL buffers
  - License stuff needs to be removed. I'm not sure what it's used for
 
-HardwareIndexBuffer - Everything OK
-
 HardwareOcclusionQuery - OK, but I might consider a more generic interface for queries (I'll need profiling queries too for example)
 
 HardwarePixelBuffer 
@@ -51,26 +50,14 @@ HardwareVertexBuffer - Very neat file
 HighLevelGpuProgram - Mostly okay
  - Has some methods for loading from a file, which I wont do
 
-RenderSystemCapabilities - I think I need all of that
-
 RenderTarget:
  - update() causes rendering to start - This probably need to be moved to camera, as I want it to be responsible for rendering
  - keeps a viewport list, which I also don't think I'll need
  - autoUpdate and various update methods that I probably don't need
 
-RenderTexture - Everything OK
-
-RenderWindow - Everything OK
-
 Texture
  - mTreatLuminanceAsAlpha and corresponding methods - I dont think I need that or that it's used
 
-TextureState - PARSED!
- - This is just an utility class representing texture state
-
-VertexIndexData - Just data structures
- - VertexCacheProfiler is a weird one, but I think I don't have to remove it as it might come in handy
-
 Viewport - MERGE WITH CAMERA
  - Remove orientation mode
  - Remove various update/clearEveryFrame methods
@@ -87,6 +74,7 @@ IMPORTANT: I think I should strive to make the renderer one unique CmRenderSyste
      - AND because I need to have it separated since I can't expect DirectX to compile on OSX or Linux
 
 Other notes:
+ - Search for all remaining "TODO PORT" comments and fix them
  - 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?)
  - Ogre::ColourValue -> CamelotEngine::Color (Other struct names are okay for the most part)