Started work on applying pass properties in the renderer

CamelotRenderer/Include/CmForwardRenderer.h

@@ -5,13 +5,28 @@
 
 namespace CamelotEngine
 {
-	class ForwardRenderer : public Renderer
+	class CM_EXPORT ForwardRenderer : public Renderer
 	{
 	public:
+		/**
+		 * @brief	Overriden from Renderer
+		 */
 		virtual const String& getName() const;
 
+		/**
+		 * @brief	Overriden from Renderer
+		 */
 		virtual void renderAll();
 
+		/**
+		 * @brief	Overriden from Renderer
+		 */
 		virtual void render(const CameraPtr camera);
+
+	protected:
+		/**
+		 * @brief	Overriden from Renderer
+		 */
+		virtual void setPass(const Pass* pass);
 	};
 }

CamelotRenderer/Include/CmPass.h

@@ -52,10 +52,6 @@ namespace CamelotEngine
 		unsigned char mAlphaRejectVal;
 		bool mAlphaToCoverageEnabled;
 
-		// Transparent depth sorting
-		bool mTransparentSorting;
-		// Transparent depth sorting forced
-		bool mTransparentSortingForced;
         //-------------------------------------------------------------------------
 
         //-------------------------------------------------------------------------
@@ -415,39 +411,6 @@ namespace CamelotEngine
 		*/
 		bool isAlphaToCoverageEnabled() const { return mAlphaToCoverageEnabled; }
 
-        /** Sets whether or not transparent sorting is enabled.
-        @param enabled
-			If false depth sorting of this material will be disabled.
-        @remarks
-			By default all transparent materials are sorted such that renderables furthest
-			away from the camera are rendered first. This is usually the desired behaviour
-			but in certain cases this depth sorting may be unnecessary and undesirable. If
-			for example it is necessary to ensure the rendering order does not change from
-			one frame to the next.
-		@note
-			This will have no effect on non-transparent materials.
-        */
-        void setTransparentSortingEnabled(bool enabled);
-
-        /** Returns whether or not transparent sorting is enabled.
-        */
-		bool getTransparentSortingEnabled(void) const;
-
-        /** Sets whether or not transparent sorting is forced.
-        @param enabled
-			If true depth sorting of this material will be depend only on the value of
-            getTransparentSortingEnabled().
-        @remarks
-			By default even if transparent sorting is enabled, depth sorting will only be
-            performed when the material is transparent and depth write/check are disabled.
-            This function disables these extra conditions.
-        */
-        void setTransparentSortingForced(bool enabled);
-
-        /** Returns whether or not transparent sorting is forced.
-        */
-		bool getTransparentSortingForced(void) const;
-
 		/** Sets the details of the vertex program to use.
 		*/
 		void setVertexProgram(GpuProgramRef gpuProgram);

CamelotRenderer/Include/CmPassRTTI.h

@@ -63,12 +63,6 @@ namespace CamelotEngine
 		bool& getAlphaToCoverageEnabled(Pass* obj) { return obj->mAlphaToCoverageEnabled; }
 		void setAlphaToCoverageEnabled(Pass* obj, bool& val) { obj->mAlphaToCoverageEnabled = val; } 
 
-		bool& getTransparentSorting(Pass* obj) { return obj->mTransparentSorting; }
-		void setTransparentSorting(Pass* obj, bool& val) { obj->mTransparentSorting = val; } 
-
-		bool& getTransparentSortingForced(Pass* obj) { return obj->mTransparentSortingForced; }
-		void setTransparentSortingForced(Pass* obj, bool& val) { obj->mTransparentSortingForced = val; } 
-
 		CullingMode& getCullMode(Pass* obj) { return obj->mCullMode; }
 		void setCullMode(Pass* obj, CullingMode& val) { obj->mCullMode = val; } 
 
@@ -119,8 +113,6 @@ namespace CamelotEngine
 			addPlainField("mAlphaRejectFunc", 15, &PassRTTI::getAlphaRejectFunc, &PassRTTI::setAlphaRejectFunc);
 			addPlainField("mAlphaRejectVal", 16, &PassRTTI::getAlphaRejectVal, &PassRTTI::setAlphaRejectVal);
 			addPlainField("mAlphaToCoverageEnabled", 17, &PassRTTI::getAlphaToCoverageEnabled, &PassRTTI::setAlphaToCoverageEnabled);
