RenderManager initial work

CamelotRenderer/CamelotRenderer.vcxproj

@@ -96,11 +96,14 @@
   <ItemGroup>
     <ClInclude Include="Include\CmApplication.h" />
     <ClInclude Include="Include\CmCamera.h" />
+    <ClInclude Include="Include\CmCameraRTTI.h" />
     <ClInclude Include="Include\CmCgProgram.h" />
     <ClInclude Include="Include\CmCgProgramFactory.h" />
     <ClInclude Include="Include\CmCommon.h" />
+    <ClInclude Include="Include\CmComponentRTTI.h" />
     <ClInclude Include="Include\CmConfigOptionMap.h" />
     <ClInclude Include="Include\CmDefaultHardwareBufferManager.h" />
+    <ClInclude Include="Include\CmForwardRenderManager.h" />
     <ClInclude Include="Include\CmGpuProgram.h" />
     <ClInclude Include="Include\CmGpuProgramManager.h" />
     <ClInclude Include="Include\CmGpuProgramParams.h" />
@@ -119,6 +122,9 @@
     <ClInclude Include="Include\CmMeshData.h" />
     <ClInclude Include="Include\CmMeshDataRTTI.h" />
     <ClInclude Include="Include\CmPrerequisites.h" />
+    <ClInclude Include="Include\CmRenderable.h" />
+    <ClInclude Include="Include\CmRenderableRTTI.h" />
+    <ClInclude Include="Include\CmRenderManager.h" />
     <ClInclude Include="Include\CmRenderOperation.h" />
     <ClInclude Include="Include\CmRenderSystem.h" />
     <ClInclude Include="Include\CmRenderSystemCapabilities.h" />
@@ -153,6 +159,7 @@
     <ClCompile Include="Source\CmCgProgram.cpp" />
     <ClCompile Include="Source\CmCgProgramFactory.cpp" />
     <ClCompile Include="Source\CmDefaultHardwareBufferManager.cpp" />
+    <ClCompile Include="Source\CmForwardRenderManager.cpp" />
     <ClCompile Include="Source\CmGpuProgram.cpp" />
     <ClCompile Include="Source\CmGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmGpuProgramParams.cpp" />
@@ -167,6 +174,7 @@
     <ClCompile Include="Source\CmInput.cpp" />
     <ClCompile Include="Source\CmMesh.cpp" />
     <ClCompile Include="Source\CmMeshData.cpp" />
+    <ClCompile Include="Source\CmRenderable.cpp" />
     <ClCompile Include="Source\CmRenderSystem.cpp" />
     <ClCompile Include="Source\CmRenderSystemCapabilities.cpp" />
     <ClCompile Include="Source\CmRenderSystemManager.cpp" />

CamelotRenderer/CamelotRenderer.vcxproj.filters

@@ -61,6 +61,12 @@
     <Filter Include="Source Files\Input">
       <UniqueIdentifier>{7f8e94f3-6990-4723-965a-2b4f9346a7ee}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\MOVETODLL">
+      <UniqueIdentifier>{f42d28e0-bbe6-4f52-a574-0e2725e3c223}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\MOVETODLL">
+      <UniqueIdentifier>{677211c0-a3d1-4e6a-8acf-f457349f1777}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <Text Include="TODO.txt" />
@@ -220,6 +226,24 @@
     <ClInclude Include="Include\CmInputHandler.h">
       <Filter>Header Files\Input</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmRenderManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmForwardRenderManager.h">
+      <Filter>Header Files\MOVETODLL</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmComponentRTTI.h">
+      <Filter>Header Files\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmCameraRTTI.h">
+      <Filter>Header Files\RTTI</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmRenderable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmRenderableRTTI.h">
+      <Filter>Header Files\RTTI</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CamelotRenderer.cpp">
@@ -336,5 +360,11 @@
     <ClCompile Include="Source\CmInput.cpp">
       <Filter>Source Files\Input</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmForwardRenderManager.cpp">
+      <Filter>Source Files\MOVETODLL</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmRenderable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotRenderer/Include/CmCamera.h

