Check in before attempting to refactor CamelotCore into a separate project

CamelotCore/CamelotCore.vcxproj

@@ -180,6 +180,7 @@
     <ClInclude Include="Include\CmGameObject.h" />
     <ClInclude Include="Include\CmGameObjectRTTI.h" />
     <ClInclude Include="Include\CmGUIMouseEvent.h" />
+    <ClInclude Include="Include\CmGUIWindowFrame.h" />
     <ClInclude Include="Include\CmSceneObjectRTTI.h" />
     <ClInclude Include="Include\CmMemAllocCategories.h" />
     <ClInclude Include="Include\CmOverlay.h" />
@@ -310,6 +311,7 @@
     <ClCompile Include="Source\CamelotRenderer.cpp" />
     <ClCompile Include="Source\CmGameObjectHandle.cpp" />
     <ClCompile Include="Source\CmGameObject.cpp" />
+    <ClCompile Include="Source\CmImageSprite.cpp" />
     <ClCompile Include="Source\CmOverlay.cpp" />
     <ClCompile Include="Source\CmApplication.cpp" />
     <ClCompile Include="Source\CmBlendState.cpp" />
@@ -351,6 +353,7 @@
     <ClCompile Include="Source\CmPixelBuffer.cpp" />
     <ClCompile Include="Source\CmGpuProgIncludeImporter.cpp" />
     <ClCompile Include="Source\CmSprite.cpp" />
+    <ClCompile Include="Source\CmSpriteTexture.cpp" />
     <ClCompile Include="Source\CmTextSprite.cpp" />
     <ClCompile Include="Source\CmTextureView.cpp" />
     <ClCompile Include="Source\CmVertexBuffer.cpp" />

CamelotCore/CamelotCore.vcxproj.filters

@@ -483,6 +483,9 @@
     <ClInclude Include="Include\CmGUIMouseEvent.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmGUIWindowFrame.h">
+      <Filter>Header Files\GUI</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CamelotRenderer.cpp">
@@ -746,5 +749,11 @@
     <ClCompile Include="Source\CmGameObject.cpp">
       <Filter>Source Files\Scene</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmSpriteTexture.cpp">
+      <Filter>Source Files\2D</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmImageSprite.cpp">
+      <Filter>Source Files\2D</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotCore/Include/CmImageSprite.h

@@ -5,8 +5,28 @@
 
 namespace CamelotEngine
 {
+	struct IMAGE_SPRITE_DESC
+	{
+		IMAGE_SPRITE_DESC()
+			:width(0), height(0), anchor(SA_TopLeft), borderLeft(0), borderRight(0), 
+			borderTop(0), borderBottom(0)
+		{ }
+
+		Point offset;
+		UINT32 width;
+		UINT32 height;
+		Rect clipRect;
+		SpriteAnchor anchor;
+
+		SpriteTexturePtr texture;
+		UINT32 borderLeft, borderRight, borderTop, borderBottom;
+	};
+
 	class CM_EXPORT ImageSprite : public Sprite
 	{
+	public:
+		ImageSprite();
 
+		void update(const IMAGE_SPRITE_DESC& desc);
 	};
 }

CamelotCore/Include/CmPrerequisites.h

@@ -168,6 +168,7 @@ namespace CamelotEngine {
 	// 2D
 	class Overlay;
 	class OverlayManager;
+	class SpriteTexture;
 	// GUI
 	class GUIManager;
 	class GUIWidget;
@@ -236,6 +237,7 @@ namespace CamelotEngine
 	typedef std::shared_ptr<TextSprite> TextSpritePtr;
 	typedef std::shared_ptr<Overlay> OverlayPtr;
 	typedef std::shared_ptr<InputHandler> InputHandlerPtr;
+	typedef std::shared_ptr<SpriteTexture> SpriteTexturePtr;
 }
 
 /************************************************************************/

CamelotCore/Include/CmSpriteTexture.h

