Added a dummy texture and a dummy mesh

BansheeEngine/Include/BsSpriteTexture.h

@@ -18,6 +18,7 @@ namespace BansheeEngine
 		const CM::HTexture& getTexture() const;
 		CM::Vector2 transformUV(const CM::Vector2& uv) const;
 
+		static SpriteTexturePtr dummy();
 	private:
 		CM::HTexture mBaseTexture;
 

BansheeEngine/Source/BsSpriteTexture.cpp

@@ -1,4 +1,5 @@
 #include "BsSpriteTexture.h"
+#include "CmTexture.h"
 
 using namespace CamelotFramework;
 
@@ -22,4 +23,17 @@ namespace BansheeEngine
 		else
 			return uv;
 	}
+
+	SpriteTexturePtr SpriteTexture::dummy()
+	{
+		static bool initialized = false;
+		static SpriteTexturePtr dummyTex = nullptr;
+
+		if(!initialized)
+		{
+			dummyTex = SpriteTexturePtr(CM_NEW(SpriteTexture, PoolAlloc) SpriteTexture(Texture::dummy()));
+		}
+
+		return dummyTex;
+	}
 }

CamelotCore/Include/CmMesh.h

@@ -60,6 +60,11 @@ namespace CamelotFramework
 
 		RenderOperation getRenderOperation(UINT32 subMeshIdx = 0) const;
 
+		/**
+		 * @brief	Returns a dummy mesh, containing just one triangle. Don't modify the returned mesh.
+		 */
+		static HMesh dummy();
+
 	protected:
 		friend class MeshManager;
 

CamelotCore/Include/CmMeshManager.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "CmPrerequisites.h"
+#include "CmDeferredRenderContextFwd.h"
 #include "CmModule.h"
 
 namespace CamelotFramework
@@ -19,9 +20,14 @@ namespace CamelotFramework
 		 * 			as 0 sized buffers will cause problems, so it contains 3 indices
 		 * 			and 1 vertex).
 		 */
-		MeshDataPtr getNullMeshData() const { return mNullMeshData; }
+		MeshDataPtr getDummyMeshData() const { return mDummyMeshData; }
 
+		HMesh getDummyMesh() const { return mDummyMesh; }
 	private:
-		MeshDataPtr mNullMeshData;
+		MeshDataPtr mDummyMeshData;
+		HMesh mDummyMesh;
+
+	protected:
+		virtual void onStartUp();
 	};
 }

CamelotCore/Include/CmTexture.h

@@ -181,6 +181,11 @@ namespace CamelotFramework {
 			another texture. */
 		void copy(TexturePtr& target);
 
+		/**
+		 * @brief	Returns a dummy 2x2 texture. Don't modify the returned texture.
+		 */
+		static HTexture dummy();
+
 		/************************************************************************/
 		/* 								TEXTURE VIEW                      		*/
 		/************************************************************************/

CamelotCore/Include/CmTextureManager.h

@@ -59,7 +59,7 @@ namespace CamelotFramework {
     {
     public:
 
-        TextureManager(void);
+        TextureManager();
         virtual ~TextureManager();
 
 		/** Create a manual texture with specified width, height and depth (not loaded from a file).
@@ -212,10 +212,16 @@ namespace CamelotFramework {
 		*/
 		virtual PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage) = 0;
 
+		HTexture getDummyTexture() const { return mDummyTexture; }
+
 	protected:
+		HTexture mDummyTexture;
+
 		virtual TexturePtr createTextureImpl() = 0;
 		virtual RenderTexturePtr createRenderTextureImpl() = 0;
 		virtual MultiRenderTexturePtr createMultiRenderTextureImpl() = 0;
+
+		virtual void onStartUp();
     };
 	/** @} */
 	/** @} */

CamelotCore/Source/CmMesh.cpp

@@ -231,7 +231,7 @@ namespace CamelotFramework
 		// TODO Low priority - Initialize an empty mesh. A better way would be to only initialize the mesh
 		// once we set the proper mesh data (then we don't have to do it twice), but this makes the code less complex.
 		// Consider changing it if there are performance issues.
-		writeSubresource(0, *MeshManager::instance().getNullMeshData());
+		writeSubresource(0, *MeshManager::instance().getDummyMeshData());
 
 		Resource::initialize_internal();
 	}
@@ -249,6 +249,11 @@ namespace CamelotFramework
 		Resource::destroy_internal();
 	}
 