@@ -620,6 +620,17 @@ namespace CamelotEngine {
 		    Forward projection may lead to intersections at infinity.
 		*/
 		void forwardIntersect(const Plane& worldPlane, vector<Vector4>::type* intersect3d) const;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class CameraRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+
+	protected:
+		Camera() {} // Serialization only
      };
 	 /** @} */
 	 /** @} */

CamelotRenderer/Include/CmCameraRTTI.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmComponent.h"
+
+namespace CamelotEngine
+{
+	class CM_EXPORT CameraRTTI : public RTTIType<Camera, Component, CameraRTTI>
+	{
+	private:
+
+	public:
+		CameraRTTI()
+		{
+
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "Camera";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_Camera;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return std::shared_ptr<Camera>(new Camera());
+		}
+	};
+}

CamelotRenderer/Include/CmComponent.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include "CmPrerequisites.h"
+#include "CmIReflectable.h"
 
 namespace CamelotEngine
 {
-	class CM_EXPORT Component
+	class CM_EXPORT Component : public IReflectable
 	{
 	public:
 		GameObjectPtr getGameObject() const { return mParent.lock(); }
@@ -25,5 +26,16 @@ namespace CamelotEngine
 
 		std::weak_ptr<GameObject> mParent;
 		bool mIsDestroyed;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class ComponentRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+
+	protected:
+		Component() {} // Serialization only
 	};
 }

CamelotRenderer/Include/CmComponentRTTI.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmComponent.h"
+
+namespace CamelotEngine
+{
+	class CM_EXPORT ComponentRTTI : public RTTIType<Component, IReflectable, ComponentRTTI>
+	{
+	private:
+
+	public:
+		ComponentRTTI()
+		{
+
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "Component";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_Component;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			CM_EXCEPT(InternalErrorException, "Cannot instantiate an abstract class.");
+		}
+	};
+}

CamelotRenderer/Include/CmForwardRenderManager.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRenderManager.h"
+
+namespace CamelotEngine
+{
+	class ForwardRenderManager : public RenderManager
+	{
+	public:
+		virtual void renderAll();
+
+		virtual void render(const CameraPtr camera);
+	};
+}

CamelotRenderer/Include/CmGameObject.h

@@ -149,6 +149,8 @@ namespace CamelotEngine
 			std::shared_ptr<T> newComponent = std::shared_ptr<T>(new T(mThis.lock()));
 			mComponents.push_back(newComponent);
 
+			gSceneManager().notifyComponentAdded(newComponent);
+
 			return newComponent;
 		}
 

CamelotRenderer/Include/CmPrerequisites.h

@@ -96,6 +96,7 @@ namespace CamelotEngine {
     class VertexDeclaration;
 	class Input;
 	class InputHandler;
+	class Renderable;
 	// Asset import
 	class SpecificImporter;
 	class Importer;
@@ -108,7 +109,7 @@ namespace CamelotEngine {
 	class GameObject;
 	class Component;
 	class SceneManager;
-	// Serialization
+	// RTTI
 	class MeshRTTI;
 }
 
@@ -122,6 +123,8 @@ namespace CamelotEngine
 	typedef std::shared_ptr<Mesh> MeshPtr;
 	typedef std::shared_ptr<Texture> TexturePtr;
 	typedef std::shared_ptr<Resource> ResourcePtr;
+	typedef std::shared_ptr<Camera> CameraPtr;
+	typedef std::shared_ptr<Renderable> RenderablePtr;
 
 	typedef std::shared_ptr<Component> ComponentPtr;
 	typedef std::shared_ptr<GameObject> GameObjectPtr;
@@ -136,7 +139,10 @@ namespace CamelotEngine
 		TID_Mesh = 1002,
 		TID_MeshData = 1003,
 		TID_VertexDeclaration = 1004,
-		TID_VertexData = 1005
+		TID_VertexData = 1005,
+		TID_Component = 1006,
+		TID_Camera = 1007,
+		TID_Renderable = 1008
 	};
 }
 