@@ -5,13 +5,24 @@
 
 namespace CamelotEngine
 {
+	/**
+	 * @brief	Texture interface that attempts to hide the underlying texture. This primarily allows us
+	 * 			to create a sprite texture atlas, without requiring any of the sprite classes to directly
+	 * 			know about it.
+	 */
 	class CM_EXPORT SpriteTexture
 	{
 	public:
-		const HTexture& getBaseTexture() const { return mBaseTexture; }
+		SpriteTexture(const HTexture& baseTexture);
+
+		const HTexture& getTexture() const;
+		Vector2 transformUV(const Vector2& uv) const;
 
 	private:
 		HTexture mBaseTexture;
+
+		bool mUsingAtlas;
+		HTexture mAtlasTexture;
 		Vector2 mUVOffset;
 		Vector2 mUVScale;
 	};

CamelotCore/Source/CmImageSprite.cpp

@@ -0,0 +1,238 @@
+#include "CmImageSprite.h"
+#include "CmSpriteTexture.h"
+#include "CmGUIMaterialManager.h"
+
+namespace CamelotEngine
+{
+	ImageSprite::ImageSprite()
+	{
+
+	}
+
+	void ImageSprite::update(const IMAGE_SPRITE_DESC& desc)
+	{
+		const FontData* fontData = nullptr;
+		if(desc.texture == nullptr || desc.texture->getTexture() == nullptr)
+		{
+			clearMesh();
+			return;
+		}
+
+		
+
+		// Actually generate a mesh
+		if(mCachedRenderElements.size() < 1)
+			mCachedRenderElements.resize(1);
+
+		bool useScale9Grid = desc.borderLeft > 0 || desc.borderRight > 0 || 
+			desc.borderTop > 0 || desc.borderBottom > 0;
+
+		UINT32 numQuads = 1;
+		if(useScale9Grid)
+			numQuads = 9;
+
+		UINT32 texPage = 0;
+		SpriteRenderElement& renderElem = mCachedRenderElements[0];
+		{
+			UINT32 newNumQuads = numQuads;
+			if(newNumQuads != renderElem.numQuads)
+			{
+				UINT32 oldVertexCount = renderElem.numQuads * 4;
+				UINT32 oldIndexCount = renderElem.numQuads * 6;
+
+				if(renderElem.vertices != nullptr) CM_DELETE_ARRAY(renderElem.vertices, Vector2, oldVertexCount, ScratchAlloc);
+				if(renderElem.uvs != nullptr) CM_DELETE_ARRAY(renderElem.uvs, Vector2, oldVertexCount, ScratchAlloc);
+				if(renderElem.indexes != nullptr) CM_DELETE_ARRAY(renderElem.indexes, UINT32, oldIndexCount, ScratchAlloc);
+
+				renderElem.vertices = CM_NEW_ARRAY(Vector2, newNumQuads * 4, ScratchAlloc);
+				renderElem.uvs = CM_NEW_ARRAY(Vector2, newNumQuads * 4, ScratchAlloc);
+				renderElem.indexes = CM_NEW_ARRAY(UINT32, newNumQuads * 6, ScratchAlloc);
+				renderElem.numQuads = newNumQuads;
+			}
+
+			HMaterial newMaterial = GUIMaterialManager::instance().requestImageMaterial(desc.texture->getTexture());
+			if(renderElem.material != nullptr)
+				GUIMaterialManager::instance().releaseMaterial(newMaterial);
+
+			renderElem.material = newMaterial;
+
+			texPage++;
+		}
+
+		for(UINT32 i = 0; i < numQuads; i++)
+		{
+			renderElem.indexes[i * 6 + 0] = i * 4 + 0;
+			renderElem.indexes[i * 6 + 1] = i * 4 + 1;
+			renderElem.indexes[i * 6 + 2] = i * 4 + 2;
+			renderElem.indexes[i * 6 + 3] = i * 4 + 1;
+			renderElem.indexes[i * 6 + 4] = i * 4 + 3;
+			renderElem.indexes[i * 6 + 5] = i * 4 + 2;
+		}
+
+		Point offset = desc.offset + getAnchorOffset(desc.anchor, desc.width, desc.height);
+		Vector2 uvOffset(0.0f, 0.0f);
+		Vector2 uvScale(1.0f, 1.0f);
+		
+
+		if(useScale9Grid)
+		{
+			UINT32 leftBorder = desc.borderLeft;
+			UINT32 rightBorder = desc.borderRight;
+			UINT32 topBorder = desc.borderTop;
+			UINT32 bottomBorder = desc.borderBottom;
+
+			float centerWidth = (float)std::max((UINT32)0, desc.width - leftBorder - rightBorder);
+			float centerHeight = (float)std::max((UINT32)0, desc.height - topBorder - bottomBorder);
+
+			float topCenterStart = (float)(offset.x + leftBorder);
+			float topRightStart = (float)(topCenterStart + centerWidth);
+
+			float middleStart = (float)(offset.y + topBorder);
+			float bottomStart = (float)(middleStart + centerHeight);
+
+			// Top left
+			renderElem.vertices[0] = Vector2((float)offset.x, (float)offset.y);
+			renderElem.vertices[1] = Vector2((float)offset.x + leftBorder, (float)offset.y);
+			renderElem.vertices[2] = Vector2((float)offset.x, (float)offset.y - topBorder);
+			renderElem.vertices[3] = Vector2((float)offset.x + leftBorder, (float)offset.y - topBorder);
+
+			// Top center
+			renderElem.vertices[4] = Vector2(topCenterStart, (float)offset.y);
+			renderElem.vertices[5] = Vector2(topCenterStart + centerWidth, (float)offset.y);
+			renderElem.vertices[6] = Vector2(topCenterStart, (float)offset.y - topBorder);
+			renderElem.vertices[7] = Vector2(topCenterStart + centerWidth, (float)offset.y - topBorder);
+
+			// Top right
+			renderElem.vertices[8] = Vector2(topRightStart, (float)offset.y);
+			renderElem.vertices[9] = Vector2(topRightStart + rightBorder, (float)offset.y);
+			renderElem.vertices[10] = Vector2(topRightStart, (float)offset.y - topBorder);
+			renderElem.vertices[11] = Vector2(topRightStart + rightBorder, (float)offset.y - topBorder);
+
+			// Middle left
+			renderElem.vertices[12] = Vector2((float)offset.x, middleStart);
+			renderElem.vertices[13] = Vector2((float)offset.x + leftBorder, middleStart);
+			renderElem.vertices[14] = Vector2((float)offset.x, middleStart - centerHeight);
+			renderElem.vertices[15] = Vector2((float)offset.x + leftBorder, middleStart - centerHeight);
+
+			// Middle center
+			renderElem.vertices[16] = Vector2(topCenterStart, middleStart);
+			renderElem.vertices[17] = Vector2(topCenterStart + centerWidth, middleStart);
+			renderElem.vertices[18] = Vector2(topCenterStart, middleStart - centerHeight);
+			renderElem.vertices[19] = Vector2(topCenterStart + centerWidth, middleStart - centerHeight);
+
+			// Middle right
+			renderElem.vertices[20] = Vector2(topRightStart, middleStart);
+			renderElem.vertices[21] = Vector2(topRightStart + rightBorder, middleStart);
+			renderElem.vertices[22] = Vector2(topRightStart, middleStart - centerHeight);
+			renderElem.vertices[23] = Vector2(topRightStart + rightBorder, middleStart - centerHeight);
+
+			// Bottom left
+			renderElem.vertices[24] = Vector2((float)offset.x, bottomStart);
+			renderElem.vertices[25] = Vector2((float)offset.x + leftBorder, bottomStart);
+			renderElem.vertices[26] = Vector2((float)offset.x, bottomStart - bottomBorder);
+			renderElem.vertices[27] = Vector2((float)offset.x + leftBorder, bottomStart - bottomBorder);
+
+			// Bottom center
+			renderElem.vertices[28] = Vector2(topCenterStart, bottomStart);
+			renderElem.vertices[29] = Vector2(topCenterStart + centerWidth, bottomStart);
+			renderElem.vertices[30] = Vector2(topCenterStart, bottomStart - bottomBorder);
+			renderElem.vertices[31] = Vector2(topCenterStart + centerWidth, bottomStart - bottomBorder);
+
+			// Bottom right
+			renderElem.vertices[32] = Vector2(topRightStart, bottomStart);
+			renderElem.vertices[33] = Vector2(topRightStart + rightBorder, bottomStart);
+			renderElem.vertices[34] = Vector2(topRightStart, bottomStart - bottomBorder);
+			renderElem.vertices[35] = Vector2(topRightStart + rightBorder, bottomStart - bottomBorder);
+
+			float invWidth = 1.0f / (float)desc.width;
+			float invHeight = 1.0f / (float)desc.height;
+
+			float uvLeftBorder = desc.borderLeft * invWidth;
+			float uvRightBorder = desc.borderRight * invWidth;
+			float uvTopBorder = desc.borderTop * invHeight;
+			float uvBottomBorder = desc.borderBottom * invHeight;
+
+			float uvCenterWidth = std::max(0.0f, uvScale.x - uvLeftBorder - uvRightBorder);
+			float uvCenterHeight = std::max(0.0f, uvScale.y - uvTopBorder - uvBottomBorder);
+
+			float uvTopCenterStart = uvOffset.x + uvLeftBorder;
+			float uvTopRightStart = uvTopCenterStart + uvCenterWidth;
+
+			float uvMiddleStart = uvOffset.y + uvTopBorder;
+			float uvBottomStart = uvMiddleStart + uvCenterHeight;
+
+			// UV - Top left
+			renderElem.uvs[0] = desc.texture->transformUV(Vector2(uvOffset.x, uvOffset.y));
+			renderElem.uvs[1] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvOffset.y));
+			renderElem.uvs[2] = desc.texture->transformUV(Vector2(uvOffset.x, uvOffset.y + uvTopBorder));
+			renderElem.uvs[3] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvOffset.y + uvTopBorder));
+
+			// UV - Top center
+			renderElem.uvs[4] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvOffset.y));
+			renderElem.uvs[5] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvOffset.y));
+			renderElem.uvs[6] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvOffset.y + uvTopBorder));
+			renderElem.uvs[7] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvOffset.y + uvTopBorder));
+
+			// UV - Top right
+			renderElem.uvs[8] = desc.texture->transformUV(Vector2(uvTopRightStart, uvOffset.y));
+			renderElem.uvs[9] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvOffset.y));
+			renderElem.uvs[10] = desc.texture->transformUV(Vector2(uvTopRightStart, uvOffset.y + uvTopBorder));
+			renderElem.uvs[11] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvOffset.y + uvTopBorder));
+
+			// UV - Middle left
+			renderElem.uvs[12] = desc.texture->transformUV(Vector2(uvOffset.x, uvMiddleStart));
+			renderElem.uvs[13] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvMiddleStart));
+			renderElem.uvs[14] = desc.texture->transformUV(Vector2(uvOffset.x, uvMiddleStart + uvCenterHeight));
+			renderElem.uvs[15] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvMiddleStart + uvCenterHeight));
+
+			// UV - Middle center
+			renderElem.uvs[16] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvMiddleStart));
+			renderElem.uvs[17] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvMiddleStart));
+			renderElem.uvs[18] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvMiddleStart + uvCenterHeight));
+			renderElem.uvs[19] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvMiddleStart + uvCenterHeight));
+
+			// UV - Middle right
+			renderElem.uvs[20] = desc.texture->transformUV(Vector2(uvTopRightStart, uvMiddleStart));
+			renderElem.uvs[21] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvMiddleStart));
+			renderElem.uvs[22] = desc.texture->transformUV(Vector2(uvTopRightStart, uvMiddleStart + uvCenterHeight));
+			renderElem.uvs[23] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvMiddleStart + uvCenterHeight));
+
+			// UV - Bottom left
+			renderElem.uvs[24] = desc.texture->transformUV(Vector2(uvOffset.x, uvBottomStart));
+			renderElem.uvs[25] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvBottomStart));
+			renderElem.uvs[26] = desc.texture->transformUV(Vector2(uvOffset.x, uvBottomStart + uvBottomBorder));
+			renderElem.uvs[27] = desc.texture->transformUV(Vector2(uvOffset.x + uvLeftBorder, uvBottomStart + uvBottomBorder));
+
+			// UV - Bottom center
+			renderElem.uvs[28] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvBottomStart));
+			renderElem.uvs[29] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvBottomStart));
+			renderElem.uvs[30] = desc.texture->transformUV(Vector2(uvTopCenterStart, uvBottomStart + uvBottomBorder));
+			renderElem.uvs[31] = desc.texture->transformUV(Vector2(uvTopCenterStart + uvCenterWidth, uvBottomStart + uvBottomBorder));
+
+			// UV - Bottom right
+			renderElem.uvs[32] = desc.texture->transformUV(Vector2(uvTopRightStart, uvBottomStart));
+			renderElem.uvs[33] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvBottomStart));
+			renderElem.uvs[34] = desc.texture->transformUV(Vector2(uvTopRightStart, uvBottomStart + uvBottomBorder));
+			renderElem.uvs[35] = desc.texture->transformUV(Vector2(uvTopRightStart + uvRightBorder, uvBottomStart + uvBottomBorder));
+		}
+		else
+		{
+			renderElem.vertices[0] = Vector2((float)offset.x, (float)offset.y);
+			renderElem.vertices[1] = Vector2((float)offset.x + desc.width, (float)offset.y);
+			renderElem.vertices[2] = Vector2((float)offset.x, (float)offset.y - desc.height);
+			renderElem.vertices[3] = Vector2((float)offset.x + desc.width, (float)offset.y - desc.height);
+
+			renderElem.uvs[0] = desc.texture->transformUV(Vector2(uvOffset.x, uvOffset.y));
+			renderElem.uvs[1] = desc.texture->transformUV(Vector2(uvOffset.x + uvScale.x, uvOffset.y));
+			renderElem.uvs[2] = desc.texture->transformUV(Vector2(uvOffset.x, uvOffset.y + uvScale.y));
+			renderElem.uvs[3] = desc.texture->transformUV(Vector2(uvOffset.x + uvScale.x, uvOffset.y + uvScale.y));
+		}
+
+		if(desc.clipRect.width > 0 && desc.clipRect.height > 0)
+		{
+			clipToRect(renderElem.vertices, renderElem.uvs, renderElem.numQuads, desc.clipRect);
+		}
+
+		updateBounds();
+	}
+}