-			addPlainField("mTransparentSorting", 18, &PassRTTI::getTransparentSorting, &PassRTTI::setTransparentSorting);
-			addPlainField("mTransparentSortingForced", 19, &PassRTTI::getTransparentSortingForced, &PassRTTI::setTransparentSortingForced);
 
 			addPlainField("mCullMode", 20, &PassRTTI::getCullMode, &PassRTTI::setCullMode);
 			addPlainField("mPolygonMode", 21, &PassRTTI::getPolygonMode, &PassRTTI::setPolygonMode);

CamelotRenderer/Include/CmRenderSystem.h

@@ -520,7 +520,7 @@ namespace CamelotEngine
 
 		// ------------------------------------------------------------------------
 		//                     Internal Rendering Access
-		// All methods below here are normally only called by other OGRE classes
+		// All methods below here are normally only called by other Camelot classes
 		// They can be called by library user if required
 		// ------------------------------------------------------------------------
 

CamelotRenderer/Include/CmRenderer.h

@@ -18,5 +18,11 @@ namespace CamelotEngine
 		 * @brief	 Renders the scene from the perspective of a single camera
 		 */
 		virtual void render(const CameraPtr camera) = 0;
+
+	protected:
+		/**
+		 * @brief	Sets the currently active pass.
+		 */
+		virtual void setPass(const Pass* pass) = 0;
 	};
 }

CamelotRenderer/Source/CmForwardRenderer.cpp

@@ -1,6 +1,9 @@
 #include "CmForwardRenderer.h"
 #include "CmCamera.h"
 #include "CmSceneManager.h"
+#include "CmPass.h"
+#include "CmRenderSystem.h"
+#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine
 {
@@ -28,4 +31,114 @@ namespace CamelotEngine
 		// Render them
 	}
 