+	HMesh Mesh::dummy()
+	{
+		return MeshManager::instance().getDummyMesh();
+	}
+
 	void Mesh::throwIfNotRenderThread() const
 	{
 		if(CM_THREAD_CURRENT_ID != RenderSystem::instancePtr()->getRenderThreadId())

CamelotCore/Source/CmMeshManager.cpp

@@ -1,4 +1,6 @@
 #include "CmMeshManager.h"
+#include "CmDeferredRenderContext.h"
+#include "CmApplication.h"
 #include "CmVector3.h"
 #include "CmMesh.h"
 
@@ -6,20 +8,7 @@ namespace CamelotFramework
 {
 	MeshManager::MeshManager()
 	{
-		mNullMeshData = MeshDataPtr(CM_NEW(MeshData, GenAlloc) MeshData(1), &MemAllocDeleter<MeshData, GenAlloc>::deleter);
 
-		mNullMeshData->beginDesc();
-		mNullMeshData->addVertElem(VET_FLOAT3, VES_POSITION);
-		mNullMeshData->addSubMesh(3);
-		mNullMeshData->endDesc();
-
-		auto vecIter = mNullMeshData->getVec3DataIter(VES_POSITION);
-		vecIter.setValue(Vector3(0, 0, 0));
-
-		auto indices = mNullMeshData->getIndices32(0);
-		indices[0] = 0;
-		indices[1] = 0;
-		indices[2] = 0;
 	}
 
 	MeshManager::~MeshManager()
@@ -43,4 +32,28 @@ namespace CamelotFramework
 
 		return mesh;
 	}
+
+	void MeshManager::onStartUp()
+	{
+		mDummyMeshData = MeshDataPtr(CM_NEW(MeshData, GenAlloc) MeshData(1), &MemAllocDeleter<MeshData, GenAlloc>::deleter);
+
+		mDummyMeshData->beginDesc();
+		mDummyMeshData->addVertElem(VET_FLOAT3, VES_POSITION);
+		mDummyMeshData->addSubMesh(3);
+		mDummyMeshData->endDesc();
+
+		auto vecIter = mDummyMeshData->getVec3DataIter(VES_POSITION);
+		vecIter.setValue(Vector3(0, 0, 0));
+
+		auto indices = mDummyMeshData->getIndices32(0);
+		indices[0] = 0;
+		indices[1] = 0;
+		indices[2] = 0;
+
+		SyncedRenderContext& renderContext = gMainSyncedRC();
+
+		mDummyMesh = Mesh::create();
+		renderContext.writeSubresource(mDummyMesh.getInternalPtr(), 0, *mDummyMeshData);
+		renderContext.submitToGpu(true); // TODO - Only temporary until I fix write/read subresource
+	}
 }

CamelotCore/Source/CmTexture.cpp

@@ -336,6 +336,11 @@ namespace CamelotFramework {
 
 		return static_resource_cast<Texture>(Resource::_createResourceHandle(texturePtr));
 	}
+
+	HTexture Texture::dummy()
+	{
+		return TextureManager::instance().getDummyTexture();
+	}
 }
 
 #undef THROW_IF_NOT_RENDER_THREAD

CamelotCore/Source/CmTextureManager.cpp

@@ -31,18 +31,36 @@ THE SOFTWARE.
 #include "CmMultiRenderTexture.h"
 #include "CmRenderSystem.h"
 
