Namespace changed to CamelotEngine

CamelotRenderer/CamelotRenderer.cpp

@@ -33,7 +33,7 @@ using namespace CamelotEngine;
 
 int _tmain(int argc, _TCHAR* argv[])
 {
-	//const Ogre::String& name = CamelotEngine::gApplication().getRenderSystem()->getName();
+	//const String& name = CamelotEngine::gApplication().getRenderSystem()->getName();
 
 	gApplication().startUp();
 

CamelotRenderer/CmApplication.cpp

@@ -19,12 +19,12 @@ namespace CamelotEngine
 
 	void Application::startUp()
 	{
-		mGpuProgramManager = new Ogre::HighLevelGpuProgramManager(); // TODO - Use Camelot::Module for instantiating this
+		mGpuProgramManager = new HighLevelGpuProgramManager(); // TODO - Use Camelot::Module for instantiating this
 
 		//RenderSystemManager::initialize("D3D9RenderSystem");
 		RenderSystemManager::initialize("GLRenderSystem");
 
-		Ogre::RenderSystem* renderSystem = RenderSystemManager::getActive();
+		RenderSystem* renderSystem = RenderSystemManager::getActive();
 		renderSystem->_initialise(false, "Camelot Renderer");
 
 		mRenderWindow = renderSystem->_createRenderWindow("Camelot Renderer", 800, 600, false);
@@ -32,9 +32,9 @@ namespace CamelotEngine
 		//renderSystem->setAmbientLight(1.0f, 1.0f, 1.0f);
 		renderSystem->setLightingEnabled(false);
 
-		mCamera = new Ogre::Camera("SimpleCam");
-		mCamera->setPosition(Ogre::Vector3(0,0,80));
-		mCamera->lookAt(Ogre::Vector3(0,0,-300));
+		mCamera = new Camera("SimpleCam");
+		mCamera->setPosition(Vector3(0,0,80));
+		mCamera->lookAt(Vector3(0,0,-300));
 		mCamera->setNearClipDistance(5);
 		mCamera->setAspectRatio(480.0f / 640.0f);
 
@@ -42,7 +42,7 @@ namespace CamelotEngine
 
 		/////////////////// HLSL SHADERS //////////////////////////
 
-		//Ogre::String fragShaderCode = "float4 ps_main() : COLOR0	\
+		//String fragShaderCode = "float4 ps_main() : COLOR0	\
 		//{														\
 		//	float4 color = float4(0, 0, 0, 0);					\
 		//	color.r = 1.0f;										\
@@ -50,42 +50,42 @@ namespace CamelotEngine
 		//	return color;										\
 		//}";
 
-		//mFragProg = mGpuProgramManager->createProgram(fragShaderCode, "ps_main", "hlsl", Ogre::GPT_FRAGMENT_PROGRAM, Ogre::GPP_PS_2_0);
+		//mFragProg = mGpuProgramManager->createProgram(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
 		//mFragProg->load();
 
-		//Ogre::String vertShaderCode = "float4x4 matViewProjection; \
+		//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 = mGpuProgramManager->createProgram(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
 		//mVertProg->load();
 
 		///////////////// GLSL SHADERS ////////////////////////////
-		Ogre::String fragShaderCode = "void main() \
+		String fragShaderCode = "void main() \
 									  {\
 									  gl_FragColor = vec4(0.0,1.0,0.0,1.0); \
 									  }";
 
-		mFragProg = mGpuProgramManager->createProgram(fragShaderCode, "main", "glsl", Ogre::GPT_FRAGMENT_PROGRAM, Ogre::GPP_PS_2_0);
+		mFragProg = mGpuProgramManager->createProgram(fragShaderCode, "main", "glsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
 		mFragProg->load();
 
 		// TODO - Ogres GLSL parsing requires some strict parameter naming, can that be avoided?
-		Ogre::String vertShaderCode = "uniform mat4 matViewProjection; \
+		String vertShaderCode = "uniform mat4 matViewProjection; \
 									  attribute vec4 vertex; \
 								void main() \
 									  { \
 									  gl_Position = matViewProjection * vertex; \
 									  }";
 
-		mVertProg = mGpuProgramManager->createProgram(vertShaderCode, "main", "glsl", Ogre::GPT_VERTEX_PROGRAM, Ogre::GPP_VS_2_0);
+		mVertProg = mGpuProgramManager->createProgram(vertShaderCode, "main", "glsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
 		mVertProg->load();
 
 
 		while(true)
 		{
-			Ogre::WindowEventUtilities::messagePump();
+			WindowEventUtilities::messagePump();
 
 			DBG_renderSimpleFrame();
 		}
@@ -102,16 +102,16 @@ namespace CamelotEngine
 
 	void Application::DBG_renderSimpleFrame()
 	{
-		Ogre::RenderOperation ro;
-		Ogre::IndexData* indexData = new Ogre::IndexData();
+		RenderOperation ro;
+		IndexData* indexData = new IndexData();
 
 		indexData->indexCount = 36;
-		indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(
-			Ogre::HardwareIndexBuffer::IT_16BIT,
+		indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer(
+			HardwareIndexBuffer::IT_16BIT,
 			36, 
-			Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
+			HardwareBuffer::HBU_STATIC_WRITE_ONLY);
 
-		unsigned short* idxData = static_cast<unsigned short*>(indexData->indexBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL));
+		unsigned short* idxData = static_cast<unsigned short*>(indexData->indexBuffer->lock(HardwareBuffer::HBL_NORMAL));
 
 		idxData[0] = 0; idxData[1] = 1; idxData[2] = 2;
 		idxData[3] = 2; idxData[4] = 3; idxData[5] = 0;
@@ -134,60 +134,60 @@ namespace CamelotEngine
 		indexData->indexBuffer->unlock();
 
 
-		Ogre::VertexData* vertexData = new Ogre::VertexData();
+		VertexData* vertexData = new VertexData();
 
 		vertexData->vertexStart = 0;
 		vertexData->vertexCount = 8;
 
-		Ogre::VertexDeclaration* decl = vertexData->vertexDeclaration;
+		VertexDeclaration* decl = vertexData->vertexDeclaration;
 		decl->removeAllElements();
 
 		size_t offset = 0;
-		decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
-		offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
+		decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
+		offset += VertexElement::getTypeSize(VET_FLOAT3);
 
-		//decl->addElement(0, offset, Ogre::VET_COLOUR, Ogre::VES_DIFFUSE);
-		//offset += Ogre::VertexElement::getTypeSize(Ogre::VET_COLOUR);
+		//decl->addElement(0, offset, VET_COLOUR, VES_DIFFUSE);
+		//offset += VertexElement::getTypeSize(VET_COLOUR);
 
-		Ogre::HardwareVertexBufferPtr vertexBuffer = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
+		HardwareVertexBufferPtr vertexBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
 			vertexData->vertexDeclaration->getVertexSize(0),
 			vertexData->vertexCount,
-			Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
+			HardwareBuffer::HBU_STATIC_WRITE_ONLY);
 
 		vertexData->vertexBufferBinding->setBinding(0, vertexBuffer);
 
 		size_t vertexSize = vertexBuffer->getVertexSize();
-		char* vertBufferData = static_cast<char*>(vertexBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL));
+		char* vertBufferData = static_cast<char*>(vertexBuffer->lock(HardwareBuffer::HBL_NORMAL));
 
-		Ogre::Vector3 position(-5.0f, -5.0f, -5.0f);
+		Vector3 position(-5.0f, -5.0f, -5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(-5.0f, 5.0f, -5.0f);
+		position = 	Vector3(-5.0f, 5.0f, -5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(5.0f, 5.0f, -5.0f);
+		position = 	Vector3(5.0f, 5.0f, -5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(5.0f, -5.0f, -5.0f);
+		position = 	Vector3(5.0f, -5.0f, -5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(-5.0f, -5.0f, 5.0f);
+		position = 	Vector3(-5.0f, -5.0f, 5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(5.0f, -5.0f, 5.0f);
+		position = 	Vector3(5.0f, -5.0f, 5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(5.0f, 5.0f, 5.0f);
+		position = 	Vector3(5.0f, 5.0f, 5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
-		position = 	Ogre::Vector3(-5.0f, 5.0f, 5.0f);
+		position = 	Vector3(-5.0f, 5.0f, 5.0f);
 		memcpy(vertBufferData, &position, vertexSize);
 		vertBufferData += vertexSize;
 
@@ -196,36 +196,36 @@ namespace CamelotEngine
 		ro.indexData = indexData;
 		ro.vertexData = vertexData;
 		ro.useIndexes = true;
-		ro.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
+		ro.operationType = RenderOperation::OT_TRIANGLE_LIST;
 
-		Ogre::RenderSystem* renderSystem = RenderSystemManager::getActive();
+		RenderSystem* renderSystem = RenderSystemManager::getActive();
 		renderSystem->_setViewport(mViewport);
 
-		//Ogre::Matrix4 projMatrix = mCamera->getProjectionMatrixRS();
+		//Matrix4 projMatrix = mCamera->getProjectionMatrixRS();
 		//renderSystem->_setProjectionMatrix(projMatrix);
 
-		//Ogre::Matrix4 viewMatrix = mCamera->getViewMatrix(true);
+		//Matrix4 viewMatrix = mCamera->getViewMatrix(true);
 		//renderSystem->_setViewMatrix(viewMatrix);
 
-		Ogre::Matrix4 projMatrixCstm = mCamera->getProjectionMatrix();
-		Ogre::Matrix4 viewMatrixCstm = mCamera->getViewMatrix(true);
+		Matrix4 projMatrixCstm = mCamera->getProjectionMatrix();
+		Matrix4 viewMatrixCstm = mCamera->getViewMatrix(true);
 
-		Ogre::Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;
+		Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;
 
 		renderSystem->setInvertVertexWinding(true);
-		renderSystem->clearFrameBuffer(Ogre::FBT_COLOUR | Ogre::FBT_DEPTH, Ogre::ColourValue::Blue);
+		renderSystem->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH, ColourValue::Blue);
 		renderSystem->_beginFrame();
 
 		mVertProg->getDefaultParameters()->setNamedConstant("matViewProjection", viewProjMatrix);
 
-		//renderSystem->bindGpuProgramParameters(Ogre::GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), Ogre::GPV_ALL);
+		//renderSystem->bindGpuProgramParameters(GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), GPV_ALL);
 
 		renderSystem->bindGpuProgram(mFragProg->_getBindingDelegate()); // TODO - I don't like this. Shader should be able to be bound directly!
 		renderSystem->bindGpuProgram(mVertProg->_getBindingDelegate()); // TODO - I don't like this. Shader should be able to be bound directly!
 
 		// TODO - Shaders need to be bound and only then parameters can be set. I need to encapuslate this better because I can't expect users to know that
-		renderSystem->bindGpuProgramParameters(Ogre::GPT_FRAGMENT_PROGRAM, mFragProg->getDefaultParameters(), Ogre::GPV_ALL); // TODO - If I dont call bind parameters before shader wont activate? I think I should handle that differently
-		renderSystem->bindGpuProgramParameters(Ogre::GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), Ogre::GPV_ALL);
+		renderSystem->bindGpuProgramParameters(GPT_FRAGMENT_PROGRAM, mFragProg->getDefaultParameters(), GPV_ALL); // TODO - If I dont call bind parameters before shader wont activate? I think I should handle that differently
+		renderSystem->bindGpuProgramParameters(GPT_VERTEX_PROGRAM, mVertProg->getDefaultParameters(), GPV_ALL);
 
 		
 		

CamelotRenderer/CmApplication.h

@@ -3,7 +3,7 @@
 #include <memory>
 #include "OgreHighLevelGpuProgram.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	class RenderWindow;
 	class Viewport;
@@ -24,13 +24,13 @@ namespace CamelotEngine
 			void DBG_renderSimpleFrame();
 
 		private:
-			Ogre::HighLevelGpuProgramManager* mGpuProgramManager;
+			HighLevelGpuProgramManager* mGpuProgramManager;
 
-			Ogre::RenderWindow* mRenderWindow;
-			Ogre::Viewport* mViewport;
-			Ogre::Camera* mCamera;
-			Ogre::HighLevelGpuProgramPtr mFragProg;
-			Ogre::HighLevelGpuProgramPtr mVertProg;
+			RenderWindow* mRenderWindow;
+			Viewport* mViewport;
+			Camera* mCamera;
+			HighLevelGpuProgramPtr mFragProg;
+			HighLevelGpuProgramPtr mVertProg;
 	};
 
 	Application& gApplication();

CamelotRenderer/CmD3D9RenderSystemFactory.cpp

@@ -10,7 +10,7 @@ namespace CamelotEngine
 		HINSTANCE hInst = GetModuleHandle( "CamelotEngine.dll" ); // TODO - Change name if I plan on using external dll
 	#endif
 
-		return RenderSystemPtr(new Ogre::D3D9RenderSystem(hInst));
+		return RenderSystemPtr(new D3D9RenderSystem(hInst));
 	}
 
 	D3D9RenderSystemFactory::InitOnStart D3D9RenderSystemFactory::initOnStart;

CamelotRenderer/CmRenderSystemFactory.h

@@ -3,14 +3,14 @@
 #include <string>
 #include <memory>
 
-namespace Ogre
+namespace CamelotEngine
 {
 	class RenderSystem;
 }
 
 namespace CamelotEngine
 {
-	typedef std::shared_ptr<Ogre::RenderSystem> RenderSystemPtr;
+	typedef std::shared_ptr<RenderSystem> RenderSystemPtr;
 
 	class RenderSystemFactory
 	{

CamelotRenderer/CmRenderSystemManager.cpp

@@ -25,7 +25,7 @@ namespace CamelotEngine
 
 		if(mActiveRenderSystem == nullptr)
 		{
-			OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, 
+			OGRE_EXCEPT(CamelotEngine::Exception::ERR_INTERNAL_ERROR, 
 				"Cannot initialize render system. Renderer with the name '" + name + "' cannot be found.",
 				"RenderSystemManager::initialize")
 		}

CamelotRenderer/CmRenderSystemManager.h

@@ -15,7 +15,7 @@ namespace CamelotEngine
 	{
 	public:
 		static void initialize(const std::string& name);
-		static Ogre::RenderSystem* getActive() { return mActiveRenderSystem.get(); }
+		static RenderSystem* getActive() { return mActiveRenderSystem.get(); }
 
 		static void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
 	private:

CamelotRenderer/OgreAlignedAllocator.cpp

@@ -47,7 +47,7 @@ THE SOFTWARE.
 * 6 -> Wasted memory at rear of data block.
 */
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //---------------------------------------------------------------------
     void* AlignedMemory::allocate(size_t size, size_t alignment)

CamelotRenderer/OgreAlignedAllocator.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 // the prerequisites header (circlar reference)
 //#include "OgrePrerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreAxisAlignedBox.cpp

@@ -27,7 +27,7 @@ THE SOFTWARE.
 */
 #include "OgreAxisAlignedBox.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	const AxisAlignedBox AxisAlignedBox::BOX_NULL;
 	const AxisAlignedBox AxisAlignedBox::BOX_INFINITE(AxisAlignedBox::EXTENT_INFINITE);

CamelotRenderer/OgreAxisAlignedBox.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreVector3.h"
 #include "OgreMatrix4.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/
@@ -808,6 +808,6 @@ namespace Ogre {
 
 	/** @} */
 	/** @} */
-} // namespace Ogre
+} // namespace CamelotEngine
 
 #endif

CamelotRenderer/OgreBitwise.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgrePrerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreBlendMode.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgrePrerequisites.h"
 #include "OgreColourValue.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreCamera.cpp

@@ -38,7 +38,7 @@ THE SOFTWARE.
 #include "macUtils.h"
 #endif
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //-----------------------------------------------------------------------
     Camera::Camera( const String& name)
@@ -856,4 +856,4 @@ namespace Ogre {
 	}
 
 
-} // namespace Ogre
+} // namespace CamelotEngine

CamelotRenderer/OgreCamera.h

@@ -43,7 +43,7 @@ THE SOFTWARE.
 #include "OgreRay.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{
@@ -440,5 +440,5 @@ namespace Ogre {
 	 /** @} */
 	 /** @} */
 
-} // namespace Ogre
+} // namespace CamelotEngine
 #endif

CamelotRenderer/OgreColourValue.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreColourValue.h"
 #include "OgreMath.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     const ColourValue ColourValue::ZERO = ColourValue(0.0,0.0,0.0,0.0);
     const ColourValue ColourValue::Black = ColourValue(0.0,0.0,0.0);

CamelotRenderer/OgreColourValue.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgrePrerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreCommon.h

@@ -42,7 +42,7 @@ THE SOFTWARE.
 #   pragma GCC visibility pop
 #endif
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreConfig.h

@@ -97,7 +97,7 @@ THE SOFTWARE.
 #  define OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR 1
 #endif
 
-//if you want to make Ogre::String use the custom memory allocator then set:
+//if you want to make String use the custom memory allocator then set:
 //#define OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR 1
 // Doing this will mean Ogre's strings will not be compatible with std::string however
 #ifndef OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR

CamelotRenderer/OgreConfigOptionMap.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreString.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/
@@ -50,7 +50,7 @@ namespace Ogre {
     {
         String name;
         String currentValue;
-        std::vector<Ogre::String> possibleValues;
+        std::vector<String> possibleValues;
         bool immutable;
     } ConfigOption;
 

CamelotRenderer/OgreD3D9Device.cpp

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	HWND D3D9Device::msSharedFocusWindow = NULL;
 
@@ -1414,7 +1414,7 @@ namespace Ogre
 			}
 		}
 
-		PixelFormat format = Ogre::D3D9Mappings::_getPF(desc.Format);
+		PixelFormat format = CamelotEngine::D3D9Mappings::_getPF(desc.Format);
 
 		if (format == PF_UNKNOWN)
 		{

CamelotRenderer/OgreD3D9Device.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreRenderTarget.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	class D3D9RenderWindow;
 	class D3D9DeviceManager;

CamelotRenderer/OgreD3D9DeviceManager.cpp

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	//---------------------------------------------------------------------
 	D3D9DeviceManager::D3D9DeviceManager()

CamelotRenderer/OgreD3D9DeviceManager.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgreD3D9Prerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	class D3D9Device;
 	class D3D9RenderWindow;

CamelotRenderer/OgreD3D9Driver.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreD3D9VideoModeList.h"
 #include "OgreD3D9VideoMode.h"
 
-namespace Ogre
+namespace CamelotEngine
 {   
 	D3D9Driver::D3D9Driver()
 	{						

CamelotRenderer/OgreD3D9Driver.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreString.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 
 	class D3D9VideoModeList;

CamelotRenderer/OgreD3D9DriverList.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	D3D9DriverList::D3D9DriverList()
 	{

CamelotRenderer/OgreD3D9DriverList.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreD3D9Driver.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	class _OgreD3D9Export D3D9DriverList
 	{

CamelotRenderer/OgreD3D9GpuProgram.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Mappings.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     //-----------------------------------------------------------------------------
     D3D9GpuProgram::D3D9GpuProgram() 
         : GpuProgram(), mpExternalMicrocode(NULL), mColumnMajorMatrices(false)

CamelotRenderer/OgreD3D9GpuProgram.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreGpuProgram.h"
 #include "OgreD3D9Resource.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     /** Direct3D implementation of a few things common to low-level vertex & fragment programs. */
     class _OgreD3D9Export D3D9GpuProgram : public GpuProgram, public D3D9Resource

CamelotRenderer/OgreD3D9GpuProgramManager.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreD3D9GpuProgram.h"
 #include "OgreException.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     //-----------------------------------------------------------------------------
     D3D9GpuProgramManager::D3D9GpuProgramManager()
 		:GpuProgramManager()

CamelotRenderer/OgreD3D9GpuProgramManager.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreGpuProgram.h"
 #include "OgreGpuProgramManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     class _OgreD3D9Export D3D9GpuProgramManager : public GpuProgramManager
     {

CamelotRenderer/OgreD3D9HLSLProgram.cpp

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreRenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	class _OgreD3D9Export HLSLIncludeHandler : public ID3DXInclude
 	{
 	public:

CamelotRenderer/OgreD3D9HLSLProgram.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreHighLevelGpuProgram.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     /** Specialisation of HighLevelGpuProgram to provide support for D3D9 
         High-Level Shader Language (HLSL).
     @remarks

CamelotRenderer/OgreD3D9HLSLProgramFactory.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #include "OgreString.h"
 #include "OgreD3D9HLSLProgram.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     //-----------------------------------------------------------------------
     String D3D9HLSLProgramFactory::sLanguageName = "hlsl";
     //-----------------------------------------------------------------------

CamelotRenderer/OgreD3D9HLSLProgramFactory.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreHighLevelGpuProgramManager.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
     /** Factory class for D3D9 HLSL programs. */
     class _OgreD3D9Export D3D9HLSLProgramFactory : public HighLevelGpuProgramFactory

CamelotRenderer/OgreD3D9HardwareBufferManager.cpp

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreStringConverter.h"
 #include "OgreException.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     //-----------------------------------------------------------------------
     D3D9HardwareBufferManagerBase::D3D9HardwareBufferManagerBase()       
     {

CamelotRenderer/OgreD3D9HardwareBufferManager.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreHardwareBufferManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     /** Implementation of HardwareBufferManager for D3D9. */
     class _OgreD3D9Export D3D9HardwareBufferManagerBase : public HardwareBufferManagerBase

CamelotRenderer/OgreD3D9HardwareIndexBuffer.cpp

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreD3D9Device.h"
 #include "OgreD3D9ResourceManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
     D3D9HardwareIndexBuffer::D3D9HardwareIndexBuffer(HardwareBufferManagerBase* mgr, HardwareIndexBuffer::IndexType idxType, 

CamelotRenderer/OgreD3D9HardwareIndexBuffer.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreHardwareIndexBuffer.h"
 #include "OgreD3D9Resource.h"
 
-namespace Ogre { 
+namespace CamelotEngine { 
 
 
     class _OgreD3D9Export D3D9HardwareIndexBuffer : public HardwareIndexBuffer, public D3D9Resource

CamelotRenderer/OgreD3D9HardwareOcclusionQuery.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/**
 	* This is a class that is the DirectX9 implementation of 

CamelotRenderer/OgreD3D9HardwareOcclusionQuery.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreD3D9Resource.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	// If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered 
 	// if the first pass results has too few pixels visible.

CamelotRenderer/OgreD3D9HardwarePixelBuffer.cpp

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreRenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 CM_STATIC_MUTEX_INSTANCE(D3D9HardwarePixelBuffer::msDeviceAccessMutex)
 //-----------------------------------------------------------------------------  
@@ -372,7 +372,7 @@ PixelBox D3D9HardwarePixelBuffer::lockImpl(const Box lockBox,  LockOptions optio
 }
 
 //-----------------------------------------------------------------------------  
-Ogre::PixelBox D3D9HardwarePixelBuffer::lockBuffer(BufferResources* bufferResources, 
+CamelotEngine::PixelBox D3D9HardwarePixelBuffer::lockBuffer(BufferResources* bufferResources, 
 												   const Box &lockBox, 
 												   DWORD flags)
 {
@@ -969,7 +969,7 @@ void D3D9HardwarePixelBuffer::updateRenderTexture(bool writeGamma, uint fsaa, co
 	if (mRenderTexture == NULL)
 	{
 		String name;
-		name = "rtt/" +Ogre::StringConverter::toString((size_t)this) + "/" + srcName;
+		name = "rtt/" +CamelotEngine::StringConverter::toString((size_t)this) + "/" + srcName;
 
 		mRenderTexture = new D3D9RenderTexture(name, this, writeGamma, fsaa);		
 

CamelotRenderer/OgreD3D9HardwarePixelBuffer.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreHardwarePixelBuffer.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	class D3D9Texture;
 	class D3D9RenderTexture;

CamelotRenderer/OgreD3D9HardwareVertexBuffer.cpp

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreD3D9Device.h"
 #include "OgreD3D9ResourceManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
     D3D9HardwareVertexBuffer::D3D9HardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize, 

CamelotRenderer/OgreD3D9HardwareVertexBuffer.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreHardwareVertexBuffer.h"
 #include "OgreD3D9Resource.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     /// Specialisation of HardwareVertexBuffer for D3D9
     class _OgreD3D9Export D3D9HardwareVertexBuffer : public HardwareVertexBuffer, public D3D9Resource

CamelotRenderer/OgreD3D9Mappings.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #include "OgreStringConverter.h"
 #include "OgreException.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	//---------------------------------------------------------------------
 	DWORD D3D9Mappings::get(ShadeOptions so)
@@ -206,7 +206,7 @@ namespace Ogre
 		return D3DBLEND_FORCE_DWORD;
 	}
 	//---------------------------------------------------------------------
-	D3DBLENDOP D3D9Mappings::get(Ogre::SceneBlendOperation sbo)
+	D3DBLENDOP D3D9Mappings::get(CamelotEngine::SceneBlendOperation sbo)
 	{
 		switch(sbo)
 		{

CamelotRenderer/OgreD3D9Mappings.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreHardwareBuffer.h"
 #include "OgreHardwareIndexBuffer.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	class _OgreD3D9Export D3D9Mappings
 	{

CamelotRenderer/OgreD3D9MultiRenderTarget.cpp

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreD3D9DeviceManager.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	D3D9MultiRenderTarget::D3D9MultiRenderTarget(const String &name):
 		MultiRenderTarget(name)

CamelotRenderer/OgreD3D9MultiRenderTarget.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreD3D9HardwarePixelBuffer.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	class _OgreD3D9Export D3D9MultiRenderTarget : public MultiRenderTarget
 	{
 	public:

CamelotRenderer/OgreD3D9Prerequisites.h

@@ -74,7 +74,7 @@ THE SOFTWARE.
 #include <DxErr.h>
 
 
-namespace Ogre
+namespace CamelotEngine
 {
 	// Predefine classes
 	class D3D9RenderSystem;

CamelotRenderer/OgreD3D9RenderSystem.cpp

@@ -51,7 +51,7 @@ THE SOFTWARE.
 
 #define FLOAT2DWORD(f) *((DWORD*)&f)
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	D3D9RenderSystem* D3D9RenderSystem::msD3D9RenderSystem = NULL;
 
@@ -307,7 +307,7 @@ namespace Ogre
 				}
 
 				// Reset video mode to default if previous doesn't avail in new possible values
-				std::vector<Ogre::String>::const_iterator itValue =
+				std::vector<CamelotEngine::String>::const_iterator itValue =
 					std::find(optVideoMode->possibleValues.begin(),
 					optVideoMode->possibleValues.end(),
 					optVideoMode->currentValue);
@@ -357,7 +357,7 @@ namespace Ogre
 
 		if( name == "FSAA" )
 		{
-			std::vector<Ogre::String> values = StringUtil::split(value, " ", 1);
+			std::vector<CamelotEngine::String> values = StringUtil::split(value, " ", 1);
 			mFSAASamples = StringConverter::parseUnsignedInt(values[0]);
 			if (values.size() > 1)
 				mFSAAHint = values[1];
@@ -438,7 +438,7 @@ namespace Ogre
 		}
 
 		// Reset FSAA to none if previous doesn't avail in new possible values
-		std::vector<Ogre::String>::const_iterator itValue =
+		std::vector<CamelotEngine::String>::const_iterator itValue =
 			std::find(optFSAA->possibleValues.begin(),
 			optFSAA->possibleValues.end(),
 			optFSAA->currentValue);
@@ -675,7 +675,7 @@ namespace Ogre
         {
 		    mDeviceManager->linkRenderWindow(renderWindow);
         }
-        catch (const Ogre::RenderingAPIException&)
+        catch (const CamelotEngine::RenderingAPIException&)
         {
             // after catching the exception, clean up
             mResourceManager->unlockDeviceAccess();

CamelotRenderer/OgreD3D9RenderSystem.h

@@ -36,7 +36,7 @@ THE SOFTWARE.
 #include "OgreRenderSystemCapabilities.h"
 #include "OgreD3D9Mappings.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 #define MAX_LIGHTS 8
 

CamelotRenderer/OgreD3D9RenderWindow.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 #include "OgreD3D9DeviceManager.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	D3D9RenderWindow::D3D9RenderWindow(HINSTANCE instance)
         : mInstance(instance)        

CamelotRenderer/OgreD3D9RenderWindow.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreRenderWindow.h"
 #include "OgreD3D9Device.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	class _OgreD3D9Export D3D9RenderWindow : public RenderWindow
 	{

CamelotRenderer/OgreD3D9Resource.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreD3D9ResourceManager.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	CM_STATIC_MUTEX_INSTANCE(D3D9Resource::msDeviceAccessMutex)
 

CamelotRenderer/OgreD3D9Resource.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgreD3D9Prerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** Represents a Direct3D rendering resource.
 	Provide unified interface to

CamelotRenderer/OgreD3D9ResourceManager.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreD3D9ResourceManager.h"
 #include "OgreD3D9HardwarePixelBuffer.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	
 	//-----------------------------------------------------------------------

CamelotRenderer/OgreD3D9ResourceManager.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgreD3D9Prerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	enum D3D9ResourceCreationPolicy
 	{

CamelotRenderer/OgreD3D9Texture.cpp

@@ -38,7 +38,7 @@ THE SOFTWARE.
 #include "OgreD3D9ResourceManager.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	/****************************************************************************************/
     D3D9Texture::D3D9Texture()

CamelotRenderer/OgreD3D9Texture.h

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreD3D9HardwarePixelBuffer.h"
 #include "OgreD3D9Resource.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	class _OgreD3D9Export D3D9Texture : public Texture, public D3D9Resource
 	{
 	protected:	

CamelotRenderer/OgreD3D9TextureManager.cpp

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreD3D9RenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	D3D9TextureManager::D3D9TextureManager()
 		:TextureManager()

CamelotRenderer/OgreD3D9TextureManager.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreD3D9Texture.h"
 #include "OgreTextureManager.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	class _OgreD3D9Export D3D9TextureManager : public TextureManager
 	{

CamelotRenderer/OgreD3D9VertexDeclaration.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //-----------------------------------------------------------------------
     D3D9VertexDeclaration::D3D9VertexDeclaration()         

CamelotRenderer/OgreD3D9VertexDeclaration.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreHardwareVertexBuffer.h"
 #include "OgreD3D9Resource.h"
 
-namespace Ogre { 
+namespace CamelotEngine { 
 
     /** Specialisation of VertexDeclaration for D3D9 */
     class _OgreD3D9Export D3D9VertexDeclaration : public VertexDeclaration, public D3D9Resource

CamelotRenderer/OgreD3D9VideoMode.cpp

@@ -27,7 +27,7 @@ THE SOFTWARE.
 */
 #include "OgreD3D9VideoMode.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	String D3D9VideoMode::getDescription() const
 	{

CamelotRenderer/OgreD3D9VideoMode.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreD3D9Prerequisites.h"
 #include "OgreString.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	static unsigned int modeCount = 0;
 

CamelotRenderer/OgreD3D9VideoModeList.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreD3D9RenderSystem.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	D3D9VideoModeList::D3D9VideoModeList( D3D9Driver* pDriver )
 	{

CamelotRenderer/OgreD3D9VideoModeList.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgreD3D9Driver.h"
 #include "OgreD3D9VideoMode.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
 	class _OgreD3D9Export D3D9VideoModeList
 	{

CamelotRenderer/OgreDefaultHardwareBufferManager.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 #include "OgreDefaultHardwareBufferManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	DefaultHardwareVertexBuffer::DefaultHardwareVertexBuffer(size_t vertexSize, size_t numVertices, 
 															 HardwareBuffer::Usage usage)

CamelotRenderer/OgreDefaultHardwareBufferManager.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreHardwareVertexBuffer.h"
 #include "OgreHardwareIndexBuffer.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreException.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
     #include <stdio.h>
 #endif
 
-namespace Ogre {
+namespace CamelotEngine {
 
     Exception::Exception(int num, const String& desc, const String& src) :
         line( 0 ),

CamelotRenderer/OgreException.h

@@ -48,9 +48,9 @@ THE SOFTWARE.
 
 #   else
 #       if OGRE_COMP != CM_COMPILER_BORL
-#           define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
+#           define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( CamelotEngine::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
 #       else
-#           define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__ )
+#           define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( CamelotEngine::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__ )
 #       endif
 
 #   endif
@@ -58,9 +58,9 @@ THE SOFTWARE.
 // EXCEPTIONS mode
 #elif OGRE_ASSERT_MODE == 2
 #   if OGRE_COMP != CM_COMPILER_BORL
-#       define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
+#       define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( CamelotEngine::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
 #   else
-#       define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__ )
+#       define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT( CamelotEngine::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__ )
 #   endif
 
 // STANDARD mode
@@ -69,7 +69,7 @@ THE SOFTWARE.
 
 #endif
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/
@@ -83,7 +83,7 @@ namespace Ogre {
             encapsulates the detail of the problem. The application using
             OGRE should always ensure that the exceptions are caught, so all
             OGRE engine functions should occur within a
-            try{} catch(Ogre::Exception& e) {} block.
+            try{} catch(CamelotEngine::Exception& e) {} block.
         @par
             The user application should never create any instances of this
             object unless it wishes to unify its error handling using the
@@ -339,13 +339,13 @@ namespace Ogre {
 
 	
 #ifndef OGRE_EXCEPT
-#define OGRE_EXCEPT(num, desc, src) throw Ogre::ExceptionFactory::create( \
-	Ogre::ExceptionCodeType<num>(), desc, src, __FILE__, __LINE__ );
+#define OGRE_EXCEPT(num, desc, src) throw CamelotEngine::ExceptionFactory::create( \
+	CamelotEngine::ExceptionCodeType<num>(), desc, src, __FILE__, __LINE__ );
 #endif
 	/** @} */
 	/** @} */
 
-} // Namespace Ogre
+} // namespace CamelotEngine
 
 #include "OgreHeaderSuffix.h"
 #endif

CamelotRenderer/OgreFrustum.cpp

@@ -38,7 +38,7 @@ THE SOFTWARE.
 #include "OgreRenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
     const Real Frustum::INFINITE_FAR_PLANE_ADJUST = 0.00001f;
     //-----------------------------------------------------------------------
     Frustum::Frustum(const String& name) : 
@@ -1118,4 +1118,4 @@ namespace Ogre {
 		outtop = mTop;
 		outbottom = mBottom;
 	}
-} // namespace Ogre
+} // namespace CamelotEngine

CamelotRenderer/OgreFrustum.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreVertexIndexData.h"
 #include "OgreString.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	/** Specifies perspective (realistic) or orthographic (architectural) projection.
     */

CamelotRenderer/OgreGpuProgram.cpp

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreRenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
     //-----------------------------------------------------------------------------
     GpuProgram::GpuProgram() 

CamelotRenderer/OgreGpuProgram.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreRenderOperation.h"
 #include "OgreGpuProgramParams.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreGpuProgramManager.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "CmRenderSystemManager.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
     //-----------------------------------------------------------------------
     template<> GpuProgramManager* Singleton<GpuProgramManager>::ms_Singleton = 0;
     GpuProgramManager* GpuProgramManager::getSingletonPtr(void)

CamelotRenderer/OgreGpuProgramManager.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreGpuProgram.h"
 #include "OgreSingleton.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreGpuProgramParams.cpp

@@ -34,7 +34,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 
 
-namespace Ogre
+namespace CamelotEngine
 {
 
 	//---------------------------------------------------------------------

CamelotRenderer/OgreGpuProgramParams.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgrePrerequisites.h"
 #include "OgreRenderOperation.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreHardwareBuffer.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 // Precompiler options
 #include "OgrePrerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreHardwareBufferManager.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #include "OgreVertexIndexData.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //-----------------------------------------------------------------------
     template<> HardwareBufferManager* Singleton<HardwareBufferManager>::ms_Singleton = 0;

CamelotRenderer/OgreHardwareBufferManager.h

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreHardwareVertexBuffer.h"
 #include "OgreHardwareIndexBuffer.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreHardwareIndexBuffer.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgreDefaultHardwareBufferManager.h"
 
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
     HardwareIndexBuffer::HardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, 

CamelotRenderer/OgreHardwareIndexBuffer.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "OgrePrerequisites.h"
 #include "OgreHardwareBuffer.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	class HardwareBufferManagerBase;
 
 	/** \addtogroup Core

CamelotRenderer/OgreHardwareOcclusionQuery.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 #include "OgreHardwareOcclusionQuery.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 
     HardwareOcclusionQuery::HardwareOcclusionQuery() : 

CamelotRenderer/OgreHardwareOcclusionQuery.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 // Precompiler options
 #include "OgrePrerequisites.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 
 

CamelotRenderer/OgreHardwarePixelBuffer.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 #include "OgreHardwarePixelBuffer.h"
 #include "OgreException.h"
 
-namespace Ogre 
+namespace CamelotEngine 
 {
   
     //-----------------------------------------------------------------------------    

CamelotRenderer/OgreHardwarePixelBuffer.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreHardwareBuffer.h"
 #include "OgrePixelFormat.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreHardwareVertexBuffer.cpp

@@ -35,7 +35,7 @@ THE SOFTWARE.
 #include "OgreRenderSystem.h"
 #include "CmRenderSystemManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
     HardwareVertexBuffer::HardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize,  

CamelotRenderer/OgreHardwareVertexBuffer.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreHardwareBuffer.h"
 #include "OgreColourValue.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 	class HardwareBufferManagerBase;
 
 	/** \addtogroup Core

CamelotRenderer/OgreHighLevelGpuProgram.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 #include "OgreHighLevelGpuProgram.h"
 #include "OgreException.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
     //---------------------------------------------------------------------------
     HighLevelGpuProgram::HighLevelGpuProgram()

CamelotRenderer/OgreHighLevelGpuProgram.h

@@ -31,7 +31,7 @@ THE SOFTWARE.
 #include "OgrePrerequisites.h"
 #include "OgreGpuProgram.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreHighLevelGpuProgramManager.cpp

@@ -27,7 +27,7 @@ THE SOFTWARE.
 */
 #include "OgreHighLevelGpuProgramManager.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	String sNullLang = "null";
 	class NullProgram : public HighLevelGpuProgram

CamelotRenderer/OgreHighLevelGpuProgramManager.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "OgreException.h"
 #include "OgreHighLevelGpuProgram.h"
 
-namespace Ogre {
+namespace CamelotEngine {
 
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreImageResampler.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 
 // this file is inlined into OgreImage.cpp!
 // do not include anywhere else.
-namespace Ogre {
+namespace CamelotEngine {
 	/** \addtogroup Core
 	*  @{
 	*/

CamelotRenderer/OgreMath.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 #include "OgrePlane.h"
 
 
-namespace Ogre
+namespace CamelotEngine
 {
 
     const Real Math::POS_INFINITY = std::numeric_limits<Real>::infinity();

CamelotRenderer/OgreMath.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "OgrePrerequisites.h"
 
-namespace Ogre
+namespace CamelotEngine
 {
 	/** \addtogroup Core
 	*  @{

CamelotRenderer/OgreMatrix3.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
 
 // Adapted from Matrix math by Wild Magic http://www.geometrictools.com/
 
-namespace Ogre
+namespace CamelotEngine
 {
     const Real Matrix3::EPSILON = 1e-06f;
     const Matrix3 Matrix3::ZERO(0,0,0,0,0,0,0,0,0);