RenderAPICore -> ct::RenderAPI

Source/BansheeCore/Include/BsCommandBuffer.h

@@ -59,7 +59,7 @@ namespace bs { namespace ct
 		 *							
 		 *							Caller must ensure to synchronize operations executing on different queues via
 		 *							sync masks. Command buffer dependant on another command buffer should provide a sync
-		 *							mask when being submitted (see RenderAPICore::executeCommands).
+		 *							mask when being submitted (see RenderAPI::executeCommands).
 		 *							
 		 *							Queue indices are unique per buffer type (e.g. upload index 0 and graphics index 0 may
 		 *							map to different queues internally). Must be in range [0, 7].

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -403,7 +403,7 @@ namespace bs
 		class SamplerStateCore;
 		class IndexBufferCore;
 		class VertexBufferCore;
-		class RenderAPICore;
+		class RenderAPI;
 		class RenderTargetCore;
 		class RenderTextureCore;
 		class RenderWindowCore;

Source/BansheeCore/Include/BsParamBlocks.h

@@ -85,7 +85,7 @@ namespace bs { namespace ct
 		void initialize() override																							\
 		{																													\
 			mParams = getEntries();																							\
-			RenderAPICore& rapi = RenderAPICore::instance();																\
+			RenderAPI& rapi = RenderAPI::instance();																		\
 																															\
 			GpuParamBlockDesc blockDesc = rapi.generateParamBlockDesc(#Name, mParams);										\
 			mBlockSize = blockDesc.blockSize * sizeof(UINT32);																\

Source/BansheeCore/Include/BsRasterizerState.h

@@ -86,7 +86,7 @@ namespace bs
 		/**
 		 * Scissor rectangle allows you to cull all pixels outside of the scissor rectangle.
 		 *			
-		 * @see		RenderAPICore::setScissorRect
+		 * @see		ct::RenderAPI::setScissorRect
 		 */
 		bool getScissorEnable() const { return mData.scissorEnable; }
 

Source/BansheeCore/Include/BsRenderAPI.h

@@ -23,10 +23,10 @@ namespace bs
 	class RenderAPIInfo;
 
 	/**
-	 * Provides access to RenderAPICore from the simulation thread. All the commands get queued on the core thread queue 
+	 * Provides access to ct::RenderAPI from the simulation thread. All the commands get queued on the core thread queue 
 	 * for the calling thread.
 	 *
-	 * @see		RenderAPICore
+	 * @see		ct::RenderAPI
 	 *
 	 * @note	Sim thread only.
 	 */
@@ -34,77 +34,77 @@ namespace bs
 	{
 	public:
 		/** 
-		 * @see ct::RenderAPICore::setGpuParams() 
+		 * @see ct::RenderAPI::setGpuParams() 
 		 *
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setGpuParams(const SPtr<GpuParams>& gpuParams);
 
 		/** 
-		 * @see ct::RenderAPICore::setGraphicsPipeline() 
+		 * @see ct::RenderAPI::setGraphicsPipeline() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setGraphicsPipeline(const SPtr<GraphicsPipelineState>& pipelineState);
 
 		/** 
-		 * @see ct::RenderAPICore::setComputePipeline() 
+		 * @see ct::RenderAPI::setComputePipeline() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setComputePipeline(const SPtr<ComputePipelineState>& pipelineState);
 
 		/** 
-		 * @see ct::RenderAPICore::setVertexBuffers() 
+		 * @see ct::RenderAPI::setVertexBuffers() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setVertexBuffers(UINT32 index, const Vector<SPtr<VertexBuffer>>& buffers);
 
 		/** 
-		 * @see ct::RenderAPICore::setIndexBuffer() 
+		 * @see ct::RenderAPI::setIndexBuffer() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setIndexBuffer(const SPtr<IndexBuffer>& buffer);
 
 		/** 
-		 * @see ct::RenderAPICore::setVertexDeclaration() 
+		 * @see ct::RenderAPI::setVertexDeclaration() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setVertexDeclaration(const SPtr<VertexDeclaration>& vertexDeclaration);
 
 		/** 
-		 * @see ct::RenderAPICore::setViewport() 
+		 * @see ct::RenderAPI::setViewport() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setViewport(const Rect2& area);
 
 		/** 
-		 * @see ct::RenderAPICore::setViewport() 
+		 * @see ct::RenderAPI::setViewport() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setStencilRef(UINT32 value);
 
 		/** 
-		 * @see ct::RenderAPICore::setDrawOperation()  
+		 * @see ct::RenderAPI::setDrawOperation()  
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setDrawOperation(DrawOperationType op);
 
 		/** 
-		 * @see ct::RenderAPICore::setScissorRect() 
+		 * @see ct::RenderAPI::setScissorRect() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void setScissorRect(UINT32 left = 0, UINT32 top = 0, UINT32 right = 800, UINT32 bottom = 600);
 
 		/** 
-		 * @see ct::RenderAPICore::setRenderTarget() 
+		 * @see ct::RenderAPI::setRenderTarget() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
@@ -112,7 +112,7 @@ namespace bs
 			RenderSurfaceMask loadMask = RT_NONE);
 
 		/** 
-		 * @see ct::RenderAPICore::clearRenderTarget() 
+		 * @see ct::RenderAPI::clearRenderTarget() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
@@ -120,7 +120,7 @@ namespace bs
 			UINT16 stencil = 0, UINT8 targetMask = 0xFF);
 
 		/** 
-		 * @see ct::RenderAPICore::clearViewport() 
+		 * @see ct::RenderAPI::clearViewport() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
@@ -128,21 +128,21 @@ namespace bs
 			UINT8 targetMask = 0xFF);
 
 		/** 
-		 * @see ct::RenderAPICore::swapBuffers() 
+		 * @see ct::RenderAPI::swapBuffers() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void swapBuffers(const SPtr<RenderTarget>& target);
 
 		/** 
-		 * @see ct::RenderAPICore::draw() 
+		 * @see ct::RenderAPI::draw() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount = 0);
 
 		/** 
-		 * @see ct::RenderAPICore::drawIndexed() 
+		 * @see ct::RenderAPI::drawIndexed() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
@@ -150,19 +150,19 @@ namespace bs
 			UINT32 instanceCount = 0);
 
 		/** 
-		 * @see ct::RenderAPICore::dispatchCompute() 
+		 * @see ct::RenderAPI::dispatchCompute() 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		static void dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY = 1, UINT32 numGroupsZ = 1);
 
-		/** @copydoc ct::RenderAPICore::getVideoModeInfo */
+		/** @copydoc ct::RenderAPI::getVideoModeInfo */
 		static const VideoModeInfo& getVideoModeInfo();
 
-		/** @copydoc ct::RenderAPICore::convertProjectionMatrix */
+		/** @copydoc ct::RenderAPI::convertProjectionMatrix */
 		static void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest);
 
-		/** @copydoc ct::RenderAPICore::getAPIInfo */
+		/** @copydoc ct::RenderAPI::getAPIInfo */
 		static const RenderAPIInfo& getAPIInfo();
 	};
 
@@ -254,11 +254,11 @@ namespace bs
 	 * @note	Accessible on any thread for methods accepting a CommandBuffer. Otherwise core thread unless specifically
 	 *			noted otherwise on per-method basis.
 	 */
-	class BS_CORE_EXPORT RenderAPICore : public Module<RenderAPICore>
+	class BS_CORE_EXPORT RenderAPI : public Module<RenderAPI>
 	{
 	public:
-		RenderAPICore();
-		virtual ~RenderAPICore();
+		RenderAPI();
+		virtual ~RenderAPI();
 
 		/**
 		 * Returns the name of the rendering system. 

Source/BansheeCore/Source/BsCamera.cpp

@@ -276,7 +276,7 @@ namespace bs
 				}
 			}
 
-			ct::RenderAPICore* renderAPI = ct::RenderAPICore::instancePtr();
+			ct::RenderAPI* renderAPI = ct::RenderAPI::instancePtr();
 			renderAPI->convertProjectionMatrix(mProjMatrix, mProjMatrixRS);
 			mProjMatrixInv = mProjMatrix.inverse();
 			mProjMatrixRSInv = mProjMatrixRS.inverse();

Source/BansheeCore/Source/BsGpuParam.cpp

@@ -43,7 +43,7 @@ namespace bs
 		UINT32 elementSizeBytes = mParamDesc->elementSize * sizeof(UINT32);
 		UINT32 sizeBytes = std::min(elementSizeBytes, (UINT32)sizeof(T)); // Truncate if it doesn't fit within parameter size
 
-		bool transposeMatrices = ct::RenderAPICore::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
+		bool transposeMatrices = ct::RenderAPI::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
 		if (TransposePolicy<T>::transposeEnabled(transposeMatrices))
 		{
 			T transposed = TransposePolicy<T>::transpose(value);
@@ -86,7 +86,7 @@ namespace bs
 		T value;
 		paramBlock->read((mParamDesc->cpuMemOffset + arrayIdx * mParamDesc->arrayElementStride) * sizeof(UINT32), &value, sizeBytes);
 
-		bool transposeMatrices = ct::RenderAPICore::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
+		bool transposeMatrices = ct::RenderAPI::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
 		if (TransposePolicy<T>::transposeEnabled(transposeMatrices))
 			return TransposePolicy<T>::transpose(value);
 		else

Source/BansheeCore/Source/BsGpuParamsSet.cpp

@@ -897,7 +897,7 @@ namespace bs
 
 			UINT8* data = params->getData(materialParamInfo->index);
 
-			bool transposeMatrices = ct::RenderAPICore::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
+			bool transposeMatrices = ct::RenderAPI::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
 			if (transposeMatrices)
 			{
 				auto writeTransposed = [&](auto& temp)

Source/BansheeCore/Source/BsMesh.cpp

@@ -71,7 +71,7 @@ namespace bs
 			[&](const SPtr<ct::MeshCore>& mesh, const SPtr<MeshData>& _meshData, AsyncOp& asyncOp)
 		{
 			// Make sure any queued command start executing before reading
-			ct::RenderAPICore::instance().submitCommandBuffer(nullptr);
+			ct::RenderAPI::instance().submitCommandBuffer(nullptr);
 
 			mesh->readData(*_meshData);
 			_meshData->_unlock();
@@ -449,7 +449,7 @@ namespace bs
 				LOGERR("Vertex buffer values for stream \"" + toString(i) + "\" are being written out of valid range.");
 			}
 
-			if (RenderAPICore::instance().getAPIInfo().getVertexColorFlipRequired())
+			if (RenderAPI::instance().getAPIInfo().getVertexColorFlipRequired())
 			{
 				UINT8* bufferCopy = (UINT8*)bs_alloc(bufferSize);
 				memcpy(bufferCopy, srcVertBufferData, bufferSize); // TODO Low priority - Attempt to avoid this copy

Source/BansheeCore/Source/BsMeshHeap.cpp

@@ -295,7 +295,7 @@ namespace bs
 			UINT8* vertDest = mCPUVertexData[i] + vertChunkStart * vertSize;
 			memcpy(vertDest, meshData->getStreamData(i), meshData->getNumVertices() * vertSize);
 
-			if (RenderAPICore::instance().getAPIInfo().getVertexColorFlipRequired())
+			if (RenderAPI::instance().getAPIInfo().getVertexColorFlipRequired())
 			{
 				UINT32 vertexStride = mVertexDesc->getVertexStride(i);
 				for (INT32 semanticIdx = 0; semanticIdx < VertexBuffer::MAX_SEMANTIC_IDX; semanticIdx++)

Source/BansheeCore/Source/BsParamBlocks.cpp

@@ -24,7 +24,7 @@ namespace bs { namespace ct
 		UINT32 elementSizeBytes = mParamDesc.elementSize * sizeof(UINT32);
 		UINT32 sizeBytes = std::min(elementSizeBytes, (UINT32)sizeof(T)); // Truncate if it doesn't fit within parameter size
 
-		bool transposeMatrices = RenderAPICore::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
+		bool transposeMatrices = RenderAPI::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
 		if (TransposePolicy<T>::transposeEnabled(transposeMatrices))
 		{
 			T transposed = TransposePolicy<T>::transpose(value);
@@ -63,7 +63,7 @@ namespace bs { namespace ct
 		paramBlock->read((mParamDesc.cpuMemOffset + arrayIdx * mParamDesc.arrayElementStride) * sizeof(UINT32), &value, 
 			sizeBytes);
 
-		bool transposeMatrices = RenderAPICore::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
+		bool transposeMatrices = RenderAPI::instance().getAPIInfo().getGpuProgramHasColumnMajorMatrices();
 		if (TransposePolicy<T>::transposeEnabled(transposeMatrices))
 			return TransposePolicy<T>::transpose(value);
 		else

Source/BansheeCore/Source/BsRenderAPI.cpp

@@ -19,19 +19,19 @@ namespace bs
 {
 	void RenderAPI::setGpuParams(const SPtr<GpuParams>& gpuParams)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setGpuParams, ct::RenderAPICore::instancePtr(), gpuParams->getCore(),
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setGpuParams, ct::RenderAPI::instancePtr(), gpuParams->getCore(),
 			nullptr));
 	}
 
 	void RenderAPI::setGraphicsPipeline(const SPtr<GraphicsPipelineState>& pipelineState)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setGraphicsPipeline, ct::RenderAPICore::instancePtr(),
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setGraphicsPipeline, ct::RenderAPI::instancePtr(),
 			pipelineState->getCore(), nullptr));
 	}
 
 	void RenderAPI::setComputePipeline(const SPtr<ComputePipelineState>& pipelineState)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setComputePipeline, ct::RenderAPICore::instancePtr(),
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setComputePipeline, ct::RenderAPI::instancePtr(),
 							  pipelineState->getCore(), nullptr));
 	}
 
@@ -41,117 +41,117 @@ namespace bs
 		for (UINT32 i = 0; i < (UINT32)buffers.size(); i++)
 			coreBuffers[i] = buffers[i] != nullptr ? buffers[i]->getCore() : nullptr;
 
-		std::function<void(ct::RenderAPICore*, UINT32, const Vector<SPtr<ct::VertexBufferCore>>&)> resizeFunc =
-			[](ct::RenderAPICore* rs, UINT32 idx, const Vector<SPtr<ct::VertexBufferCore>>& _buffers)
+		std::function<void(ct::RenderAPI*, UINT32, const Vector<SPtr<ct::VertexBufferCore>>&)> resizeFunc =
+			[](ct::RenderAPI* rs, UINT32 idx, const Vector<SPtr<ct::VertexBufferCore>>& _buffers)
 		{
 			rs->setVertexBuffers(idx, (SPtr<ct::VertexBufferCore>*)_buffers.data(), (UINT32)_buffers.size());
 		};
 
-		gCoreThread().queueCommand(std::bind(resizeFunc, ct::RenderAPICore::instancePtr(), index, coreBuffers));
+		gCoreThread().queueCommand(std::bind(resizeFunc, ct::RenderAPI::instancePtr(), index, coreBuffers));
 	}
 
 	void RenderAPI::setIndexBuffer(const SPtr<IndexBuffer>& buffer)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setIndexBuffer, ct::RenderAPICore::instancePtr(), buffer->getCore(),
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setIndexBuffer, ct::RenderAPI::instancePtr(), buffer->getCore(),
 			nullptr));
 	}
 
 	void RenderAPI::setVertexDeclaration(const SPtr<VertexDeclaration>& vertexDeclaration)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setVertexDeclaration, ct::RenderAPICore::instancePtr(),
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setVertexDeclaration, ct::RenderAPI::instancePtr(),
 			vertexDeclaration->getCore(), nullptr));
 	}
 
 	void RenderAPI::setViewport(const Rect2& vp)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setViewport, ct::RenderAPICore::instancePtr(), vp, nullptr));
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setViewport, ct::RenderAPI::instancePtr(), vp, nullptr));
 	}
 
 	void RenderAPI::setStencilRef(UINT32 value)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setStencilRef, ct::RenderAPICore::instancePtr(), value, nullptr));
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setStencilRef, ct::RenderAPI::instancePtr(), value, nullptr));
 	}
 
 	void RenderAPI::setDrawOperation(DrawOperationType op)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setDrawOperation, ct::RenderAPICore::instancePtr(), op,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setDrawOperation, ct::RenderAPI::instancePtr(), op,
 			nullptr));
 	}
 
 	void RenderAPI::setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setScissorRect, ct::RenderAPICore::instancePtr(), left, top, right, bottom,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setScissorRect, ct::RenderAPI::instancePtr(), left, top, right, bottom,
 			nullptr));
 	}
 
 	void RenderAPI::setRenderTarget(const SPtr<RenderTarget>& target, bool readOnlyDepthStencil,
 									RenderSurfaceMask loadMask)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::setRenderTarget,
-											 ct::RenderAPICore::instancePtr(), target->getCore(), readOnlyDepthStencil, loadMask, nullptr));
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::setRenderTarget,
+											 ct::RenderAPI::instancePtr(), target->getCore(), readOnlyDepthStencil, loadMask, nullptr));
 	}
 
 	void RenderAPI::clearRenderTarget(UINT32 buffers, const Color& color, float depth, 
 		UINT16 stencil, UINT8 targetMask)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::clearRenderTarget, ct::RenderAPICore::instancePtr(), buffers, color,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::clearRenderTarget, ct::RenderAPI::instancePtr(), buffers, color,
 			depth, stencil, targetMask, nullptr));
 	}
 
 	void RenderAPI::clearViewport(UINT32 buffers, const Color& color, float depth, UINT16 stencil, 
 		UINT8 targetMask)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::clearViewport, ct::RenderAPICore::instancePtr(), buffers, color, depth,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::clearViewport, ct::RenderAPI::instancePtr(), buffers, color, depth,
 			stencil, targetMask, nullptr));
 	}
 
 	void RenderAPI::swapBuffers(const SPtr<RenderTarget>& target)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::swapBuffers, ct::RenderAPICore::instancePtr(), target->getCore(), 1));
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::swapBuffers, ct::RenderAPI::instancePtr(), target->getCore(), 1));
 	}
 
 	void RenderAPI::draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::draw, ct::RenderAPICore::instancePtr(), vertexOffset,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::draw, ct::RenderAPI::instancePtr(), vertexOffset,
 			vertexCount, instanceCount, nullptr));
 	}
 
 	void RenderAPI::drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, 
 		UINT32 vertexCount, UINT32 instanceCount)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::drawIndexed, ct::RenderAPICore::instancePtr(), startIndex, indexCount,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::drawIndexed, ct::RenderAPI::instancePtr(), startIndex, indexCount,
 			vertexOffset, vertexCount, instanceCount, nullptr));
 	}
 
 	void RenderAPI::dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY, UINT32 numGroupsZ)
 	{
-		gCoreThread().queueCommand(std::bind(&ct::RenderAPICore::dispatchCompute, ct::RenderAPICore::instancePtr(), numGroupsX,
+		gCoreThread().queueCommand(std::bind(&ct::RenderAPI::dispatchCompute, ct::RenderAPI::instancePtr(), numGroupsX,
 			numGroupsY, numGroupsZ, nullptr));
 	}
 
 	const VideoModeInfo& RenderAPI::getVideoModeInfo()
 	{
-		return ct::RenderAPICore::instance().getVideoModeInfo();
+		return ct::RenderAPI::instance().getVideoModeInfo();
 	}
 
 	void RenderAPI::convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest)
 	{
-		ct::RenderAPICore::instance().convertProjectionMatrix(matrix, dest);
+		ct::RenderAPI::instance().convertProjectionMatrix(matrix, dest);
 	}
 
 	const RenderAPIInfo& RenderAPI::getAPIInfo()
 	{
-		return ct::RenderAPICore::instance().getAPIInfo();
+		return ct::RenderAPI::instance().getAPIInfo();
 	}
 
 	namespace ct
 	{
-    RenderAPICore::RenderAPICore()
+    RenderAPI::RenderAPI()
         : mCurrentCapabilities(nullptr), mNumDevices(0)
     {
     }
 
-    RenderAPICore::~RenderAPICore()
+    RenderAPI::~RenderAPI()
     {
 		// Base classes need to call virtual destroy_internal method instead of a destructor
 
@@ -159,42 +159,42 @@ namespace bs
 		mCurrentCapabilities = nullptr;
     }
 
-	SPtr<RenderWindow> RenderAPICore::initialize(const RENDER_WINDOW_DESC& primaryWindowDesc)
+	SPtr<RenderWindow> RenderAPI::initialize(const RENDER_WINDOW_DESC& primaryWindowDesc)
 	{
-		gCoreThread().queueCommand(std::bind((void(RenderAPICore::*)())&RenderAPICore::initialize, this), 
+		gCoreThread().queueCommand(std::bind((void(RenderAPI::*)())&RenderAPI::initialize, this), 
 			CTQF_InternalQueue | CTQF_BlockUntilComplete);
 
 		RENDER_WINDOW_DESC windowDesc = primaryWindowDesc;
 		SPtr<RenderWindow> renderWindow = RenderWindow::create(windowDesc, nullptr);
 
-		gCoreThread().queueCommand(std::bind(&RenderAPICore::initializeWithWindow, this, renderWindow->getCore()), 
+		gCoreThread().queueCommand(std::bind(&RenderAPI::initializeWithWindow, this, renderWindow->getCore()), 
 			CTQF_InternalQueue | CTQF_BlockUntilComplete);
 
 		return renderWindow;
 	}
 
-	void RenderAPICore::initialize()
+	void RenderAPI::initialize()
 	{
 		// Do nothing
 	}
 
-	void RenderAPICore::initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow)
+	void RenderAPI::initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 	}
 
-	void RenderAPICore::destroy()
+	void RenderAPI::destroy()
 	{
-		gCoreThread().queueCommand(std::bind(&RenderAPICore::destroyCore, this));
+		gCoreThread().queueCommand(std::bind(&RenderAPI::destroyCore, this));
 		gCoreThread().submitAll(true);
 	}
 
-	void RenderAPICore::destroyCore()
+	void RenderAPI::destroyCore()
 	{
 		mActiveRenderTarget = nullptr;
 	}
 
-	const RenderAPICapabilities& RenderAPICore::getCapabilities(UINT32 deviceIdx) const
+	const RenderAPICapabilities& RenderAPI::getCapabilities(UINT32 deviceIdx) const
 	{
 		if(deviceIdx >= mNumDevices)
 		{
@@ -205,7 +205,7 @@ namespace bs
 		return mCurrentCapabilities[deviceIdx];
 	}
 
-	UINT32 RenderAPICore::vertexCountToPrimCount(DrawOperationType type, UINT32 elementCount)
+	UINT32 RenderAPI::vertexCountToPrimCount(DrawOperationType type, UINT32 elementCount)
 	{
 		UINT32 primCount = 0;
 		switch (type)

Source/BansheeCore/Source/BsRenderAPIManager.cpp

@@ -16,8 +16,8 @@ namespace bs
 	{
 		if(mRenderAPIInitialized)
 		{
-			ct::RenderAPICore::instance().destroy();
-			ct::RenderAPICore::shutDown();
+			ct::RenderAPI::instance().destroy();
+			ct::RenderAPI::shutDown();
 		}
 	}
 
@@ -43,7 +43,7 @@ namespace bs
 			{
 				(*iter)->create();		
 				mRenderAPIInitialized = true;
-				return ct::RenderAPICore::instance().initialize(primaryWindowDesc);
+				return ct::RenderAPI::instance().initialize(primaryWindowDesc);
 			}
 		}
 

Source/BansheeCore/Source/BsTechnique.cpp

@@ -19,7 +19,7 @@ namespace bs
 
 	bool TechniqueBase::isSupported() const
 	{
-		if ((ct::RenderAPICore::instancePtr()->getShadingLanguageName() == mLanguage || mLanguage == "Any") &&
+		if ((ct::RenderAPI::instancePtr()->getShadingLanguageName() == mLanguage || mLanguage == "Any") &&
 			(RendererManager::instance().getActive()->getName() == mRenderer ||
 			RendererAny == mRenderer))
 		{

Source/BansheeCore/Source/BsTexture.cpp

@@ -146,7 +146,7 @@ namespace bs
 				AsyncOp& asyncOp)
 		{
 			// Make sure any queued command start executing before reading
-			ct::RenderAPICore::instance().submitCommandBuffer(nullptr);
+			ct::RenderAPI::instance().submitCommandBuffer(nullptr);
 
 			texture->readData(*_pixData, _mipLevel, _face);
 			_pixData->_unlock();

Source/BansheeCore/Source/BsVertexDeclaration.cpp

@@ -113,9 +113,9 @@ namespace bs
 	VertexElementType VertexElement::getBestColorVertexElementType()
 	{
 		// Use the current render system to determine if possible
-		if (ct::RenderAPICore::instancePtr() != nullptr)
+		if (ct::RenderAPI::instancePtr() != nullptr)
 		{
-			return ct::RenderAPICore::instance().getAPIInfo().getColorVertexElementType();
+			return ct::RenderAPI::instance().getAPIInfo().getColorVertexElementType();
 		}
 		else
 		{

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderAPI.h

@@ -12,96 +12,96 @@ namespace bs { namespace ct
 	 */
 
 	/** Implementation of a render system using DirectX 11. Provides abstracted access to various low level DX11 methods. */
-	class BS_D3D11_EXPORT D3D11RenderAPI : public RenderAPICore
+	class BS_D3D11_EXPORT D3D11RenderAPI : public RenderAPI
 	{
 	public:
 		D3D11RenderAPI();
 		~D3D11RenderAPI();
 
-		/** @copydoc RenderAPICore::getName */
+		/** @copydoc RenderAPI::getName */
 		const StringID& getName() const override;
 		
-		/** @copydoc RenderAPICore::getShadingLanguageName */
+		/** @copydoc RenderAPI::getShadingLanguageName */
 		const String& getShadingLanguageName() const override;
 
-		/** @copydoc RenderAPICore::setGraphicsPipeline */
+		/** @copydoc RenderAPI::setGraphicsPipeline */
 		void setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setComputePipeline */
+		/** @copydoc RenderAPI::setComputePipeline */
 		void setComputePipeline(const SPtr<ComputePipelineStateCore>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setGpuParams */
+		/** @copydoc RenderAPI::setGpuParams */
 		void setGpuParams(const SPtr<GpuParamsCore>& gpuParams, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearRenderTarget */
+		/** @copydoc RenderAPI::clearRenderTarget */
 		void clearRenderTarget(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0, 
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearViewport */
+		/** @copydoc RenderAPI::clearViewport */
 		void clearViewport(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0,
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setRenderTarget */
+		/** @copydoc RenderAPI::setRenderTarget */
 		void setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil = false, 
 			RenderSurfaceMask loadMask = RT_NONE, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setViewport */
+		/** @copydoc RenderAPI::setViewport */
 		void setViewport(const Rect2& area, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setScissorRect */
+		/** @copydoc RenderAPI::setScissorRect */
 		void setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setStencilRef */
+		/** @copydoc RenderAPI::setStencilRef */
 		void setStencilRef(UINT32 value, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexBuffers */
+		/** @copydoc RenderAPI::setVertexBuffers */
 		void setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setIndexBuffer */
+		/** @copydoc RenderAPI::setIndexBuffer */
 		void setIndexBuffer(const SPtr<IndexBufferCore>& buffer, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexDeclaration */
+		/** @copydoc RenderAPI::setVertexDeclaration */
 		void setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setDrawOperation */
+		/** @copydoc RenderAPI::setDrawOperation */
 		void setDrawOperation(DrawOperationType op,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::draw */
+		/** @copydoc RenderAPI::draw */
 		void draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount = 0,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::drawIndexed */
+		/** @copydoc RenderAPI::drawIndexed */
 		void drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, UINT32 vertexCount, 
 			UINT32 instanceCount = 0, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::dispatchCompute */
+		/** @copydoc RenderAPI::dispatchCompute */
 		void dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY = 1, UINT32 numGroupsZ = 1,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::swapBuffers() */
+		/** @copydoc RenderAPI::swapBuffers() */
 		void swapBuffers(const SPtr<RenderTargetCore>& target, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::addCommands() */
+		/** @copydoc RenderAPI::addCommands() */
 		void addCommands(const SPtr<CommandBuffer>& commandBuffer, const SPtr<CommandBuffer>& secondary) override;
 
-		/** @copydoc RenderAPICore::submitCommandBuffer() */
+		/** @copydoc RenderAPI::submitCommandBuffer() */
 		void submitCommandBuffer(const SPtr<CommandBuffer>& commandBuffer, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::convertProjectionMatrix */
+		/** @copydoc RenderAPI::convertProjectionMatrix */
 		void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest) override;
 
-		/** @copydoc RenderAPICore::getAPIInfo */
+		/** @copydoc RenderAPI::getAPIInfo */
 		const RenderAPIInfo& getAPIInfo() const override;
 
-		/** @copydoc RenderAPICore::generateParamBlockDesc() */
+		/** @copydoc RenderAPI::generateParamBlockDesc() */
 		GpuParamBlockDesc generateParamBlockDesc(const String& name, Vector<GpuParamDataDesc>& params) override;
 
 		/************************************************************************/
@@ -129,13 +129,13 @@ namespace bs { namespace ct
 	protected:
 		friend class D3D11RenderAPIFactory;
 
-		/** @copydoc RenderAPICore::initialize */
+		/** @copydoc RenderAPI::initialize */
 		void initialize() override;
 
-		/** @copydoc RenderAPICore::initializeWithWindow */
+		/** @copydoc RenderAPI::initializeWithWindow */
 		void initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow) override;
 
-		/** @copydoc RenderAPICore::destroyCore */
+		/** @copydoc RenderAPI::destroyCore */
 		void destroyCore() override;
 
 		/**

Source/BansheeD3D11RenderAPI/Source/BsD3D11BlendState.cpp

@@ -39,7 +39,7 @@ namespace bs { namespace ct
 			blendStateDesc.RenderTarget[i].SrcBlendAlpha = D3D11Mappings::get(mProperties.getAlphaSrcBlend(i));
 		}
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateBlendState(&blendStateDesc, &mBlendState);
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11DepthStencilState.cpp

@@ -39,7 +39,7 @@ namespace bs { namespace ct
 		depthStencilState.StencilReadMask = mProperties.getStencilReadMask();
 		depthStencilState.StencilWriteMask = mProperties.getStencilWriteMask();
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateDepthStencilState(&depthStencilState, &mDepthStencilState);
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11EventQuery.cpp

@@ -14,7 +14,7 @@ namespace bs { namespace ct
 	{
 		assert(deviceIdx == 0 && "Multiple GPUs not supported natively on DirectX 11.");
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 
 		D3D11_QUERY_DESC queryDesc;

Source/BansheeD3D11RenderAPI/Source/BsD3D11GpuParamBlockBuffer.cpp

@@ -25,7 +25,7 @@ namespace bs { namespace ct
 
 	void D3D11GpuParamBlockBuffer::initialize()
 	{
-		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = d3d11rs->getPrimaryDevice();
 
 		if(mUsage == GPBU_STATIC)

Source/BansheeD3D11RenderAPI/Source/BsD3D11GpuProgram.cpp

@@ -65,7 +65,7 @@ namespace bs { namespace ct
 			break;
 		}
 
-		D3D11RenderAPI* rapi = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rapi = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 
 		ID3DBlob* microcode = compileMicrocode(hlslProfile);
 		if (microcode != nullptr)

Source/BansheeD3D11RenderAPI/Source/BsD3D11InputLayoutManager.cpp

@@ -144,7 +144,7 @@ namespace bs { namespace ct
 			}
 		}
 
-		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = d3d11rs->getPrimaryDevice();
 
 		const HLSLMicroCode& microcode = vertexProgram.getMicroCode();

Source/BansheeD3D11RenderAPI/Source/BsD3D11OcclusionQuery.cpp

@@ -14,7 +14,7 @@ namespace bs { namespace ct
 	{
 		assert(deviceIdx == 0 && "Multiple GPUs not supported natively on DirectX 11.");
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 
 		D3D11_QUERY_DESC queryDesc;

Source/BansheeD3D11RenderAPI/Source/BsD3D11RasterizerState.cpp

@@ -38,7 +38,7 @@ namespace bs { namespace ct
 		rasterizerStateDesc.SlopeScaledDepthBias = mProperties.getSlopeScaledDepthBias();
 		rasterizerStateDesc.FrontCounterClockwise = false;
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateRasterizerState(&rasterizerStateDesc, &mRasterizerState);
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderAPI.cpp

@@ -123,7 +123,7 @@ namespace bs { namespace ct
 
 		mIAManager = bs_new<D3D11InputLayoutManager>();
 
-		RenderAPICore::initialize();
+		RenderAPI::initialize();
 	}
 
 	void D3D11RenderAPI::initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow)
@@ -132,7 +132,7 @@ namespace bs { namespace ct
 
 		QueryManager::startUp<D3D11QueryManager>();
 
-		RenderAPICore::initializeWithWindow(primaryWindow);
+		RenderAPI::initializeWithWindow(primaryWindow);
 	}
 
     void D3D11RenderAPI::destroyCore()
@@ -203,7 +203,7 @@ namespace bs { namespace ct
 
 		mActiveD3DDriver = nullptr;
 
-		RenderAPICore::destroyCore();
+		RenderAPI::destroyCore();
 	}
 
 	void D3D11RenderAPI::setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState,

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderAPIFactory.cpp

@@ -9,7 +9,7 @@ namespace bs { namespace ct
 
 	void D3D11RenderAPIFactory::create()
 	{
-		RenderAPICore::startUp<D3D11RenderAPI>();
+		RenderAPI::startUp<D3D11RenderAPI>();
 	}
 
 	D3D11RenderAPIFactory::InitOnStart D3D11RenderAPIFactory::initOnStart;

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderWindow.cpp

@@ -169,7 +169,7 @@ namespace bs
 
 		const D3D11VideoOutputInfo* outputInfo = nullptr;
 
-		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs > 0)
 		{
@@ -335,7 +335,7 @@ namespace bs
 		if (mIsChild)
 			return;
 
-		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs == 0)
 			return;
@@ -391,7 +391,7 @@ namespace bs
 			return;
 		}
 
-		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const D3D11VideoModeInfo& videoModeInfo = static_cast<const D3D11VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs == 0)
 			return;
@@ -641,7 +641,7 @@ namespace bs
 
 		mSwapChainDesc.Windowed	= true;
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		rs->determineMultisampleSettings(props.mMultisampleCount, format, &mMultisampleType);
 		mSwapChainDesc.SampleDesc.Count = mMultisampleType.Count;
 		mSwapChainDesc.SampleDesc.Quality = mMultisampleType.Quality;

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderWindowManager.cpp

@@ -16,7 +16,7 @@ namespace bs
 	SPtr<RenderWindow> D3D11RenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, 
 		const SPtr<RenderWindow>& parentWindow)
 	{
-		ct::RenderAPICore* rs = ct::RenderAPICore::instancePtr();
+		ct::RenderAPI* rs = ct::RenderAPI::instancePtr();
 		ct::D3D11RenderAPI* d3d11rs = static_cast<ct::D3D11RenderAPI*>(rs);
 
 		if(parentWindow != nullptr)
@@ -42,7 +42,7 @@ namespace bs
 
 	SPtr<RenderWindowCore> D3D11RenderWindowManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
-		RenderAPICore* rs = RenderAPICore::instancePtr();
+		RenderAPI* rs = RenderAPI::instancePtr();
 		D3D11RenderAPI* d3d11rs = static_cast<D3D11RenderAPI*>(rs);
 
 		// Create the window

Source/BansheeD3D11RenderAPI/Source/BsD3D11SamplerState.cpp

@@ -94,7 +94,7 @@ namespace bs { namespace ct
 			samplerState.Filter = (D3D11_FILTER)(0x80 | samplerState.Filter);
 		}
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateSamplerState(&samplerState, &mSamplerState);
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11Texture.cpp

@@ -66,7 +66,7 @@ namespace bs { namespace ct
 		UINT32 srcResIdx = D3D11CalcSubresource(srcMipLevel, srcFace, mProperties.getNumMipmaps() + 1);
 		UINT32 destResIdx = D3D11CalcSubresource(destMipLevel, destFace, target->getProperties().getNumMipmaps() + 1);
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 
 		bool srcHasMultisample = mProperties.getNumSamples() > 1;
@@ -200,7 +200,7 @@ namespace bs { namespace ct
 		}
 		else if ((mProperties.getUsage() & TU_DEPTHSTENCIL) == 0)
 		{
-			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 			D3D11Device& device = rs->getPrimaryDevice();
 
 			UINT subresourceIdx = D3D11CalcSubresource(mipLevel, face, mProperties.getNumMipmaps() + 1);
@@ -296,7 +296,7 @@ namespace bs { namespace ct
 			desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
 
 		// Create the texture
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture1D(&desc, nullptr, &m1DTex);
 
@@ -388,7 +388,7 @@ namespace bs { namespace ct
 			desc.MipLevels		= 1;
 
 			DXGI_SAMPLE_DESC sampleDesc;
-			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 			rs->determineMultisampleSettings(sampleCount, d3dPF, &sampleDesc);
 			desc.SampleDesc		= sampleDesc;
 
@@ -410,7 +410,7 @@ namespace bs { namespace ct
 				desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
 
 			DXGI_SAMPLE_DESC sampleDesc;
-			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+			D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 			rs->determineMultisampleSettings(sampleCount, d3dPF, &sampleDesc);
 			desc.SampleDesc		= sampleDesc;
 
@@ -444,7 +444,7 @@ namespace bs { namespace ct
 			desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
 
 		// Create the texture
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture2D(&desc, nullptr, &m2DTex);
 
@@ -562,7 +562,7 @@ namespace bs { namespace ct
 			desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
 
 		// Create the texture
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture3D(&desc, nullptr, &m3DTex);
 
@@ -617,7 +617,7 @@ namespace bs { namespace ct
 		if (mProperties.getTextureType() == TEX_TYPE_3D)
 			face = 0;
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 
 		mLockedSubresourceIdx = D3D11CalcSubresource(mipLevel, face, mProperties.getNumMipmaps() + 1);
@@ -638,7 +638,7 @@ namespace bs { namespace ct
 
 	void D3D11Texture::unmap(ID3D11Resource* res)
 	{
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->Unmap(res, mLockedSubresourceIdx);
 
@@ -658,7 +658,7 @@ namespace bs { namespace ct
 		if(!mStagingBuffer)
 			createStagingBuffer(); 
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->CopyResource(mStagingBuffer, mTex);
 
@@ -687,7 +687,7 @@ namespace bs { namespace ct
 		UINT32 rowWidth = D3D11Mappings::getSizeInBytes(mStaticBuffer->getFormat(), mStaticBuffer->getWidth());
 		UINT32 sliceWidth = D3D11Mappings::getSizeInBytes(mStaticBuffer->getFormat(), mStaticBuffer->getWidth(), mStaticBuffer->getHeight());
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->UpdateSubresource(mTex, mLockedSubresourceIdx, nullptr, mStaticBuffer->getData(), rowWidth, sliceWidth);
 
@@ -708,7 +708,7 @@ namespace bs { namespace ct
 
 	void D3D11Texture::createStagingBuffer()
 	{
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 		switch (mProperties.getTextureType())
 		{

Source/BansheeD3D11RenderAPI/Source/BsD3D11TimerQuery.cpp

@@ -15,7 +15,7 @@ namespace bs { namespace ct
 	{
 		assert(deviceIdx == 0 && "Multiple GPUs not supported natively on DirectX 11.");
 
-		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
+		D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
 		D3D11Device& device = rs->getPrimaryDevice();
 
 		D3D11_QUERY_DESC queryDesc;

Source/BansheeEditor/Source/BsGizmoManager.cpp

@@ -1100,7 +1100,7 @@ namespace bs
 	void GizmoRenderer::renderIconGizmos(Rect2I screenArea, SPtr<MeshCoreBase> mesh, 
 		GizmoManager::IconRenderDataVecPtr renderData, bool usePickingMaterial)
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		SPtr<VertexData> vertexData = mesh->getVertexData();
 
 		rapi.setVertexDeclaration(vertexData->vertexDeclaration);

Source/BansheeEditor/Source/BsScenePicking.cpp

@@ -260,7 +260,7 @@ namespace bs
 	void ScenePicking::corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea,
 		const bs::ScenePicking::RenderableSet& renderables, const Vector2I& position, const Vector2I& area)
 	{
-		RenderAPICore& rs = RenderAPICore::instance();
+		RenderAPI& rs = RenderAPI::instance();
 
 		SPtr<RenderTextureCore> rtt = std::static_pointer_cast<RenderTextureCore>(target);
 
@@ -381,7 +381,7 @@ namespace bs
 		const Vector2I& position, const Vector2I& area, bool gatherSnapData, AsyncOp& asyncOp)
 	{
 		const RenderTargetProperties& rtProps = target->getProperties();
-		RenderAPICore& rs = RenderAPICore::instance();
+		RenderAPI& rs = RenderAPI::instance();
 
 		rs.setRenderTarget(nullptr);
 		rs.submitCommandBuffer(nullptr);

Source/BansheeEngine/Source/BsGUIManager.cpp

@@ -1762,7 +1762,7 @@ namespace bs
 
 		float invViewportWidth = 1.0f / (camera.getViewport()->getWidth() * 0.5f);
 		float invViewportHeight = 1.0f / (camera.getViewport()->getHeight() * 0.5f);
-		float viewflipYFlip = RenderAPI::getAPIInfo().getNDCYAxisDown() ? -1.0f : 1.0f;
+		float viewflipYFlip = bs::RenderAPI::getAPIInfo().getNDCYAxisDown() ? -1.0f : 1.0f;
 
 		for (auto& entry : renderData)
 		{

Source/BansheeEngine/Source/BsRendererUtility.cpp

@@ -139,7 +139,7 @@ namespace bs { namespace ct
 
 	void RendererUtility::setPass(const SPtr<MaterialCore>& material, UINT32 passIdx, UINT32 techniqueIdx)
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 
 		SPtr<PassCore> pass = material->getPass(passIdx, techniqueIdx);
 		rapi.setGraphicsPipeline(pass->getGraphicsPipelineState());
@@ -148,7 +148,7 @@ namespace bs { namespace ct
 
 	void RendererUtility::setComputePass(const SPtr<MaterialCore>& material, UINT32 passIdx)
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 
 		SPtr<PassCore> pass = material->getPass(passIdx);
 		rapi.setComputePipeline(pass->getComputePipelineState());
@@ -160,13 +160,13 @@ namespace bs { namespace ct
 		if (gpuParams == nullptr)
 			return;
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setGpuParams(gpuParams);
 	}
 
 	void RendererUtility::draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh, UINT32 numInstances)
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		SPtr<VertexData> vertexData = mesh->getVertexData();
 
 		rapi.setVertexDeclaration(mesh->getVertexData()->vertexDeclaration);
@@ -211,7 +211,7 @@ namespace bs { namespace ct
 		const SPtr<VertexBufferCore>& morphVertices, const SPtr<VertexDeclarationCore>& morphVertexDeclaration)
 	{
 		// Bind buffers and draw
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 
 		SPtr<VertexData> vertexData = mesh->getVertexData();
 		rapi.setVertexDeclaration(morphVertexDeclaration);
@@ -288,7 +288,7 @@ namespace bs { namespace ct
 	{
 		// Note: Consider drawing the quad using a single large triangle for possibly better performance
 
-		const RenderAPIInfo& rapiInfo = RenderAPICore::instance().getAPIInfo();
+		const RenderAPIInfo& rapiInfo = RenderAPI::instance().getAPIInfo();
 
 		Vector3 vertices[4];
 

Source/BansheeGLRenderAPI/Include/BsGLRenderAPI.h

@@ -15,95 +15,95 @@ namespace bs { namespace ct
 	 */
 
 	/** Implementation of a render system using OpenGL. Provides abstracted access to various low level OpenGL methods. */
-    class BS_RSGL_EXPORT GLRenderAPI : public RenderAPICore
+    class BS_RSGL_EXPORT GLRenderAPI : public RenderAPI
     {
     public:
         GLRenderAPI();
         ~GLRenderAPI();
 
-		/** @copydoc RenderAPICore::getName() */
+		/** @copydoc RenderAPI::getName() */
 		const StringID& getName() const override;
 
-		/** @copydoc RenderAPICore::getShadingLanguageName() */
+		/** @copydoc RenderAPI::getShadingLanguageName() */
 		const String& getShadingLanguageName() const override;
 
-		/** @copydoc RenderAPICore::setGraphicsPipeline */
+		/** @copydoc RenderAPI::setGraphicsPipeline */
 		void setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setComputePipeline */
+		/** @copydoc RenderAPI::setComputePipeline */
 		void setComputePipeline(const SPtr<ComputePipelineStateCore>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setGpuParams() */
+		/** @copydoc RenderAPI::setGpuParams() */
 		void setGpuParams(const SPtr<GpuParamsCore>& gpuParams,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setViewport() */
+		/** @copydoc RenderAPI::setViewport() */
 		void setViewport(const Rect2& area, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setScissorRect() */
+		/** @copydoc RenderAPI::setScissorRect() */
 		void setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setStencilRef */
+		/** @copydoc RenderAPI::setStencilRef */
 		void setStencilRef(UINT32 value, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexBuffers() */
+		/** @copydoc RenderAPI::setVertexBuffers() */
 		void setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setIndexBuffer() */
+		/** @copydoc RenderAPI::setIndexBuffer() */
 		void setIndexBuffer(const SPtr<IndexBufferCore>& buffer,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexDeclaration() */
+		/** @copydoc RenderAPI::setVertexDeclaration() */
 		void setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setDrawOperation() */
+		/** @copydoc RenderAPI::setDrawOperation() */
 		void setDrawOperation(DrawOperationType op, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::draw() */
+		/** @copydoc RenderAPI::draw() */
 		void draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount = 0,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::drawIndexed() */
+		/** @copydoc RenderAPI::drawIndexed() */
 		void drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, UINT32 vertexCount
 			, UINT32 instanceCount = 0, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::dispatchCompute() */
+		/** @copydoc RenderAPI::dispatchCompute() */
 		void dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY = 1, UINT32 numGroupsZ = 1, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::swapBuffers() */
+		/** @copydoc RenderAPI::swapBuffers() */
 		void swapBuffers(const SPtr<RenderTargetCore>& target, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::setRenderTarget() */
+		/** @copydoc RenderAPI::setRenderTarget() */
 		void setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil = false, 
 			RenderSurfaceMask loadMask = RT_NONE, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearRenderTarget() */
+		/** @copydoc RenderAPI::clearRenderTarget() */
 		void clearRenderTarget(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0, 
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearViewport() */
+		/** @copydoc RenderAPI::clearViewport() */
 		void clearViewport(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0, 
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::addCommands() */
+		/** @copydoc RenderAPI::addCommands() */
 		void addCommands(const SPtr<CommandBuffer>& commandBuffer, const SPtr<CommandBuffer>& secondary) override;
 
-		/** @copydoc RenderAPICore::submitCommandBuffer() */
+		/** @copydoc RenderAPI::submitCommandBuffer() */
 		void submitCommandBuffer(const SPtr<CommandBuffer>& commandBuffer, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::convertProjectionMatrix() */
+		/** @copydoc RenderAPI::convertProjectionMatrix() */
 		void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest) override;
 
-		/** @copydoc RenderAPICore::getAPIInfo */
+		/** @copydoc RenderAPI::getAPIInfo */
 		const RenderAPIInfo& getAPIInfo() const override;
 
-		/** @copydoc RenderAPICore::generateParamBlockDesc() */
+		/** @copydoc RenderAPI::generateParamBlockDesc() */
 		GpuParamBlockDesc generateParamBlockDesc(const String& name, Vector<GpuParamDataDesc>& params) override;
 
 		/************************************************************************/
@@ -120,13 +120,13 @@ namespace bs { namespace ct
 		GLSupport* getGLSupport() const { return mGLSupport; }
 
 	protected:
-		/** @copydoc RenderAPICore::initialize */
+		/** @copydoc RenderAPI::initialize */
 		void initialize() override;
 
-		/** @copydoc RenderAPICore::initializeWithWindow */
+		/** @copydoc RenderAPI::initializeWithWindow */
 		void initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow) override;
 
-		/** @copydoc RenderAPICore::destroyCore */
+		/** @copydoc RenderAPI::destroyCore */
 		void destroyCore() override;
 
 		/**	Call before doing a draw operation, this method sets everything up. */

Source/BansheeGLRenderAPI/Source/BsGLFrameBufferObject.cpp

@@ -64,7 +64,7 @@ namespace bs { namespace ct
         // Store basic stats
         UINT32 width = mColor[0].buffer->getWidth();
         UINT32 height = mColor[0].buffer->getHeight();
-        UINT16 maxSupportedMRTs = RenderAPICore::instancePtr()->getCapabilities(0).getNumMultiRenderTargets();
+        UINT16 maxSupportedMRTs = RenderAPI::instancePtr()->getCapabilities(0).getNumMultiRenderTargets();
 
 		// Bind simple buffer to add color attachments
 		glBindFramebuffer(GL_FRAMEBUFFER, mFB);

Source/BansheeGLRenderAPI/Source/BsGLRenderAPI.cpp

@@ -106,7 +106,7 @@ namespace bs { namespace ct
 
 		QueryManager::startUp<GLQueryManager>();
 
-		RenderAPICore::initialize();
+		RenderAPI::initialize();
 	}
 
 	void GLRenderAPI::initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow)
@@ -142,12 +142,12 @@ namespace bs { namespace ct
 
 		mGLInitialised = true;
 
-		RenderAPICore::initializeWithWindow(primaryWindow);
+		RenderAPI::initializeWithWindow(primaryWindow);
 	}
 
 	void GLRenderAPI::destroyCore()
 	{
-		RenderAPICore::destroyCore();
+		RenderAPI::destroyCore();
 
 		// Deleting the GLSL program factory
 		if (mGLSLProgramFactory)

Source/BansheeGLRenderAPI/Source/BsGLRenderAPIFactory.cpp

@@ -7,7 +7,7 @@ namespace bs { namespace ct
 {
 	void GLRenderAPIFactory::create()
 	{
-		RenderAPICore::startUp<GLRenderAPI>();
+		RenderAPI::startUp<GLRenderAPI>();
 	}
 
 	GLRenderAPIFactory::InitOnStart GLRenderAPIFactory::initOnStart;

Source/BansheeGLRenderAPI/Source/GLSL/src/BsGLSLGpuProgram.cpp

@@ -207,7 +207,7 @@ namespace bs { namespace ct
 		if (!isRequiredCapabilitiesSupported())
 			return false;
 
-		RenderAPICore* rapi = RenderAPICore::instancePtr();
+		RenderAPI* rapi = RenderAPI::instancePtr();
 		return rapi->getCapabilities(0).isShaderProfileSupported("glsl");
 	}
 }}

Source/BansheeGLRenderAPI/Source/Win32/BsWin32GLSupport.cpp

@@ -87,7 +87,7 @@ namespace bs { namespace ct
 
 	SPtr<Win32Context> Win32GLSupport::createContext(HDC hdc, HGLRC externalGlrc)
 	{
-		GLRenderAPI* rs = static_cast<GLRenderAPI*>(RenderAPICore::instancePtr());
+		GLRenderAPI* rs = static_cast<GLRenderAPI*>(RenderAPI::instancePtr());
 
 		// If RenderAPI has initialized a context use that, otherwise we create our own
 		HGLRC glrc = externalGlrc;

Source/BansheeGLRenderAPI/Source/Win32/BsWin32RenderWindow.cpp

@@ -151,7 +151,7 @@ namespace bs
 		if (opt != mDesc.platformSpecific.end())
 			windowDesc.external = (HWND)parseUINT64(opt->second);
 		
-		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs > 0)
 		{
@@ -267,7 +267,7 @@ namespace bs
 		if (mIsChild)
 			return;
 
-		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs == 0)
 			return;

Source/BansheeVulkanRenderAPI/Include/BsVulkanCommandBuffer.h

@@ -131,7 +131,7 @@ namespace bs { namespace ct
 		 *							from the actual VulkanQueue index since multiple command buffer queue indices can map
 		 *							to the same queue.
 		 * @param[in]	syncMask	Mask that controls which other command buffers does this command buffer depend upon
-		 *							(if any). See description of @p syncMask parameter in RenderAPICore::executeCommands().
+		 *							(if any). See description of @p syncMask parameter in RenderAPI::executeCommands().
 		 */
 		void submit(VulkanQueue* queue, UINT32 queueIdx, UINT32 syncMask);
 
@@ -434,7 +434,7 @@ namespace bs { namespace ct
 		 * Submits the command buffer for execution. 
 		 * 
 		 * @param[in]	syncMask	Mask that controls which other command buffers does this command buffer depend upon
-		 *							(if any). See description of @p syncMask parameter in RenderAPICore::executeCommands().
+		 *							(if any). See description of @p syncMask parameter in RenderAPI::executeCommands().
 		 */
 		void submit(UINT32 syncMask);
 

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderAPI.h

@@ -12,96 +12,96 @@ namespace bs { namespace ct
 	 */
 
 	/** Implementation of a render system using Vulkan. Provides abstracted access to various low level Vulkan methods. */
-	class VulkanRenderAPI : public RenderAPICore
+	class VulkanRenderAPI : public RenderAPI
 	{
 	public:
 		VulkanRenderAPI();
 		~VulkanRenderAPI();
 
-		/** @copydoc RenderAPICore::getName */
+		/** @copydoc RenderAPI::getName */
 		const StringID& getName() const override;
 		
-		/** @copydoc RenderAPICore::getShadingLanguageName */
+		/** @copydoc RenderAPI::getShadingLanguageName */
 		const String& getShadingLanguageName() const override;
 
-		/** @copydoc RenderAPICore::setGraphicsPipeline */
+		/** @copydoc RenderAPI::setGraphicsPipeline */
 		void setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setComputePipeline */
+		/** @copydoc RenderAPI::setComputePipeline */
 		void setComputePipeline(const SPtr<ComputePipelineStateCore>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setGpuParams */
+		/** @copydoc RenderAPI::setGpuParams */
 		void setGpuParams(const SPtr<GpuParamsCore>& gpuParams, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearRenderTarget */
+		/** @copydoc RenderAPI::clearRenderTarget */
 		void clearRenderTarget(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0, 
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::clearViewport */
+		/** @copydoc RenderAPI::clearViewport */
 		void clearViewport(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0,
 			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setRenderTarget */
+		/** @copydoc RenderAPI::setRenderTarget */
 		void setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil = false,
 			RenderSurfaceMask loadMask = RT_NONE, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setViewport */
+		/** @copydoc RenderAPI::setViewport */
 		void setViewport(const Rect2& area, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setScissorRect */
+		/** @copydoc RenderAPI::setScissorRect */
 		void setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setStencilRef */
+		/** @copydoc RenderAPI::setStencilRef */
 		void setStencilRef(UINT32 value, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexBuffers */
+		/** @copydoc RenderAPI::setVertexBuffers */
 		void setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setIndexBuffer */
+		/** @copydoc RenderAPI::setIndexBuffer */
 		void setIndexBuffer(const SPtr<IndexBufferCore>& buffer, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setVertexDeclaration */
+		/** @copydoc RenderAPI::setVertexDeclaration */
 		void setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::setDrawOperation */
+		/** @copydoc RenderAPI::setDrawOperation */
 		void setDrawOperation(DrawOperationType op,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::draw */
+		/** @copydoc RenderAPI::draw */
 		void draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount = 0,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::drawIndexed */
+		/** @copydoc RenderAPI::drawIndexed */
 		void drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, UINT32 vertexCount, 
 			UINT32 instanceCount = 0, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::dispatchCompute */
+		/** @copydoc RenderAPI::dispatchCompute */
 		void dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY = 1, UINT32 numGroupsZ = 1,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
 
-		/** @copydoc RenderAPICore::swapBuffers() */
+		/** @copydoc RenderAPI::swapBuffers() */
 		void swapBuffers(const SPtr<RenderTargetCore>& target, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::addCommands() */
+		/** @copydoc RenderAPI::addCommands() */
 		void addCommands(const SPtr<CommandBuffer>& commandBuffer, const SPtr<CommandBuffer>& secondary) override;
 
-		/** @copydoc RenderAPICore::executeCommands() */
+		/** @copydoc RenderAPI::executeCommands() */
 		void submitCommandBuffer(const SPtr<CommandBuffer>& commandBuffer, UINT32 syncMask = 0xFFFFFFFF) override;
 
-		/** @copydoc RenderAPICore::convertProjectionMatrix */
+		/** @copydoc RenderAPI::convertProjectionMatrix */
 		void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest) override;
 
-		/** @copydoc RenderAPICore::getAPIInfo */
+		/** @copydoc RenderAPI::getAPIInfo */
 		const RenderAPIInfo& getAPIInfo() const override;
 
-		/** @copydoc RenderAPICore::generateParamBlockDesc() */
+		/** @copydoc RenderAPI::generateParamBlockDesc() */
 		GpuParamBlockDesc generateParamBlockDesc(const String& name, Vector<GpuParamDataDesc>& params) override;
 
 		/**
@@ -134,10 +134,10 @@ namespace bs { namespace ct
 	protected:
 		friend class VulkanRenderAPIFactory;
 
-		/** @copydoc RenderAPICore::initializePrepare */
+		/** @copydoc RenderAPI::initializePrepare */
 		void initialize() override;
 
-		/** @copydoc RenderAPICore::destroyCore */
+		/** @copydoc RenderAPI::destroyCore */
 		void destroyCore() override;
 
 		/** Creates and populates a set of render system capabilities describing which functionality is available. */

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuParams.cpp

@@ -49,7 +49,7 @@ namespace bs { namespace ct
 	{
 		VulkanGpuPipelineParamInfo& vkParamInfo = static_cast<VulkanGpuPipelineParamInfo&>(*mParamInfo);
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice* devices[BS_MAX_DEVICES];
 
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);
@@ -713,7 +713,7 @@ namespace bs { namespace ct
 		}
 
 		// Acquire sets as needed, and updated their contents if dirty
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice& device = *rapi._getDevice(deviceIdx);
 		VulkanDescriptorManager& descManager = device.getDescriptorManager();
 

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuPipelineParamInfo.cpp

@@ -20,7 +20,7 @@ namespace bs { namespace ct
 
 	void VulkanGpuPipelineParamInfo::initialize()
 	{
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuPipelineState.cpp

@@ -288,7 +288,7 @@ namespace bs { namespace ct
 		if(mData.vertexProgram != nullptr)
 			mVertexDecl = mData.vertexProgram->getInputDeclaration();
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);
@@ -541,7 +541,7 @@ namespace bs { namespace ct
 		pipelineCI.basePipelineHandle = VK_NULL_HANDLE;
 		pipelineCI.basePipelineIndex = -1;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuProgram.cpp

@@ -643,7 +643,7 @@ namespace bs { namespace ct
 		moduleCI.codeSize = spirv.size() * sizeof(UINT32);
 		moduleCI.pCode = spirv.data();
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);

Source/BansheeVulkanRenderAPI/Source/BsVulkanHardwareBuffer.cpp

@@ -125,7 +125,7 @@ namespace bs { namespace ct
 		mViewCI.offset = 0;
 		mViewCI.range = VK_WHOLE_SIZE;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, deviceMask, devices);
 
@@ -225,7 +225,7 @@ namespace bs { namespace ct
 		mMappedSize = length;
 		mMappedLockOptions = options;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice& device = *rapi._getDevice(deviceIdx);
 
 		VulkanCommandBufferManager& cbManager = gVulkanCBManager();
@@ -430,7 +430,7 @@ namespace bs { namespace ct
 			// We the caller wrote anything to the staging buffer, we need to upload it back to the main buffer
 			if(isWrite)
 			{
-				VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+				VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 				VulkanDevice& device = *rapi._getDevice(mMappedDeviceIdx);
 
 				VulkanCommandBufferManager& cbManager = gVulkanCBManager();
@@ -552,7 +552,7 @@ namespace bs { namespace ct
 
 		VulkanHardwareBuffer& vkSource = static_cast<VulkanHardwareBuffer&>(srcBuffer);
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanCommandBufferManager& cbManager = gVulkanCBManager();
 
 		GpuQueueType queueType;

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPI.cpp

@@ -262,7 +262,7 @@ namespace bs { namespace ct
 
 		initCapabilites();
 		
-		RenderAPICore::initialize();
+		RenderAPI::initialize();
 	}
 
     void VulkanRenderAPI::destroyCore()
@@ -307,7 +307,7 @@ namespace bs { namespace ct
 
 		vkDestroyInstance(mInstance, gVulkanAllocator);
 
-		RenderAPICore::destroyCore();
+		RenderAPI::destroyCore();
 	}
 
 	void VulkanRenderAPI::setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState,
@@ -738,6 +738,6 @@ namespace bs { namespace ct
 
 	VulkanRenderAPI& gVulkanRenderAPI()
 	{
-		return static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		return static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 	}
 }}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPIFactory.cpp

@@ -9,7 +9,7 @@ namespace bs { namespace ct
 
 	void VulkanRenderAPIFactory::create()
 	{
-		RenderAPICore::startUp<VulkanRenderAPI>();
+		RenderAPI::startUp<VulkanRenderAPI>();
 	}
 
 	VulkanRenderAPIFactory::InitOnStart VulkanRenderAPIFactory::initOnStart;

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderTexture.cpp

@@ -125,7 +125,7 @@ namespace bs
 			}
 		}
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		SPtr<VulkanDevice> device = rapi._getDevice(mDeviceIdx);
 
 		mFramebuffer = device->getResourceManager().create<VulkanFramebuffer>(fbDesc);

Source/BansheeVulkanRenderAPI/Source/BsVulkanSamplerState.cpp

@@ -62,7 +62,7 @@ namespace bs { namespace ct
 		samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
 		samplerInfo.unnormalizedCoordinates = false;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);
 

Source/BansheeVulkanRenderAPI/Source/BsVulkanTexture.cpp

@@ -491,7 +491,7 @@ namespace bs { namespace ct
 		mImageCI.queueFamilyIndexCount = 0;
 		mImageCI.pQueueFamilyIndices = nullptr;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice* devices[BS_MAX_DEVICES];
 		VulkanUtility::getDevices(rapi, mDeviceMask, devices);
 
@@ -741,7 +741,7 @@ namespace bs { namespace ct
 		dstRange.baseMipLevel = destMipLevel;
 		dstRange.levelCount = 1;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		for(UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			VulkanDevice& device = *rapi._getDevice(i);
@@ -876,7 +876,7 @@ namespace bs { namespace ct
 		mMappedMip = mipLevel;
 		mMappedLockOptions = options;
 
-		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+		VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 		VulkanDevice& device = *rapi._getDevice(deviceIdx);
 
 		VulkanCommandBufferManager& cbManager = gVulkanCBManager();
@@ -1112,7 +1112,7 @@ namespace bs { namespace ct
 			// We the caller wrote anything to the staging buffer, we need to upload it back to the main buffer
 			if (isWrite)
 			{
-				VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPICore::instance());
+				VulkanRenderAPI& rapi = static_cast<VulkanRenderAPI&>(RenderAPI::instance());
 				VulkanDevice& device = *rapi._getDevice(mMappedDeviceIdx);
 
 				VulkanCommandBufferManager& cbManager = gVulkanCBManager();

Source/BansheeVulkanRenderAPI/Source/Win32/BsWin32RenderWindow.cpp

@@ -136,7 +136,7 @@ namespace bs
 		if (opt != mDesc.platformSpecific.end())
 			windowDesc.external = (HWND)parseUINT64(opt->second);
 		
-		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs > 0)
 		{
@@ -468,7 +468,7 @@ namespace bs
 		if (mIsChild)
 			return;
 
-		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPICore::instance().getVideoModeInfo());
+		const Win32VideoModeInfo& videoModeInfo = static_cast<const Win32VideoModeInfo&>(RenderAPI::instance().getVideoModeInfo());
 		UINT32 numOutputs = videoModeInfo.getNumOutputs();
 		if (numOutputs == 0)
 			return;

Source/RenderBeast/Source/BsPostProcessing.cpp

@@ -47,7 +47,7 @@ namespace bs { namespace ct
 		// Render
 		ppInfo.downsampledSceneTex = RenderTexturePool::instance().get(mOutputDesc);
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(ppInfo.downsampledSceneTex->renderTexture, true);
 
 		gRendererUtility().setPass(mMaterial);
@@ -111,7 +111,7 @@ namespace bs { namespace ct
 
 		mOutputTex.set(ppInfo.histogramTex->texture);
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		gRendererUtility().setComputePass(mMaterial);
 		gRendererUtility().setPassParams(mParamsSet);
 		rapi.dispatchCompute(threadGroupCount.x, threadGroupCount.y);
@@ -194,7 +194,7 @@ namespace bs { namespace ct
 		// Render
 		ppInfo.histogramReduceTex = RenderTexturePool::instance().get(mOutputDesc);
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(ppInfo.histogramReduceTex->renderTexture, true);
 
 		gRendererUtility().setPass(mMaterial);
@@ -276,7 +276,7 @@ namespace bs { namespace ct
 		// Render
 		SPtr<PooledRenderTexture> eyeAdaptationRT = ppInfo.eyeAdaptationTex[ppInfo.lastEyeAdaptationTex];
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(eyeAdaptationRT->renderTexture, true);
 
 		gRendererUtility().setPass(mMaterial);
@@ -350,7 +350,7 @@ namespace bs { namespace ct
 
 		mOutputTex.set(ppInfo.colorLUT->texture);
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		
 		gRendererUtility().setComputePass(mMaterial);
 		gRendererUtility().setPassParams(mParamsSet);
@@ -414,7 +414,7 @@ namespace bs { namespace ct
 		mEyeAdaptationTex.set(eyeAdaptationTexture);
 
 		// Render
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		SPtr<RenderTargetCore> target = outputViewport->getTarget();
 
 		rapi.setRenderTarget(target);

Source/RenderBeast/Source/BsRenderBeast.cpp

@@ -611,7 +611,7 @@ namespace bs { namespace ct
 		for (auto& rtInfo : mRenderTargets)
 		{
 			if(rtInfo.target->getProperties().isWindow())
-				RenderAPICore::instance().swapBuffers(rtInfo.target);
+				RenderAPI::instance().swapBuffers(rtInfo.target);
 		}
 
 		gProfilerCPU().endSample("renderAllCore");
@@ -823,7 +823,7 @@ namespace bs { namespace ct
 		// If first camera in render target, prepare the render target
 		if (camIdx == 0)
 		{
-			RenderAPICore::instance().setRenderTarget(target);
+			RenderAPI::instance().setRenderTarget(target);
 
 			UINT32 clearBuffers = 0;
 			if (viewport->getRequiresColorClear())
@@ -837,14 +837,14 @@ namespace bs { namespace ct
 
 			if (clearBuffers != 0)
 			{
-				RenderAPICore::instance().clearViewport(clearBuffers, viewport->getClearColor(),
+				RenderAPI::instance().clearViewport(clearBuffers, viewport->getClearColor(),
 					viewport->getClearDepthValue(), viewport->getClearStencilValue());
 			}
 		}
 		else
-			RenderAPICore::instance().setRenderTarget(target, false, RT_COLOR0);
+			RenderAPI::instance().setRenderTarget(target, false, RT_COLOR0);
 
-		RenderAPICore::instance().setViewport(viewport->getNormArea());
+		RenderAPI::instance().setViewport(viewport->getNormArea());
 
 		// Trigger overlay callbacks
 		auto iterRenderCallback = mCallbacks.begin();

Source/RenderBeast/Source/BsRenderTargets.cpp

@@ -91,7 +91,7 @@ namespace bs { namespace ct
 
 	void RenderTargets::release()
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(nullptr);
 
 		RenderTexturePool& texPool = RenderTexturePool::instance();
@@ -104,7 +104,7 @@ namespace bs { namespace ct
 
 	void RenderTargets::bindGBuffer()
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(mGBufferRT);
 
 		Rect2 area(0.0f, 0.0f, 1.0f, 1.0f);
@@ -123,17 +123,17 @@ namespace bs { namespace ct
 		// Clear scene color, depth, stencil according to user defined values
 		if (clearBuffers != 0)
 		{
-			RenderAPICore::instance().clearViewport(clearBuffers, mViewport->getClearColor(),
+			RenderAPI::instance().clearViewport(clearBuffers, mViewport->getClearColor(),
 				mViewport->getClearDepthValue(), mViewport->getClearStencilValue(), 0x01);
 		}
 
 		// Clear all others
-		RenderAPICore::instance().clearViewport(FBT_COLOR, Color::ZERO, 1.0f, 0, 0xFF & ~0x01);
+		RenderAPI::instance().clearViewport(FBT_COLOR, Color::ZERO, 1.0f, 0, 0xFF & ~0x01);
 	}
 
 	void RenderTargets::bindSceneColor(bool readOnlyDepthStencil)
 	{
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(mSceneColorRT, readOnlyDepthStencil, RT_COLOR0 | RT_DEPTH);
 
 		Rect2 area(0.0f, 0.0f, 1.0f, 1.0f);

Source/RenderBeast/Source/BsRendererCamera.cpp

@@ -187,7 +187,7 @@ namespace bs { namespace ct
 		// Are we reorganize it because it needs to fit the "(1.0f / (depth + y)) * x" format used in the shader:
 		// z = 1.0f / (depth + minDepth/(maxDepth - minDepth) - A/((maxDepth - minDepth) * C)) * B/((maxDepth - minDepth) * C)
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		const RenderAPIInfo& rapiInfo = rapi.getAPIInfo();
 
 		float depthRange = rapiInfo.getMaximumDepthInputValue() - rapiInfo.getMinimumDepthInputValue();
@@ -253,7 +253,7 @@ namespace bs { namespace ct
 			rtHeight = 20.0f;
 		}
 
-		RenderAPICore& rapi = RenderAPICore::instance();
+		RenderAPI& rapi = RenderAPI::instance();
 		const RenderAPIInfo& rapiInfo = rapi.getAPIInfo();
 
 		Vector4 clipToUVScaleOffset;