Removed ShaderProxy and added ShaderCore

BansheeCore/BansheeCore.vcxproj

@@ -353,7 +353,6 @@
     <ClInclude Include="Include\BsOcclusionQuery.h" />
     <ClInclude Include="Include\BsPixelBuffer.h" />
     <ClInclude Include="Include\BsGpuProgIncludeImporter.h" />
-    <ClInclude Include="Include\BsShaderProxy.h" />
     <ClInclude Include="Include\BsSubMesh.h" />
     <ClInclude Include="Include\BsTextureImportOptions.h" />
     <ClInclude Include="Include\BsTextureImportOptionsRTTI.h" />

BansheeCore/BansheeCore.vcxproj.filters

@@ -501,9 +501,6 @@
     <ClInclude Include="Include\BsMaterialProxy.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsShaderProxy.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="Include\BsTextureImportOptions.h">
       <Filter>Header Files\Importer</Filter>
     </ClInclude>

BansheeCore/Include/BsCorePrerequisites.h

@@ -145,7 +145,6 @@ namespace BansheeEngine
 	struct MaterialProxyPass;
 	class MeshCoreBase;
 	class MeshCore;
-	struct ShaderProxy;
 	class ViewportProxy;
 	class DrawList;
 	struct SubMesh;
@@ -156,6 +155,7 @@ namespace BansheeEngine
 	class GpuBufferCore;
 	class GpuParamBlockBufferCore;
 	class GpuParamsCore;
+	class ShaderCore;
 	// Asset import
 	class SpecificImporter;
 	class Importer;
@@ -252,7 +252,6 @@ namespace BansheeEngine
 	typedef std::shared_ptr<RenderQueue> RenderQueuePtr;
 	typedef std::shared_ptr<CameraProxy> CameraProxyPtr;
 	typedef std::shared_ptr<MaterialProxy> MaterialProxyPtr;
-	typedef std::shared_ptr<ShaderProxy> ShaderProxyPtr;
 	typedef std::shared_ptr<ViewportProxy> ViewportProxyPtr;
 	typedef std::shared_ptr<GpuParamDesc> GpuParamDescPtr;
 	typedef std::shared_ptr<ResourceMetaData> ResourceMetaDataPtr;

BansheeCore/Include/BsMaterialProxy.h

@@ -54,7 +54,7 @@ namespace BansheeEngine
 		Vector<MaterialProxyPass> passes;
 		Vector<SPtr<GpuParamsCore>> params;
 
-		ShaderProxyPtr shader;
+		SPtr<ShaderCore> shader;
 
 		Vector<BufferBindInfo> rendererBuffers;
 	};

BansheeCore/Include/BsShader.h

@@ -62,9 +62,11 @@ namespace BansheeEngine
 	 *			system, render manager and other properties. So make sure to add most important techniques
 	 *			first so you make sure they are used if they are supported.
 	 */