CamelotRenderer/Include/CmRenderManager.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+
+namespace CamelotEngine
+{
+	class RenderManager
+	{
+	public:
+		/**
+		 * @brief	Renders all cameras.
+		 */
+		virtual void renderAll() = 0;
+
+		/**
+		 * @brief	 Renders the scene from the perspective of a single camera
+		 */
+		virtual void render(const CameraPtr camera) = 0;
+	};
+}

CamelotRenderer/Include/CmRenderable.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmComponent.h"
+
+namespace CamelotEngine
+{
+	class Renderable : public Component
+	{
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class RenderableRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+
+	protected:
+		Renderable() {} // Serialization only
+	};
+}

CamelotRenderer/Include/CmRenderableRTTI.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmRTTIType.h"
+#include "CmRenderable.h"
+
+namespace CamelotEngine
+{
+	class CM_EXPORT RenderableRTTI : public RTTIType<Renderable, Component, RenderableRTTI>
+	{
+	private:
+
+	public:
+		RenderableRTTI()
+		{
+
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "Renderable";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_Renderable;
+		}
+
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return std::shared_ptr<Renderable>(new Renderable());
+		}
+	};
+}

CamelotRenderer/Include/CmSceneManager.h

@@ -19,6 +19,13 @@ namespace CamelotEngine
 
 		GameObjectPtr getRootNode() const { return mRootNode; }
 
+		/**
+		 * @brief	Returns all cameras in the scene.
+		 */
+		const vector<CameraPtr>::type& getAllCameras() const { return mCachedCameras; }
+
+		vector<RenderablePtr>::type getVisibleRenderables(const CameraPtr camera) const;
+
 	private:
 		friend class GameObject;
 		GameObjectPtr mRootNode;
@@ -32,6 +39,11 @@ namespace CamelotEngine
 		 * @param [in]	node	Node you wish to add. It's your responsibility not to add duplicate or null nodes. This method won't check.
 		 */
 		void registerNewGO(GameObjectPtr node);
+
+		void notifyComponentAdded(ComponentPtr component);
+		void notifyComponentRemoved(ComponentPtr component);
+
+		vector<CameraPtr>::type mCachedCameras;
 	};
 
 	CM_EXPORT SceneManager& gSceneManager();

CamelotRenderer/Source/CmCamera.cpp

@@ -26,6 +26,7 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmCamera.h"
+#include "CmCameraRTTI.h"
 
 #include "CmMath.h"
 #include "CmMatrix3.h"
@@ -40,10 +41,6 @@ THE SOFTWARE.
 #include "CmRenderSystem.h"
 #include "CmGameObject.h"
 
-#if CM_PLATFORM == OGRE_PLATFORM_IPHONE
-#include "macUtils.h"
-#endif
-
 namespace CamelotEngine {
 	const float Camera::INFINITE_FAR_PLANE_ADJUST = 0.00001f;
 
@@ -1341,4 +1338,14 @@ namespace CamelotEngine {
 			}
 		}
 	}
+
+	RTTITypeBase* Camera::getRTTIStatic()
+	{
+		return CameraRTTI::instance();
+	}
+
+	RTTITypeBase* Camera::getRTTI() const
+	{
+		return Camera::getRTTIStatic();
+	}
 } // namespace CamelotEngine

CamelotRenderer/Source/CmComponent.cpp

@@ -1,4 +1,5 @@
 #include "CmComponent.h"
+#include "CmComponentRTTI.h"
 
 namespace CamelotEngine
 {
@@ -18,4 +19,14 @@ namespace CamelotEngine
 	{
 		mIsDestroyed = true;
 	}
+
+	RTTITypeBase* Component::getRTTIStatic()
+	{
+		return ComponentRTTI::instance();
+	}
+
+	RTTITypeBase* Component::getRTTI() const
+	{
+		return Component::getRTTIStatic();
+	}
 }

CamelotRenderer/Source/CmForwardRenderManager.cpp

