Editor runs after material refactor - hasn't been extensively tested

BansheeCore/Include/BsGpuParams.h

@@ -194,11 +194,11 @@ namespace BansheeEngine
 		void setParamBlockBuffer(const String& name, const ParamsBufferType& paramBlockBuffer);
 
 		/**
-		* @brief	Returns a handle for the parameter with the specified name.
-		*			Handle may then be stored and used for quickly setting or retrieving
-		*			values to/from that parameter.
-		*
-		*			Throws exception if parameter with that name and type doesn't exist.
+		 * @brief	Returns a handle for the parameter with the specified name.
+		 *			Handle may then be stored and used for quickly setting or retrieving
+		 *			values to/from that parameter.
+		 *
+		 *			Throws exception if parameter with that name and type doesn't exist.
 		*
 		*			Parameter handles will be invalidated when their parent GpuParams object changes.
 		*/

BansheeCore/Include/BsMaterial.h

@@ -580,6 +580,9 @@ namespace BansheeEngine
 
 		MaterialCore() { }
 		MaterialCore(const SPtr<ShaderCore>& shader);
+		MaterialCore(const SPtr<ShaderCore>& shader, const SPtr<TechniqueCore>& bestTechnique, 
+			const Set<String>& validShareableParamBlocks, const Map<String, String>& validParams, 
+			const Vector<SPtr<PassParametersCore>>& passParams);
 
 		/**
 		 * @copydoc	CoreObjectCore::syncToCore

BansheeCore/Source/BsMaterial.cpp

@@ -24,6 +24,43 @@ namespace BansheeEngine
 		bool create;
 	};
 
+	SPtr<PassParametersCore> convertParamsToCore(const SPtr<PassParameters>& passParams)
+	{
+		SPtr<PassParametersCore> passParameters = bs_shared_ptr<PassParametersCore>();
+
+		if (passParams->mVertParams != nullptr)
+			passParameters->mVertParams = passParams->mVertParams->getCore();
+		else
+			passParameters->mVertParams = nullptr;
+
+		if (passParams->mFragParams != nullptr)
+			passParameters->mFragParams = passParams->mFragParams->getCore();
+		else
+			passParameters->mFragParams = nullptr;
+
+		if (passParams->mGeomParams != nullptr)
+			passParameters->mGeomParams = passParams->mGeomParams->getCore();
+		else
+			passParameters->mGeomParams = nullptr;
+
+		if (passParams->mHullParams != nullptr)
+			passParameters->mHullParams = passParams->mHullParams->getCore();
+		else
+			passParameters->mHullParams = nullptr;
+
+		if (passParams->mDomainParams != nullptr)
+			passParameters->mDomainParams = passParams->mDomainParams->getCore();
+		else
+			passParameters->mDomainParams = nullptr;
+
+		if (passParams->mComputeParams != nullptr)
+			passParameters->mComputeParams = passParams->mComputeParams->getCore();
+		else
+			passParameters->mComputeParams = nullptr;
+
+		return passParameters;
+	}
+
 	bool areParamsEqual(const GpuParamDataDesc& paramA, const GpuParamDataDesc& paramB, bool ignoreBufferOffsets)
 	{
 		bool equal = paramA.arraySize == paramB.arraySize && paramA.elementSize == paramB.elementSize
@@ -776,6 +813,17 @@ namespace BansheeEngine
 		setShader(shader);
 	}
 
+	MaterialCore::MaterialCore(const SPtr<ShaderCore>& shader, const SPtr<TechniqueCore>& bestTechnique,
+		const Set<String>& validShareableParamBlocks, const Map<String, String>& validParams,
+		const Vector<SPtr<PassParametersCore>>& passParams)
+	{
+		mShader = shader;
+		mBestTechnique = bestTechnique;
+		mValidShareableParamBlocks = validShareableParamBlocks;
+		mValidParams = validParams;
+		mParametersPerPass = passParams;
+	}
+
 	void MaterialCore::syncToCore(const CoreSyncData& data)
 	{
 		char* dataPtr = (char*)data.getBuffer();
@@ -828,11 +876,28 @@ namespace BansheeEngine
 
 	SPtr<CoreObjectCore> Material::createCore() const
 	{
+		MaterialCore* material = nullptr;
+
 		SPtr<ShaderCore> shader;
 		if (mShader != nullptr)
+		{
 			shader = mShader->getCore();
 
-		MaterialCore* material = new (bs_alloc<MaterialCore>()) MaterialCore(shader);
+			if (mBestTechnique != nullptr)
+			{
+				SPtr<TechniqueCore> technique = mBestTechnique->getCore();
+
+				Vector<SPtr<PassParametersCore>> passParams;
+				for (auto& passParam : mParametersPerPass)
+					passParams.push_back(convertParamsToCore(passParam));
+
+				material = new (bs_alloc<MaterialCore>()) MaterialCore(shader, technique, mValidShareableParamBlocks, mValidParams, passParams);
+			}
+		}
+		
+		if (material == nullptr)
+			material = new (bs_alloc<MaterialCore>()) MaterialCore(shader);
+
 		SPtr<MaterialCore> materialPtr = bs_shared_ptr<MaterialCore, GenAlloc>(material);
 		materialPtr->_setThisPtr(materialPtr);
 
@@ -856,37 +921,7 @@ namespace BansheeEngine
 		for (UINT32 i = 0; i < numPasses; i++)
 		{
 			SPtr<PassParametersCore>* passParameters = new (dataPtr) SPtr<PassParametersCore>();
-			*passParameters = bs_shared_ptr<PassParametersCore>();
-
-			if (mParametersPerPass[i]->mVertParams != nullptr)
-				(*passParameters)->mVertParams = mParametersPerPass[i]->mVertParams->getCore();
-			else
-				(*passParameters)->mVertParams = nullptr;
-			
-			if (mParametersPerPass[i]->mFragParams != nullptr)
-				(*passParameters)->mFragParams = mParametersPerPass[i]->mFragParams->getCore();
-			else
-				(*passParameters)->mFragParams = nullptr;
-
-			if (mParametersPerPass[i]->mGeomParams != nullptr)
-				(*passParameters)->mGeomParams = mParametersPerPass[i]->mGeomParams->getCore();
-			else
-				(*passParameters)->mGeomParams = nullptr;
-
-			if (mParametersPerPass[i]->mHullParams != nullptr)
-				(*passParameters)->mHullParams = mParametersPerPass[i]->mHullParams->getCore();
-			else
-				(*passParameters)->mHullParams = nullptr;
-
-			if (mParametersPerPass[i]->mDomainParams != nullptr)
-				(*passParameters)->mDomainParams = mParametersPerPass[i]->mDomainParams->getCore();
-			else
-				(*passParameters)->mDomainParams = nullptr;
-
-			if (mParametersPerPass[i]->mComputeParams != nullptr)
-				(*passParameters)->mComputeParams = mParametersPerPass[i]->mComputeParams->getCore();
-			else
-				(*passParameters)->mComputeParams = nullptr;
+			*passParameters = convertParamsToCore(mParametersPerPass[i]);
 
 			dataPtr += sizeof(SPtr<PassParametersCore>);
 		}

BansheeEditor/Include/BsScenePicking.h

@@ -7,6 +7,8 @@
 
 namespace BansheeEngine
 {
+	class ScenePickingCore;
+
 	class ScenePicking : public Module<ScenePicking>
 	{
 		struct RenderablePickData
@@ -19,13 +21,28 @@ namespace BansheeEngine
 			HTexture mainTexture;
 		};
 
+	public:
+		ScenePicking();
+		~ScenePicking();
+
+		HSceneObject pickClosestObject(const CameraHandlerPtr& cam, const Vector2I& position, const Vector2I& area);
+		Vector<HSceneObject> pickObjects(const CameraHandlerPtr& cam, const Vector2I& position, const Vector2I& area);
+
+	private:
+		friend class ScenePickingCore;
+
+		typedef Set<RenderablePickData, std::function<bool(const RenderablePickData&, const RenderablePickData&)>> RenderableSet;
+
+		static Color encodeIndex(UINT32 index);
+		static UINT32 decodeIndex(Color color);
+
+		ScenePickingCore* mCore;
+	};
+
+	class ScenePickingCore
+	{
 		struct MaterialData
 		{
-			// Sim thread
-			HMaterial mMatPicking;
-			HMaterial mMatPickingAlpha;
-
-			// Core thread
 			SPtr<MaterialCore> mMatPickingCore;
 			SPtr<MaterialCore> mMatPickingAlphaCore;
 
@@ -42,24 +59,17 @@ namespace BansheeEngine
 		};
 
 	public:
-		ScenePicking();
+		void initialize();
+		void destroy();
 
-		HSceneObject pickClosestObject(const CameraHandlerPtr& cam, const Vector2I& position, const Vector2I& area);
-		Vector<HSceneObject> pickObjects(const CameraHandlerPtr& cam, const Vector2I& position, const Vector2I& area);
-
-	private:
-		typedef Set<RenderablePickData, std::function<bool(const RenderablePickData&, const RenderablePickData&)>> RenderableSet;
-
-		void initializeCore();
-
-		Color encodeIndex(UINT32 index);
-		UINT32 decodeIndex(Color color);
-
-		void corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const RenderableSet& renderables, 
+		void corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const ScenePicking::RenderableSet& renderables,
 			const Vector2I& position, const Vector2I& area);
-		void corePickingEnd(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const Vector2I& position, 
+		void corePickingEnd(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const Vector2I& position,
 			const Vector2I& area, AsyncOp& asyncOp);
 
+	private:
+		friend class ScenePicking;
+
 		static const float ALPHA_CUTOFF;
 
 		MaterialData mMaterialData[3];

BansheeEditor/Source/BsScenePicking.cpp

@@ -28,54 +28,27 @@ using namespace std::placeholders;
 
 namespace BansheeEngine
 {
-	const float ScenePicking::ALPHA_CUTOFF = 0.5f;
+	const float ScenePickingCore::ALPHA_CUTOFF = 0.5f;
 
 	ScenePicking::ScenePicking()
 	{
+		mCore = bs_new<ScenePickingCore>();
+
 		for (UINT32 i = 0; i < 3; i++)
 		{
-			mMaterialData[i].mMatPicking = BuiltinEditorResources::instance().createPicking((CullingMode)i);
-			mMaterialData[i].mMatPickingAlpha = BuiltinEditorResources::instance().createPickingAlpha((CullingMode)i);
+			HMaterial matPicking = BuiltinEditorResources::instance().createPicking((CullingMode)i);
+			HMaterial matPickingAlpha = BuiltinEditorResources::instance().createPickingAlpha((CullingMode)i);
 
-			mMaterialData[i].mMatPickingCore = mMaterialData[i].mMatPicking->getCore();
-			mMaterialData[i].mMatPickingAlphaCore = mMaterialData[i].mMatPickingAlpha->getCore();
+			mCore->mMaterialData[i].mMatPickingCore = matPicking->getCore();
+			mCore->mMaterialData[i].mMatPickingAlphaCore = matPickingAlpha->getCore();
 		}
 
-		gCoreAccessor().queueCommand(std::bind(&ScenePicking::initializeCore, this));
+		gCoreAccessor().queueCommand(std::bind(&ScenePickingCore::initialize, mCore));
 	}
 
-	void ScenePicking::initializeCore()
+	ScenePicking::~ScenePicking()
 	{
-		for (UINT32 i = 0; i < 3; i++)
-		{
-			MaterialData& md = mMaterialData[i];
-
-			{
-				SPtr<PassParametersCore> passParams = md.mMatPickingCore->getPassParameters(0);
-
-				md.mParamPickingVertParams = passParams->mVertParams;
-				md.mParamPickingVertParams->getParam("matWorldViewProj", md.mParamPickingWVP);
-
-				md.mParamPickingFragParams = passParams->mFragParams;
-				md.mParamPickingFragParams->getParam("colorIndex", md.mParamPickingColor);
-			}
-
-			{
-				SPtr<PassParametersCore> passParams = md.mMatPickingAlphaCore->getPassParameters(0);
-
-				md.mParamPickingAlphaVertParams = passParams->mVertParams;
-				md.mParamPickingAlphaVertParams->getParam("matWorldViewProj", md.mParamPickingAlphaWVP);
-
-				md.mParamPickingAlphaFragParams = passParams->mFragParams;
-
-				md.mParamPickingAlphaFragParams->getParam("colorIndex", md.mParamPickingAlphaColor);
-				md.mParamPickingAlphaFragParams->getTextureParam("mainTexture", md.mParamPickingAlphaTexture);
-
-				GpuParamFloatCore alphaCutoffParam;
-				md.mParamPickingAlphaFragParams->getParam("alphaCutoff", alphaCutoffParam);
-				alphaCutoffParam.set(ALPHA_CUTOFF);
-			}
-		}
+		gCoreAccessor().queueCommand(std::bind(&ScenePickingCore::destroy, mCore));
 	}
 
 	HSceneObject ScenePicking::pickClosestObject(const CameraHandlerPtr& cam, const Vector2I& position, const Vector2I& area)
@@ -182,12 +155,12 @@ namespace BansheeEngine
 		UINT32 firstGizmoIdx = (UINT32)pickData.size();
 
 		SPtr<RenderTargetCore> target = cam->getViewport()->getTarget()->getCore();
-		gCoreAccessor().queueCommand(std::bind(&ScenePicking::corePickingBegin, this, target, 
+		gCoreAccessor().queueCommand(std::bind(&ScenePickingCore::corePickingBegin, mCore, target,
 			cam->getViewport()->getNormArea(), std::cref(pickData), position, area));
 
 		GizmoManager::instance().renderForPicking(cam, [&](UINT32 inputIdx) { return encodeIndex(firstGizmoIdx + inputIdx); });
 
-		AsyncOp op = gCoreAccessor().queueReturnCommand(std::bind(&ScenePicking::corePickingEnd, this, target, 
+		AsyncOp op = gCoreAccessor().queueReturnCommand(std::bind(&ScenePickingCore::corePickingEnd, mCore, target, 
 			cam->getViewport()->getNormArea(), position, area, _1));
 		gCoreAccessor().submitToCoreThread(true);
 
@@ -218,8 +191,70 @@ namespace BansheeEngine
 		return results;
 	}
 
-	void ScenePicking::corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, 
-		const RenderableSet& renderables, const Vector2I& position, const Vector2I& area)
+	Color ScenePicking::encodeIndex(UINT32 index)
+	{
+		Color encoded;
+		encoded.r = (index & 0xFF) / 255.0f;
+		encoded.g = ((index >> 8) & 0xFF) / 255.0f;
+		encoded.b = ((index >> 16) & 0xFF) / 255.0f;
+		encoded.a = 1.0f;
+
+		if (((index >> 24) & 0xFF))
+			LOGERR("Index when picking out of valid range.");
+
+		return encoded;
+	}
+
+	UINT32 ScenePicking::decodeIndex(Color color)
+	{
+		UINT32 r = Math::roundToInt(color.r * 255.0f);
+		UINT32 g = Math::roundToInt(color.g * 255.0f);
+		UINT32 b = Math::roundToInt(color.b * 255.0f);
+
+		return (r & 0xFF) | ((g & 0xFF) << 8) | ((b & 0xFF) << 16);
+	}
+
+	void ScenePickingCore::initialize()
+	{
+		for (UINT32 i = 0; i < 3; i++)
+		{
+			MaterialData& md = mMaterialData[i];
+
+			{
+				SPtr<PassParametersCore> passParams = md.mMatPickingCore->getPassParameters(0);
+
+				md.mParamPickingVertParams = passParams->mVertParams;
+				md.mParamPickingVertParams->getParam("matWorldViewProj", md.mParamPickingWVP);
+
+				md.mParamPickingFragParams = passParams->mFragParams;
+				md.mParamPickingFragParams->getParam("colorIndex", md.mParamPickingColor);
+			}
+
+			{
+				SPtr<PassParametersCore> passParams = md.mMatPickingAlphaCore->getPassParameters(0);
+
+				md.mParamPickingAlphaVertParams = passParams->mVertParams;
+				md.mParamPickingAlphaVertParams->getParam("matWorldViewProj", md.mParamPickingAlphaWVP);
+
+				md.mParamPickingAlphaFragParams = passParams->mFragParams;
+
+				md.mParamPickingAlphaFragParams->getParam("colorIndex", md.mParamPickingAlphaColor);
+				md.mParamPickingAlphaFragParams->getTextureParam("mainTexture", md.mParamPickingAlphaTexture);
+
+				GpuParamFloatCore alphaCutoffParam;
+				md.mParamPickingAlphaFragParams->getParam("alphaCutoff", alphaCutoffParam);
+				alphaCutoffParam.set(ALPHA_CUTOFF);
+			}
+		}
+	}
+
+	void ScenePickingCore::destroy()
+	{
+		bs_delete(this);
+	}
+
+	void ScenePickingCore::corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea,
+		const ScenePicking::RenderableSet& renderables, const Vector2I& position, const Vector2I& area)
 	{
 		RenderSystem& rs = RenderSystem::instance();
 
@@ -246,7 +281,7 @@ namespace BansheeEngine
 					Renderer::setPass(mMaterialData[(UINT32)activeMaterialCull].mMatPickingCore, 0);
 			}
 
-			Color color = encodeIndex(renderable.index);
+			Color color = ScenePicking::encodeIndex(renderable.index);
 			MaterialData& md = mMaterialData[(UINT32)activeMaterialCull];
 
 			if (activeMaterialIsAlpha)
@@ -271,7 +306,7 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScenePicking::corePickingEnd(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const Vector2I& position, 
+	void ScenePickingCore::corePickingEnd(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const Vector2I& position,
 		const Vector2I& area, AsyncOp& asyncOp)
 	{
 		const RenderTargetProperties& rtProps = target->getProperties();
@@ -315,7 +350,7 @@ namespace BansheeEngine
 				for (UINT32 x = (UINT32)position.x; x < maxWidth; x++)
 				{
 					Color color = outputPixelData->getColorAt(x, vertOffset - y);
-					UINT32 index = decodeIndex(color);
+					UINT32 index = ScenePicking::decodeIndex(color);
 
 					if (index == 0x00FFFFFF) // Nothing selected
 						continue;
@@ -335,7 +370,7 @@ namespace BansheeEngine
 				for (UINT32 x = (UINT32)position.x; x < maxWidth; x++)
 				{
 					Color color = outputPixelData->getColorAt(x, y);
-					UINT32 index = decodeIndex(color);
+					UINT32 index = ScenePicking::decodeIndex(color);
 
 					if (index == 0x00FFFFFF) // Nothing selected
 						continue;
@@ -371,27 +406,4 @@ namespace BansheeEngine
 
 		asyncOp._completeOperation(results);
 	}
-
-	Color ScenePicking::encodeIndex(UINT32 index)
-	{
-		Color encoded;
-		encoded.r = (index & 0xFF) / 255.0f;
-		encoded.g = ((index >> 8) & 0xFF) / 255.0f;
-		encoded.b = ((index >> 16) & 0xFF) / 255.0f;
-		encoded.a = 1.0f;
-
-		if (((index >> 24) & 0xFF))
-			LOGERR("Index when picking out of valid range.");
-
-		return encoded;
-	}
-
-	UINT32 ScenePicking::decodeIndex(Color color)
-	{
-		UINT32 r = Math::roundToInt(color.r * 255.0f);
-		UINT32 g = Math::roundToInt(color.g * 255.0f);
-		UINT32 b = Math::roundToInt(color.b * 255.0f);
-
-		return (r & 0xFF) | ((g & 0xFF) << 8) | ((b & 0xFF) << 16);
-	}
 }

BansheeGLRenderSystem/Include/BsGLRenderSystem.h

@@ -181,7 +181,7 @@ namespace BansheeEngine
 		/**
 		 * @brief	Returns main context. Caller must ensure the context has been initialized.
 		 */
