Dont store name for render window

CamelotClient/CamelotClient.cpp

@@ -27,8 +27,8 @@ using namespace CamelotEngine;
 
 int _tmain(int argc, _TCHAR* argv[])
 {
-	gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
-	//gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
+	//gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
+	gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
 
 	RenderSystem* renderSystem = RenderSystemManager::getActive();
 	RenderWindow* renderWindow = gApplication().getPrimaryRenderWindow();

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -237,7 +237,7 @@ namespace CamelotEngine
 		void startUp_internal();
 		void createRenderWindow_internal(const String &name, unsigned int width, unsigned int height, 
 			bool fullScreen, const NameValuePairList& miscParams, AsyncOp& asyncOp);
-		void destroyRenderTarget_internal(const String& name);
+		void destroyRenderTarget_internal(RenderTarget* renderTarget);
 		void setRenderTarget_internal(RenderTarget *target);
 
 		void bindGpuProgram_internal(GpuProgramHandle prg);

CamelotD3D9Renderer/Source/CmD3D9HardwarePixelBuffer.cpp

@@ -950,7 +950,7 @@ void D3D9HardwarePixelBuffer::destroyRenderTexture()
 {
 	if (mRenderTexture != NULL)
 	{
-		CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget_internal(mRenderTexture->getName());
+		CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget_internal(mRenderTexture);
 		mRenderTexture = NULL;
 	}
 }

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -229,15 +229,6 @@ namespace CamelotEngine
 
 		String msg;
 
-		// Make sure we don't already have a render target of the 
-		// same name as the one supplied
-		if( mRenderTargets.find( name ) != mRenderTargets.end() )
-		{
-			msg = "A render target of the same name '" + name + "' already "
-				"exists.  You cannot create a new window with this name.";
-			CM_EXCEPT(InternalErrorException, msg);
-		}
-
 		D3D9RenderWindow* renderWindow = new D3D9RenderWindow(mhInstance);
 
 		renderWindow->create(name, width, height, fullScreen, &miscParams);
@@ -476,7 +467,7 @@ namespace CamelotEngine
 		};
 	}
 	//---------------------------------------------------------------------