CamelotCore/Source/CmSpriteTexture.cpp

@@ -0,0 +1,23 @@
+#include "CmSpriteTexture.h"
+
+namespace CamelotEngine
+{
+	SpriteTexture::SpriteTexture(const HTexture& baseTexture)
+		:mBaseTexture(baseTexture), mUsingAtlas(false)
+	{
+
+	}
+
+	const HTexture& SpriteTexture::getTexture() const 
+	{ 
+		return mUsingAtlas ? mAtlasTexture : mBaseTexture; 
+	}
+
+	Vector2 SpriteTexture::transformUV(const Vector2& uv) const
+	{
+		if(mUsingAtlas)
+			return mUVOffset + uv * mUVScale;
+		else
+			return uv;
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11BuiltinMaterialManager.cpp

@@ -64,7 +64,7 @@ namespace CamelotEngine
 		vsProgram.waitUntilLoaded();
 		psProgram.waitUntilLoaded();
 
-		mSpriteTextShader = Shader::create("TextShader");
+		mSpriteTextShader = Shader::create("TextSpriteShader");
 
 		mSpriteTextShader->addParameter("worldTransform", "worldTransform", GPDT_MATRIX_4X4);
 		mSpriteTextShader->addParameter("halfViewportWidth", "halfViewportWidth", GPDT_FLOAT1);
@@ -89,6 +89,63 @@ namespace CamelotEngine
 
 	void D3D11BuiltinMaterialManager::initSpriteImageShader()
 	{
-		// TODO
+		String vsCode = "										\
+						float halfViewportWidth;							\
+						float halfViewportHeight;							\
+						float4x4 worldTransform;							\
+						\
+						void vs_main(										\
+						in float3 inPos : POSITION,							\
+						in float2 uv : TEXCOORD0,							\
+						out float4 oPosition : SV_Position,					\
+						out float2 oUv : TEXCOORD0)							\
+						{													\
+						float4 tfrmdPos = mul(worldTransform, float4(inPos.xy, 0, 1));	\
+						\
+						float tfrmdX = (tfrmdPos.x / halfViewportWidth) - 1.0f;			\
+						float tfrmdY = (tfrmdPos.y / halfViewportHeight) + 1.0f;		\
+						\
+						oPosition = float4(tfrmdX, tfrmdY, 0, 1);		\
+						oUv = uv;										\
+						}													\
+						";
+
+		String psCode = "																					\
+						SamplerState mainTexSamp : register(s0);											\
+						Texture2D mainTexture : register(t0);												\
+																											\
+						float4 ps_main(in float4 inPos : SV_Position, float2 uv : TEXCOORD0) : SV_Target	\
+						{																					\
+						float4 color = mainTexture.Sample(mainTexSamp, uv);									\
+						return color;																		\
+						}";
+
+		HHighLevelGpuProgram vsProgram = HighLevelGpuProgram::create(vsCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
+		HHighLevelGpuProgram psProgram = HighLevelGpuProgram::create(psCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_4_0);
+
+		vsProgram.waitUntilLoaded();
+		psProgram.waitUntilLoaded();
+
+		mSpriteImageShader = Shader::create("ImageSpriteShader");
+
+		mSpriteImageShader->addParameter("worldTransform", "worldTransform", GPDT_MATRIX_4X4);
+		mSpriteImageShader->addParameter("halfViewportWidth", "halfViewportWidth", GPDT_FLOAT1);
+		mSpriteImageShader->addParameter("halfViewportHeight", "halfViewportHeight", GPDT_FLOAT1);
+		mSpriteImageShader->addParameter("mainTexSamp", "mainTexSamp", GPOT_SAMPLER2D);
+		mSpriteImageShader->addParameter("mainTexture", "mainTexture", GPOT_TEXTURE2D);
+
+		TechniquePtr newTechnique = mSpriteImageShader->addTechnique("D3D11RenderSystem", RendererManager::getCoreRendererName()); 
+		PassPtr newPass = newTechnique->addPass();
+		newPass->setVertexProgram(vsProgram);
+		newPass->setFragmentProgram(psProgram);
+
+		BLEND_STATE_DESC desc;
+		desc.renderTargetDesc[0].blendEnable = true;
+		desc.renderTargetDesc[0].srcBlend = BF_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].dstBlend = BF_INV_SOURCE_ALPHA;
+		desc.renderTargetDesc[0].blendOp = BO_ADD;
+
+		HBlendState blendState = BlendState::create(desc);
+		newPass->setBlendState(blendState);
 	}
 }

Notes.txt

@@ -13,6 +13,8 @@ Reminders:
   - When displaying inspector data for a component, take into consideration that it will need to be able
     to display that data for user created C# classes as well. AND I will most certainly have C# versions of all my
 	components. Therefore is there any purpose of having C++ only inspector parsing code?
+  - When I'll be doing SRGB write make sure GUI textures are handled properly. Right now they are read in gamma space, and displayed
+    as normal, but if I switch to SRGB write then gamma would be applied twice to those textures.
 
 ----------------------------------------------------------------------------------------------
 More detailed thought out system descriptions:

TODO.txt

@@ -26,12 +26,8 @@ Longterm plans:
 <<Multithreaded GUI rendering>>
  - Event handling and normal "update" will still be done on the main thread
  - At the beginning of each frame a GUI mesh update is queued on the GUI thread
-   - I might need to modify Sprite/TextSprite as they might re-create their meshes whenever they are dirty. I probably want them to do it only 
-     when specifically commanded by calling "updateMesh" to make sure they're only updated on GUI thread.
  - Since we're queuing the update at the beggining of the frame we will be using last frames transform and gui element states.
    - When queing we need to make sure to store GUIWidget transform, and specific element states (e.g. "text" in GUILabel)
-     - I might want to remove Sprite and TextSprite classes in their current form and just make them utility classes? Because right now I'm storing 
-	   same data (e.g. text, font, etc) in both GUILabel (for example) and TextSprite, which makes state-saving problematic.
  - At the end of simulation frame wait until GUI update is complete. After both simulation and GUI updates are complete, proceed with submitting it to render system.
 
 <<Figure out how to store texture references in a font>>