-	class BS_CORE_EXPORT Shader : public Resource
+	class BS_CORE_EXPORT ShaderBase
 	{
 	public:
+		virtual ~ShaderBase() { }
+
 		/**
 		 * @brief	Adds a new technique that supports the provided render system
 		 *			and renderer to the shader. It's up to the caller to populate the
@@ -236,93 +238,102 @@ namespace BansheeEngine
 
 		/** 
 		 * @brief	Returns a map of all data parameters in the shader.
-		 * 			
-		 * @note	Internal method.
 		 */
-		const Map<String, SHADER_DATA_PARAM_DESC>& _getDataParams() const { return mDataParams; }
+		const Map<String, SHADER_DATA_PARAM_DESC>& getDataParams() const { return mDataParams; }
 
 		/** 
 		 * @brief	Returns a map of all object parameters in the shader. 
-		 * 			
-		 * @note	Internal method.
 		 */
-		const Map<String, SHADER_OBJECT_PARAM_DESC>& _getObjectParams() const { return mObjectParams; }
+		const Map<String, SHADER_OBJECT_PARAM_DESC>& getObjectParams() const { return mObjectParams; }
 
 		/** 
 		 * @brief	Returns a map of all parameter blocks.
-		 * 			
-		 * @note	Internal method.
 		 */
-		const Map<String, SHADER_PARAM_BLOCK_DESC>& _getParamBlocks() const { return mParamBlocks; }
+		const Map<String, SHADER_PARAM_BLOCK_DESC>& getParamBlocks() const { return mParamBlocks; }
 
-		static bool isSampler(GpuParamObjectType type);
-		static bool isTexture(GpuParamObjectType type);
-		static bool isBuffer(GpuParamObjectType type);
+	protected:
+		ShaderBase(const String& name);
 
-		/** 
-		 * @brief	Returns an empty shader object with the specified name. Caller must register
-		 *			techniques with the shader before using it in a Material.
+		/**
+		 * @copydoc	CoreObject::markCoreDirty
 		 */
-		static ShaderPtr create(const String& name);
+		virtual void _markCoreDirty() { }
 
-		/************************************************************************/
-		/* 								CORE PROXY                      		*/
-		/************************************************************************/
+		QueueSortType mQueueSortType;
+		UINT32 mQueuePriority;
+		bool mSeparablePasses;
+		
+		Map<String, SHADER_DATA_PARAM_DESC> mDataParams;
+		Map<String, SHADER_OBJECT_PARAM_DESC> mObjectParams;
+		Map<String, SHADER_PARAM_BLOCK_DESC> mParamBlocks;
 
-		/**
-		 * @brief	Checks is the core dirty flag set. This is used by external systems 
-		 *			to know when internal data has changed and core thread potentially needs to be notified.
-		 */
-		bool _isCoreDirty(ShaderDirtyFlag flag) const { return (mCoreDirtyFlags & (UINT32)flag) != 0; }
+		Vector<TechniquePtr> mTechniques;
+		String mName;
+	};
 
+	/**
+	 * @copydoc	ShaderBase
+	 */
+	class BS_CORE_EXPORT ShaderCore : public CoreObjectCore, public ShaderBase
+	{
+	public:
 		/**
-		 * @brief	Marks the core dirty flag as clean.
+		 * @copydoc	Shader::create
 		 */
-		void _markCoreClean(ShaderDirtyFlag flag) { mCoreDirtyFlags &= ~(UINT32)flag; }
+		static SPtr<ShaderCore> create(const String& name);
+
+	protected:
+		friend class Shader;
+
+		ShaderCore(const String& name);
 
 		/**
-		 * @brief	Gets the currently active proxy of this material.
+		 * @copydoc	CoreObjectCore::syncToCore
 		 */
-		ShaderProxyPtr _getActiveProxy() const { return mActiveProxy; }
+		void syncToCore(const CoreSyncData& data);
+	};
 