+	void ForwardRenderer::setPass(const Pass* pass)
+	{
+		RenderSystem* renderSystem = RenderSystemManager::getActive();
+
+		GpuProgramRef vertProgram = pass->getVertexProgram();
+		if(vertProgram)
+		{
+			renderSystem->bindGpuProgram(vertProgram->_getBindingDelegate());
+		}
+		else
+		{
+			if(renderSystem->isGpuProgramBound(GPT_VERTEX_PROGRAM))
+				renderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
+		}
+
+		GpuProgramRef fragProgram = pass->getFragmentProgram();
+		if(fragProgram)
+		{
+			renderSystem->bindGpuProgram(fragProgram->_getBindingDelegate());
+		}
+		else
+		{
+			if(renderSystem->isGpuProgramBound(GPT_FRAGMENT_PROGRAM))
+				renderSystem->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
+		}
+
+		GpuProgramRef geomProgram = pass->getGeometryProgram();
+		if(geomProgram)
+		{
+			renderSystem->bindGpuProgram(geomProgram->_getBindingDelegate());
+		}	
+		else
+		{
+			if(renderSystem->isGpuProgramBound(GPT_GEOMETRY_PROGRAM))
+				renderSystem->unbindGpuProgram(GPT_GEOMETRY_PROGRAM);
+		}
+
+		// The rest of the settings are the same no matter whether we use programs or not
+
+		// Set scene blending
+		if ( pass->hasSeparateSceneBlending( ) )
+		{
+			renderSystem->_setSeparateSceneBlending(
+				pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
+				pass->getSourceBlendFactorAlpha(), pass->getDestBlendFactorAlpha(),
+				pass->getSceneBlendingOperation(), 
+				pass->hasSeparateSceneBlendingOperations() ? pass->getSceneBlendingOperation() : pass->getSceneBlendingOperationAlpha() );
+		}
+		else
+		{
+			if(pass->hasSeparateSceneBlendingOperations( ) )
+			{
+				renderSystem->_setSeparateSceneBlending(
+					pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
+					pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
+					pass->getSceneBlendingOperation(), pass->getSceneBlendingOperationAlpha() );
+			}
+			else
+			{
+				renderSystem->_setSceneBlending(
+					pass->getSourceBlendFactor(), pass->getDestBlendFactor(), pass->getSceneBlendingOperation() );
+			}
+		}
+
+		// Set point parameters
+		renderSystem->_setPointParameters(
+			pass->getPointSize(),
+			false, 
+			false, 
+			false, 
+			false, 
+			pass->getPointMinSize(), 
+			pass->getPointMaxSize());
+
+
+
+
+
+		// TODO - Set texture sampler states!
+		
+		// TODO - Try to limit amount of state changes, if previous state is already the same (especially with textures)
+		
+		// TODO: Disable remaining texture units
+		//renderSystem->_disableTextureUnitsFrom(pass->getNumTextureUnitStates());
+
+
+
+
+		// Set up non-texture related material settings
+		// Depth buffer settings
+		renderSystem->_setDepthBufferFunction(pass->getDepthFunction());
+		renderSystem->_setDepthBufferCheckEnabled(pass->getDepthCheckEnabled());
+		renderSystem->_setDepthBufferWriteEnabled(pass->getDepthWriteEnabled());
+		renderSystem->_setDepthBias(pass->getDepthBiasConstant(), pass->getDepthBiasSlopeScale());
+
+		// Alpha-reject settings
+		renderSystem->_setAlphaRejectSettings(
+			pass->getAlphaRejectFunction(), pass->getAlphaRejectValue(), pass->isAlphaToCoverageEnabled());
+
+		// Set colour write mode
+		// Right now we only use on/off, not per-channel
+		bool colWrite = pass->getColourWriteEnabled();
+		renderSystem->_setColourBufferWriteEnabled(colWrite, colWrite, colWrite, colWrite);
+
+		// Culling mode
+		renderSystem->_setCullingMode(pass->getCullingMode());
+		
+		// Polygon mode
+		renderSystem->_setPolygonMode(pass->getPolygonMode());
+	}
 }

CamelotRenderer/Source/CmPass.cpp

@@ -24,8 +24,6 @@ namespace CamelotEngine
 		, mAlphaRejectFunc(CMPF_ALWAYS_PASS)
 		, mAlphaRejectVal(0)
 		, mAlphaToCoverageEnabled(false)
-		, mTransparentSorting(true)
-		, mTransparentSortingForced(false)
 		, mCullMode(CULL_CLOCKWISE)
 		, mPolygonMode(PM_SOLID)
 		, mPassIterationCount(1)
@@ -66,8 +64,6 @@ namespace CamelotEngine
 		mAlphaRejectFunc = oth.mAlphaRejectFunc;
 		mAlphaRejectVal = oth.mAlphaRejectVal;
 		mAlphaToCoverageEnabled = oth.mAlphaToCoverageEnabled;
-		mTransparentSorting = oth.mTransparentSorting;
-		mTransparentSortingForced = oth.mTransparentSortingForced;
         mColourWrite = oth.mColourWrite;
 	    mDepthFunc = oth.mDepthFunc;
         mDepthBiasConstant = oth.mDepthBiasConstant;
@@ -256,26 +252,6 @@ namespace CamelotEngine
 	{
 		mAlphaToCoverageEnabled = enabled;
 	}
-	//-----------------------------------------------------------------------
-	void Pass::setTransparentSortingEnabled(bool enabled)
-	{
-		mTransparentSorting = enabled;
-	}
-	//-----------------------------------------------------------------------
-	bool Pass::getTransparentSortingEnabled(void) const
-	{
-		return mTransparentSorting;
-	}
-	//-----------------------------------------------------------------------
-	void Pass::setTransparentSortingForced(bool enabled)
-	{
-		mTransparentSortingForced = enabled;
-	}
-	//-----------------------------------------------------------------------
-	bool Pass::getTransparentSortingForced(void) const
-	{
-		return mTransparentSortingForced;
-	}
     //-----------------------------------------------------------------------
 	void Pass::setColourWriteEnabled(bool enabled)
 	{