-namespace CamelotFramework {
-    //-----------------------------------------------------------------------
-    TextureManager::TextureManager(void)
+namespace CamelotFramework 
+{
+    TextureManager::TextureManager()
     {
         // Subclasses should register (when this is fully constructed)
     }
-    //-----------------------------------------------------------------------
+
     TextureManager::~TextureManager()
     {
         // subclasses should unregister with resource group manager
     }
-    //-----------------------------------------------------------------------
+
+	void TextureManager::onStartUp()
+	{
+		// Internally this will call our createTextureImpl virtual method. But since this is guaranteed
+		// to be the last class in the hierarchy, we can call a virtual method from constructor.
+		mDummyTexture = Texture::create(TEX_TYPE_2D, 2, 2, 0, PF_R8G8B8A8);
+
+		UINT32 subresourceIdx = mDummyTexture->mapToSubresourceIdx(0, 0);
+		PixelDataPtr data = mDummyTexture->allocateSubresourceBuffer(subresourceIdx);
+
+		data->setColorAt(Color::Red, 0, 0);
+		data->setColorAt(Color::Red, 0, 1);
+		data->setColorAt(Color::Red, 1, 0);
+		data->setColorAt(Color::Red, 1, 1);
+
+		AsyncOp op;
+		RenderSystem::instance().writeSubresource(mDummyTexture.getInternalPtr(), mDummyTexture->mapToSubresourceIdx(0, 0), *data, op);
+	}
+
     TexturePtr TextureManager::createTexture(TextureType texType, UINT32 width, UINT32 height, UINT32 depth, int numMipmaps,
         PixelFormat format, int usage, bool hwGamma, 
 		UINT32 fsaa, const String& fsaaHint)
@@ -53,7 +71,7 @@ namespace CamelotFramework {
 
 		return ret;
     }
-	//-----------------------------------------------------------------------
+
 	TexturePtr TextureManager::createEmpty()
 	{
 		TexturePtr texture = createTextureImpl();
@@ -61,7 +79,7 @@ namespace CamelotFramework {
 
 		return texture;
 	}
-	//-----------------------------------------------------------------------
+
 	RenderTexturePtr TextureManager::createRenderTexture(TextureType textureType, UINT32 width, UINT32 height, 
 			PixelFormat format, bool hwGamma, UINT32 fsaa, const String& fsaaHint, 
 			bool createDepth, PixelFormat depthStencilFormat)
@@ -89,7 +107,7 @@ namespace CamelotFramework {
 
 		return newRT;
 	}
-	//-----------------------------------------------------------------------
+
 	RenderTexturePtr TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC& desc)
 	{
 		RenderTexturePtr newRT = createRenderTextureImpl();
@@ -98,7 +116,7 @@ namespace CamelotFramework {
 
 		return newRT;
 	}
-	//-----------------------------------------------------------------------
+
 	MultiRenderTexturePtr TextureManager::createEmptyMultiRenderTexture()
 	{
 		MultiRenderTexturePtr newRT = createMultiRenderTextureImpl();
@@ -106,12 +124,12 @@ namespace CamelotFramework {
 
 		return newRT;
 	}
-    //-----------------------------------------------------------------------
+
 	bool TextureManager::isFormatSupported(TextureType ttype, PixelFormat format, int usage)
 	{
 		return getNativeFormat(ttype, format, usage) == format;
 	}
-    //-----------------------------------------------------------------------
+
 	bool TextureManager::isEquivalentFormatSupported(TextureType ttype, PixelFormat format, int usage)
 	{
 		PixelFormat supportedFormat = getNativeFormat(ttype, format, usage);

CamelotD3D9Renderer/Include/CmD3D9TextureManager.h

@@ -43,7 +43,7 @@ namespace CamelotFramework
 		/// @copydoc TextureManager::getNativeFormat
 		PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage);
 
-	protected:		
+	protected:	
 		TexturePtr createTextureImpl();
 		RenderTexturePtr createRenderTextureImpl();
 		MultiRenderTexturePtr createMultiRenderTextureImpl();

CamelotD3D9Renderer/Source/CmD3D9TextureManager.cpp

@@ -37,13 +37,10 @@ namespace CamelotFramework
 {
 	D3D9TextureManager::D3D9TextureManager()
 		:TextureManager()
-	{		
-	}
+	{ }
 	
 	D3D9TextureManager::~D3D9TextureManager()
-	{
-
-	}
+	{ }
 
     TexturePtr D3D9TextureManager::createTextureImpl()
     {

CamelotGLRenderer/Include/CmGLTextureManager.h

@@ -42,8 +42,6 @@ namespace CamelotFramework {
         GLTextureManager(GLSupport& support);
         virtual ~GLTextureManager();
 
-		GLuint getWarningTextureID() { return mWarningTextureID; }
-
 		/// @copydoc TextureManager::getNativeFormat
 		PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage);
 
@@ -52,11 +50,7 @@ namespace CamelotFramework {
 		RenderTexturePtr createRenderTextureImpl();
 		MultiRenderTexturePtr createMultiRenderTextureImpl();
 
-		/// Internal method to create a warning texture (bound when a texture unit is blank)
-		void createWarningTexture();
-
         GLSupport& mGLSupport;
-		GLuint mWarningTextureID;
     };
 }
 #endif

CamelotGLRenderer/Source/CmGLTextureManager.cpp

@@ -31,71 +31,40 @@ THE SOFTWARE.
 #include "CmGLRenderTexture.h"
 #include "CmGLMultiRenderTexture.h"
 
-namespace CamelotFramework {
-    //-----------------------------------------------------------------------------
-    GLTextureManager::GLTextureManager(GLSupport& support)
-        :TextureManager(), mGLSupport(support), mWarningTextureID(0)
+namespace CamelotFramework
+{
+    GLTextureManager::GLTextureManager( GLSupport& support)
+        :TextureManager(), mGLSupport(support)
     {
-		createWarningTexture();
+
     }
-    //-----------------------------------------------------------------------------
+
     GLTextureManager::~GLTextureManager()
     {
-		// Delete warning texture
-		glDeleteTextures(1, &mWarningTextureID);
+
     }
-    //-----------------------------------------------------------------------------
+
     TexturePtr GLTextureManager::createTextureImpl()
     {
         GLTexture* tex = CM_NEW(GLTexture, PoolAlloc) GLTexture(mGLSupport);
 
 		return TexturePtr(tex, &CoreObject::_deleteDelayed<GLTexture, PoolAlloc>);
     }
-	//-----------------------------------------------------------------------------
+
 	RenderTexturePtr GLTextureManager::createRenderTextureImpl()
 	{
 		GLRenderTexture* tex = CM_NEW(GLRenderTexture, PoolAlloc) GLRenderTexture();
 
 		return RenderTexturePtr(tex, &CoreObject::_deleteDelayed<GLRenderTexture, PoolAlloc>);
 	}
-	//----------------------------------------------------------------------------
+
 	MultiRenderTexturePtr GLTextureManager::createMultiRenderTextureImpl()
 	{
 		GLMultiRenderTexture* tex = CM_NEW(GLMultiRenderTexture, PoolAlloc) GLMultiRenderTexture();
 
 		return MultiRenderTexturePtr(tex, &CoreObject::_deleteDelayed<GLMultiRenderTexture, PoolAlloc>);
 	}
-	//-----------------------------------------------------------------------------
-	void GLTextureManager::createWarningTexture()
-	{
-		// Generate warning texture
-		UINT32 width = 8;
-		UINT32 height = 8;
-		UINT32 *data = (UINT32*)CM_NEW_BYTES(sizeof(UINT32)*width*height, ScratchAlloc);		// 0xXXRRGGBB
-		// Yellow/black stripes
-		for(UINT32 y=0; y<height; ++y)
-		{
-			for(UINT32 x=0; x<width; ++x)
-			{
-				data[y*width+x] = (((x+y)%8)<4)?0x000000:0xFFFF00;
-			}
-		}
-		// Create GL resource
-        glGenTextures(1, &mWarningTextureID);
-		glBindTexture(GL_TEXTURE_2D, mWarningTextureID);
-		if (GLEW_VERSION_1_2)
-		{
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, (void*)data);
-		}
-		else
-		{
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_BGRA, GL_UNSIGNED_INT, (void*)data);
-		}
-		// Free memory
-		CM_DELETE_BYTES(data, ScratchAlloc);
-	}
-	//-----------------------------------------------------------------------------
+
 	PixelFormat GLTextureManager::getNativeFormat(TextureType ttype, PixelFormat format, int usage)
 	{
 		// Adjust requested parameters to capabilities

CamelotUtility/Include/CmModule.h

@@ -63,7 +63,7 @@ namespace CamelotFramework
 			_instance = moduleInstance;
 			isShutDown = false;
 
-			moduleInstance->onStartUp();
+			((Module*)moduleInstance)->onStartUp();
 		}
 
 		/**
@@ -77,7 +77,7 @@ namespace CamelotFramework
 					"Trying to shut down an already shut down module.");
 			}
 
-			_instance->onShutDown();
+			((Module*)_instance)->onShutDown();
 
 			CM_DELETE(_instance, T, GenAlloc);
 			isShutDown = true;

TODO.txt

@@ -26,13 +26,15 @@ IMMEDIATE:
  - GUIButton needs:
   - Padding
   - Icon image
-  - Text
   - Support for text color in GUIStyles
+ - Using linear filtering on scale9grid textures doesn't look good, mostly true if the center get stretched a lot (the border colors seep through)
  - What happens when I don't set a texture for a state of a GUI element. Use a dummy white texture probably?
-    - Add Texture.dummy which can always easily be accessed anywhere in code. Something similar like dummy mesh (which I already have but I might want to also add Mesh.dummy for easier access)
+    - Make sure GUI system uses a dummy texture if one isn't available
+	- SpriteTexture keeps a static reference to DUmmyTexture which I need to release before shutdown
  - GUITexture gui element, with support for tileable textures I can use window background!
  - Add "Arial" size 10 font
   - Add support for bold (and maybe italic) fonts in Font importer
+  - Add support to disable aliasing when importing font
 
 -----------