+	/**
+	 * @copydoc	ShaderBase
+	 */
+	class BS_CORE_EXPORT Shader : public Resource, public ShaderBase
+	{
+	public:
 		/**
-		 * @brief	Sets an active proxy for this material.
+		 * @brief	Retrieves an implementation of a shader usable only from the
+		 *			core thread.
 		 */
-		void _setActiveProxy(const ShaderProxyPtr& proxy) { mActiveProxy = proxy; }
+		SPtr<ShaderCore> getCore() const;
+
+		static bool isSampler(GpuParamObjectType type);
+		static bool isTexture(GpuParamObjectType type);
+		static bool isBuffer(GpuParamObjectType type);
 
 		/**
-		 * @brief	Creates a new core proxy from the currently set shader data. Core proxies ensure
-		 *			that the core thread has all the necessary data, while avoiding the need
-		 *			to manage Shader itself on the core thread.
-		 *
-		 * @note	Sim thread only. 
-		 *			You generally need to update the core thread with a new proxy whenever core 
-		 *			dirty flag is set.
+		 * @brief	Returns an empty shader object with the specified name. Caller must register
+		 *			techniques with the shader before using it in a Material.
 		 */
-		ShaderProxyPtr _createProxy();
+		static ShaderPtr create(const String& name);
 
 	private:
 		Shader(const String& name);
 
 		/**
-		 * @brief	Marks the core data as dirty.
+		 * @copydoc	CoreObject::createCore
 		 */
-		void markCoreDirty() { mCoreDirtyFlags = 0xFFFFFFFF; }
-
-	private:
-		String mName;
-		QueueSortType mQueueSortType;
-		UINT32 mQueuePriority;
-		bool mSeparablePasses;
-		Vector<TechniquePtr> mTechniques;
-		UINT32 mCoreDirtyFlags;
+		SPtr<CoreObjectCore> createCore() const;
 
-		Map<String, SHADER_DATA_PARAM_DESC> mDataParams;
-		Map<String, SHADER_OBJECT_PARAM_DESC> mObjectParams;
-		Map<String, SHADER_PARAM_BLOCK_DESC> mParamBlocks;
+		/**
+		 * @copydoc	CoreObject::markCoreDirty
+		 */
+		void _markCoreDirty();
 
-		ShaderProxyPtr mActiveProxy;
+		/**
+		 * @copydoc	CoreObject::syncToCore
+		 */
+		CoreSyncData syncToCore(FrameAlloc* allocator);
 
+	private:
 		/************************************************************************/
 		/* 								RTTI		                     		*/
 		/************************************************************************/

BansheeCore/Include/BsShaderProxy.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "BsCorePrerequisites.h"
-#include "BsShader.h"
-
-namespace BansheeEngine
-{
-	struct BS_CORE_EXPORT ShaderProxy
-	{
-		QueueSortType queueSortType;
-		UINT32 queuePriority;
-		bool separablePasses;
-
-		Map<String, SHADER_DATA_PARAM_DESC> dataParams;
-		Map<String, SHADER_OBJECT_PARAM_DESC> objectParams;
-		Map<String, SHADER_PARAM_BLOCK_DESC> paramBlocks;
-	};
-}

BansheeCore/Source/BsMaterial.cpp

@@ -109,7 +109,7 @@ namespace BansheeEngine
 			Map<String, GpuParamBlockBufferPtr> paramBlockBuffers;
 
 			// Create param blocks
-			const Map<String, SHADER_PARAM_BLOCK_DESC>& shaderDesc = mShader->_getParamBlocks();
+			const Map<String, SHADER_PARAM_BLOCK_DESC>& shaderDesc = mShader->getParamBlocks();
 			for(auto iter = validShareableParamBlocks.begin(); iter != validShareableParamBlocks.end(); ++iter)
 			{
 				bool createBlockBuffer = true;
@@ -146,7 +146,7 @@ namespace BansheeEngine
 			}
 
 			// Create data param mappings
-			const Map<String, SHADER_DATA_PARAM_DESC>& dataParamDesc = mShader->_getDataParams();
+			const Map<String, SHADER_DATA_PARAM_DESC>& dataParamDesc = mShader->getDataParams();
 			for(auto iter = dataParamDesc.begin(); iter != dataParamDesc.end(); ++iter)
 			{
 				auto findIter = validDataParameters.find(iter->second.gpuVariableName);
@@ -179,7 +179,7 @@ namespace BansheeEngine
 			}
 
 			// Create object param mappings
-			const Map<String, SHADER_OBJECT_PARAM_DESC>& objectParamDesc = mShader->_getObjectParams();
+			const Map<String, SHADER_OBJECT_PARAM_DESC>& objectParamDesc = mShader->getObjectParams();
 			for(auto iter = objectParamDesc.begin(); iter != objectParamDesc.end(); ++iter)
 			{
 				const Vector<String>& gpuVariableNames = iter->second.gpuVariableNames;
@@ -730,18 +730,12 @@ namespace BansheeEngine
 
 	bool Material::_isCoreDirty(MaterialDirtyFlag flag) const
 	{ 
-		return (mCoreDirtyFlags & (UINT32)flag) != 0 || (mShader != nullptr && mShader->_isCoreDirty(ShaderDirtyFlag::Shader));
+		return (mCoreDirtyFlags & (UINT32)flag) != 0;
 	}
 
 	void Material::_markCoreClean(MaterialDirtyFlag flag)
 	{ 
 		mCoreDirtyFlags &= ~(UINT32)flag;
-
-		if (flag == MaterialDirtyFlag::Material)
-		{
-			if (mShader != nullptr)
-				mShader->_markCoreClean(ShaderDirtyFlag::Shader);
-		}
 	}
 
 	MaterialProxyPtr Material::_createProxy()
@@ -819,13 +813,7 @@ namespace BansheeEngine
 			passData.stencilRefValue = pass->getStencilRefValue();
 		}
 
-		if (mShader->_isCoreDirty(ShaderDirtyFlag::Proxy))
-		{
-			mShader->_setActiveProxy(mShader->_createProxy());
-			mShader->_markCoreClean(ShaderDirtyFlag::Proxy);
-		}
-
-		proxy->shader = mShader->_getActiveProxy();
+		proxy->shader = mShader->getCore();
 
 		return proxy;
 	}

