More renames of core thread objects

Source/BansheeCore/Include/BsCommonTypes.h

@@ -607,7 +607,7 @@ namespace bs
 
 	template<bool Core> struct TMaterialPtrType {};
 	template<> struct TMaterialPtrType < false > { typedef HMaterial Type; };
-	template<> struct TMaterialPtrType < true > { typedef SPtr<ct::MaterialCore> Type; };
+	template<> struct TMaterialPtrType < true > { typedef SPtr<ct::Material> Type; };
 
 	template<bool Core> struct TTextureType {};
 	template<> struct TTextureType < false > { typedef HTexture Type; };

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -421,19 +421,19 @@ namespace bs
 		class GpuBufferCore;
 		class GpuParamBlockBufferCore;
 		class GpuParamsCore;
-		class ShaderCore;
+		class Shader;
 		class ViewportCore;
-		class PassCore;
-		class GpuParamsSetCore;
-		class TechniqueCore;
-		class MaterialCore;
+		class Pass;
+		class GpuParamsSet;
+		class Technique;
+		class Material;
 		class GpuProgramCore;
 		class LightCore;
 		class ComputePipelineStateCore;
 		class GraphicsPipelineStateCore;
 		class CameraCore;
-		class GpuParamsSetCore;
-		class MaterialParamsCore;
+		class GpuParamsSet;
+		class MaterialParams;
 		class GpuPipelineParamInfoCore;
 		class CommandBuffer;
 		class EventQuery;

Source/BansheeCore/Include/BsGpuParamsSet.h

@@ -196,12 +196,12 @@ namespace bs
 	namespace ct
 	{
 	/** Core thread version of TGpuParamsSet<Core>. */
-	class BS_CORE_EXPORT GpuParamsSetCore : public TGpuParamsSet<true>
+	class BS_CORE_EXPORT GpuParamsSet : public TGpuParamsSet<true>
 	{
 	public:
-		GpuParamsSetCore() { }
-		GpuParamsSetCore(const SPtr<TechniqueCore>& technique, const SPtr<ShaderCore>& shader,
-			const SPtr<MaterialParamsCore>& params)
+		GpuParamsSet() { }
+		GpuParamsSet(const SPtr<Technique>& technique, const SPtr<Shader>& shader,
+			const SPtr<MaterialParams>& params)
 			:TGpuParamsSet(technique, shader, params)
 		{ }
 	};

Source/BansheeCore/Include/BsMaterial.h

@@ -30,7 +30,7 @@ namespace bs
 
 	template<bool Core> struct TShaderType {};
 	template<> struct TShaderType < false > { typedef HShader Type; };
-	template<> struct TShaderType < true > { typedef SPtr<ct::ShaderCore> Type; };
+	template<> struct TShaderType < true > { typedef SPtr<ct::Shader> Type; };
 
 	template<bool Core> struct TGpuParamBlockBufferType {};
 	template<> struct TGpuParamBlockBufferType < false > { typedef GpuParamBlockBuffer Type; };
@@ -38,7 +38,7 @@ namespace bs
 	
 	template<bool Core> struct TGpuParamsSetType {};
 	template<> struct TGpuParamsSetType < false > { typedef GpuParamsSet Type; };
-	template<> struct TGpuParamsSetType < true > { typedef ct::GpuParamsSetCore Type; };
+	template<> struct TGpuParamsSetType < true > { typedef ct::GpuParamsSet Type; };
 
 	/**
 	 * Material that controls how objects are rendered. It is represented by a shader and parameters used to set up that
@@ -564,7 +564,7 @@ namespace bs
 		void setShader(const HShader& shader);
 
 		/** Retrieves an implementation of a material usable only from the core thread. */
-		SPtr<ct::MaterialCore> getCore() const;
+		SPtr<ct::Material> getCore() const;
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
@@ -656,24 +656,24 @@ namespace bs
 	 */
 
 	/** @copydoc MaterialBase */
-	class BS_CORE_EXPORT MaterialCore : public CoreObject, public TMaterial<true>
+	class BS_CORE_EXPORT Material : public CoreObject, public TMaterial<true>
 	{
 	public:
-		~MaterialCore() { }
+		~Material() { }
 
-		/** @copydoc Material::setShader */
-		void setShader(const SPtr<ShaderCore>& shader);
+		/** @copydoc bs::Material::setShader */
+		void setShader(const SPtr<Shader>& shader);
 
 		/** Creates a new material with the specified shader. */
-		static SPtr<MaterialCore> create(const SPtr<ShaderCore>& shader);
+		static SPtr<Material> create(const SPtr<Shader>& shader);
 
 	private:
-		friend class Material;
+		friend class bs::Material;
 
-		MaterialCore() { }
-		MaterialCore(const SPtr<ShaderCore>& shader);
-		MaterialCore(const SPtr<ShaderCore>& shader, const Vector<SPtr<TechniqueCore>>& techniques,
-			const SPtr<MaterialParamsCore>& materialParams);
+		Material() { }
+		Material(const SPtr<Shader>& shader);
+		Material(const SPtr<Shader>& shader, const Vector<SPtr<Technique>>& techniques,
+			const SPtr<MaterialParams>& materialParams);
 
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;

Source/BansheeCore/Include/BsMaterialParam.h

@@ -13,11 +13,11 @@ namespace bs
 
 	template<bool Core> struct TMaterialType { };
 	template<> struct TMaterialType<false> { typedef SPtr<Material> Type; };
-	template<> struct TMaterialType<true> { typedef SPtr<ct::MaterialCore> Type; };
+	template<> struct TMaterialType<true> { typedef SPtr<ct::Material> Type; };
 
 	template<bool Core> struct TMaterialParamsType { };
 	template<> struct TMaterialParamsType<false> { typedef MaterialParams Type; };
-	template<> struct TMaterialParamsType<true> { typedef ct::MaterialParamsCore Type; };
+	template<> struct TMaterialParamsType<true> { typedef ct::MaterialParams Type; };
 
 	/**
 	 * A handle that allows you to set a Material parameter. Internally keeps a reference to the material parameters so that

Source/BansheeCore/Include/BsMaterialParams.h

@@ -17,7 +17,7 @@ namespace bs
 	struct SHADER_DATA_PARAM_DESC;
 	struct SHADER_OBJECT_PARAM_DESC;
 
-	/** Common functionality for MaterialParams and MaterialParamsCore. */
+	/** Common functionality for MaterialParams and ct::MaterialParams. */
 	class BS_CORE_EXPORT MaterialParamsBase
 	{
 	public:
@@ -333,10 +333,10 @@ namespace bs
 		typedef MaterialParamTextureDataCore TextureParamDataType;
 		typedef MaterialParamBufferDataCore BufferParamDataType;
 		typedef MaterialParamSamplerStateDataCore SamplerStateParamDataType;
-		typedef SPtr<ct::ShaderCore> ShaderType;
+		typedef SPtr<ct::Shader> ShaderType;
 	};
 
-	/** Common code that may be specialized for both MaterialParams and MaterialParamsCore. */
+	/** Common code that may be specialized for both MaterialParams and ct::MaterialParams. */
 	template<bool Core>
 	class BS_CORE_EXPORT TMaterialParams : public MaterialParamsBase
 	{
@@ -581,7 +581,7 @@ namespace bs
 
 		/** 
 		 * Populates the provided buffer with parameters that can be used for syncing this object with its core-thread
-		 * counterpart. Can be applied by calling MaterialParamsCore::setSyncData.
+		 * counterpart. Can be applied by calling ct::MaterialParams::setSyncData.
 		 *
 		 * @param[in]		buffer		Pre-allocated buffer to store the sync data in. Set to null to calculate the size
 		 *								of the required buffer.
@@ -591,7 +591,7 @@ namespace bs
 		void getSyncData(UINT8* buffer, UINT32& size);
 
 	private:
-		friend class ct::MaterialParamsCore;
+		friend class ct::MaterialParams;
 
 		UINT64 mLastSyncVersion;
 
@@ -609,18 +609,18 @@ namespace bs
 	namespace ct
 	{
 	/** Core thread version of MaterialParams. */
-	class BS_CORE_EXPORT MaterialParamsCore : public TMaterialParams<true>
+	class BS_CORE_EXPORT MaterialParams : public TMaterialParams<true>
 	{
 	public:
 		/** Initializes the core thread version of MaterialParams from its sim thread counterpart. */
-		MaterialParamsCore(const SPtr<ShaderCore>& shader, const SPtr<MaterialParams>& params);
+		MaterialParams(const SPtr<Shader>& shader, const SPtr<bs::MaterialParams>& params);
 		
 		/** @copydoc TMaterialParams::TMaterialParams(const ShaderType&) */
-		MaterialParamsCore(const SPtr<ShaderCore>& shader);
+		MaterialParams(const SPtr<Shader>& shader);
 
 		/** 
 		 * Updates the stored parameters from the provided buffer, allowing changes to be transfered between the sim and 
-		 * core thread material param objects. Buffer must be retrieved from MaterialParams::getSyncData. 
+		 * core thread material param objects. Buffer must be retrieved from bs::MaterialParams::getSyncData. 
 		 *
 		 * @param[in]		buffer		Buffer containing the dirty data.
 		 * @param[in, out]	size		Size of the provided buffer.

Source/BansheeCore/Include/BsPass.h

@@ -163,7 +163,7 @@ namespace bs
 		virtual ~Pass() { }
 
 		/** Retrieves an implementation of a pass usable only from the core thread. */
-		SPtr<ct::PassCore> getCore() const;
+		SPtr<ct::Pass> getCore() const;
 
 		/**	Creates a new empty pass. */
 		static SPtr<Pass> create(const PASS_DESC& desc);
@@ -211,25 +211,25 @@ namespace bs
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT PassCore : public CoreObject, public TPass<true>
+	class BS_CORE_EXPORT Pass : public CoreObject, public TPass<true>
     {
     public:
-		virtual ~PassCore() { }
+		virtual ~Pass() { }
 
 		/**	Creates a new empty pass. */
-		static SPtr<PassCore> create(const PASS_DESC& desc);
+		static SPtr<Pass> create(const PASS_DESC& desc);
 
 	protected:
-		friend class Pass;
-		friend class TechniqueCore;
+		friend class bs::Pass;
+		friend class Technique;
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
 
-		PassCore() { }
-		PassCore(const PASS_DESC& desc);
-		PassCore(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState);
-		PassCore(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState);
+		Pass() { }
+		Pass(const PASS_DESC& desc);
+		Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState);
+		Pass(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState);
 
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;

Source/BansheeCore/Include/BsShader.h

@@ -380,7 +380,7 @@ namespace bs
 	{
 	public:
 		/** Retrieves an implementation of a shader usable only from the core thread. */
-		SPtr<ct::ShaderCore> getCore() const;
+		SPtr<ct::Shader> getCore() const;
 
 		/**
 		 * Sets a list include file paths that are referenced by this shader.
@@ -483,16 +483,16 @@ namespace bs
 	 */
 
 	/** Core thread version of Shader. */
-	class BS_CORE_EXPORT ShaderCore : public CoreObject, public TShader<true>
+	class BS_CORE_EXPORT Shader : public CoreObject, public TShader<true>
 	{
 	public:
-		/** @copydoc Shader::create */
-		static SPtr<ShaderCore> create(const String& name, const SHADER_DESC& desc, const Vector<SPtr<TechniqueCore>>& techniques);
+		/** @copydoc bs::Shader::create */
+		static SPtr<Shader> create(const String& name, const SHADER_DESC& desc, const Vector<SPtr<Technique>>& techniques);
 
 	protected:
-		friend class Shader;
+		friend class bs::Shader;
 
-		ShaderCore(const String& name, const SHADER_DESC& desc, const Vector<SPtr<TechniqueCore>>& techniques, UINT32 id);
+		Shader(const String& name, const SHADER_DESC& desc, const Vector<SPtr<Technique>>& techniques, UINT32 id);
 
 		static std::atomic<UINT32> mNextShaderId;
 	};

Source/BansheeCore/Include/BsTechnique.h

@@ -36,11 +36,11 @@ namespace bs
 
 	template<bool Core> struct TPassType { };
 	template<> struct TPassType < false > { typedef Pass Type; };
-	template<> struct TPassType < true > { typedef ct::PassCore Type; };
+	template<> struct TPassType < true > { typedef ct::Pass Type; };
 
 	template<bool Core> struct TTechniqueType {};
 	template<> struct TTechniqueType < false > { typedef Technique Type; };
-	template<> struct TTechniqueType < true > { typedef ct::TechniqueCore Type; };
+	template<> struct TTechniqueType < true > { typedef ct::Technique Type; };
 
 	/** Templated class that is used for implementing both sim and core versions of Technique. */
 	template<bool Core>
@@ -87,7 +87,7 @@ namespace bs
 			const Vector<SPtr<Pass>>& passes);
 
 		/** Retrieves an implementation of a technique usable only from the core thread. */
-		SPtr<ct::TechniqueCore> getCore() const;
+		SPtr<ct::Technique> getCore() const;
 
 		/** 
 		 * Creates a new technique. 
@@ -148,20 +148,20 @@ namespace bs
 	 *  @{
 	 */
 
-	/** Core thread version of Technique. */
-	class BS_CORE_EXPORT TechniqueCore : public CoreObject, public TTechnique<true>
+	/** Core thread version of bs::Technique. */
+	class BS_CORE_EXPORT Technique : public CoreObject, public TTechnique<true>
 	{
 	public:
-		TechniqueCore(const String& language, const StringID& renderer, const Vector<StringID>& tags,
-			const Vector<SPtr<PassCore>>& passes);
+		Technique(const String& language, const StringID& renderer, const Vector<StringID>& tags,
+			const Vector<SPtr<Pass>>& passes);
 
-		/** @copydoc Technique::create(const String&, const StringID&, const Vector<SPtr<Pass>>&) */
-		static SPtr<TechniqueCore> create(const String& language, const StringID& renderer,
-			const Vector<SPtr<PassCore>>& passes);
+		/** @copydoc bs::Technique::create(const String&, const StringID&, const Vector<SPtr<Pass>>&) */
+		static SPtr<Technique> create(const String& language, const StringID& renderer,
+			const Vector<SPtr<Pass>>& passes);
 
-		/** @copydoc Technique::create(const String&, const StringID&, const Vector<StringID>&, const Vector<SPtr<Pass>>&) */
-		static SPtr<TechniqueCore> create(const String& language, const StringID& renderer, const Vector<StringID>& tags,
-			const Vector<SPtr<PassCore>>& passes);
+		/** @copydoc bs::Technique::create(const String&, const StringID&, const Vector<StringID>&, const Vector<SPtr<Pass>>&) */
+		static SPtr<Technique> create(const String& language, const StringID& renderer, const Vector<StringID>& tags,
+			const Vector<SPtr<Pass>>& passes);
 	};
 
 	/** @} */

Source/BansheeCore/Source/BsGpuParamsSet.cpp

@@ -124,14 +124,14 @@ namespace bs
 		return allParamDescs;
 	}
 
-	Vector<SPtr<GpuParamDesc>> getAllParamDescs(const SPtr<ct::TechniqueCore>& technique)
+	Vector<SPtr<GpuParamDesc>> getAllParamDescs(const SPtr<ct::Technique>& technique)
 	{
 		Vector<SPtr<GpuParamDesc>> allParamDescs;
 
 		// Make sure all gpu programs are fully loaded
 		for (UINT32 i = 0; i < technique->getNumPasses(); i++)
 		{
-			SPtr<ct::PassCore> curPass = technique->getPass(i);
+			SPtr<ct::Pass> curPass = technique->getPass(i);
 
 			SPtr<ct::GpuProgramCore> vertProgram = curPass->getVertexProgram();
 			if (vertProgram)

Source/BansheeCore/Source/BsMaterial.cpp

@@ -31,11 +31,11 @@ namespace bs
 	bool isShaderValid(const HShader& shader) { return shader.isLoaded(); }
 
 	template<>
-	bool isShaderValid(const SPtr<ct::ShaderCore>& shader) { return shader != nullptr; }
+	bool isShaderValid(const SPtr<ct::Shader>& shader) { return shader != nullptr; }
 
 	template<bool Core> struct TMatType { };
 	template<> struct TMatType<false> { typedef Material Type; };
-	template<> struct TMatType<true> { typedef ct::MaterialCore Type; };
+	template<> struct TMatType<true> { typedef ct::Material Type; };
 
 	template<bool Core>
 	SPtr<typename TMatType<Core>::Type> getMaterialPtr(const TMaterial<Core>* material)
@@ -404,33 +404,33 @@ namespace bs
 		markListenerResourcesDirty();
 	}
 
-	SPtr<ct::MaterialCore> Material::getCore() const
+	SPtr<ct::Material> Material::getCore() const
 	{
-		return std::static_pointer_cast<ct::MaterialCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Material>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> Material::createCore() const
 	{
-		ct::MaterialCore* material = nullptr;
+		ct::Material* material = nullptr;
 
-		SPtr<ct::ShaderCore> shader;
+		SPtr<ct::Shader> shader;
 		if (mShader.isLoaded())
 		{
 			shader = mShader->getCore();
 
-			Vector<SPtr<ct::TechniqueCore>> techniques(mTechniques.size());
+			Vector<SPtr<ct::Technique>> techniques(mTechniques.size());
 			for (UINT32 i = 0; i < (UINT32)mTechniques.size(); i++)
 				techniques[i] = mTechniques[i]->getCore();
 			
-			SPtr<ct::MaterialParamsCore> materialParams = bs_shared_ptr_new<ct::MaterialParamsCore>(shader, mParams);
+			SPtr<ct::MaterialParams> materialParams = bs_shared_ptr_new<ct::MaterialParams>(shader, mParams);
 
-			material = new (bs_alloc<ct::MaterialCore>()) ct::MaterialCore(shader, techniques, materialParams);
+			material = new (bs_alloc<ct::Material>()) ct::Material(shader, techniques, materialParams);
 		}
 		
 		if (material == nullptr)
-			material = new (bs_alloc<ct::MaterialCore>()) ct::MaterialCore(shader);
+			material = new (bs_alloc<ct::Material>()) ct::Material(shader);
 
-		SPtr<ct::MaterialCore> materialPtr = bs_shared_ptr<ct::MaterialCore>(material);
+		SPtr<ct::Material> materialPtr = bs_shared_ptr<ct::Material>(material);
 		materialPtr->_setThisPtr(materialPtr);
 
 		return materialPtr;
@@ -443,27 +443,27 @@ namespace bs
 			mParams->getSyncData(nullptr, paramsSize);
 
 		UINT32 numTechniques = (UINT32)mTechniques.size();
-		UINT32 size = sizeof(UINT32) * 2 + sizeof(SPtr<ct::ShaderCore>) + 
-			sizeof(SPtr<ct::TechniqueCore>) * numTechniques + paramsSize;
+		UINT32 size = sizeof(UINT32) * 2 + sizeof(SPtr<ct::Shader>) + 
+			sizeof(SPtr<ct::Technique>) * numTechniques + paramsSize;
 
 		UINT8* buffer = allocator->alloc(size);
 		char* dataPtr = (char*)buffer;
 		
-		SPtr<ct::ShaderCore>* shader = new (dataPtr)SPtr<ct::ShaderCore>();
+		SPtr<ct::Shader>* shader = new (dataPtr)SPtr<ct::Shader>();
 		if (mShader.isLoaded(false))
 			*shader = mShader->getCore();
 		else
 			*shader = nullptr;
 
-		dataPtr += sizeof(SPtr<ct::ShaderCore>);
+		dataPtr += sizeof(SPtr<ct::Shader>);
 		dataPtr = rttiWriteElem(numTechniques, dataPtr);
 
 		for(UINT32 i = 0; i < numTechniques; i++)
 		{
-			SPtr<ct::TechniqueCore>* technique = new (dataPtr)SPtr<ct::TechniqueCore>();
+			SPtr<ct::Technique>* technique = new (dataPtr)SPtr<ct::Technique>();
 				*technique = mTechniques[i]->getCore();
 
-			dataPtr += sizeof(SPtr<ct::TechniqueCore>);
+			dataPtr += sizeof(SPtr<ct::Technique>);
 		}
 
 		dataPtr = rttiWriteElem(paramsSize, dataPtr);
@@ -722,20 +722,20 @@ namespace bs
 
 	namespace ct
 	{
-	MaterialCore::MaterialCore(const SPtr<ShaderCore>& shader)
+	Material::Material(const SPtr<Shader>& shader)
 	{
 		setShader(shader);
 	}
 
-	MaterialCore::MaterialCore(const SPtr<ShaderCore>& shader, const Vector<SPtr<TechniqueCore>>& techniques,
-		const SPtr<MaterialParamsCore>& materialParams)
+	Material::Material(const SPtr<Shader>& shader, const Vector<SPtr<Technique>>& techniques,
+		const SPtr<MaterialParams>& materialParams)
 	{
 		mShader = shader;
 		mParams = materialParams;
 		mTechniques = techniques;
 	}
 
-	void MaterialCore::setShader(const SPtr<ShaderCore>& shader)
+	void Material::setShader(const SPtr<Shader>& shader)
 	{
 		mShader = shader;
 
@@ -744,15 +744,15 @@ namespace bs
 		_markCoreDirty();
 	}
 
-	void MaterialCore::syncToCore(const CoreSyncData& data)
+	void Material::syncToCore(const CoreSyncData& data)
 	{
 		char* dataPtr = (char*)data.getBuffer();
 
-		SPtr<ShaderCore>* shader = (SPtr<ShaderCore>*)dataPtr;
+		SPtr<Shader>* shader = (SPtr<Shader>*)dataPtr;
 
 		mShader = *shader;
-		shader->~SPtr<ShaderCore>();
-		dataPtr += sizeof(SPtr<ShaderCore>);
+		shader->~SPtr<Shader>();
+		dataPtr += sizeof(SPtr<Shader>);
 
 		UINT32 numTechniques;
 		dataPtr = rttiReadElem(numTechniques, dataPtr);
@@ -760,10 +760,10 @@ namespace bs
 		mTechniques.resize(numTechniques);
 		for(UINT32 i = 0; i < numTechniques; i++)
 		{
-			SPtr<TechniqueCore>* technique = (SPtr<TechniqueCore>*)dataPtr;
+			SPtr<Technique>* technique = (SPtr<Technique>*)dataPtr;
 			mTechniques[i] = *technique;
-			technique->~SPtr<TechniqueCore>();
-			dataPtr += sizeof(SPtr<TechniqueCore>);
+			technique->~SPtr<Technique>();
+			dataPtr += sizeof(SPtr<Technique>);
 		}
 
 		UINT32 paramsSize = 0;
@@ -774,10 +774,10 @@ namespace bs
 		dataPtr += paramsSize;
 	}
 
-	SPtr<MaterialCore> MaterialCore::create(const SPtr<ShaderCore>& shader)
+	SPtr<Material> Material::create(const SPtr<Shader>& shader)
 	{
-		MaterialCore* material = new (bs_alloc<MaterialCore>()) MaterialCore(shader);
-		SPtr<MaterialCore> materialPtr = bs_shared_ptr<MaterialCore>(material);
+		Material* material = new (bs_alloc<Material>()) Material(shader);
+		SPtr<Material> materialPtr = bs_shared_ptr<Material>(material);
 		materialPtr->_setThisPtr(materialPtr);
 		materialPtr->initialize();
 

Source/BansheeCore/Source/BsMaterialParams.cpp

@@ -715,11 +715,11 @@ namespace bs
 
 	namespace ct
 	{
-	MaterialParamsCore::MaterialParamsCore(const SPtr<ShaderCore>& shader)
+	MaterialParams::MaterialParams(const SPtr<Shader>& shader)
 		:TMaterialParams(shader)
 	{ }
 
-	MaterialParamsCore::MaterialParamsCore(const SPtr<ShaderCore>& shader, const SPtr<MaterialParams>& params)
+	MaterialParams::MaterialParams(const SPtr<Shader>& shader, const SPtr<bs::MaterialParams>& params)
 		: TMaterialParams(shader)
 	{
 		memcpy(mDataParamsBuffer, params->mDataParamsBuffer, mDataSize);
@@ -764,7 +764,7 @@ namespace bs
 		}
 	}
 
-	void MaterialParamsCore::setSyncData(UINT8* buffer, UINT32 size)
+	void MaterialParams::setSyncData(UINT8* buffer, UINT32 size)
 	{
 		char* sourceData = (char*)buffer;
 

Source/BansheeCore/Source/BsPass.cpp

@@ -99,9 +99,9 @@ namespace bs
 		:TPass(desc)
 	{ }
 
-	SPtr<ct::PassCore> Pass::getCore() const
+	SPtr<ct::Pass> Pass::getCore() const
 	{
-		return std::static_pointer_cast<ct::PassCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Pass>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> Pass::createCore() const
@@ -109,11 +109,11 @@ namespace bs
 		ct::PASS_DESC desc;
 		convertPassDesc(mData, desc);
 
-		ct::PassCore* pass;
+		ct::Pass* pass;
 		if(mComputePipelineState != nullptr)
 		{
 			SPtr<ct::ComputePipelineStateCore> corePipeline = mComputePipelineState->getCore();
-			pass = new (bs_alloc<ct::PassCore>()) ct::PassCore(desc, corePipeline);
+			pass = new (bs_alloc<ct::Pass>()) ct::Pass(desc, corePipeline);
 		}
 		else
 		{
@@ -121,10 +121,10 @@ namespace bs
 			if (mGraphicsPipelineState != nullptr)
 				corePipeline = mGraphicsPipelineState->getCore();
 
-			pass = new (bs_alloc<ct::PassCore>()) ct::PassCore(desc, corePipeline);
+			pass = new (bs_alloc<ct::Pass>()) ct::Pass(desc, corePipeline);
 		}
 
-		SPtr<ct::PassCore> passPtr = bs_shared_ptr<ct::PassCore>(pass);
+		SPtr<ct::Pass> passPtr = bs_shared_ptr<ct::Pass>(pass);
 		passPtr->_setThisPtr(passPtr);
 
 		return passPtr;
@@ -220,24 +220,24 @@ namespace bs
 
 	namespace ct
 	{
-	PassCore::PassCore(const PASS_DESC& desc)
+	Pass::Pass(const PASS_DESC& desc)
 		:TPass(desc)
 	{ }
 
-	PassCore::PassCore(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState)
+	Pass::Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState)
 		:TPass(desc)
 	{
 		mGraphicsPipelineState = pipelineState;
 	}
 
 
-	PassCore::PassCore(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState)
+	Pass::Pass(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState)
 		:TPass(desc)
 	{
 		mComputePipelineState = pipelineState;
 	}
 
-	void PassCore::initialize()
+	void Pass::initialize()
 	{
 		if(hasComputeProgram())
 		{
@@ -258,7 +258,7 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	void PassCore::syncToCore(const CoreSyncData& data)
+	void Pass::syncToCore(const CoreSyncData& data)
 	{
 		UINT8* dataPtr = data.getBuffer();
 		PASS_DESC* desc = (PASS_DESC*)dataPtr;
@@ -267,10 +267,10 @@ namespace bs
 		desc->~PASS_DESC();
 	}
 
-	SPtr<PassCore> PassCore::create(const PASS_DESC& desc)
+	SPtr<Pass> Pass::create(const PASS_DESC& desc)
 	{
-		PassCore* newPass = new (bs_alloc<PassCore>()) PassCore(desc);
-		SPtr<PassCore> newPassPtr = bs_shared_ptr<PassCore>(newPass);
+		Pass* newPass = new (bs_alloc<Pass>()) Pass(desc);
+		SPtr<Pass> newPassPtr = bs_shared_ptr<Pass>(newPass);
 		newPassPtr->_setThisPtr(newPassPtr);
 		newPassPtr->initialize();
 

Source/BansheeCore/Source/BsShader.cpp

@@ -325,9 +325,9 @@ namespace bs
 		mMetaData = bs_shared_ptr_new<ShaderMetaData>();
 	}
 
-	SPtr<ct::ShaderCore> Shader::getCore() const
+	SPtr<ct::Shader> Shader::getCore() const
 	{
-		return std::static_pointer_cast<ct::ShaderCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Shader>(mCoreSpecific);
 	}
 
 	void Shader::setIncludeFiles(const Vector<String>& includes)
@@ -338,12 +338,12 @@ namespace bs
 
 	SPtr<ct::CoreObject> Shader::createCore() const
 	{
-		Vector<SPtr<ct::TechniqueCore>> techniques;
+		Vector<SPtr<ct::Technique>> techniques;
 		for (auto& technique : mTechniques)
 			techniques.push_back(technique->getCore());
 
-		ct::ShaderCore* shaderCore = new (bs_alloc<ct::ShaderCore>()) ct::ShaderCore(mName, convertDesc(mDesc), techniques, mId);
-		SPtr<ct::ShaderCore> shaderCorePtr = bs_shared_ptr<ct::ShaderCore>(shaderCore);
+		ct::Shader* shaderCore = new (bs_alloc<ct::Shader>()) ct::Shader(mName, convertDesc(mDesc), techniques, mId);
+		SPtr<ct::Shader> shaderCorePtr = bs_shared_ptr<ct::Shader>(shaderCore);
 		shaderCorePtr->_setThisPtr(shaderCorePtr);
 
 		return shaderCorePtr;
@@ -455,7 +455,7 @@ namespace bs
 
 	SPtr<Shader> Shader::_createPtr(const String& name, const SHADER_DESC& desc, const Vector<SPtr<Technique>>& techniques)
 	{
-		UINT32 id = ct::ShaderCore::mNextShaderId.fetch_add(1, std::memory_order_relaxed);
+		UINT32 id = ct::Shader::mNextShaderId.fetch_add(1, std::memory_order_relaxed);
 		assert(id < std::numeric_limits<UINT32>::max() && "Created too many shaders, reached maximum id.");
 
 		SPtr<Shader> newShader = bs_core_ptr<Shader>(new (bs_alloc<Shader>()) Shader(name, desc, techniques, id));
@@ -495,23 +495,23 @@ namespace bs
 
 	namespace ct
 	{
-	std::atomic<UINT32> ShaderCore::mNextShaderId;
+	std::atomic<UINT32> Shader::mNextShaderId;
 
-	ShaderCore::ShaderCore(const String& name, const SHADER_DESC& desc, const Vector<SPtr<TechniqueCore>>& techniques, 
+	Shader::Shader(const String& name, const SHADER_DESC& desc, const Vector<SPtr<Technique>>& techniques, 
 		UINT32 id)
 		:TShader(name, desc, techniques, id)
 	{
 
 	}
 
-	SPtr<ShaderCore> ShaderCore::create(const String& name, const SHADER_DESC& desc, 
-		const Vector<SPtr<TechniqueCore>>& techniques)
+	SPtr<Shader> Shader::create(const String& name, const SHADER_DESC& desc, 
+		const Vector<SPtr<Technique>>& techniques)
 	{
 		UINT32 id = mNextShaderId.fetch_add(1, std::memory_order_relaxed);
 		assert(id < std::numeric_limits<UINT32>::max() && "Created too many shaders, reached maximum id.");
 
-		ShaderCore* shaderCore = new (bs_alloc<ShaderCore>()) ShaderCore(name, desc, techniques, id);
-		SPtr<ShaderCore> shaderCorePtr = bs_shared_ptr<ShaderCore>(shaderCore);
+		Shader* shaderCore = new (bs_alloc<Shader>()) Shader(name, desc, techniques, id);
+		SPtr<Shader> shaderCorePtr = bs_shared_ptr<Shader>(shaderCore);
 		shaderCorePtr->_setThisPtr(shaderCorePtr);
 		shaderCorePtr->initialize();
 

Source/BansheeCore/Source/BsTechnique.cpp

@@ -72,19 +72,19 @@ namespace bs
 		: TTechnique()
 	{ }
 
-	SPtr<ct::TechniqueCore> Technique::getCore() const
+	SPtr<ct::Technique> Technique::getCore() const
 	{
-		return std::static_pointer_cast<ct::TechniqueCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Technique>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> Technique::createCore() const
 	{
-		Vector<SPtr<ct::PassCore>> passes;
+		Vector<SPtr<ct::Pass>> passes;
 		for (auto& pass : mPasses)
 			passes.push_back(pass->getCore());
 
-		ct::TechniqueCore* technique = new (bs_alloc<ct::TechniqueCore>()) ct::TechniqueCore(mLanguage, mRenderer, mTags, passes);
-		SPtr<ct::TechniqueCore> techniquePtr = bs_shared_ptr<ct::TechniqueCore>(technique);
+		ct::Technique* technique = new (bs_alloc<ct::Technique>()) ct::Technique(mLanguage, mRenderer, mTags, passes);
+		SPtr<ct::Technique> techniquePtr = bs_shared_ptr<ct::Technique>(technique);
 		techniquePtr->_setThisPtr(techniquePtr);
 
 		return techniquePtr;
@@ -138,27 +138,27 @@ namespace bs
 
 	namespace ct
 	{
-	TechniqueCore::TechniqueCore(const String& language, const StringID& renderer, const Vector<StringID>& tags,
-		const Vector<SPtr<PassCore>>& passes)
+	Technique::Technique(const String& language, const StringID& renderer, const Vector<StringID>& tags,
+		const Vector<SPtr<Pass>>& passes)
 		:TTechnique(language, renderer, tags, passes)
 	{ }
 
-	SPtr<TechniqueCore> TechniqueCore::create(const String& language, const StringID& renderer,
-		const Vector<SPtr<PassCore>>& passes)
+	SPtr<Technique> Technique::create(const String& language, const StringID& renderer,
+		const Vector<SPtr<Pass>>& passes)
 	{
-		TechniqueCore* technique = new (bs_alloc<TechniqueCore>()) TechniqueCore(language, renderer, {}, passes);
-		SPtr<TechniqueCore> techniquePtr = bs_shared_ptr<TechniqueCore>(technique);
+		Technique* technique = new (bs_alloc<Technique>()) Technique(language, renderer, {}, passes);
+		SPtr<Technique> techniquePtr = bs_shared_ptr<Technique>(technique);
 		techniquePtr->_setThisPtr(techniquePtr);
 		techniquePtr->initialize();
 
 		return techniquePtr;
 	}
 
-	SPtr<TechniqueCore> TechniqueCore::create(const String& language, const StringID& renderer,
-		const Vector<StringID>& tags, const Vector<SPtr<PassCore>>& passes)
+	SPtr<Technique> Technique::create(const String& language, const StringID& renderer,
+		const Vector<StringID>& tags, const Vector<SPtr<Pass>>& passes)
 	{
-		TechniqueCore* technique = new (bs_alloc<TechniqueCore>()) TechniqueCore(language, renderer, tags, passes);
-		SPtr<TechniqueCore> techniquePtr = bs_shared_ptr<TechniqueCore>(technique);
+		Technique* technique = new (bs_alloc<Technique>()) Technique(language, renderer, tags, passes);
+		SPtr<Technique> techniquePtr = bs_shared_ptr<Technique>(technique);
 		techniquePtr->_setThisPtr(techniquePtr);
 		techniquePtr->initialize();
 

Source/BansheeEditor/Include/BsDockManager.h

@@ -288,8 +288,8 @@ namespace bs
 			DockManager::DockLocation location);
 
 		SPtr<CameraCore> mCamera;
-		SPtr<MaterialCore> mMaterial;
-		SPtr<GpuParamsSetCore> mParams;
+		SPtr<Material> mMaterial;
+		SPtr<GpuParamsSet> mParams;
 		SPtr<MeshCore> mMesh;
 		DockManager::DockLocation mHighlightedDropLoc;
 		bool mShowOverlay;

Source/BansheeEditor/Include/BsGizmoManager.h

@@ -387,13 +387,13 @@ namespace bs
 		/**	Data used for initializing the core thread equivalent of the gizmo manager. */
 		struct CoreInitData
 		{
-			SPtr<ct::MaterialCore> solidMat;
-			SPtr<ct::MaterialCore> wireMat;
-			SPtr<ct::MaterialCore> lineMat;
-			SPtr<ct::MaterialCore> iconMat;
-			SPtr<ct::MaterialCore> textMat;
-			SPtr<ct::MaterialCore> pickingMat;
-			SPtr<ct::MaterialCore> alphaPickingMat;
+			SPtr<ct::Material> solidMat;
+			SPtr<ct::Material> wireMat;
+			SPtr<ct::Material> lineMat;
+			SPtr<ct::Material> iconMat;
+			SPtr<ct::Material> textMat;
+			SPtr<ct::Material> pickingMat;
+			SPtr<ct::Material> alphaPickingMat;
 		};
 
 		typedef Vector<IconRenderData> IconRenderDataVec;
@@ -577,9 +577,9 @@ namespace bs
 		SPtr<MeshCoreBase> mIconMesh;
 		GizmoManager::IconRenderDataVecPtr mIconRenderData;
 
-		Vector<SPtr<GpuParamsSetCore>> mMeshParamSets[(UINT32)GizmoMeshType::Count];
-		Vector<SPtr<GpuParamsSetCore>> mIconParamSets;
-		Vector<SPtr<GpuParamsSetCore>> mPickingParamSets[2];
+		Vector<SPtr<GpuParamsSet>> mMeshParamSets[(UINT32)GizmoMeshType::Count];
+		Vector<SPtr<GpuParamsSet>> mIconParamSets;
+		Vector<SPtr<GpuParamsSet>> mPickingParamSets[2];
 
 		SPtr<GpuParamBlockBufferCore> mMeshGizmoBuffer;
 		SPtr<GpuParamBlockBufferCore> mIconGizmoBuffer;
@@ -587,9 +587,9 @@ namespace bs
 		SPtr<GpuParamBlockBufferCore> mIconPickingParamBuffer;
 
 		// Immutable
-		SPtr<MaterialCore> mMeshMaterials[(UINT32)GizmoMeshType::Count];
-		SPtr<MaterialCore> mIconMaterial;
-		SPtr<MaterialCore> mPickingMaterials[2];
+		SPtr<Material> mMeshMaterials[(UINT32)GizmoMeshType::Count];
+		SPtr<Material> mIconMaterial;
+		SPtr<Material> mPickingMaterials[2];
 	};
 
 	/** @} */

Source/BansheeEditor/Include/BsHandleDrawManager.h

@@ -229,10 +229,10 @@ namespace bs
 		/** Data used for initializing the renderer. */
 		struct InitData
 		{
-			SPtr<MaterialCore> lineMat;
-			SPtr<MaterialCore> solidMat;
-			SPtr<MaterialCore> textMat;
-			SPtr<MaterialCore> clearMat;
+			SPtr<Material> lineMat;
+			SPtr<Material> solidMat;
+			SPtr<Material> textMat;
+			SPtr<Material> clearMat;
 		};
 
 	public:
@@ -267,12 +267,12 @@ namespace bs
 		Vector<QueuedData> mQueuedData;
 
 		SPtr<GpuParamBlockBufferCore> mParamBuffer;
-		Vector<SPtr<GpuParamsSetCore>> mParamSets[(UINT32)MeshType::Count];
+		Vector<SPtr<GpuParamsSet>> mParamSets[(UINT32)MeshType::Count];
 		UINT32 mTypeCounters[(UINT32)MeshType::Count];
 
 		// Immutable
-		SPtr<MaterialCore> mMaterials[(UINT32)MeshType::Count];
-		SPtr<MaterialCore> mClearMaterial;
+		SPtr<Material> mMaterials[(UINT32)MeshType::Count];
+		SPtr<Material> mClearMaterial;
 	};
 
 	/** @} */

Source/BansheeEditor/Include/BsSceneGrid.h

@@ -79,7 +79,7 @@ namespace bs
 		struct InitData
 		{
 			SPtr<CameraCore> camera;
-			SPtr<MaterialCore> material;
+			SPtr<Material> material;
 		};
 
 		SceneGridRenderer();
@@ -109,8 +109,8 @@ namespace bs
 
 		SPtr<CameraCore> mCamera;
 		SPtr<MeshCore> mGridMesh;
-		SPtr<MaterialCore> mGridMaterial;
-		SPtr<GpuParamsSetCore> mMaterialParams;
+		SPtr<Material> mGridMaterial;
+		SPtr<GpuParamsSet> mMaterialParams;
 		float mSpacing = 1.0f;
 		bool mFadeGrid = true;
 		Vector3 mGridPlaneNormal = Vector3::ZERO;

Source/BansheeEditor/Include/BsScenePicking.h

@@ -155,8 +155,8 @@ namespace bs
 
 		SPtr<RenderTextureCore> mPickingTexture;
 
-		SPtr<MaterialCore> mMaterials[6];
-		Vector<SPtr<GpuParamsSetCore>> mParamSets[6];
+		SPtr<Material> mMaterials[6];
+		Vector<SPtr<GpuParamsSet>> mParamSets[6];
 		Vector<SPtr<GpuParamBlockBufferCore>> mParamBuffers;
 	};
 

Source/BansheeEditor/Include/BsSelectionRenderer.h

@@ -64,8 +64,8 @@ namespace bs
 		SPtr<CameraCore> mCamera;
 
 		// Immutable
-		SPtr<MaterialCore> mMaterial;
-		SPtr<GpuParamsSetCore> mParams[4];
+		SPtr<Material> mMaterial;
+		SPtr<GpuParamsSet> mParams[4];
 		GpuParamMat4 mMatWorldViewProj[4];
 		GpuParamColor mColor[4];
 		GpuParamBuffer mBoneMatrices[4];

Source/BansheeEditor/Source/BsDockManager.cpp

@@ -1126,7 +1126,7 @@ namespace bs
 
 	void DockOverlayRenderer::initialize(const Any& data)
 	{
-		mMaterial = any_cast<SPtr<MaterialCore>>(data);
+		mMaterial = any_cast<SPtr<Material>>(data);
 		mParams = mMaterial->createParamsSet();
 	}
 

Source/BansheeEditor/Source/BsGizmoManager.cpp

@@ -956,7 +956,7 @@ namespace bs
 
 			if (paramsIdx >= mMeshParamSets[typeIdx].size())
 			{
-				SPtr<GpuParamsSetCore> paramsSet = mMeshMaterials[typeIdx]->createParamsSet();
+				SPtr<GpuParamsSet> paramsSet = mMeshMaterials[typeIdx]->createParamsSet();
 				paramsSet->setParamBlockBuffer("Uniforms", mMeshGizmoBuffer, true);
 
 				mMeshParamSets[typeIdx].push_back(paramsSet);
@@ -970,7 +970,7 @@ namespace bs
 		{
 			iconData.paramsIdx = iconMeshIdx;
 
-			SPtr<GpuParamsSetCore> paramsSet;
+			SPtr<GpuParamsSet> paramsSet;
 			if (iconMeshIdx >= mIconParamSets.size())
 			{
 				mIconMaterial->createParamsSet();
@@ -1055,7 +1055,7 @@ namespace bs
 
 				if (paramsIdx >= mPickingParamSets[typeIdx].size())
 				{
-					SPtr<GpuParamsSetCore> paramsSet = mPickingMaterials[typeIdx]->createParamsSet();
+					SPtr<GpuParamsSet> paramsSet = mPickingMaterials[typeIdx]->createParamsSet();
 					paramsSet->setParamBlockBuffer("Uniforms", mMeshPickingParamBuffer, true);
 
 					mPickingParamSets[typeIdx].push_back(paramsSet);
@@ -1070,7 +1070,7 @@ namespace bs
 
 				if (iconData.paramsIdx >= mPickingParamSets[1].size())
 				{
-					SPtr<GpuParamsSetCore> paramsSet = mPickingMaterials[1]->createParamsSet();
+					SPtr<GpuParamsSet> paramsSet = mPickingMaterials[1]->createParamsSet();
 					paramsSet->setParamBlockBuffer("Uniforms", mIconPickingParamBuffer, true);
 
 					mPickingParamSets[1].push_back(paramsSet);
@@ -1157,7 +1157,7 @@ namespace bs
 
 			for (auto& iconData : *renderData)
 			{
-				SPtr<GpuParamsSetCore> paramsSet = mPickingParamSets[1][iconData.paramsIdx];
+				SPtr<GpuParamsSet> paramsSet = mPickingParamSets[1][iconData.paramsIdx];
 				SPtr<GpuParamsCore> params = paramsSet->getGpuParams();
 
 				GpuParamTexture textureParam;

Source/BansheeEditor/Source/BsHandleDrawManager.cpp

@@ -261,7 +261,7 @@ namespace bs
 
 				entry.paramIdx = paramsIdx;
 
-				SPtr<GpuParamsSetCore> paramsSet;
+				SPtr<GpuParamsSet> paramsSet;
 				if (paramsIdx >= mParamSets[typeIdx].size())
 				{
 					paramsSet = mMaterials[typeIdx]->createParamsSet();

Source/BansheeEditor/Source/BsScenePicking.cpp

@@ -315,7 +315,7 @@ namespace bs
 			UINT32 renderableIdx = typeCounters[typeIdx];
 			renderableIndices[idx] = renderableIdx;
 
-			SPtr<GpuParamsSetCore> paramsSet;
+			SPtr<GpuParamsSet> paramsSet;
 			if (renderableIdx >= mParamSets[typeIdx].size())
 			{
 				paramsSet = mMaterials[typeIdx]->createParamsSet();

Source/BansheeEditor/Source/BsSelectionRenderer.cpp

@@ -80,7 +80,7 @@ namespace bs
 		constexpr int numTechniques = sizeof(mTechniqueIndices) / sizeof(mTechniqueIndices[0]);
 		static_assert(numTechniques == (int)RenderableAnimType::Count, "Number of techniques doesn't match the number of possible animation types.");
 
-		SPtr<MaterialCore> mat = any_cast<SPtr<MaterialCore>>(data);
+		SPtr<Material> mat = any_cast<SPtr<Material>>(data);
 		for(UINT32 i = 0; i < numTechniques; i++)
 		{
 			RenderableAnimType animType = (RenderableAnimType)i;

Source/BansheeEngine/Include/BsRenderableElement.h

@@ -22,7 +22,7 @@ namespace bs { namespace ct
 		SubMesh subMesh;
 
 		/**	Material to render the mesh with. */
-		SPtr<MaterialCore> material;
+		SPtr<Material> material;
 	};
 
 	/** @} */

Source/BansheeEngine/Include/BsRendererMaterial.h

@@ -32,7 +32,7 @@ namespace bs { namespace ct
 	/**	Contains data common to all render material instances of a specific type. */
 	struct RendererMaterialMetaData
 	{
-		SPtr<ShaderCore> shader;
+		SPtr<Shader> shader;
 		ShaderDefines defines;
 	};
 
@@ -43,16 +43,16 @@ namespace bs { namespace ct
 		virtual ~RendererMaterialBase() { }
 
 		/**	Returns the internal material. */
-		SPtr<MaterialCore> getMaterial() const { return mMaterial; }
+		SPtr<Material> getMaterial() const { return mMaterial; }
 
 		/** Returns the internal parameter set containing GPU bindable parameters. */
-		SPtr<GpuParamsSetCore> getParamsSet() const { return mParamsSet; }
+		SPtr<GpuParamsSet> getParamsSet() const { return mParamsSet; }
 
 	protected:
 		friend class RendererMaterialManager;
 
-		SPtr<MaterialCore> mMaterial;
-		SPtr<GpuParamsSetCore> mParamsSet;
+		SPtr<Material> mMaterial;
+		SPtr<GpuParamsSet> mParamsSet;
 	};
 
 	/**	Helper class to initialize all renderer materials as soon as the library is loaded. */
@@ -77,7 +77,7 @@ namespace bs { namespace ct
 		RendererMaterial()
 		{
 			mInitOnStart.instantiate();
-			mMaterial = MaterialCore::create(mMetaData.shader);
+			mMaterial = Material::create(mMetaData.shader);
 			mParamsSet = mMaterial->createParamsSet();
 		}
 

Source/BansheeEngine/Include/BsRendererMaterialManager.h

@@ -47,7 +47,7 @@ namespace bs
 		friend class RendererMaterial;
 
 		/**	Initializes all materials on the core thread. */
-		static void initOnCore(const Vector<SPtr<ct::ShaderCore>>& shaders);
+		static void initOnCore(const Vector<SPtr<ct::Shader>>& shaders);
 
 		/**	Destroys all materials on the core thread. */
 		static void destroyOnCore();

Source/BansheeEngine/Include/BsRendererUtility.h

@@ -38,7 +38,7 @@ namespace bs { namespace ct
 		 *
 		 * @note	Core thread.
 		 */
-		void setPass(const SPtr<MaterialCore>& material, UINT32 passIdx = 0, UINT32 techniqueIdx = 0);
+		void setPass(const SPtr<Material>& material, UINT32 passIdx = 0, UINT32 techniqueIdx = 0);
 
 		/**
 		 * Activates the specified material pass for compute. Any further dispatch calls will be executed using this pass.
@@ -48,7 +48,7 @@ namespace bs { namespace ct
 		 *
 		 * @note	Core thread.
 		 */
-		void setComputePass(const SPtr<MaterialCore>& material, UINT32 passIdx = 0);
+		void setComputePass(const SPtr<Material>& material, UINT32 passIdx = 0);
 
 		/**
 		 * Sets parameters (textures, samplers, buffers) for the currently active pass.
@@ -58,7 +58,7 @@ namespace bs { namespace ct
 		 *					
 		 * @note	Core thread.
 		 */
-		void setPassParams(const SPtr<GpuParamsSetCore>& params, UINT32 passIdx = 0);
+		void setPassParams(const SPtr<GpuParamsSet>& params, UINT32 passIdx = 0);
 
 		/**
 		 * Draws the specified mesh.

Source/BansheeEngine/Include/BsSpriteMaterial.h

@@ -101,15 +101,15 @@ namespace bs
 		virtual void initialize();
 
 		/** Destroys the core thread material. */
-		static void destroy(const SPtr<ct::MaterialCore>& material, const SPtr<ct::GpuParamsSetCore>& params);
+		static void destroy(const SPtr<ct::Material>& material, const SPtr<ct::GpuParamsSet>& params);
 
 		UINT32 mId;
 
 		// Core thread only (everything below)
-		SPtr<ct::MaterialCore> mMaterial;
+		SPtr<ct::Material> mMaterial;
 		std::atomic<bool> mMaterialStored;
 
-		SPtr<ct::GpuParamsSetCore> mParams;
+		SPtr<ct::GpuParamsSet> mParams;
 		UINT32 mParamBufferIdx;
 		mutable ct::MaterialParamTexture mTextureParam;
 		mutable ct::MaterialParamSampState mSamplerParam;

Source/BansheeEngine/Source/BsRenderQueue.cpp

@@ -28,8 +28,8 @@ namespace bs { namespace ct
 
 	void RenderQueue::add(RenderableElement* element, float distFromCamera)
 	{
-		SPtr<MaterialCore> material = element->material;
-		SPtr<ShaderCore> shader = material->getShader();
+		SPtr<Material> material = element->material;
+		SPtr<Shader> shader = material->getShader();
 
 		mElements.push_back(element);
 		

Source/BansheeEngine/Source/BsRenderable.cpp

@@ -318,7 +318,7 @@ namespace bs
 			rttiGetElemSize(mAnimType) + 
 			rttiGetElemSize(getCoreDirtyFlags()) +
 			sizeof(SPtr<ct::MeshCore>) +
-			numMaterials * sizeof(SPtr<ct::MaterialCore>);
+			numMaterials * sizeof(SPtr<ct::Material>);
 
 		UINT8* data = allocator->alloc(size);
 		char* dataPtr = (char*)data;
@@ -342,11 +342,11 @@ namespace bs
 
 		for (UINT32 i = 0; i < numMaterials; i++)
 		{
-			SPtr<ct::MaterialCore>* material = new (dataPtr)SPtr<ct::MaterialCore>();
+			SPtr<ct::Material>* material = new (dataPtr)SPtr<ct::Material>();
 			if (mMaterials[i].isLoaded())
 				*material = mMaterials[i]->getCore();
 
-			dataPtr += sizeof(SPtr<ct::MaterialCore>);
+			dataPtr += sizeof(SPtr<ct::Material>);
 		}
 
 		return CoreSyncData(data, size);
@@ -611,10 +611,10 @@ namespace bs
 
 		for (UINT32 i = 0; i < numMaterials; i++)
 		{
-			SPtr<MaterialCore>* material = (SPtr<MaterialCore>*)dataPtr;
+			SPtr<Material>* material = (SPtr<Material>*)dataPtr;
 			mMaterials.push_back(*material);
-			material->~SPtr<MaterialCore>();
-			dataPtr += sizeof(SPtr<MaterialCore>);
+			material->~SPtr<Material>();
+			dataPtr += sizeof(SPtr<Material>);
 		}
 
 		if (dirtyFlags == (UINT32)RenderableDirtyFlag::Transform)

Source/BansheeEngine/Source/BsRendererMaterialManager.cpp

@@ -12,7 +12,7 @@ namespace bs
 		BuiltinResources& br = BuiltinResources::instance();
 
 		Vector<RendererMaterialData>& materials = getMaterials();
-		Vector<SPtr<ct::ShaderCore>> shaders;
+		Vector<SPtr<ct::Shader>> shaders;
 		for (auto& material : materials)
 		{
 			HShader shader = br.getShader(material.resourcePath);
@@ -76,7 +76,7 @@ namespace bs
 		}
 	}
 
-	void RendererMaterialManager::initOnCore(const Vector<SPtr<ct::ShaderCore>>& shaders)
+	void RendererMaterialManager::initOnCore(const Vector<SPtr<ct::Shader>>& shaders)
 	{
 		Lock lock(getMutex());
 

Source/BansheeEngine/Source/BsRendererUtility.cpp

@@ -137,24 +137,24 @@ namespace bs { namespace ct
 
 	}
 
-	void RendererUtility::setPass(const SPtr<MaterialCore>& material, UINT32 passIdx, UINT32 techniqueIdx)
+	void RendererUtility::setPass(const SPtr<Material>& material, UINT32 passIdx, UINT32 techniqueIdx)
 	{
 		RenderAPI& rapi = RenderAPI::instance();
 
-		SPtr<PassCore> pass = material->getPass(passIdx, techniqueIdx);
+		SPtr<Pass> pass = material->getPass(passIdx, techniqueIdx);
 		rapi.setGraphicsPipeline(pass->getGraphicsPipelineState());
 		rapi.setStencilRef(pass->getStencilRefValue());
 	}
 
-	void RendererUtility::setComputePass(const SPtr<MaterialCore>& material, UINT32 passIdx)
+	void RendererUtility::setComputePass(const SPtr<Material>& material, UINT32 passIdx)
 	{
 		RenderAPI& rapi = RenderAPI::instance();
 
-		SPtr<PassCore> pass = material->getPass(passIdx);
+		SPtr<Pass> pass = material->getPass(passIdx);
 		rapi.setComputePipeline(pass->getComputePipelineState());
 	}
 
-	void RendererUtility::setPassParams(const SPtr<GpuParamsSetCore>& params, UINT32 passIdx)
+	void RendererUtility::setPassParams(const SPtr<GpuParamsSet>& params, UINT32 passIdx)
 	{
 		SPtr<GpuParamsCore> gpuParams = params->getGpuParams(passIdx);
 		if (gpuParams == nullptr)
@@ -254,8 +254,8 @@ namespace bs { namespace ct
 	void RendererUtility::blit(const SPtr<TextureCore>& texture, const Rect2I& area)
 	{
 		auto& texProps = texture->getProperties();
-		SPtr<MaterialCore> mat;
-		SPtr<GpuParamsSetCore> params;
+		SPtr<Material> mat;
+		SPtr<GpuParamsSet> params;
 		if (texProps.getNumSamples() > 1)
 		{
 			mat = mResolveMat->getMaterial();

Source/BansheeEngine/Source/BsSpriteMaterial.cpp

@@ -33,7 +33,7 @@ namespace bs
 
 		mParams = mMaterial->createParamsSet();
 
-		SPtr<ct::ShaderCore> shader = mMaterial->getShader();
+		SPtr<ct::Shader> shader = mMaterial->getShader();
 		if(shader->hasTextureParam("gMainTexture"))
 		{
 			mTextureParam = mMaterial->getParamTexture("gMainTexture");
@@ -53,7 +53,7 @@ namespace bs
 			LOGERR("Sprite material shader missing \"GUIParams\" block.");
 	}
 
-	void SpriteMaterial::destroy(const SPtr<ct::MaterialCore>& material, const SPtr<ct::GpuParamsSetCore>& params)
+	void SpriteMaterial::destroy(const SPtr<ct::Material>& material, const SPtr<ct::GpuParamsSet>& params)
 	{
 		// Do nothing, we just need to make sure the material pointer's last reference is lost while on the core thread
 	}

Source/RenderBeast/Include/BsLightRendering.h

@@ -27,7 +27,7 @@ namespace bs { namespace ct
 	class LightRenderingParams
 	{
 	public:
-		LightRenderingParams(const SPtr<MaterialCore>& lightMaterial, const SPtr<GpuParamsSetCore>& paramsSet);
+		LightRenderingParams(const SPtr<Material>& lightMaterial, const SPtr<GpuParamsSet>& paramsSet);
 
 		/** Updates parameters that are common for all lights. */
 		void setStaticParameters(const SPtr<RenderTargets>& gbuffer,
@@ -39,8 +39,8 @@ namespace bs { namespace ct
 		/** Returns the internal parameter buffer that can be bound to the pipeline. */
 		const SPtr<GpuParamBlockBufferCore>& getBuffer() const;
 	private:
-		SPtr<MaterialCore> mMaterial;
-		SPtr<GpuParamsSetCore> mParamsSet;
+		SPtr<Material> mMaterial;
+		SPtr<GpuParamsSet> mParamsSet;
 
 		GpuParamTexture mGBufferA;
 		GpuParamTexture mGBufferB;

Source/RenderBeast/Include/BsRenderBeast.h

@@ -62,7 +62,7 @@ namespace bs
 		/** Renderer information for a single material. */
 		struct RendererMaterial
 		{
-			Vector<SPtr<GpuParamsSetCore>> params;
+			Vector<SPtr<GpuParamsSet>> params;
 			UINT32 matVersion;
 		};
 

Source/RenderBeast/Include/BsRendererObject.h

@@ -47,7 +47,7 @@ namespace bs { namespace ct
 		MaterialSamplerOverrides* samplerOverrides;
 
 		/** All GPU parameters from the material used by the renderable. */
-		SPtr<GpuParamsSetCore> params;
+		SPtr<GpuParamsSet> params;
 
 		/**	Identifier of the owner renderable. */
 		UINT32 renderableId;

Source/RenderBeast/Include/BsSamplerOverrides.h

@@ -41,7 +41,7 @@ namespace bs { namespace ct
 	/** Key used for uniquely identifying a sampler override entry. */
 	struct SamplerOverrideKey
 	{
-		SamplerOverrideKey(const SPtr<MaterialCore>& material, UINT32 techniqueIdx)
+		SamplerOverrideKey(const SPtr<Material>& material, UINT32 techniqueIdx)
 			:material(material), techniqueIdx(techniqueIdx)
 		{ }
 
@@ -55,7 +55,7 @@ namespace bs { namespace ct
 			return !(*this == rhs); 
 		}
 
-		SPtr<MaterialCore> material;
+		SPtr<Material> material;
 		UINT32 techniqueIdx;
 	};
 
@@ -67,9 +67,9 @@ namespace bs { namespace ct
 		 * Generates a set of sampler overrides for the specified set of GPU program parameters. Overrides are generates
 		 * according to the provided render options. 
 		 */
-		static MaterialSamplerOverrides* generateSamplerOverrides(const SPtr<ShaderCore>& shader,
-			const SPtr<MaterialParamsCore>& params, 
-			const SPtr<GpuParamsSetCore>& paramsSet,
+		static MaterialSamplerOverrides* generateSamplerOverrides(const SPtr<Shader>& shader,
+			const SPtr<MaterialParams>& params, 
+			const SPtr<GpuParamsSet>& paramsSet,
 			const SPtr<RenderBeastOptions>& options);
 
 		/**	Destroys sampler overrides previously generated with generateSamplerOverrides(). */

Source/RenderBeast/Source/BsLightRendering.cpp

@@ -14,7 +14,7 @@ namespace bs { namespace ct
 {
 	PerLightParamDef gPerLightParamDef;
 
-	LightRenderingParams::LightRenderingParams(const SPtr<MaterialCore>& material, const SPtr<GpuParamsSetCore>& paramsSet)
+	LightRenderingParams::LightRenderingParams(const SPtr<Material>& material, const SPtr<GpuParamsSet>& paramsSet)
 		:mMaterial(material), mParamsSet(paramsSet)
 	{
 		SPtr<GpuParamsCore> params = mParamsSet->getGpuParams();

Source/RenderBeast/Source/BsObjectRendering.cpp

@@ -23,7 +23,7 @@ namespace bs { namespace ct
 
 	void ObjectRenderer::initElement(RendererObject& owner, BeastRenderableElement& element)
 	{
-		SPtr<ShaderCore> shader = element.material->getShader();
+		SPtr<Shader> shader = element.material->getShader();
 		if (shader == nullptr)
 		{
 			element.perCameraBindingIdx = -1;

Source/RenderBeast/Source/BsRenderBeast.cpp

@@ -181,7 +181,7 @@ namespace bs { namespace ct
 					UINT32 numPasses = renElement.material->getNumPasses(techniqueIdx);
 					for (UINT32 j = 0; j < numPasses; j++)
 					{
-						SPtr<PassCore> pass = renElement.material->getPass(j, techniqueIdx);
+						SPtr<Pass> pass = renElement.material->getPass(j, techniqueIdx);
 
 						SPtr<VertexDeclarationCore> shaderDecl = pass->getVertexProgram()->getInputDeclaration();
 						if (!vertexDecl->isCompatible(shaderDecl))
@@ -229,7 +229,7 @@ namespace bs { namespace ct
 				}
 				else
 				{
-					SPtr<ShaderCore> shader = renElement.material->getShader();
+					SPtr<Shader> shader = renElement.material->getShader();
 					MaterialSamplerOverrides* samplerOverrides = SamplerOverrideUtility::generateSamplerOverrides(shader,
 						renElement.material->_getInternalParams(), renElement.params, mCoreOptions);
 
@@ -552,7 +552,7 @@ namespace bs { namespace ct
 		gProfilerCPU().beginSample("renderAllCore");
 
 		// Note: I'm iterating over all sampler states every frame. If this ends up being a performance
-		// issue consider handling this internally in MaterialCore which can only do it when sampler states
+		// issue consider handling this internally in ct::Material which can only do it when sampler states
 		// are actually modified after sync
 		refreshSamplerOverrides();
 
@@ -871,7 +871,7 @@ namespace bs { namespace ct
 	void RenderBeast::renderElement(const BeastRenderableElement& element, UINT32 passIdx, bool bindPass,
 		const RendererFrame& frameInfo, const Matrix4& viewProj)
 	{
-		SPtr<MaterialCore> material = element.material;
+		SPtr<Material> material = element.material;
 
 		if (bindPass)
 			gRendererUtility().setPass(material, passIdx, element.techniqueIdx);
@@ -890,7 +890,7 @@ namespace bs { namespace ct
 		bool anyDirty = false;
 		for (auto& entry : mSamplerOverrides)
 		{
-			SPtr<MaterialParamsCore> materialParams = entry.first.material->_getInternalParams();
+			SPtr<MaterialParams> materialParams = entry.first.material->_getInternalParams();
 
 			MaterialSamplerOverrides* materialOverrides = entry.second;
 			for(UINT32 i = 0; i < materialOverrides->numOverrides; i++)

Source/RenderBeast/Source/BsSamplerOverrides.cpp

@@ -12,8 +12,8 @@
 
 namespace bs { namespace ct
 {
-	MaterialSamplerOverrides* SamplerOverrideUtility::generateSamplerOverrides(const SPtr<ShaderCore>& shader, 
-		const SPtr<MaterialParamsCore>& params, const SPtr<GpuParamsSetCore>& paramsSet, 
+	MaterialSamplerOverrides* SamplerOverrideUtility::generateSamplerOverrides(const SPtr<Shader>& shader, 
+		const SPtr<MaterialParams>& params, const SPtr<GpuParamsSet>& paramsSet, 
 		const SPtr<RenderBeastOptions>& options)
 	{
 		MaterialSamplerOverrides* output = nullptr;
@@ -72,7 +72,7 @@ namespace bs { namespace ct
 				UINT32 maxSamplerSet = 0;
 
 				SPtr<GpuParamsCore> paramsPtr = paramsSet->getGpuParams(i);
-				for (UINT32 j = 0; j < GpuParamsSetCore::NUM_STAGES; j++)
+				for (UINT32 j = 0; j < GpuParamsSet::NUM_STAGES; j++)
 				{
 					GpuProgramType progType = (GpuProgramType)j;
 					SPtr<GpuParamDesc> paramDesc = paramsPtr->getParamDesc(progType);
@@ -98,7 +98,7 @@ namespace bs { namespace ct
 			for (UINT32 i = 0; i < numPasses; i++)
 			{
 				SPtr<GpuParamsCore> paramsPtr = paramsSet->getGpuParams(i);
-				for (UINT32 j = 0; j < GpuParamsSetCore::NUM_STAGES; j++)
+				for (UINT32 j = 0; j < GpuParamsSet::NUM_STAGES; j++)
 				{
 					GpuProgramType progType = (GpuProgramType)j;
 					SPtr<GpuParamDesc> paramDesc = paramsPtr->getParamDesc(progType);
@@ -151,7 +151,7 @@ namespace bs { namespace ct
 					outputData += sizeof(UINT32) * slotsPerSetIter[j];
 				}
 
-				for (UINT32 j = 0; j < GpuParamsSetCore::NUM_STAGES; j++)
+				for (UINT32 j = 0; j < GpuParamsSet::NUM_STAGES; j++)
 				{
 					GpuProgramType progType = (GpuProgramType)j;
 					SPtr<GpuParamDesc> paramDesc = paramsPtr->getParamDesc(progType);