@@ -0,0 +1,25 @@
+#include "CmForwardRenderManager.h"
+#include "CmCamera.h"
+#include "CmSceneManager.h"
+
+namespace CamelotEngine
+{
+	void ForwardRenderManager::renderAll() 
+	{
+		const vector<CameraPtr>::type& allCameras = gSceneManager().getAllCameras();
+
+		for(auto iter = allCameras.begin(); iter != allCameras.end(); ++iter)
+		{
+			render(*iter);
+		}
+	}
+
+	void ForwardRenderManager::render(const CameraPtr camera) 
+	{
+		vector<RenderablePtr>::type allRenderables = gSceneManager().getVisibleRenderables(camera);
+
+		// TODO - Sort renderables
+		// Render them
+	}
+
+}

CamelotRenderer/Source/CmGameObject.cpp

@@ -279,6 +279,8 @@ namespace CamelotEngine
 		{
 			(*iter)->destroy();
 			mComponents.erase(iter);
+
+			gSceneManager().notifyComponentRemoved((*iter));
 		}
 		else
 			LOGDBG("Trying to remove a component that doesn't exist on this GameObject.");

CamelotRenderer/Source/CmRenderable.cpp

@@ -0,0 +1,15 @@
+#include "CmRenderable.h"
+#include "CmRenderableRTTI.h"
+
+namespace CamelotEngine
+{
+	RTTITypeBase* Renderable::getRTTIStatic()
+	{
+		return RenderableRTTI::instance();
+	}
+
+	RTTITypeBase* Renderable::getRTTI() const
+	{
+		return Renderable::getRTTIStatic();
+	}
+}

CamelotRenderer/Source/CmSceneManager.cpp

@@ -1,5 +1,7 @@
 #include "CmSceneManager.h"
 #include "CmGameObject.h"
+#include "CmComponent.h"
+#include "CmCamera.h"
 
 namespace CamelotEngine
 {
@@ -14,12 +16,51 @@ namespace CamelotEngine
 			mRootNode->destroy();
 	}
 
+	vector<RenderablePtr>::type SceneManager::getVisibleRenderables(const CameraPtr camera) const
+	{
+		// TODO - Actually iterate over all game objects and find visible renderables
+
+		return vector<RenderablePtr>::type();
+	}
+
 	void SceneManager::registerNewGO(GameObjectPtr node) 
 	{ 
 		if(mRootNode) // If root node is null, then this new node is the root node
 			node->setParent(mRootNode);
 	}
 
+	void SceneManager::notifyComponentAdded(ComponentPtr component)
+	{
+		if(component->getTypeId() == TID_Camera)
+		{
+			CameraPtr camera = std::static_pointer_cast<Camera>(component);
+			auto findIter = std::find(mCachedCameras.begin(), mCachedCameras.end(), camera);
+
+			if(findIter != mCachedCameras.end())
+			{
+				CM_EXCEPT(InternalErrorException, "Trying to add an already existing camera!");
+			}
+
+			mCachedCameras.push_back(camera);
+		}
+	}
+
+	void SceneManager::notifyComponentRemoved(ComponentPtr component)
+	{
+		if(component->getTypeId() == TID_Camera)
+		{
+			CameraPtr camera = std::static_pointer_cast<Camera>(component);
+			auto findIter = std::find(mCachedCameras.begin(), mCachedCameras.end(), camera);
+
+			if(findIter == mCachedCameras.end())
+			{
+				CM_EXCEPT(InternalErrorException, "Cannot find specified camera!");
+			}
+
+			mCachedCameras.erase(findIter);
+		}
+	}
+
 	SceneManager& gSceneManager()
 	{
 		return SceneManager::instance();

CamelotUtility/Include/CmIReflectable.h

@@ -43,5 +43,7 @@ namespace CamelotEngine
 		 * 			(Or if it is the same type as base)
 		 */
 		bool isDerivedFrom(RTTITypeBase* base);
+
+		UINT32 getTypeId();
 	};
 }

CamelotUtility/Source/CmIReflectable.cpp

@@ -76,4 +76,9 @@ namespace CamelotEngine
 
 		return false;
 	}
+
+	UINT32 IReflectable::getTypeId()
+	{ 
+		return getRTTI()->getRTTIId(); 
+	}
 }