BansheeCore/Source/BsShader.cpp

@@ -2,19 +2,19 @@
 #include "BsTechnique.h"
 #include "BsException.h"
 #include "BsDebug.h"
-#include "BsShaderProxy.h"
 #include "BsShaderRTTI.h"
+#include "BsFrameAlloc.h"
 
 namespace BansheeEngine
 {
-	Shader::Shader(const String& name)
-		:mName(name), mQueueSortType(QueueSortType::FrontToBack), mQueuePriority((UINT32)QueuePriority::Opaque), 
-		mSeparablePasses(true), mCoreDirtyFlags(0xFFFFFFFF)
+	ShaderBase::ShaderBase(const String& name)
+		:mName(name), mQueueSortType(QueueSortType::FrontToBack), mQueuePriority((UINT32)QueuePriority::Opaque),
+		mSeparablePasses(true)
 	{
 
 	}
 
-	TechniquePtr Shader::addTechnique(const String& renderSystem, const String& renderer)
+	TechniquePtr ShaderBase::addTechnique(const String& renderSystem, const String& renderer)
 	{
 		TechniquePtr technique = bs_shared_ptr<Technique, PoolAlloc>(renderSystem, renderer);
 		mTechniques.push_back(technique);
@@ -22,14 +22,14 @@ namespace BansheeEngine
 		return technique;
 	}
 
-	void Shader::removeTechnique(UINT32 idx)
+	void ShaderBase::removeTechnique(UINT32 idx)
 	{
-		if(idx < 0 || idx >= mTechniques.size())
+		if (idx < 0 || idx >= mTechniques.size())
 			BS_EXCEPT(InvalidParametersException, "Index out of range: " + toString(idx));
 
 		int count = 0;
 		auto iter = mTechniques.begin();
-		while(count != idx)
+		while (count != idx)
 		{
 			++count;
 			++iter;
@@ -38,21 +38,21 @@ namespace BansheeEngine
 		mTechniques.erase(iter);
 	}
 
-	void Shader::removeTechnique(TechniquePtr technique)
+	void ShaderBase::removeTechnique(TechniquePtr technique)
 	{
 		auto iterFind = std::find(mTechniques.begin(), mTechniques.end(), technique);
 
-		if(iterFind == mTechniques.end())
+		if (iterFind == mTechniques.end())
 			BS_EXCEPT(InvalidParametersException, "Cannot remove specified technique because it wasn't found in this shader.");
 
 		mTechniques.erase(iterFind);
 	}
 
-	TechniquePtr Shader::getBestTechnique() const
+	TechniquePtr ShaderBase::getBestTechnique() const
 	{
-		for(auto iter = mTechniques.begin(); iter != mTechniques.end(); ++iter)
+		for (auto iter = mTechniques.begin(); iter != mTechniques.end(); ++iter)
 		{
-			if((*iter)->isSupported())
+			if ((*iter)->isSupported())
 			{
 				return *iter;
 			}
@@ -63,28 +63,28 @@ namespace BansheeEngine
 		// TODO - Low priority. Instead of returning null use an extremely simple technique that will be supported almost everywhere as a fallback.
 	}
 
-	void Shader::setQueueSortType(QueueSortType sortType) 
+	void ShaderBase::setQueueSortType(QueueSortType sortType) 
 	{ 
 		mQueueSortType = sortType;
 
-		markCoreDirty();
+		_markCoreDirty();
 	}
 
-	void Shader::setQueuePriority(UINT32 priority) 
+	void ShaderBase::setQueuePriority(UINT32 priority) 
 	{ 
 		mQueuePriority = priority;
 
-		markCoreDirty();
+		_markCoreDirty();
 	}
 
-	void Shader::setAllowSeparablePasses(bool enable) 
+	void ShaderBase::setAllowSeparablePasses(bool enable) 
 	{ 
 		mSeparablePasses = enable;
 
-		markCoreDirty();
+		_markCoreDirty();
 	}
 
-	void Shader::addParameter(const String& name, const String& gpuVariableName, GpuParamDataType type, UINT32 rendererSemantic, UINT32 arraySize, UINT32 elementSize)
+	void ShaderBase::addParameter(const String& name, const String& gpuVariableName, GpuParamDataType type, UINT32 rendererSemantic, UINT32 arraySize, UINT32 elementSize)
 	{
 		if(type == GPDT_STRUCT && elementSize <= 0)
 			BS_EXCEPT(InvalidParametersException, "You need to provide a non-zero element size for a struct parameter.")
@@ -100,10 +100,10 @@ namespace BansheeEngine
 		mDataParams[name] = desc;
 		mObjectParams.erase(name);
 
-		markCoreDirty();
+		_markCoreDirty();
 	}
 
-	void Shader::addParameter(const String& name, const String& gpuVariableName, GpuParamObjectType type, UINT32 rendererSemantic)
+	void ShaderBase::addParameter(const String& name, const String& gpuVariableName, GpuParamObjectType type, UINT32 rendererSemantic)
 	{
 		auto iterFind = mObjectParams.find(name);
 
@@ -141,10 +141,10 @@ namespace BansheeEngine
 
 		mDataParams.erase(name);
 
-		markCoreDirty();
+		_markCoreDirty();
 	}
 
-	GpuParamType Shader::getParamType(const String& name) const
+	GpuParamType ShaderBase::getParamType(const String& name) const
 	{
 		auto findIterData = mDataParams.find(name);
 		if(findIterData != mDataParams.end())
@@ -157,7 +157,7 @@ namespace BansheeEngine
 		BS_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
 	}
 
-	const SHADER_DATA_PARAM_DESC& Shader::getDataParamDesc(const String& name) const
+	const SHADER_DATA_PARAM_DESC& ShaderBase::getDataParamDesc(const String& name) const
 	{
 		auto findIterData = mDataParams.find(name);
 		if(findIterData != mDataParams.end())
@@ -166,7 +166,7 @@ namespace BansheeEngine
 		BS_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
 	}
 
-	const SHADER_OBJECT_PARAM_DESC& Shader::getObjectParamDesc(const String& name) const
+	const SHADER_OBJECT_PARAM_DESC& ShaderBase::getObjectParamDesc(const String& name) const
 	{
 		auto findIterObject = mObjectParams.find(name);
 		if(findIterObject != mObjectParams.end())
@@ -175,7 +175,7 @@ namespace BansheeEngine
 		BS_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
 	}
 
-	bool Shader::hasDataParam(const String& name) const
+	bool ShaderBase::hasDataParam(const String& name) const
 	{
 		auto findIterData = mDataParams.find(name);
 		if(findIterData != mDataParams.end())
@@ -184,7 +184,7 @@ namespace BansheeEngine
 		return false;
 	}
 
-	bool Shader::hasObjectParam(const String& name) const
+	bool ShaderBase::hasObjectParam(const String& name) const
 	{
 		auto findIterObject = mObjectParams.find(name);
 		if(findIterObject != mObjectParams.end())
@@ -193,13 +193,15 @@ namespace BansheeEngine
 		return false;
 	}
 
-	void Shader::removeParameter(const String& name)
+	void ShaderBase::removeParameter(const String& name)
 	{
 		mDataParams.erase(name);
 		mObjectParams.erase(name);
+
+		_markCoreDirty();
 	}
 
-	void Shader::setParamBlockAttribs(const String& name, bool shared, GpuParamBlockUsage usage, UINT32 rendererSemantic)
+	void ShaderBase::setParamBlockAttribs(const String& name, bool shared, GpuParamBlockUsage usage, UINT32 rendererSemantic)
 	{
 		SHADER_PARAM_BLOCK_DESC desc;
 		desc.name = name;
@@ -209,9 +211,89 @@ namespace BansheeEngine
 
 		mParamBlocks[name] = desc;
 
+		_markCoreDirty();
+	}
+
+	ShaderCore::ShaderCore(const String& name)
+		:ShaderBase(name)
+	{
+
+	}
+
+	void ShaderCore::syncToCore(const CoreSyncData& data)
+	{
+		char* buffer = (char*)data.getBuffer();
+
+		mDataParams.clear();
+		mObjectParams.clear();
+		mParamBlocks.clear();
+
+		buffer = rttiReadElem(mQueueSortType, buffer);
+		buffer = rttiReadElem(mQueuePriority, buffer);
+		buffer = rttiReadElem(mSeparablePasses, buffer);
+		buffer = rttiReadElem(mDataParams, buffer);
+		buffer = rttiReadElem(mObjectParams, buffer);
+		buffer = rttiReadElem(mParamBlocks, buffer);
+	}
+
+	SPtr<ShaderCore> ShaderCore::create(const String& name)
+	{
+		ShaderCore* shaderCore = new (bs_alloc<ShaderCore>()) ShaderCore(name);
+		SPtr<ShaderCore> shaderCorePtr = bs_shared_ptr<ShaderCore, GenAlloc>(shaderCore);
+		shaderCorePtr->_setThisPtr(shaderCorePtr);
+		shaderCorePtr->initialize();
+
+		return shaderCorePtr;
+	}
+
+	Shader::Shader(const String& name)
+		:ShaderBase(name)
+	{
+
+	}
+
+	void Shader::_markCoreDirty()
+	{
 		markCoreDirty();
 	}
 
+	CoreSyncData Shader::syncToCore(FrameAlloc* allocator)
+	{
+		UINT32 size = 0;
+		size += rttiGetElemSize(mQueueSortType);
+		size += rttiGetElemSize(mQueuePriority);
+		size += rttiGetElemSize(mSeparablePasses);
+		size += rttiGetElemSize(mDataParams);
+		size += rttiGetElemSize(mObjectParams);
+		size += rttiGetElemSize(mParamBlocks);
+
+		UINT8* buffer = allocator->alloc(size);
+
+		char* dataPtr = (char*)buffer;
+		dataPtr = rttiWriteElem(mQueueSortType, dataPtr);
+		dataPtr = rttiWriteElem(mQueuePriority, dataPtr);
+		dataPtr = rttiWriteElem(mSeparablePasses, dataPtr);
+		dataPtr = rttiWriteElem(mDataParams, dataPtr);
+		dataPtr = rttiWriteElem(mObjectParams, dataPtr);
+		dataPtr = rttiWriteElem(mParamBlocks, dataPtr);
+
+		return CoreSyncData((UINT8*)buffer, size);
+	}
+
+	SPtr<ShaderCore> Shader::getCore() const
+	{
+		return std::static_pointer_cast<ShaderCore>(mCoreSpecific);
+	}
+
+	SPtr<CoreObjectCore> Shader::createCore() const
+	{
+		ShaderCore* shaderCore = new (bs_alloc<ShaderCore>()) ShaderCore(mName);
+		SPtr<ShaderCore> shaderCorePtr = bs_shared_ptr<ShaderCore, GenAlloc>(shaderCore);
+		shaderCorePtr->_setThisPtr(shaderCorePtr);
+
+		return shaderCorePtr;
+	}
+
 	bool Shader::isSampler(GpuParamObjectType type)
 	{
 		switch(type)
@@ -269,19 +351,6 @@ namespace BansheeEngine
 		return newShader;
 	}
 
-	ShaderProxyPtr Shader::_createProxy()
-	{
-		ShaderProxyPtr proxy = bs_shared_ptr<ShaderProxy>();
-		proxy->dataParams = mDataParams;
-		proxy->objectParams = mObjectParams;
-		proxy->paramBlocks = mParamBlocks;
-		proxy->queuePriority = mQueuePriority;
-		proxy->queueSortType = mQueueSortType;
-		proxy->separablePasses = mSeparablePasses;
-
-		return proxy;
-	}
-
 	RTTITypeBase* Shader::getRTTIStatic()
 	{
 		return ShaderRTTI::instance();

BansheeEditor/Source/BsScenePicking.cpp

@@ -160,7 +160,7 @@ namespace BansheeEngine
 						HTexture mainTexture;
 						if (useAlphaShader)
 						{
-							const Map<String, SHADER_OBJECT_PARAM_DESC>& objectParams = originalMat->getShader()->_getObjectParams();
+							const Map<String, SHADER_OBJECT_PARAM_DESC>& objectParams = originalMat->getShader()->getObjectParams();
 							for (auto& objectParam : objectParams)
 							{
 								if (objectParam.second.rendererSemantic == RPS_MainTex)

BansheeEngine/Source/BsRenderQueue.cpp

@@ -1,8 +1,8 @@
 #include "BsRenderQueue.h"
 #include "BsMaterialProxy.h"
-#include "BsShaderProxy.h"
 #include "BsRenderableProxy.h"
 #include "BsSubMesh.h"
+#include "BsShader.h"
 #include "BsMesh.h"
 
 namespace BansheeEngine
@@ -30,8 +30,8 @@ namespace BansheeEngine
 		renderOp.subMesh = element->subMesh;
 
 		sortData.distFromCamera = distFromCamera;
-		sortData.priority = element->material->shader->queuePriority;
-		sortData.sortType = element->material->shader->queueSortType;
+		sortData.priority = element->material->shader->getQueuePriority();
+		sortData.sortType = element->material->shader->getQueueSortType();
 		sortData.seqIdx = (UINT32)mRenderElements.size();
 
 		// TODO - Make sure elements are cached so we dont allocate memory for them every frame
@@ -49,8 +49,8 @@ namespace BansheeEngine
 		renderOp.subMesh = subMesh;
 
 		sortData.distFromCamera = distFromCamera;
-		sortData.priority = material->shader->queuePriority;
-		sortData.sortType = material->shader->queueSortType;
+		sortData.priority = material->shader->getQueuePriority();
+		sortData.sortType = material->shader->getQueueSortType();
 		sortData.seqIdx = (UINT32)mRenderElements.size();
 
 		// TODO - Make sure elements are cached so we dont allocate memory for them every frame

BansheeRenderer/Include/BsBansheeLitTexRenderableController.h

@@ -61,9 +61,9 @@ namespace BansheeEngine
 		 *			It is used for matching custom shaders and determining if they
 		 *			comply with lit textured renderable requirements.
 		 */
-		ShaderPtr createDefaultShader();
+		SPtr<ShaderCore> createDefaultShader();
 
-		ShaderPtr defaultShader;
+		SPtr<ShaderCore> defaultShader;
 
 		GpuParamBlockDesc staticParamBlockDesc;
 		GpuParamBlockDesc perFrameParamBlockDesc;

BansheeRenderer/Source/BsBansheeLitTexRenderableController.cpp

@@ -1,7 +1,6 @@
 #include "BsBansheeLitTexRenderableController.h"
 #include "BsRenderableProxy.h"
 #include "BsShader.h"
-#include "BsShaderProxy.h"
 #include "BsGpuParams.h"
 #include "BsBansheeRenderer.h"
 #include "BsHardwareBufferManager.h"
@@ -33,7 +32,7 @@ namespace BansheeEngine
 		bool foundPerFrame = false;
 		bool foundPerObject = false;
 
-		const Map<String, SHADER_DATA_PARAM_DESC>& dataParams = defaultShader->_getDataParams();
+		const Map<String, SHADER_DATA_PARAM_DESC>& dataParams = defaultShader->getDataParams();
 		for (auto& param : dataParams)
 		{
 			if (!foundLightDir && param.second.rendererSemantic == RPS_LightDir)
@@ -68,7 +67,7 @@ namespace BansheeEngine
 			}
 		}
 
-		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlocks = defaultShader->_getParamBlocks();
+		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlocks = defaultShader->getParamBlocks();
 		for (auto& block : paramBlocks)
 		{
 			if (!foundStatic && block.second.rendererSemantic == RBS_Static)
@@ -133,10 +132,10 @@ namespace BansheeEngine
 		element->rendererData = PerObjectData();
 		PerObjectData* rendererData = any_cast_unsafe<PerObjectData>(&element->rendererData);
 
-		ShaderProxyPtr shader = element->material->shader;
+		SPtr<ShaderCore> shader = element->material->shader;
 
-		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlockDescs = shader->paramBlocks;
-		const Map<String, SHADER_DATA_PARAM_DESC>& dataParamDescs = shader->dataParams;
+		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlockDescs = shader->getParamBlocks();
+		const Map<String, SHADER_DATA_PARAM_DESC>& dataParamDescs = shader->getDataParams();
 		String staticBlockName;
 		String perFrameBlockName;
 		String perObjectBlockName;
@@ -262,7 +261,7 @@ namespace BansheeEngine
 			rendererData->perObjectParamBuffer->flushToGPU();
 	}
 
-	ShaderPtr LitTexRenderableController::createDefaultShader()
+	SPtr<ShaderCore> LitTexRenderableController::createDefaultShader()
 	{
 		String rsName = RenderSystem::instance().getName();
 
@@ -372,7 +371,7 @@ namespace BansheeEngine
 		vsProgram.synchronize();
 		psProgram.synchronize();
 
-		ShaderPtr defaultShader = Shader::create("LitTexDefault");
+		SPtr<ShaderCore> defaultShader = ShaderCore::create("LitTexDefault");
 		defaultShader->setParamBlockAttribs("Static", true, GPBU_DYNAMIC, RBS_Static);
 		defaultShader->setParamBlockAttribs("PerFrame", true, GPBU_DYNAMIC, RBS_PerFrame);
 		defaultShader->setParamBlockAttribs("PerObject", true, GPBU_DYNAMIC, RBS_PerObject);

BansheeRenderer/Source/BsBansheeRenderer.cpp

@@ -24,7 +24,6 @@
 #include "BsHardwareBufferManager.h"
 #include "BsGpuParamBlockBuffer.h"
 #include "BsShader.h"
-#include "BsShaderProxy.h"
 #include "BsBansheeLitTexRenderableController.h"
 #include "BsTime.h"
 #include "BsFrameAlloc.h"

BansheeUtility/Include/BsFrameAlloc.h

@@ -20,7 +20,7 @@ namespace BansheeEngine
 			MemBlock(UINT32 size);
 			~MemBlock();
 
-			UINT8* alloc(UINT8 amount);
+			UINT8* alloc(UINT32 amount);
 			void clear();
 
 			UINT8* mData;

BansheeUtility/Source/BsFrameAlloc.cpp

@@ -10,7 +10,7 @@ namespace BansheeEngine
 	FrameAlloc::MemBlock::~MemBlock()
 	{ }
 
-	UINT8* FrameAlloc::MemBlock::alloc(UINT8 amount)
+	UINT8* FrameAlloc::MemBlock::alloc(UINT32 amount)
 	{
 		UINT8* freePtr = &mData[mFreePtr];
 		mFreePtr += amount;