-	void D3D9RenderSystem::destroyRenderTarget_internal(const String& name)
+	void D3D9RenderSystem::destroyRenderTarget_internal(RenderTarget* renderTarget)
 	{		
 		THROW_IF_NOT_RENDER_THREAD;
 
@@ -486,7 +477,7 @@ namespace CamelotEngine
 		D3D9RenderWindowList::iterator sw;
 		for (sw = mRenderWindows.begin(); sw != mRenderWindows.end(); ++sw)
 		{
-			if ((*sw)->getName() == name)
+			if ((*sw) == renderTarget)
 			{
 				renderWindow = (*sw);					
 				mRenderWindows.erase(sw);
@@ -496,7 +487,7 @@ namespace CamelotEngine
 		
 
 		// Do the real removal
-		RenderSystem::destroyRenderTarget_internal(name);	
+		RenderSystem::destroyRenderTarget_internal(renderTarget);	
 	}
 
 	//---------------------------------------------------------------------

CamelotD3D9Renderer/Source/CmD3D9RenderWindow.cpp

@@ -299,13 +299,13 @@ namespace CamelotEngine
 			// NB allow 4 bytes of window data for D3D9RenderWindow pointer
 			WNDCLASS wc = { 0, WindowEventUtilities::_WndProc, 0, 0, hInst,
 				LoadIcon(0, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),
-				(HBRUSH)GetStockObject(BLACK_BRUSH), 0, "OgreD3D9Wnd" };
+				(HBRUSH)GetStockObject(BLACK_BRUSH), 0, "D3D9Wnd" };
 			RegisterClass(&wc);
 
 			// Create our main window
 			// Pass pointer to self
 			mIsExternal = false;
-			mHWnd = CreateWindowEx(dwStyleEx, "OgreD3D9Wnd", title.c_str(), dwStyle,
+			mHWnd = CreateWindowEx(dwStyleEx, "D3D9Wnd", title.c_str(), dwStyle,
 				mLeft, mTop, winWidth, winHeight, parentHWnd, 0, hInst, this);
 			mStyle = dwStyle;
 

CamelotGLRenderer/Include/CmGLRenderSystem.h

@@ -202,10 +202,6 @@ namespace CamelotEngine {
          * Set current render target to target, enabling its GL context if needed
          */
         void setRenderTarget_internal(RenderTarget *target);
-        /** See
-          RenderSystem
-         */
-        void destroyRenderWindow_internal(RenderWindow* pWin);
 		/** See
           RenderSystem
          */

CamelotGLRenderer/Source/CmGLHardwarePixelBuffer.cpp

@@ -278,7 +278,7 @@ GLTextureBuffer::~GLTextureBuffer()
         // was deleted by the user.
         for (SliceTRT::const_iterator it = mSliceTRT.begin(); it != mSliceTRT.end(); ++it)
         {
-			CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget_internal((*it)->getName());
+			CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget_internal(*it);
         }
 	}
 }

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -128,11 +128,11 @@ namespace CamelotEngine {
 		shutdown();
 
 		// Destroy render windows
-		RenderTargetMap::iterator i;
-		for (i = mRenderTargets.begin(); i != mRenderTargets.end(); ++i)
+		for (auto i = mRenderTargets.begin(); i != mRenderTargets.end(); ++i)
 		{
-			delete i->second;
+			delete *i;
 		}
+
 		mRenderTargets.clear();
 
         if(mGLSupport)
@@ -210,12 +210,6 @@ namespace CamelotEngine {
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 
-		if (mRenderTargets.find(name) != mRenderTargets.end())
-		{
-			CM_EXCEPT(InvalidParametersException, 
-				"Window with name '" + name + "' already exists");
-		}
-
 		// Create the window
 		RenderWindow* win = mGLSupport->newWindow(name, width, height, 
 			fullScreen, &miscParams);
@@ -383,24 +377,6 @@ namespace CamelotEngine {
 			break;
 		}
 	}
-	//-----------------------------------------------------------------------
-	void GLRenderSystem::destroyRenderWindow_internal(RenderWindow* pWin)
-	{
-		THROW_IF_NOT_RENDER_THREAD;
-
-		// Find it to remove from list
-		RenderTargetMap::iterator i = mRenderTargets.begin();
-
-		while (i != mRenderTargets.end())
-		{
-			if (i->second == pWin)
-			{
-				mRenderTargets.erase(i);
-				delete pWin;
-				break;
-			}
-		}
-	}
 	//-----------------------------------------------------------------------------
 	void GLRenderSystem::setPointParameters_internal(float size, 
 		bool attenuationEnabled, float constant, float linear, float quadratic,

CamelotGLRenderer/Source/CmWin32Window.cpp

@@ -309,7 +309,7 @@ namespace CamelotEngine {
 			// register class and create window
 			WNDCLASS wc = { CS_OWNDC, WindowEventUtilities::_WndProc, 0, 0, hInst,
 				LoadIcon(NULL, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),
-				(HBRUSH)GetStockObject(BLACK_BRUSH), NULL, "OgreGLWindow" };
+				(HBRUSH)GetStockObject(BLACK_BRUSH), NULL, "GLWindow" };
 			RegisterClass(&wc);
 
 			if (mIsFullScreen)

CamelotRenderer/Include/CmRenderSystem.h

@@ -57,7 +57,6 @@ namespace CamelotEngine
 	*  @{
 	*/
 
-	typedef map< String, RenderTarget * >::type RenderTargetMap;
 	typedef multimap<UINT8, RenderTarget * >::type RenderTargetPriorityMap;
 
 	class TextureManager;
@@ -354,14 +353,20 @@ namespace CamelotEngine
 
 		/** Attaches the passed render target to the render system.
 		*/
-		virtual void attachRenderTarget_internal( RenderTarget &target );
+		virtual void attachRenderTarget_internal(RenderTarget &target);
+
+		/** Detaches the render target from the render system.
+		@note
+		If the render target cannot be found, NULL is returned.
+		*/
+		virtual void detachRenderTarget_internal(RenderTarget& renderTarget);
 
 		/** Destroys a render window */
-		virtual void destroyRenderWindow_internal(const String& name);
+		virtual void destroyRenderWindow_internal(RenderWindow* renderWindow);
 		/** Destroys a render texture */
-		virtual void destroyRenderTexture_internal(const String& name);
+		virtual void destroyRenderTexture_internal(RenderTexture* renderTexture);
 		/** Destroys a render target of any sort */
-		virtual void destroyRenderTarget_internal(const String& name);
+		virtual void destroyRenderTarget_internal(RenderTarget* renderTarget);
 
 		/** Defines whether or now fullscreen render windows wait for the vertical blank before flipping buffers.
 		@remarks
@@ -911,7 +916,7 @@ namespace CamelotEngine
 		/************************************************************************/
 	protected:
 		/** The render targets. */
-		RenderTargetMap mRenderTargets;
+		vector<RenderTarget*>::type mRenderTargets;
 		/** The render targets, ordered by priority. */
 		RenderTargetPriorityMap mPrioritisedRenderTargets;
 		/** The Active render target. */
@@ -961,17 +966,6 @@ namespace CamelotEngine
 		*/
 		virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0; 
 
-		/** Returns a pointer to the render target with the passed name, or NULL if that
-		render target cannot be found.
-		*/
-		virtual RenderTarget * getRenderTarget( const String &name );
-		/** Detaches the render target with the passed name from the render system and
-		returns a pointer to it.
-		@note
-		If the render target cannot be found, NULL is returned.
-		*/
-		virtual RenderTarget * detachRenderTarget( const String &name );
-
 		/** Returns a description of an error code.
 		*/
 		virtual String getErrorDescription(long errorNumber) const = 0;

CamelotRenderer/Source/CmRenderSystem.cpp

@@ -111,12 +111,12 @@ namespace CamelotEngine {
 		// Remove all the render targets.
 		// (destroy primary target last since others may depend on it)
 		RenderTarget* primary = 0;
-		for (RenderTargetMap::iterator it = mRenderTargets.begin(); it != mRenderTargets.end(); ++it)
+		for (auto it = mRenderTargets.begin(); it != mRenderTargets.end(); ++it)
 		{
-			if (!primary && it->second->isPrimary())
-				primary = it->second;
+			if (!primary && (*it)->isPrimary())
+				primary = *it;
 			else
-				delete it->second;
+				delete *it;
 		}
 		delete primary;
 		mRenderTargets.clear();
@@ -162,26 +162,26 @@ namespace CamelotEngine {
 		return op.getReturnValue<RenderWindow*>();
 	}
     //---------------------------------------------------------------------------------------------
-    void RenderSystem::destroyRenderWindow_internal(const String& name)
+    void RenderSystem::destroyRenderWindow_internal(RenderWindow* renderWindow)
     {
 		THROW_IF_NOT_RENDER_THREAD;
 
-        destroyRenderTarget_internal(name);
+        destroyRenderTarget_internal(renderWindow);
     }
     //---------------------------------------------------------------------------------------------
-    void RenderSystem::destroyRenderTexture_internal(const String& name)
+    void RenderSystem::destroyRenderTexture_internal(RenderTexture* renderTexture)
     {
 		THROW_IF_NOT_RENDER_THREAD;
 
-        destroyRenderTarget_internal(name);
+        destroyRenderTarget_internal(renderTexture);
     }
     //---------------------------------------------------------------------------------------------
-    void RenderSystem::destroyRenderTarget_internal(const String& name)
+    void RenderSystem::destroyRenderTarget_internal(RenderTarget* renderTarget)
     {
 		THROW_IF_NOT_RENDER_THREAD;
 
-        RenderTarget* rt = detachRenderTarget(name);
-        delete rt;
+        detachRenderTarget_internal(*renderTarget);
+        delete renderTarget;
     }
     //---------------------------------------------------------------------------------------------
     void RenderSystem::attachRenderTarget_internal( RenderTarget &target )
@@ -190,26 +190,39 @@ namespace CamelotEngine {
 
 		assert( target.getPriority() < CM_NUM_RENDERTARGET_GROUPS );
 
-        mRenderTargets.insert( RenderTargetMap::value_type( target.getName(), &target ) );
+        mRenderTargets.push_back(&target);
         mPrioritisedRenderTargets.insert(
             RenderTargetPriorityMap::value_type(target.getPriority(), &target ));
     }
-
-    //---------------------------------------------------------------------------------------------
-    RenderTarget * RenderSystem::getRenderTarget( const String &name )
-    {
+	//---------------------------------------------------------------------------------------------
+	void RenderSystem::detachRenderTarget_internal(RenderTarget& renderTarget)
+	{
 		THROW_IF_NOT_RENDER_THREAD;
 
-        RenderTargetMap::iterator it = mRenderTargets.find( name );
-        RenderTarget *ret = NULL;
+		auto it = std::find(mRenderTargets.begin(), mRenderTargets.end(), &renderTarget);
+		RenderTarget* foundRT = nullptr;
 
-        if( it != mRenderTargets.end() )
-        {
-            ret = it->second;
-        }
+		if( it != mRenderTargets.end() )
+		{
+			foundRT = *it;
 
-        return ret;
-    }
+			/* Remove the render target from the priority groups. */
+			RenderTargetPriorityMap::iterator itarg, itargend;
+			itargend = mPrioritisedRenderTargets.end();
+			for( itarg = mPrioritisedRenderTargets.begin(); itarg != itargend; ++itarg )
+			{
+				if( itarg->second == *it ) {
+					mPrioritisedRenderTargets.erase( itarg );
+					break;
+				}
+			}
+
+			mRenderTargets.erase( it );
+		}
+		/// If detached render target is the active render target, reset active render target
+		if(foundRT == mActiveRenderTarget)
+			mActiveRenderTarget = 0;
+	}
 	//---------------------------------------------------------------------------------------------
 	const RenderSystemCapabilities* RenderSystem::getCapabilities_internal(void) const 
 	{ 
@@ -224,37 +237,6 @@ namespace CamelotEngine {
 
 		return mDriverVersion; 
 	}
-    //---------------------------------------------------------------------------------------------
-    RenderTarget * RenderSystem::detachRenderTarget( const String &name )
-    {
-		THROW_IF_NOT_RENDER_THREAD;
-
-        RenderTargetMap::iterator it = mRenderTargets.find( name );
-        RenderTarget *ret = NULL;
-
-        if( it != mRenderTargets.end() )
-        {
-            ret = it->second;
-			
-			/* Remove the render target from the priority groups. */
-            RenderTargetPriorityMap::iterator itarg, itargend;
-            itargend = mPrioritisedRenderTargets.end();
-			for( itarg = mPrioritisedRenderTargets.begin(); itarg != itargend; ++itarg )
-            {
-				if( itarg->second == ret ) {
-					mPrioritisedRenderTargets.erase( itarg );
-					break;
-				}
-            }
-
-            mRenderTargets.erase( it );
-        }
-        /// If detached render target is the active render target, reset active render target
-        if(ret == mActiveRenderTarget)
-            mActiveRenderTarget = 0;
-
-        return ret;
-    }
 	//-----------------------------------------------------------------------
 	void RenderSystem::setViewport(const Viewport& vp)
 	{

CamelotRenderer/TODO.txt

@@ -29,18 +29,14 @@ Command buffer TODO:
 	 anisoLevel
 	 wrapMode
 	 mipMapBias
-   - Make sure resource deletion is handled on the proper thread
 
 Mesh
- - Add initialize and initialize_internal
- - Make sure MeshRTTI calls initialize properly
- - Make sure FBX importer calls initialize properly
+ - Make sure to queue up mesh deletion to make sure it gets destroyed on the render thread
 
 GpuProgram/HighLevelGpuProgram
  - Do a pass of refactoring
  - Fix it up for multithreading
   - In general everything needs to be checked
-  - Specifically HighLevelGpuParam::createParameters
   - Add thread checks
 
 Make initialize & initialize_internal protected?
@@ -48,21 +44,9 @@ Make initialize & initialize_internal protected?
  - Would need to modify HighLevelGpuProgram::mAssemblerProgram
 
 When saving a resource, make sure resource is properly loaded before saving
- - Add blockUntilLoaded method to Resource
-  - Probably need a flag to make sure loading even started?
-    (Or not if I make Resource constructors and initialize methods protected)
-  - Make sure this is never called on the render thread
   - Add doc to Resources::save that says it will block until render thread updates the resource
-  - Remove Response handlers from Resources
-
- Immediate:
-  - Port resource creation to use RenderContext (texture/mesh/shader/etc initialization and updates)
-  - Make sure to add thread checks (surrounded by #if DEBUG) to Vertex/Index/Pixel buffers, textures, meshes, etc.
-
- Later:
-  - Modify resource loading so we don't need a special Response handler on the main thread. We should be able to immediately queue up resource command instead.
   - Add documentation that tells the user that reading a resource non-async will block the thread and execute all queued render commands first
-  - Create render thread in Application, and not in RenderSystem?
+  - Remove Response handlers from Resources
 
 HIGH PRIORITY TODO:
  - Issue with deserialization and value types: