Set up shaders, pass and rendering through them

CamelotRenderer/CmApplication.cpp

@@ -39,8 +39,25 @@ namespace CamelotEngine
 
 		mViewport = mRenderWindow->addViewport();
 
-		Ogre::HighLevelGpuProgramPtr fragProg = mGpuProgramManager->createProgram("barg", "barg", "hlsl", Ogre::GPT_FRAGMENT_PROGRAM, Ogre::GPP_PS_1_1);
-		fragProg->load();
+		Ogre::String fragShaderCode = "float4 ps_main() : COLOR0	\
+		{														\
+			float4 color = float4(0, 0, 0, 0);					\
+			color.r = 1.0f;										\
+			color.a = 1.0f;										\
+			return color;										\
+		}";
+
+		mFragProg = mGpuProgramManager->createProgram(fragShaderCode, "ps_main", "hlsl", Ogre::GPT_FRAGMENT_PROGRAM, Ogre::GPP_PS_2_0);
+		mFragProg->load();
+
+		Ogre::String vertShaderCode = "float4x4 matViewProjection; \
+		float4 vs_main(float4 inPos : POSITION) : POSITION \
+		{ \
+			return mul(matViewProjection, inPos); \
+		}";
+
+		mVertProg = mGpuProgramManager->createProgram(vertShaderCode, "vs_main", "hlsl", Ogre::GPT_VERTEX_PROGRAM, Ogre::GPP_VS_2_0);
+		mVertProg->load();
 
 		while(true)
 		{
@@ -160,16 +177,28 @@ namespace CamelotEngine
 		Ogre::RenderSystem* renderSystem = RenderSystemManager::getActive();
 		renderSystem->_setViewport(mViewport);
 
-		Ogre::Matrix4 projMatrix = mCamera->getProjectionMatrixRS();
-		renderSystem->_setProjectionMatrix(projMatrix);
+		//Ogre::Matrix4 projMatrix = mCamera->getProjectionMatrixRS();
+		//renderSystem->_setProjectionMatrix(projMatrix);
 
+		//Ogre::Matrix4 viewMatrix = mCamera->getViewMatrix(true);
+		//renderSystem->_setViewMatrix(viewMatrix);
+
+		Ogre::Matrix4 projMatrix = mCamera->getProjectionMatrix();
 		Ogre::Matrix4 viewMatrix = mCamera->getViewMatrix(true);
-		renderSystem->_setViewMatrix(viewMatrix);
+
+		Ogre::Matrix4 viewProjMatrix = projMatrix * viewMatrix;
 
 		renderSystem->setInvertVertexWinding(true);
 		renderSystem->clearFrameBuffer(Ogre::FBT_COLOUR | Ogre::FBT_DEPTH, Ogre::ColourValue::Blue);
 		renderSystem->_beginFrame();
 
+		mVertProg->getDefaultParameters()->setNamedConstant("matViewProjection", viewProjMatrix);
+
+		renderSystem->bindGpuProgramParameters(Ogre::GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), Ogre::GPV_ALL);
+		renderSystem->bindGpuProgram(mVertProg->_getBindingDelegate()); // TODO - I don't like this. Shader should be able to be bound directly!
+		renderSystem->bindGpuProgramParameters(Ogre::GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), Ogre::GPV_ALL);
+
+		renderSystem->bindGpuProgram(mFragProg->_getBindingDelegate()); // TODO - I don't like this. Shader should be able to be bound directly!
 		renderSystem->_render(ro);
 
 		renderSystem->_endFrame();

CamelotRenderer/CmApplication.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include "OgreHighLevelGpuProgram.h"
 
 namespace Ogre
 {
@@ -28,6 +29,8 @@ namespace CamelotEngine
 			Ogre::RenderWindow* mRenderWindow;
 			Ogre::Viewport* mViewport;
 			Ogre::Camera* mCamera;
+			Ogre::HighLevelGpuProgramPtr mFragProg;
+			Ogre::HighLevelGpuProgramPtr mVertProg;
 	};
 
 	Application& gApplication();

CamelotRenderer/OgreD3D9GpuProgram.cpp

@@ -248,6 +248,10 @@ namespace Ogre {
 		}
 		else
 		{
+			OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, 
+				"Specified D3D9 vertex shader is not supported!",
+				"D3D9GpuVertexProgram::loadFromMicrocode");
+
 			// TODO PORT - Log this error somewhere
 			//LogManager::getSingleton().logMessage(
 			//	"Unsupported D3D9 vertex shader '" + mName + "' was not loaded.");

CamelotRenderer/OgreD3D9GpuProgram.h

@@ -60,11 +60,11 @@ namespace Ogre {
         D3D9GpuProgram();
         ~D3D9GpuProgram();
 
-		void load(void);
+		virtual void load(void);
 		/** Loads this program to specified device */
-		void load(IDirect3DDevice9* d3d9Device);
+		virtual void load(IDirect3DDevice9* d3d9Device);
 		/** Overridden from GpuProgram */
-		void unload(void);
+		virtual void unload(void);
 
         /** Sets whether matrix packing in column-major order. */ 
         void setColumnMajorMatrices(bool columnMajor) { mColumnMajorMatrices = columnMajor; }

CamelotRenderer/OgreGpuProgram.cpp

@@ -93,21 +93,9 @@ namespace Ogre
 		{
 			loadFromSource();
 
-			if (!mDefaultParams.isNull())
-			{
-				// Keep a reference to old ones to copy
-				GpuProgramParametersSharedPtr savedParams = mDefaultParams;
-				// reset params to stop them being referenced in the next create
-				mDefaultParams.setNull();
-
-				// Create new params
-				mDefaultParams = createParameters();
+			assert(mDefaultParams.isNull());
 
-				// Copy old (matching) values across
-				// Don't use copyConstantsFrom since program may be different
-				mDefaultParams->copyMatchingNamedConstantsFrom(*savedParams.get());
-
-			}
+			mDefaultParams = createParameters();
 		}
 		catch (const Exception&)
 		{

CamelotRenderer/OgreGpuProgram.h

@@ -218,7 +218,8 @@ namespace Ogre {
 
 		virtual ~GpuProgram() {}
 
-		void load(void);
+		virtual void load(void);
+		virtual void unload() {}
 
         /** Sets the filename of the source assembly for this program.
         @remarks

CamelotRenderer/OgreHighLevelGpuProgram.cpp

@@ -47,6 +47,11 @@ namespace Ogre
 			// create low-level implementation
 			createLowLevelImpl();
 
+			// load constructed assembler program (if it exists)
+			if (!mAssemblerProgram.isNull() && mAssemblerProgram.getPointer() != this)
+			{
+				mAssemblerProgram->load();
+			}
 		}
     }
     //---------------------------------------------------------------------------
@@ -77,13 +82,9 @@ namespace Ogre
 		// Only populate named parameters if we can support this program
 		if (this->isSupported())
 		{
-			loadHighLevel();
-			// Errors during load may have prevented compile
-			if (this->isSupported())
-			{
-				populateParameterNames(params);
-			}
+			populateParameterNames(params);
 		}
+
 		// Copy in default parameters if present
 		if (!mDefaultParams.isNull())
 			params->copyConstantsFrom(*(mDefaultParams.get()));
@@ -98,21 +99,9 @@ namespace Ogre
 			{
 				loadHighLevelImpl();
 				mHighLevelLoaded = true;
-				if (!mDefaultParams.isNull())
-				{
-					// Keep a reference to old ones to copy
-					GpuProgramParametersSharedPtr savedParams = mDefaultParams;
-					// reset params to stop them being referenced in the next create
-					mDefaultParams.setNull();
-
-					// Create new params
-					mDefaultParams = createParameters();
-
-					// Copy old (matching) values across
-					// Don't use copyConstantsFrom since program may be different
-					mDefaultParams->copyMatchingNamedConstantsFrom(*savedParams.get());
 
-				}
+				assert(mDefaultParams.isNull()); // TODO - These two lines and replicated both here and in GpuProgram. I should probably add another load method that holds it all in one place?
+				mDefaultParams = createParameters();
 
 			}
 			catch (const Exception& e)

CamelotRenderer/OgreHighLevelGpuProgram.h

@@ -98,8 +98,8 @@ namespace Ogre {
         HighLevelGpuProgram();
         ~HighLevelGpuProgram();
 
-		void load();
-		void unload();
+		virtual void load();
+		virtual void unload();
 
         /** Creates a new parameters object compatible with this program definition. 
         @remarks

CamelotRenderer/TODO.txt

@@ -83,6 +83,7 @@ Viewport - MERGE WITH CAMERA
 TODO:
  - Make sure to parse D3D9 implementations of above classes and see what needs removing there as well
 
+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
 
 Other notes:
  - Make sure to remove all ogre memory allocators and memory category bullshit (Possibly replace with Camelot versions?)