-		GLContext* getMainContext() const { return mMainContext; } 
+		SPtr<GLContext> getMainContext() const { return mMainContext; } 
 
 		/**
 		 * @brief	Returns a support object you may use for creating
@@ -307,7 +307,7 @@ namespace BansheeEngine
 		 * @brief	Switch the currently used OpenGL context. You will need to re-bind
 		 *			any previously bound values manually. (e.g. textures, gpu programs and such)
 		 */
-		void switchContext(GLContext* context);
+		void switchContext(const SPtr<GLContext>& context);
 
 		/************************************************************************/
 		/* 								Sampler states                     		*/
@@ -585,8 +585,8 @@ namespace BansheeEngine
 		SPtr<IndexBufferCore> mBoundIndexBuffer;
 		DrawOperationType mCurrentDrawOperation;
 
-		GLContext* mMainContext;
-		GLContext* mCurrentContext;
+		SPtr<GLContext> mMainContext;
+		SPtr<GLContext> mCurrentContext;
 
 		bool mDrawCallInProgress;
 

BansheeGLRenderSystem/Include/BsWin32GLSupport.h

@@ -54,7 +54,7 @@ namespace BansheeEngine
 		 *
 		 * @returns	Newly created GLContext class referencing the created or external context handle.
 		 */
-		Win32Context* createContext(HDC hdc, HGLRC externalGlrc = 0);
+		SPtr<Win32Context> createContext(HDC hdc, HGLRC externalGlrc = 0);
 
 		/**
 		 * @brief	Selects and sets an appropriate pixel format based on the provided parameters.

BansheeGLRenderSystem/Include/BsWin32Window.h

@@ -126,7 +126,7 @@ namespace BansheeEngine
 		bool mIsExternalGLControl;
 		int mDisplayFrequency;
 		HWND mHWnd;
-		Win32Context *mContext;
+		SPtr<Win32Context> mContext;
 		Win32RenderWindowProperties mProperties;
     };
 

BansheeGLRenderSystem/Source/BsGLRenderSystem.cpp

@@ -120,7 +120,7 @@ namespace BansheeEngine
 	void GLRenderSystem::initializeFinalize(const SPtr<RenderWindowCore>& primaryWindow)
 	{
 		// Get the context from the window and finish initialization
-		GLContext *context = nullptr;
+		SPtr<GLContext> context;
 		primaryWindow->getCustomAttribute("GLCONTEXT", &context);
 
 		// Set main and current context
@@ -583,7 +583,7 @@ namespace BansheeEngine
 		THROW_IF_NOT_CORE_THREAD;
 
 		// Switch context if different from current one
-		GLContext *newContext = 0;
+		SPtr<GLContext> newContext;
 		target->getCustomAttribute("GLCONTEXT", &newContext);
 		if(newContext && mCurrentContext != newContext) 
 		{
@@ -1769,7 +1769,7 @@ namespace BansheeEngine
 		TextureCoreManager::startUp<GLTextureCoreManager>(std::ref(*mGLSupport));
 	}
 
-	void GLRenderSystem::switchContext(GLContext *context)
+	void GLRenderSystem::switchContext(const SPtr<GLContext>& context)
 	{
 		// Unbind GPU programs and rebind to new context later, because
 		// scene manager treat render system as ONE 'context' ONLY, and it

BansheeGLRenderSystem/Source/BsWin32GLSupport.cpp

@@ -83,7 +83,7 @@ namespace BansheeEngine
         }
 	}
 
-	Win32Context* Win32GLSupport::createContext(HDC hdc, HGLRC externalGlrc)
+	SPtr<Win32Context> Win32GLSupport::createContext(HDC hdc, HGLRC externalGlrc)
 	{
 		GLRenderSystem* rs = static_cast<GLRenderSystem*>(RenderSystem::instancePtr());
 
@@ -129,7 +129,7 @@ namespace BansheeEngine
 			glrc = wglGetCurrentContext();
 		}
 
-		return bs_new<Win32Context>(hdc, glrc, createdNew);
+		return bs_shared_ptr<Win32Context>(hdc, glrc, createdNew);
 	}
 
 	void* Win32GLSupport::getProcAddress(const String& procname)

BansheeGLRenderSystem/Source/BsWin32Window.cpp

@@ -35,9 +35,6 @@ namespace BansheeEngine
 		if (!mHWnd)
 			return;
 
-		// Unregister and destroy GLContext
-		bs_delete(mContext);
-
 		if (!mIsExternal)
 		{
 			if (props.mIsFullScreen)
@@ -563,7 +560,8 @@ namespace BansheeEngine
 	{
 		if(name == "GLCONTEXT") 
 		{
-			*static_cast<GLContext**>(pData) = mContext;
+			SPtr<GLContext>* contextPtr = static_cast<SPtr<GLContext>*>(pData);
+			*contextPtr = mContext;
 			return;
 		} 
 		else if(name == "WINDOW")

TODO.txt

@@ -2,12 +2,6 @@
 
  - Make RenderableHandler a CoreObject and remove RenderableProxy
    - BansheeRenderer::mDeletedRenderableProxies is holding references to core objects
- - Rename CoreObject initialize_internal and destroy_internal to initializeCore/destroyCore and make them private
-
-Add getCore/createCore and MaterialCore for Material
-Try compiling and see if that works. Then begin on template refactor:
- - Refactor Material/GpuParams/MaterialParam/GpuParam/Technique/Shader so they use explicit tempalate instantiation and move their implementations to the source file
-Dont forget material sync methods
 
 GpuParams refactor:
 
@@ -17,17 +11,12 @@ I need to ensure renderer buffers get set properly after GpuParams are synced
    (In case user overrides Renderer buffers)
     - Likely just an extra field on GPuParamsCore
 
-
-Should I force CoreObject sync whenever submitCoreAccessors is called?
- - This way I ensure the data is up to date. e.g. if user updates GpuParams and immediately performs
-   some rendering use CoreAccessor that update will not register.
- - Also I can properly handle cases where sim thread needs to access core thread data immediately (e.g. RenderWindow HWND)
- - I'd have to remove submit() calls from CoreAccessors themselves and leave just the one on CoreThread
-
 Disallow CoreObject creation from core thread
  - Add asserts in CoreObject::destroy and CoreObject::initialize
  - Possibly also add asserts to CoreThread::queueCommand and CoreThread::queueReturnCommand
 
+Refactor RenderSystem and CoreThreadAccessor methods (move them to RenderSystem and make current RenderSystem a RenderSystemCore)
+
  New issues:
   - Since Mesh refactor when I select/deselect a gizmo the entire render texture flashes white for one frame (might be related to RT refactor instead)