Final set of refactors to rename core thread objects

Documentation/Manuals/Native/architecture.md

@@ -75,7 +75,7 @@ Handles physics: rigidbodies, colliders, triggers, joints, character controller
 Provides access to the C# scripting language using the Mono runtime. This allows the C++ code to call into C# code, and vice versa, as well as providing various meta-data about the managed code, and other functionality. All the script interop libraries (listed below) depend on this plugin. See the [scripting](@ref scripting) manual to learn more about this layer.
 
 ### RenderBeast ###					
-Banshee's default renderer. Implements the @ref bs::Renderer "Renderer" interface. This plugin might seem similar to the render API plugins mentioned above but it is a higher level system. While render API plugins provide low level access to rendering functionality the renderer handles rendering of all scene objects in a specific manner without requiring the developer to issue draw calls manually. A specific set of options can be configured, both globally and per object that control how an object is rendered, as well as specifying completely custom materials. e.g. the renderer will handle physically based rendering, HDR, shadows, global illumination and similar features.
+Banshee's default renderer. Implements the @ref bs::ct::Renderer "Renderer" interface. This plugin might seem similar to the render API plugins mentioned above but it is a higher level system. While render API plugins provide low level access to rendering functionality the renderer handles rendering of all scene objects in a specific manner without requiring the developer to issue draw calls manually. A specific set of options can be configured, both globally and per object that control how an object is rendered, as well as specifying completely custom materials. e.g. the renderer will handle physically based rendering, HDR, shadows, global illumination and similar features.
 
 See the [renderer](@ref renderer) manual to learn more about how the renderer works and how to implement your own.
 

Documentation/Manuals/Native/coreThread.md

@@ -58,11 +58,11 @@ For example, a @ref bs::Mesh "Mesh" is a core object because we want to allow th
 
 Every core object is split into two interfaces:
  - @ref bs::CoreObject "CoreObject" - Implementations of this interface represents the simulation thread counterpart of the object.
- - @ref bs::CoreObjectCore "CoreObjectCore" - Implementations of this interface represents the core thread counterpart of the object.
+ - @ref bs::ct::CoreObject "ct::CoreObject" - Implementations of this interface represents the core thread counterpart of the object.
  
-When a @ref bs::CoreObject "CoreObject" is created it internally queues the creation of its @ref bs::CoreObjectCore "CoreObjectCore" counterpart on the main command queue. Similar thing happens when it is destroyed, a destroy operation is queued and sent to the core thread.
+When a @ref bs::CoreObject "CoreObject" is created it internally queues the creation of its @ref bs::ct::CoreObject "ct::CoreObject" counterpart on the main command queue. Similar thing happens when it is destroyed, a destroy operation is queued and sent to the core thread. Objects used on the core thread are named the same as their simulation thread counterparts, but are in the **ct** namespace.
 
-Aside from initialization/destruction, core objects also support synchronization of data between the two threads (e.g. a @ref bs::Light "Light" is a core object, and when the user changes light radius, it is automatically synchronized to its core thread counterpart @ref bs::LightCore "LightCore").
+Aside from initialization/destruction, core objects also support synchronization of data between the two threads (e.g. a @ref bs::Light "Light" is a core object, and when the user changes light radius, it is automatically synchronized to its core thread counterpart @ref bs::ct::Light "ct::Light").
 
 ## Creating your own core objects {#coreThread_b_a}
 To create a custom core object, you need to implement the @ref bs::CoreObject "CoreObject" class, which by default requires no methods to be implemented. 
@@ -79,21 +79,21 @@ SPtr<MyCoreObject> MyCoreObject::create()
 }
 ~~~~~~~~~~~~~
 
-You will also want to override @ref bs::CoreObject::createCore "CoreObject::createCore", which creates the core thread counterpart of your object. It should return a normal shared pointer to your implementation of @ref bs::CoreObjectCore "CoreObjectCore".
+You will also want to override @ref bs::CoreObject::createCore "CoreObject::createCore", which creates the core thread counterpart of your object. It should return a normal shared pointer to your implementation of @ref bs::ct::CoreObject "CoreObject".
 
 Once a core object is created you can use it as a normal object, while you can retrieve its core thread counterpart by calling @ref bs::CoreObject::getCore "CoreObject::getCore", which you can use on the core thread. Object creation/destruction will happen automatically on the valid thread, and you also get the ability to synchronize information between the two (see below).
 
 ### CoreObjectCore {#coreThread_b_a_a}
-To create the core thread counterpart of a @ref bs::CoreObject "CoreObject" you must implement the @ref bs::CoreObjectCore "CoreObjectCore" class. 
+To create the core thread counterpart of a @ref bs::CoreObject "CoreObject" you must implement the @ref bs::ct::CoreObject "ct::CoreObject" class. 
 
 This object provides an @ref bs::CoreObject::initialize "CoreObject::initialize" method. You should perform any initialization in this method instead of the constructor, as it is guaranteed to be run on the core thread.
 
 The destructor is always assumed to be executed on the core thread. For this reason you must ensure never to store references to CoreObjectCore on the simulation thread, because if they go out of scope there it will trigger an error. Similar rule applies to @ref bs::CoreObject "CoreObjects" as they shouldn't be stored on the core thread.
 
 ### Synchronization {#coreThread_b_a_b}
-Earlier we mentioned that aside from handling construction/destruction the core objects also provide a way to synchronize between the two threads. The synchronization is always one way, from @ref bs::CoreObject "CoreObject" to @ref bs::CoreObjectCore "CoreObjectCore". 
+Earlier we mentioned that aside from handling construction/destruction the core objects also provide a way to synchronize between the two threads. The synchronization is always one way, from @ref bs::CoreObject "CoreObject" to @ref bs::ct::CoreObject "ct::CoreObject". 
 
-Synchronization should happen whenever some property on the @ref bs::CoreObject "CoreObject" changes, that you would wish to make available on the core thread. To synchronize implement the @ref bs::CoreObject::syncToCore(FrameAlloc*) "CoreObject::syncToCore" method, which generates the data for synchronization, and @ref bs::CoreObjectCore::syncToCore "CoreObjectCore::syncToCore" which accepts it.
+Synchronization should happen whenever some property on the @ref bs::CoreObject "CoreObject" changes, that you would wish to make available on the core thread. To synchronize implement the @ref bs::CoreObject::syncToCore(FrameAlloc*) "CoreObject::syncToCore" method, which generates the data for synchronization, and @ref bs::ct::CoreObject::syncToCore "ct::CoreObject::syncToCore" which accepts it.
 
 The synchronized data is transfered between the objects in the form of raw bytes, within the @ref bs::CoreSyncData "CoreSyncData" structure. You can use @ref bs::rttiGetElemSize "rttiGetElemSize" and @ref bs::rttiWriteElem "rttiWriteElem" to encode fields into raw memory, and @ref bs::rttiReadElem "rttiReadElem" to decode them. See the manual about [rtti](@ref rtti) for more information about serialization. @ref bs::CoreObject::syncToCore(FrameAlloc*) "CoreObject::syncToCore" is provided an instance of @ref bs::FrameAlloc "FrameAlloc" which should be used for allocating the serialization buffer. This is an allocator that is fast and doesn't require explicit memory deallocation making it perfect for synchronization. A simple synchronization example would look like so:
 ~~~~~~~~~~~~~{.cpp}
@@ -127,7 +127,7 @@ void MyCoreObjectCore::syncToCore(const CoreSyncData& data)
 
 Whenever you need to trigger synchronization you must call @ref bs::CoreObject::markCoreDirty "CoreObject::markCoreDirty" which notifies the system that synchronization is required. This will in turn trigger a call to @ref bs::CoreObject::syncToCore(FrameAlloc*) "CoreObject::syncToCore" method you implemented earlier. Synchronization happens automatically for all dirty core objects once per frame. Optionally you may call @ref bs::CoreObject::syncToCore() "CoreObject::syncToCore" to manually queue the synchronization.
 
-See implementation of @ref bs::Light "Light" and @ref bs::LightCore "LightCore" in "BsLight.cpp" for a simple example of synchronization.
+See implementation of @ref bs::Light "Light" and @ref bs::ct::Light "ct::Light" in "BsLight.cpp" for a simple example of synchronization.
 
 ### Dependencies {#coreThread_b_a_c}
 Core objects might be dependant on other core objects. For example a @ref bs::Material "Material" is dependant on a @ref bs::Shader "Shader". Whenever the shader's object is marked as dirty the material might need to perform synchronization as well. In general whenever a dependancy core object is marked as dirty, its dependant will be synchronized as well.
@@ -144,8 +144,8 @@ This ensures that @ref bs::CoreObject::initialize "CoreObject::initialize" has a
 ## Other features {#coreThread_b_c}
 Core objects also have some other potentially useful features:
  - @ref bs::CoreObject::getInternalID "CoreObject::getInternalID" will return a globally unique ID for the core object
- - @ref bs::CoreObject::destroy "CoreObject::destroy" will destroy the core object and its core thread counterpart. You do not need to call this manually as it will be automatically called when the object goes out of scope (is no longer referenced). The core thread counterpart (@ref bs::CoreObjectCore "CoreObjectCore") will not be destroyed if something on the core thread is still holding a reference to it.
+ - @ref bs::CoreObject::destroy "CoreObject::destroy" will destroy the core object and its core thread counterpart. You do not need to call this manually as it will be automatically called when the object goes out of scope (is no longer referenced). The core thread counterpart (@ref bs::ct::CoreObject "ct::CoreObject") will not be destroyed if something on the core thread is still holding a reference to it.
  - Override @ref bs::CoreObject::initialize "CoreObject::initialize" or @ref bs::CoreObject::destroy "CoreObject::destroy" methods instead of using the constructor/destructor. This ensures that your initialization code runs after things like serialization, and also allows you to call virtual methods.
  - You can construct a core object without a core thread counterpart. Simply don't override @ref bs::CoreObject::createCore "CoreObject::createCore".
- - You can construct a core object with a @ref bs::CoreObjectCore "CoreObjectCore" that isn't initialized on the core thread by setting the @ref bs::CoreObject "CoreObject" constructor parameter `requiresCoreInit` to false.
+ - You can construct a core object with a @ref bs::ct::CoreObject "CoreObject" that isn't initialized on the core thread by setting the @ref bs::CoreObject "CoreObject" constructor parameter `requiresCoreInit` to false.
  - Core objects always hold a shared pointer to themselves. Use @ref bs::CoreObject::getThisPtr "CoreObject::getThisPtr" to access it.

Documentation/Manuals/Native/gpuPrograms.md

@@ -4,7 +4,7 @@ GPU programs									{#gpuPrograms}
 
 GPU programs are programmable parts of the GPU pipeline, in other literature often called shaders (Banshee uses the word shader for a higher level concept, see the [material](@ref materials) manual).
 
-GPU programs in Banshee are represented with the @ref bs::GpuProgram "GpuProgram" and @ref bs::GpuProgramCore "GpuProgramCore" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
+GPU programs in Banshee are represented with the @ref bs::GpuProgram "GpuProgram" and @ref bs::ct::GpuProgram "ct::GpuProgram" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
 
 In this manual we will focus on the simulation thread implementation, and then note the differences in the core thread version at the end.
 
@@ -43,28 +43,28 @@ There are two types of pipeline objects: @ref bs::GraphicsPipelineState "Graphic
 
 Example to create a graphics pipeline:
 ~~~~~~~~~~~~~{.cpp}
-PIPELINE_STATE_CORE_DESC desc;
+PIPELINE_STATE_DESC desc;
 desc.vertexProgram = ...
 desc.fragmentProgram = ...;
 desc.geometryProgram = ...;
 desc.hullProgram = ...;
 desc.domainProgram = ...;
 
-SPtr<GraphicsPipelineStateCore> graphicsPipeline = GraphicsPipelineStateCore::create(desc);
+SPtr<GraphicsPipelineState> graphicsPipeline = GraphicsPipelineState::create(desc);
 ~~~~~~~~~~~~~
 
 Example to create a compute pipeline:
 ~~~~~~~~~~~~~{.cpp}
-SPtr<GpuProgramCore> computeProgram = ...;
-SPtr<ComputePipelineStateCore> computePipeline = ComputePipelineStateCore::create(computeProgram);
+SPtr<GpuProgram> computeProgram = ...;
+SPtr<ComputePipelineState> computePipeline = ComputePipelineState::create(computeProgram);
 ~~~~~~~~~~~~~
 
-Once created the pipeline can be bound for rendering by calling @ref bs::RenderAPICore::setGraphicsPipeline "RenderAPICore::setGraphicsPipeline" or @ref bs::RenderAPI::setComputePipeline "RenderAPI::setComputePipeline".
+Once created the pipeline can be bound for rendering by calling @ref bs::ct::RenderAPI::setGraphicsPipeline "ct::RenderAPI::setGraphicsPipeline" or @ref bs::RenderAPI::setComputePipeline "RenderAPI::setComputePipeline".
 
 ~~~~~~~~~~~~~{.cpp}
 // Bind pipeline for use (continued from above)
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setGraphicsPipeline(graphicsPipeline);
 // Or: rapi.setComputePipeline(computePipeline);
 ~~~~~~~~~~~~~
@@ -104,9 +104,9 @@ As you can see we must first retrieve a handle to the parameter, and then we can
 See the [render API manual](@ref renderAPI) for more information about how to set and bind GPU program parameters.
 
 # Core thread GPU programs {#gpuPrograms_e}
-So far we have only talked about the simulation thread @ref bs::GpuProgram "GpuProgram" but have ignored the core thread @ref bs::GpuProgramCore "GpuProgramCore". The functionality between the two is mostly the same, with the major difference being that operations performed on the core thread version are immediate. So calls to @ref bs::GpuProgramCore::isCompiled() "GpuProgramCore::isCompiled" and @ref bs::GpuProgramCore::getCompileErrorMessage() "GpuProgramCore::getCompileErrorMessage" don't require any waiting.
+So far we have only talked about the simulation thread @ref bs::GpuProgram "GpuProgram" but have ignored the core thread @ref bs::ct::GpuProgram "ct::GpuProgram". The functionality between the two is mostly the same, with the major difference being that operations performed on the core thread version are immediate. So calls to @ref bs::ct::GpuProgram::isCompiled() "ct::GpuProgram::isCompiled" and @ref bs::ct::GpuProgram::getCompileErrorMessage() "ct::GpuProgram::getCompileErrorMessage" don't require any waiting.
 
-Addtionally the core thread object can provide information about vertex input declaration. Vertex input declaration is only available for vertex shaders, and it defines in what format does the GPU program expect vertices to be in. This can be useful for setting up your meshes in the valid format. Use @ref bs::GpuProgramCore::getInputDeclaration "GpuProgramCore::getInputDeclaration" to retrieve the @ref bs::VertexDeclarationCore "VertexDeclaration". Check out the [mesh](@ref meshes) manual for more information on how to use vertex declarations.
+Addtionally the core thread object can provide information about vertex input declaration. Vertex input declaration is only available for vertex shaders, and it defines in what format does the GPU program expect vertices to be in. This can be useful for setting up your meshes in the valid format. Use @ref bs::ct::GpuProgram::getInputDeclaration "ct::GpuProgram::getInputDeclaration" to retrieve the @ref bs::ct::VertexDeclaration "ct::VertexDeclaration". Check out the [mesh](@ref meshes) manual for more information on how to use vertex declarations.
 
 # OpenGL specifics {#gpuPrograms_f}
 When creating vertex inputs for a GPU program written in GLSL a set of built-in variables are provided:

Documentation/Manuals/Native/materials.md

@@ -2,9 +2,9 @@ Materials									{#materials}
 ===============
 [TOC]
 
-A material controls how is an object rendered. In Banshee it is represented with @ref bs::Material "Material" and @ref bs::MaterialCore "MaterialCore" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
+A material controls how is an object rendered. In Banshee it is represented with @ref bs::Material "Material" and @ref bs::ct::Material "ct::Material" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
 
-We'll focus on the simulation thread @ref bs::Material "Material" throughout this manual, but aside from the `Core` suffix there are no major differences between the two interfaces.
+We'll focus on the simulation thread @ref bs::Material "Material" throughout this manual, but aside from the `ct` namespace there are no major differences between the two interfaces.
 
 Internally material contains a set of GPU programs, render states and GPU program parameters. GPU programs and render states are immutable and are controlled by the @ref bs::Shader "Shader" assigned to the material. The parameters can be modified by the interface provided by the material, and this parameter access actually constitutes the bulk of the material's interface. Essentially materials can be thought of as shader "instances".
 
@@ -46,8 +46,8 @@ Now that we know how to create a pass, we can use one or multiple passes to init
 
 To create a technique call @ref bs::Technique::create "Technique::create" and provide it with:
  - One or multiple passes
- - Supported render API name: Use built-in `RenderAPIAny` to signal that the technique works on any API, or use the render API identifier to signal that it only works on a specific one. By default supported identifiers are: `"VulkanRenderAPI"`, `"D3D11RenderAPI"`, `"GLRenderAPI"`, but more can be added via plugins. In general those identifiers are returned from @ref bs::RenderAPICore::getName "RenderAPICore::getName". Most users should be okay by providing `RenderAPIAny`.
- - Supported renderer name: Use built-in `RendererAny` to signal that the technique works on any renderer, or use the renderer identifier to signal that it only works on a specific one. By default the only supported identifier is `"RenderBeast"`, but more can be added via plugins. In general those identifiers are returned from @ref bs::Renderer::getName "Renderer::getName". Most users should be okay by providing `RendererAny`.
+ - Supported render API name: Use built-in `RenderAPIAny` to signal that the technique works on any API, or use the render API identifier to signal that it only works on a specific one. By default supported identifiers are: `"VulkanRenderAPI"`, `"D3D11RenderAPI"`, `"GLRenderAPI"`, but more can be added via plugins. In general those identifiers are returned from @ref bs::ct::RenderAPI::getName "ct::RenderAPI::getName". Most users should be okay by providing `RenderAPIAny`.
+ - Supported renderer name: Use built-in `RendererAny` to signal that the technique works on any renderer, or use the renderer identifier to signal that it only works on a specific one. By default the only supported identifier is `"RenderBeast"`, but more can be added via plugins. In general those identifiers are returned from @ref bs::ct::Renderer::getName "ct::Renderer::getName". Most users should be okay by providing `RendererAny`.
  - An optional list of tags that allows renderer to pick which technique to use when rendering objects. Can be left empty in most cases.
 
 For example:
@@ -185,7 +185,7 @@ albedoParam.set(Texture::White);
 # Rendering with material {#materials_d}
 From the simulation thread you cannot use material to render manually (you must instead use GPU programs and states manually as described by the [render API](@ref renderAPI) manual). You are instead expected to set the material on a @ref bs::Renderable "Renderable" object which will then be used for rendering automatically. Read the [renderer](@ref renderer) manual for more information.
 
-Core thread gives you more flexibility and you can use @ref bs::RendererUtility::setPass "RendererUtility::setPass" to bind a specific pass from a material to the pipeline, and @ref bs::RendererUtility::setPassParams "RendererUtility::setPassParams" to bind material parameters for a specific pass. 
+Core thread gives you more flexibility and you can use @ref bs::ct::RendererUtility::setPass "ct::RendererUtility::setPass" to bind a specific pass from a material to the pipeline, and @ref bs::ct::RendererUtility::setPassParams "ct::RendererUtility::setPassParams" to bind material parameters for a specific pass. 
 
 In order to retrieve a set of per-pass @ref bs::GpuParams "GpuParams" that can be used for binding directly to the pipeline, call @ref bs::Material::createParamsSet "Material::createParamsSet", followed by @ref bs::Material::updateParamsSet "Material::updateParamsSet". You are required to call @ref bs::Material::updateParamsSet "Material::updateParamsSet" whenever material parameters change, in order to transfer the new data to @ref bs::GpuParams "GpuParams".
 

Documentation/Manuals/Native/meshes.md

@@ -2,7 +2,7 @@ Meshes									{#meshes}
 ===============
 [TOC]
 
-Mesh is an object represented by a set of points, their properties and a set of primitives formed by those points. In Banshee mesh is represented with the @ref bs::Mesh "Mesh" and @ref bs::MeshCore "MeshCore" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
+Mesh is an object represented by a set of points, their properties and a set of primitives formed by those points. In Banshee mesh is represented with the @ref bs::Mesh "Mesh" and @ref bs::ct::Mesh "ct::Mesh" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
 
 We're going to focus on the simulation thread implementation in this manual, and then note the differences in the core thread version at the end.
 
@@ -127,15 +127,15 @@ To use a mesh for rendering you need to bind its vertex buffer(s), index buffer,
 
 See the [render API](@ref renderAPI) manual for more information on how to manually execute rendering commands.
 
-If working on the core thread you can use the helper @ref bs::RendererUtility::draw "RendererUtility::draw" method that performs these operations for you.
+If working on the core thread you can use the helper @ref bs::ct::RendererUtility::draw "ct::RendererUtility::draw" method that performs these operations for you.
 
 # Saving/loading {#meshes_e}
 A mesh is a @ref bs::Resource "Resource" and can be saved/loaded like any other. See the [resource](@ref resources) manual.
 
 # Core thread meshes {#meshes_f}
-So far we have only talked about the simulation thread @ref bs::Mesh "Mesh" but have ignored the core thread @ref bs::MeshCore "MeshCore". The functionality between the two is mostly the same, with the major difference being that the core thread version doesn't have asychronous write/read methods, and those operations are instead performed immediately.
+So far we have only talked about the simulation thread @ref bs::Mesh "Mesh" but have ignored the core thread @ref bs::ct::Mesh "ct::Mesh". The functionality between the two is mostly the same, with the major difference being that the core thread version doesn't have asychronous write/read methods, and those operations are instead performed immediately.
 
-You can also use the core thread version to access and manipulate vertex and index buffers directly (including binding them to the pipeline as described earlier). Use @ref bs::MeshCore::getVertexData "MeshCore::getVertexData" to retrieve information about all @ref bs::VertexBufferCore "vertex buffers", @ref bs::MeshCore::getIndexBuffer "MeshCore::getIndexBuffer" to retrieve the @ref bs::IndexBufferCore "index buffer" and @ref bs::MeshCore::getVertexDesc "MeshCore::getVertexDesc" to retrieve the @ref bs::VertexDataDesc "vertex description".
+You can also use the core thread version to access and manipulate vertex and index buffers directly (including binding them to the pipeline as described earlier). Use @ref bs::ct::Mesh::getVertexData "ct::Mesh::getVertexData" to retrieve information about all @ref bs::ct::VertexBuffer "vertex buffers", @ref bs::ct::Mesh::getIndexBuffer "ct::Mesh::getIndexBuffer" to retrieve the @ref bs::ct::IndexBuffer "index buffer" and @ref bs::ct::Mesh::getVertexDesc "ct::Mesh::getVertexDesc" to retrieve the @ref bs::VertexDataDesc "vertex description".
 
 # Advanced meshes {#meshes_g}
 So far we have described the use of standard meshes. And while the described meshes can be used for all purposes, when we have a mesh that is updated often (every frame or every few frames) it can be beneficial for performance to use a different mesh type. This is because updates to a normal mesh can introduce GPU-CPU synchronization points if that mesh is still being used by the GPU while we are updating it (which can happen often).

Documentation/Manuals/Native/renderAPI.md

@@ -2,7 +2,7 @@ Render API									{#renderAPI}
 ===============
 [TOC]
 
-Render API is an interface that allows you to perform low-level rendering operations akin to DirectX or OpenGL. In Banshee this API is provided through the @ref bs::RenderAPI "RenderAPI" for the simulation thread, and @ref bs::RenderAPICore "RenderAPICore" for the core thread. If you are confused by the dual nature of  objects, read the [core thread](@ref coreThread) manual. 
+Render API is an interface that allows you to perform low-level rendering operations akin to DirectX or OpenGL. In Banshee this API is provided through the @ref bs::RenderAPI "RenderAPI" for the simulation thread, and @ref bs::ct::RenderAPI "ct::RenderAPI" for the core thread. If you are confused by the dual nature of objects, read the [core thread](@ref coreThread) manual. 
 
 For the remainder of this manual we'll focus on the core thread portion of the API, but both provide essentially identical functionality. The main difference that the execution of commands on the simulation thread isn't immediate, instead they are queued on an internal queue which is sent to the core thread at the end of the frame.
 
@@ -28,19 +28,19 @@ We'll cover each step of this process, and at the end also show an alternate pip
 # Render targets {#renderAPI_a}
 Before any rendering can be done you must bind at least one render target. To learn more about, and how to create a render target check out the [render target](@ref renderTargets) manual. 
 
-Binding a render target involves calling @ref bs::RenderAPICore::setRenderTarget "RenderAPICore::setRenderTarget". This will cause any rendering to be output to the entirety of the render target. Optionally you can also call @ref bs::RenderAPICore::setViewport "RenderAPICore::setViewport" to select a sub-rectangle of the target to render to. 
+Binding a render target involves calling @ref bs::ct::RenderAPI::setRenderTarget "ct::RenderAPI::setRenderTarget". This will cause any rendering to be output to the entirety of the render target. Optionally you can also call @ref bs::ct::RenderAPI::setViewport "ct::RenderAPI::setViewport" to select a sub-rectangle of the target to render to. 
 
-Binding a render target means you cannot use it for reading within a GPU program. However if your render target has a depth-buffer you can optionally set the `readOnlyDepthStencil` parameter of @ref bs::RenderAPICore::setRenderTarget "RenderAPICore::setRenderTarget" to true, which will allow you to have a depth buffer be bound for both depth-testing and reading from the GPU program.
+Binding a render target means you cannot use it for reading within a GPU program. However if your render target has a depth-buffer you can optionally set the `readOnlyDepthStencil` parameter of @ref bs::ct::RenderAPI::setRenderTarget "ct::RenderAPI::setRenderTarget" to true, which will allow you to have a depth buffer be bound for both depth-testing and reading from the GPU program.
  
-Before doing any rendering it's always good to clear the render target to some default value. Use @ref bs::RenderAPICore::clearRenderTarget "RenderAPICore::clearRenderTarget" to clear the entire target, or @ref bs::RenderAPICore::clearViewport "RenderAPICore::clearViewport" to clear just the viewport portion of the target. When clearing you can choose whether to clear color, depth or stencil buffers (or all) determined by @ref bs::FrameBufferType "FrameBufferType" flags. You can also choose the values to clear each of the buffers to. And finally if your render target has multiple surfaces, you can choose to clear only some of the surfaces by providing a bitmask.
+Before doing any rendering it's always good to clear the render target to some default value. Use @ref bs::ct::RenderAPI::clearRenderTarget "ct::RenderAPI::clearRenderTarget" to clear the entire target, or @ref bs::ct::RenderAPI::clearViewport "ct::RenderAPI::clearViewport" to clear just the viewport portion of the target. When clearing you can choose whether to clear color, depth or stencil buffers (or all) determined by @ref bs::FrameBufferType "FrameBufferType" flags. You can also choose the values to clear each of the buffers to. And finally if your render target has multiple surfaces, you can choose to clear only some of the surfaces by providing a bitmask.
 
-Once you are done rendering make sure to call @ref bs::RenderAPICore::swapBuffers "RenderAPICore::swapBuffers" if your render target has multiple buffers (like a window). This will swap the buffers and present the rendered image on the screen.
+Once you are done rendering make sure to call @ref bs::ct::RenderAPI::swapBuffers "ct::RenderAPI::swapBuffers" if your render target has multiple buffers (like a window). This will swap the buffers and present the rendered image on the screen.
 
 A simple example covering all these commands:
 ~~~~~~~~~~~~~{.cpp}
 SPtr<RenderTarget> myRt = ...; // Assuming we created this earlier, and it's a double-buffered window
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setRenderTarget(myRt);
 rapi.setViewport(Rect2(0.5f, 0.0f, 0.5f, 1.0f)); // Draw only to the right side of the target
 
@@ -51,11 +51,11 @@ rapi.swapBuffers();
 ~~~~~~~~~~~~~
  
 # Pipeline state {#renderAPI_b}
-Before executing the drawing operation you must set up an @ref bs::GraphicsPipelineStateCore "GraphicsPipelineStateCore" object, which contains a set of fixed and programmable states that control primitive rendering. This includes GPU programs (e.g. vertex/fragment) and fixed states (depth-stencil, blend, rasterizer).
+Before executing the drawing operation you must set up an @ref bs::ct::GraphicsPipelineState "ct::GraphicsPipelineState" object, which contains a set of fixed and programmable states that control primitive rendering. This includes GPU programs (e.g. vertex/fragment) and fixed states (depth-stencil, blend, rasterizer).
 
-To create a pipeline state you must fill out @ref bs::PIPELINE_STATE_CORE_DESC "PIPELINE_STATE_CORE_DESC" descriptor, and use it to construct the state, like so:
+To create a pipeline state you must fill out @ref bs::PIPELINE_STATE_DESC "PIPELINE_STATE_DESC" descriptor, and use it to construct the state, like so:
 ~~~~~~~~~~~~~{.cpp}
-PIPELINE_STATE_CORE_DESC desc;
+PIPELINE_STATE_DESC desc;
 // Fixed states (see below on how to create them)
 desc.blendState = ...;
 desc.rasterizerState = ...;
@@ -68,43 +68,43 @@ desc.geometryProgram = ...;
 desc.hullProgram = ...;
 desc.domainProgram = ...;
 
-SPtr<GraphicsPipelineStateCore> state = GraphicsPipelineStateCore::create(desc);
+SPtr<GraphicsPipelineState> state = GraphicsPipelineState::create(desc);
 ~~~~~~~~~~~~~
 
-Once created the pipeline can be bound for rendering by calling @ref bs::RenderAPICore::setGraphicsPipeline "RenderAPICore::setGraphicsPipeline".
+Once created the pipeline can be bound for rendering by calling @ref bs::ct::RenderAPI::setGraphicsPipeline "ct::RenderAPI::setGraphicsPipeline".
 
 ~~~~~~~~~~~~~{.cpp}
 // Bind pipeline for use (continued from above)
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setGraphicsPipeline(state);
 ~~~~~~~~~~~~~
 
-We continue below with explanation on how to create fixed and programmable states required to initialize GraphicsPipelineStateCore.
+We continue below with explanation on how to create fixed and programmable states required to initialize GraphicsPipelineState.
 
 ## Fixed pipeline states {#renderAPI_b_a}
 Fixed pipeline states allow you to control (to some extent) non-programmable parts of the pipeline. This includes anything from blend operations, rasterization mode to depth testing. Setting these states is optional and if not set, default values will be used.
 
 States can be created by:
- - @ref bs::DepthStencilStateCore "DepthStencilStateCore" - Populate @ref bs::DEPTH_STENCIL_STATE_DESC "DEPTH_STENCIL_STATE_DESC" and call @ref bs::DepthStencilStateCore::create "DepthStencilStateCore::create" 
- - @ref bs::BlendStateCore "BlendStateCore" - Populate @ref bs::BLEND_STATE_DESC "BLEND_STATE_DESC" and call @ref bs::BlendStateCore::create "BlendStateCore::create" 
- - @ref bs::RasterizerStateCore "RasterizerStateCore" - Populate @ref bs::RASTERIZER_STATE_DESC "RASTERIZER_STATE_DESC" and call @ref bs::RasterizerStateCore::create "RasterizerStateCore::create" 
+ - @ref bs::ct::DepthStencilState "ct::DepthStencilState" - Populate @ref bs::DEPTH_STENCIL_STATE_DESC "DEPTH_STENCIL_STATE_DESC" and call @ref bs::ct::DepthStencilState::create "ct::DepthStencilState::create" 
+ - @ref bs::ct::BlendState "ct::BlendState" - Populate @ref bs::BLEND_STATE_DESC "BLEND_STATE_DESC" and call @ref bs::ct::BlendState::create "ct::BlendState::create" 
+ - @ref bs::ct::RasterizerState "ct::RasterizerState" - Populate @ref bs::RASTERIZER_STATE_DESC "RASTERIZER_STATE_DESC" and call @ref bs::ct::RasterizerState::create "ct::RasterizerState::create" 
  
 We won't explain what each of the states does. For that you can check out the class documentation of the states themselves, or familiarize yourself with the modern GPU pipeline in general, as the states mirror it exactly.
 
 ## GPU programs {#renderAPI_b_b}
 The pipeline state also requires you to bind at least one GPU program (programmable state). At minimum you will need to bind a vertex program, while in most cases you will also need a fragment program. Optionally you can also bind geometry, hull or domain programs for more advanced functionality. To learn how to create GPU programs see [GPU program manual](@ref gpuPrograms).
 
-Most GPU programs also accept a number of parameters, whether textures, buffers, sampler states or primitive values like floats or integers. These parameters are accessed through @ref bs::GpuParamsCore "GpuParamsCore" object. You can use this object to assign individual parameters and then bind the object to the render API using @ref bs::RenderAPICore::setGpuParams "RenderAPICore::setGpuParams". See below for an example.
+Most GPU programs also accept a number of parameters, whether textures, buffers, sampler states or primitive values like floats or integers. These parameters are accessed through @ref bs::ct::GpuParams "ct::GpuParams" object. You can use this object to assign individual parameters and then bind the object to the render API using @ref bs::ct::RenderAPI::setGpuParams "ct::RenderAPI::setGpuParams". See below for an example.
 
 ~~~~~~~~~~~~~{.cpp}
 ... assuming graphics pipeline state and relevant GPU programs are created ...
-SPtr<GraphicsPipelineStateCore> state = ...;
-SPtr<GpuParamsCore> params = GpuParamsCore::create(state);
+SPtr<GraphicsPipelineState> state = ...;
+SPtr<GpuParams> params = GpuParams::create(state);
 
 // Retrieve GPU param handles we can then read/write to
-GpuParamVec2Core myVectorParam;
-GpuParamTextureCore myTextureParam;
+GpuParamVec2 myVectorParam;
+GpuParamTexture myTextureParam;
 
 params->getParam(GPT_FRAGMENT_PROGRAM, "myVector", myVectorParam); // Assuming "myVector" is the variable name in the program source code
 params->getTextureParam(GPT_FRAGMENT_PROGRAM, "myTexture", myTextureParam); // Assuming "myTexture" is the variable name in the program source code
@@ -113,30 +113,30 @@ myVectorParam.set(Vector2(1, 2));
 myTextureParam.set(myTexture); // Assuming we created "myTexture" earlier.
 
 // Bind parameters for use 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setGpuParams(params);
 ~~~~~~~~~~~~~
  
 All parameters are bound by first retrieving their handles, and then using those handles for parameter access. In the example above we show how to bind a texture and a 2D vector to a GPU program. Same approach follows for all available parameter types.
 
-After the parameters are set, we bind them to the pipeline by calling @ref bs::RenderAPICore::setGpuParams "RenderAPICore::setGpuParams".
+After the parameters are set, we bind them to the pipeline by calling @ref bs::ct::RenderAPI::setGpuParams "ct::RenderAPI::setGpuParams".
 
 ### Data parameters {#renderAPI_c_a_a} 
-Handles for data parameters like int, float, 2D vector, etc. can be retrieved by calling @ref bs::GpuParamsCore::getParam "GpuParamsCore::getParam" which can then be assigned to as shown above.
+Handles for data parameters like int, float, 2D vector, etc. can be retrieved by calling @ref bs::ct::GpuParams::getParam "ct::GpuParams::getParam" which can then be assigned to as shown above.
 
-Alternatively you may also assign entire blocks of data parameters by calling @ref bs::GpuParamsCore::setParamBlockBuffer(GpuProgramType,const String&,const ParamsBufferType&) "GpuParamsCore::setParamBlockBuffer". When assigning entire blocks you must create and populate the @ref bs::GpuParamBlockBuffer "GpuParamBlockBuffer" object manually.
+Alternatively you may also assign entire blocks of data parameters by calling @ref bs::ct::GpuParams::setParamBlockBuffer(GpuProgramType,const String&,const ParamsBufferType&) "ct::GpuParams::setParamBlockBuffer". When assigning entire blocks you must create and populate the @ref bs::GpuParamBlockBuffer "GpuParamBlockBuffer" object manually.
 
-When writing to buffers manually you must ensure to write to offsets the GPU program expects the data to be at. You can find thise information from @ref bs::GpuParamDesc "GpuParamDesc" structure accessible from @ref bs::GpuProgramCore::getParamDesc "GpuProgramCore::getParamDesc". 
+When writing to buffers manually you must ensure to write to offsets the GPU program expects the data to be at. You can find thise information from @ref bs::GpuParamDesc "GpuParamDesc" structure accessible from @ref bs::ct::GpuProgram::getParamDesc "ct::GpuProgram::getParamDesc". 
 
 ### Texture parameters {#renderAPI_c_a_b} 
-Handles for texture parameters can be retrieved by calling @ref bs::GpuParamsCore::getTextureParam "GpuParamsCore::getTextureParam", or @ref bs::GpuParamsCore::getLoadStoreTextureParam "GpuParamsCore::getLoadStoreTextureParam" if the texture should be bound for load-store operations.
+Handles for texture parameters can be retrieved by calling @ref bs::ct::GpuParams::getTextureParam "ct::GpuParams::getTextureParam", or @ref bs::ct::GpuParams::getLoadStoreTextureParam "ct::GpuParams::getLoadStoreTextureParam" if the texture should be bound for load-store operations.
 
 Learn more about textures and their different types in the [texture manual](@ref textures).
 
 ### Sampler state parameters {#renderAPI_c_a_c}
-Sampler states can be used to customize how is the texture sampled. You can retrieve a handle for a sampler state parameter by calling @ref bs::GpuParamsCore::getSamplerStateParam "GpuParamsCore::getSamplerStateParam".
+Sampler states can be used to customize how is the texture sampled. You can retrieve a handle for a sampler state parameter by calling @ref bs::ct::GpuParams::getSamplerStateParam "ct::GpuParams::getSamplerStateParam".
 
-Sampler states are represented by the @ref bs::SamplerStateCore "SamplerStateCore" object, which you can create by populating the @ref bs::SAMPLER_STATE_DESC "SAMPLER_STATE_DESC" and calling @ref bs::SamplerStateCore::create "SamplerStateCore::create". 
+Sampler states are represented by the @ref bs::ct::SamplerState "ct::SamplerState" object, which you can create by populating the @ref bs::SAMPLER_STATE_DESC "SAMPLER_STATE_DESC" and calling @ref bs::ct::SamplerState::create "ct::SamplerState::create". 
 
 An example to create and bind a sampler state:
 ~~~~~~~~~~~~~{.cpp}
@@ -147,11 +147,11 @@ ssDesc.magFilter = FO_POINT;
 ssDesc.minFilter = FO_POINT;
 ssDesc.mipFilter = FO_POINT;
 
-SPtr<SamplerStateCore> mySamplerState = SamplerStateCore::create(ssDesc);
+SPtr<SamplerState> mySamplerState = SamplerState::create(ssDesc);
 
-SPtr<GpuParamsCore> params = ...;
+SPtr<GpuParams> params = ...;
 
-GpuParamSampStateCore mySamplerParam;
+GpuParamSampState mySamplerParam;
 params->getSamplerStateParam(GPT_FRAGMENT_PROGRAM, "mySamplerState", mySamplerParam); // Assuming "mySamplerState" is the variable name in the program source code
 
 mySamplerParam.set(mySamplerState);
@@ -159,31 +159,31 @@ mySamplerParam.set(mySamplerState);
 ~~~~~~~~~~~~~
 
 # Vertex buffer {#renderAPI_d}
-@ref bs::VertexBufferCore "Vertex buffer" is a buffer that contains all vertices of the object we wish to render. When drawing the vertices will be interpreted as primitives (either points, lines or triangles) and rendered. Each vertex can have one or multiple properties associated with it.
+@ref bs::ct::VertexBuffer "Vertex buffer" is a buffer that contains all vertices of the object we wish to render. When drawing the vertices will be interpreted as primitives (either points, lines or triangles) and rendered. Each vertex can have one or multiple properties associated with it.
 
-To create a vertex buffer call @ref bs::VertexBufferCore::create "VertexBufferCore::create". You need to know the size of an individual vertex (determined by the properties each vertex requires) and the number of vertices. Optionally if your vertex buffer is used for output from the geometry GPU program you can toggle on the `streamOut` parameter.
+To create a vertex buffer call @ref bs::ct::VertexBuffer::create "ct::VertexBuffer::create". You need to know the size of an individual vertex (determined by the properties each vertex requires) and the number of vertices. Optionally if your vertex buffer is used for output from the geometry GPU program you can toggle on the `streamOut` parameter.
 
-Once the vertex buffer is created you will want to populate it with some data (detailed below) and then bind it to the pipeline using @ref bs::RenderAPICore::setVertexBuffers "RenderAPICore::setVertexBuffers". You can bind one or multiple vertex buffers at once. They all must have the same vertex counts but can have different properties, which will all be fed to the pipeline when rendering.
+Once the vertex buffer is created you will want to populate it with some data (detailed below) and then bind it to the pipeline using @ref bs::ct::RenderAPI::setVertexBuffers "ct::RenderAPI::setVertexBuffers". You can bind one or multiple vertex buffers at once. They all must have the same vertex counts but can have different properties, which will all be fed to the pipeline when rendering.
 
 Creation of an example vertex buffer:
 ~~~~~~~~~~~~~{.cpp}
 // Create a vertex buffer containing 8 vertices with just a vertex position
-SPtr<VertexBufferCore> vb = VertexBufferCore::create(sizeof(Vector3), 8);
+SPtr<VertexBuffer> vb = VertexBuffer::create(sizeof(Vector3), 8);
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setVertexBuffers(0, { vb });
 ~~~~~~~~~~~~~
 
 ## Reading/writing {#renderAPI_d_a}
-@ref bs::VertexBufferCore "VertexBuffer" provides a couple of way to read and write data from/to it:
- - @ref bs::VertexBufferCore::lock "VertexBufferCore::lock" locks a specific region of the vertex buffer and returns a pointer you can then use for reading and writing. Make sure to specify valid @ref bs::GpuLockOptions "GpuLockOptions" signaling whether you are planning on read or writing from the buffer. Once done call @ref bs::VertexBufferCore::unlock "VertexBufferCore::unlock" to make the locked region accessible to the GPU again.
- - @ref bs::VertexBufferCore::readData "VertexBufferCore::readData" and @ref bs::VertexBufferCore::writeData "VertexBufferCore::writeData" to write or read entire blocks at once, but are more or less similar to the previous method.
- - @ref bs::VertexBufferCore::copyData "VertexBufferCore::copyData" can be used to efficiently copy data between two vertex buffers.
+@ref bs::ct::VertexBuffer "ct::VertexBuffer" provides a couple of way to read and write data from/to it:
+ - @ref bs::ct::VertexBuffer::lock "ct::VertexBuffer::lock" locks a specific region of the vertex buffer and returns a pointer you can then use for reading and writing. Make sure to specify valid @ref bs::GpuLockOptions "GpuLockOptions" signaling whether you are planning on read or writing from the buffer. Once done call @ref bs::ct::VertexBuffer::unlock "ct::VertexBuffer::unlock" to make the locked region accessible to the GPU again.
+ - @ref bs::ct::VertexBuffer::readData "ct::VertexBuffer::readData" and @ref bs::ct::VertexBuffer::writeData "ct::VertexBuffer::writeData" to write or read entire blocks at once, but are more or less similar to the previous method.
+ - @ref bs::ct::VertexBuffer::copyData "ct::VertexBuffer::copyData" can be used to efficiently copy data between two vertex buffers.
 
 An example of writing to the vertex buffer:
 ~~~~~~~~~~~~~{.cpp}
 // Create a vertex buffer containing 8 vertices with just a vertex position
-SPtr<VertexBufferCore> vb = VertexBufferCore::create(sizeof(Vector3), 8);
+SPtr<VertexBuffer> vb = VertexBuffer::create(sizeof(Vector3), 8);
 
 Vector3* positions = (Vector3)vb->lock(0, sizeof(Vector3) * 8, GBL_WRITE_ONLY_DISCARD);
 ... write to the positions array ...
@@ -204,52 +204,52 @@ You can then use methods like @ref bs::VertexDataDesc::getElementSize "VertexDat
 To learn more about vertex descriptors read the [mesh](@ref meshes) manual.
 
 ## Vertex declaration {#renderAPI_d_b}
-Before a vertex buffer can be used for rendering, you need to tell the pipeline in what format are its vertices structured in. You do that by creating a @ref bs::VertexDeclarationCore "VertexDeclarationCore" object using the @ref bs::VertexDataDesc "VertexDataDesc" we described in the previous section. This object can then be passed to @ref bs::RenderAPICore::setVertexDeclaration "RenderAPICore::setVertexDeclaration" to bind it to the pipeline.
+Before a vertex buffer can be used for rendering, you need to tell the pipeline in what format are its vertices structured in. You do that by creating a @ref bs::ct::VertexDeclaration "ct::VertexDeclaration" object using the @ref bs::VertexDataDesc "VertexDataDesc" we described in the previous section. This object can then be passed to @ref bs::ct::RenderAPI::setVertexDeclaration "ct::RenderAPI::setVertexDeclaration" to bind it to the pipeline.
 
 For example:
 ~~~~~~~~~~~~~{.cpp}
 SPtr<VertexDataDesc> vertexDesc = ...; // Creating vertex desc as above
-SPtr<VertexDeclarationCore> vertexDecl = VertexDeclarationCore::create(vertexDesc);
+SPtr<VertexDeclaration> vertexDecl = VertexDeclaration::create(vertexDesc);
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setVertexDeclaration(vertexDecl);
 ~~~~~~~~~~~~~
 
 It is important that the vertex declaration contains properties needed by the bound vertex GPU program, as well as that it matches the vertex layout in the vertex buffer. See the [gpu program](@ref gpuPrograms) manual to learn how to retrieve vertex properties expected by a GPU program.
 
 # Index buffer {#renderAPI_e}
-Normally when you draw data from a vertex buffer, the vertices are assumed to form primitives sequentially (e.g. every three vertices is a triangle). By using an @ref bs::IndexBufferCore "index buffer" you an provide an additional layer of abstraction. Index buffer is fully optional, but when bound it will be used for forming primitives instead of the vertex buffer (i.e. every three indices will form a triangle). Each entry in an index buffer points to a vertex in the vertex buffer. This level of abstraction allows you to re-use the same vertex in multiple primitives, as well as create more optimal vertex order for GPU processing.
+Normally when you draw data from a vertex buffer, the vertices are assumed to form primitives sequentially (e.g. every three vertices is a triangle). By using an @ref bs::ct::IndexBuffer "index buffer" you an provide an additional layer of abstraction. Index buffer is fully optional, but when bound it will be used for forming primitives instead of the vertex buffer (i.e. every three indices will form a triangle). Each entry in an index buffer points to a vertex in the vertex buffer. This level of abstraction allows you to re-use the same vertex in multiple primitives, as well as create more optimal vertex order for GPU processing.
 
-To create an index buffer call @ref bs::IndexBufferCore::create "IndexBufferCore::create". It expects a number of indices, and the type of indices. Index type can be either 16- or 32-bit. To bind an index buffer to the pipeline call @ref bs::RenderAPICore::setIndexBuffer "RenderAPICore::setIndexBuffer".
+To create an index buffer call @ref bs::ct::IndexBuffer::create "ct::IndexBuffer::create". It expects a number of indices, and the type of indices. Index type can be either 16- or 32-bit. To bind an index buffer to the pipeline call @ref bs::ct::RenderAPI::setIndexBuffer "ct::RenderAPI::setIndexBuffer".
 
 Reading and writing from/to the index buffer has the identical interface to the vertex buffer, so we won't show it again.
 
 # Drawing {#renderAPI_f}
-Once all the previous states, programs and buffers have been set up, we can finally render our object. First of we must set up the type of primitives we wish to render by calling @ref bs::RenderAPICore::setDrawOperation "RenderAPICore::setDrawOperation" with a @ref bs::DrawOperationType "DrawOperationType" specifying the primitive type. This determines how the the vertices (or indices) in our buffers interpreted.
+Once all the previous states, programs and buffers have been set up, we can finally render our object. First of we must set up the type of primitives we wish to render by calling @ref bs::ct::RenderAPI::setDrawOperation "ct::RenderAPI::setDrawOperation" with a @ref bs::DrawOperationType "DrawOperationType" specifying the primitive type. This determines how the the vertices (or indices) in our buffers interpreted.
 
-After that you can issue a @ref bs::RenderAPICore::draw "RenderAPICore::draw" call if rendering without an index buffer. It expects the vertex index to start rendering from, and the number of vertices to render. The number of vertices must be divisible by the number of vertices expected by the @ref bs::DrawOperationType "DrawOperationType" you're using (e.g. three for triangles, two for lines, one for points). The vertices will then be pulled from the vertex buffers, processed by the fixed pipeline controlled by the states, and by the programmable pipeline controlled by the GPU programs and the output image will be rendered to the bound render target.
+After that you can issue a @ref bs::ct::RenderAPI::draw "ct::RenderAPI::draw" call if rendering without an index buffer. It expects the vertex index to start rendering from, and the number of vertices to render. The number of vertices must be divisible by the number of vertices expected by the @ref bs::DrawOperationType "DrawOperationType" you're using (e.g. three for triangles, two for lines, one for points). The vertices will then be pulled from the vertex buffers, processed by the fixed pipeline controlled by the states, and by the programmable pipeline controlled by the GPU programs and the output image will be rendered to the bound render target.
 
-If using an index buffer you should issue a @ref bs::RenderAPICore::drawIndexed "RenderAPICore::drawIndexed" call. Aside from vertex offset/count, it also expects an offset into the index buffer to start rendering from, and number of indices to render from. In this case the vertex offset will be added to every read index, allowing you to re-use the index buffer for potentially different geometry. 
+If using an index buffer you should issue a @ref bs::ct::RenderAPI::drawIndexed "ct::RenderAPI::drawIndexed" call. Aside from vertex offset/count, it also expects an offset into the index buffer to start rendering from, and number of indices to render from. In this case the vertex offset will be added to every read index, allowing you to re-use the index buffer for potentially different geometry. 
  
 And this wraps up the rendering pipeline. After this step your object should be rendered to your render target and ready to display. 
  
 # Compute {#renderAPI_g}
 The compute pipeline is a very simple pipeline that can be used for general purpose calculations. It is separate from the graphics pipeline we have been describing so far, but uses the same functionality, just in a more limited way. You don't have to set fixed states, render targets, vertex/index buffers and only one GPU program type is supported (compute GPU program).
 
-The pipeline is represented with the @ref bs::ComputePipelineStateCore "ComputePipelineStateCore" object, which must be initialized with the compute GPU program to use.
+The pipeline is represented with the @ref bs::ct::ComputePipelineState "ct::ComputePipelineState" object, which must be initialized with the compute GPU program to use.
 
-After creation use @ref bs::RenderAPICore::setComputePipeline "RenderAPICore::setComputePipeline" to bind the pipeline for further operations. When the pipeline is set up you can execute it by calling @ref bs::RenderAPICore::dispatchCompute "RenderAPICore::dispatchCompute". You should provide it a three dimensional number that determines how many instances of the currently bound GPU program to execute. The total number of executions will be X * Y * Z.
+After creation use @ref bs::ct::RenderAPI::setComputePipeline "ct::RenderAPI::setComputePipeline" to bind the pipeline for further operations. When the pipeline is set up you can execute it by calling @ref bs::ct::RenderAPI::dispatchCompute "ct::RenderAPI::dispatchCompute". You should provide it a three dimensional number that determines how many instances of the currently bound GPU program to execute. The total number of executions will be X * Y * Z.
 
 Since compute pipeline doesn't support render targets, you will want to use load-store textures for output. An example of a simple compute pipeline:
 ~~~~~~~~~~~~~{.cpp}
-SPtr<GpuProgramCore> computeProgram = ...;
+SPtr<GpuProgram> computeProgram = ...;
 
-SPtr<ComputePipelineStateCore> state = ComputePipelineStateCore::create(computeProgram);
-SPtr<GpuParamsCore> computeGpuParams = GpuParamsCore::create(state);
+SPtr<ComputePipelineState> state = ComputePipelineState::create(computeProgram);
+SPtr<GpuParams> computeGpuParams = GpuParams::create(state);
 
 ... optionally set some parameters ...
 
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setComputePipeline(state);
 rapi.setGpuParams(computeGpuParams);
 rapi.dispatchCompute(512, 512);
@@ -267,9 +267,9 @@ Use @ref bs::RenderAPI::getAPIInfo "RenderAPI::getAPIInfo" to receive the @ref b
 For convenience a specialized @ref bs::RenderAPI::convertProjectionMatrix "RenderAPI::convertProjectionMatrix" method is also provided, which converts a generic engine projection matrix, into a render API specific one.
 
 # Command buffers {#renderAPI_i}
-Almost all @ref bs::RenderAPICore "RenderAPICore" commands we talked about so far support @ref bs::CommandBuffer "CommandBuffer"s. Command buffers are optional, but they allow the rendering commands to be generated from threads other than the core thread.
+Almost all @ref bs::ct::RenderAPI "ct::RenderAPI" commands we talked about so far support @ref bs::ct::CommandBuffer "ct::CommandBuffer"s. Command buffers are optional, but they allow the rendering commands to be generated from threads other than the core thread.
 
-To create a command buffer call @ref bs::CommandBuffer::create "CommandBuffer::create" after which provide it to the relevant @ref bs::RenderAPICore "RenderAPICore" calls. Those commands will get recorded in the command buffer, but not executed. To actually execute the commands call @ref bs::RenderAPICore::submitCommandBuffer "RenderAPICore::submitCommandBuffer".
+To create a command buffer call @ref bs::ct::CommandBuffer::create "ct::CommandBuffer::create" after which provide it to the relevant @ref bs::ct::RenderAPI "ct::RenderAPI" calls. Those commands will get recorded in the command buffer, but not executed. To actually execute the commands call @ref bs::ct::RenderAPI::submitCommandBuffer "ct::RenderAPI::submitCommandBuffer".
 
 This allows rendering to be faster since work can be distributed over multiple CPU cores. Note that only command queuing can happen on a separate thread, command buffer creation and execution must still happen on the core thread.
 
@@ -277,14 +277,14 @@ Command buffer example:
 ~~~~~~~~~~~~~{.cpp}
 // Core thread
 SPtr<CommandBuffer> cmdBuffer = CommandBuffer::create(CBT_COMPUTE);
-SPtr<GpuProgramCore> computeProgram = ...;
-SPtr<GpuParamsCore> computeGpuParams = ...;
-SPtr<ComputePipelineStateCore> state = ComputePipelineStateCore::create(computeProgram);
+SPtr<GpuProgram> computeProgram = ...;
+SPtr<GpuParams> computeGpuParams = ...;
+SPtr<ComputePipelineState> state = ComputePipelineState::create(computeProgram);
 
 ... queue up worker thread(s) ...
 
 // Worker thread
-RenderAPICore& rapi = RenderAPICore::instance();
+RenderAPI& rapi = RenderAPI::instance();
 rapi.setComputePipeline(state, cmdBuffer);
 rapi.setGpuParams(computeGpuParams, cmdBuffer);
 rapi.dispatchCompute(512, 512, cmdBuffer);

Documentation/Manuals/Native/renderTargets.md

@@ -5,8 +5,8 @@ Render targets				{#renderTargets}
 Render targets represent destination surfaces onto which objects are rendered. They can be textures or windows.
 
 In Banshee render targets are represented with:
- - Windows - @ref bs::RenderWindow "RenderWindow" and @ref bs::RenderWindowCore "RenderWindowCore"
- - Textures - @ref bs::RenderTexture "RenderTexture" and @ref bs::RenderTextureCore "RenderTextureCore"
+ - Windows - @ref bs::RenderWindow "RenderWindow" and @ref bs::ct::RenderWindow "ct::RenderWindow"
+ - Textures - @ref bs::RenderTexture "RenderTexture" and @ref bs::ct::RenderTexture "ct::RenderTexture"
  
 Each type comes in two variants, both of which provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
 
@@ -120,9 +120,9 @@ Use `BS_MAX_MULTIPLE_RENDER_TARGETS` to learn what is the maximum supported numb
 ## Multi-sampled surfaces {#renderTargets_b_c}
 Same as windows, render textures can be created with support for multiple samples per pixel. This allows affects such as multi-sampled antialiasing and similar. To create a multi-sampled render texture simply create a @ref bs::Texture "Texture" with its `multisampleCount` parameter larger than one, which you then use to initialize a render texture. Make sure that all surfaces (including depth-stencil) in a render texture have the same number of samples.
 
-In order to display a multi-sampled render texture on the screen you need to resolve the texture into a non-multi-sampled one. For windows this is done automatically for you, but for textures you must do it manually. You can do it from the GPU program (render API dependant), or by calling @ref bs::TextureCore::copy "TextureCore::copy". 
+In order to display a multi-sampled render texture on the screen you need to resolve the texture into a non-multi-sampled one. For windows this is done automatically for you, but for textures you must do it manually. You can do it from the GPU program (render API dependant), or by calling @ref bs::ct::Texture::copy "ct::Texture::copy". 
 
-@ref bs::TextureCore::copy "TextureCore::copy" works only on the core thread, and it will copy contents of one texture to another texture. If you ensure that the source texture is multi-sampled but the destination is not, it will automatically resolve the multi-sampled texture.
+@ref bs::ct::Texture::copy "ct::Texture::copy" works only on the core thread, and it will copy contents of one texture to another texture. If you ensure that the source texture is multi-sampled but the destination is not, it will automatically resolve the multi-sampled texture.
 
 # Priority {#renderTargets_c}
 All render targets have a priority that can be set by calling @ref bs::RenderTarget::setPriority "RenderTarget::setPriority". This priority can be used as a hint to the renderer in which order should the targets be rendered to. Targets with higher priority will be rendered to before targets with lower priority. If you are rendering manually using the @ref bs::RenderAPI "RenderAPI" then this value is not used.

Documentation/Manuals/Native/renderer.md

@@ -79,26 +79,26 @@ light->setIntensity(1000.0f);
 # Creating your own renderer {#renderer_b}
 Renderer is the system that makes use of all the components we listed so far. Renderer isn't actually aware of scene objects and components, and instead operates on @ref bs::Camera "Camera", @ref bs::Renderable "Renderable" and @ref bs::Light "Light" types directly. These are the internal objects that are managed by @ref bs::CCamera "CCamera", @ref bs::CRenderable "CRenderable" and @ref bs::CLight "CLight", respectively. They provide the same interface as their component versions. They are also @ref bs::CoreObject "core objects", meaning they have both a simulation and a core thread counterparts.
 
-To create your own renderer you must implement the @ref bs::Renderer "Renderer" interface. The implementation should iterate over all renderable objects, cameras and lights and perform rendering according to your own rules. At the end of rendering, every render target in every active camera should be filled with an image of the rendered scene. During rendering you must consider mesh and material provided by the renderable objects, and apply lighting according to light objects. You should use the low level @ref bs::RenderAPI "RenderAPI" to render individual objects.
+To create your own renderer you must implement the @ref bs::ct::Renderer "ct::Renderer" interface. The implementation should iterate over all renderable objects, cameras and lights and perform rendering according to your own rules. At the end of rendering, every render target in every active camera should be filled with an image of the rendered scene. During rendering you must consider mesh and material provided by the renderable objects, and apply lighting according to light objects. You should use the low level @ref bs::RenderAPI "RenderAPI" to render individual objects.
 
 The renderer is mostly a core-thread system as then it has a more direct access to the @ref bs::RenderAPI "RenderAPI", as well as various utility functionality we'll describe later. Read the [core thread](@ref coreThread) manual for more information about the core thread and core objects, and the [render API](@ref renderAPI) manual on how to use the low level rendering functionality.
 
-The @ref bs::Renderer "Renderer" interface requires you to implement the following methods:
- - @ref bs::CoreRenderer::getName "Renderer::getName" - Returns a unique name of the renderer. This can be used by shader techniques to identify which renderer is active and when they should run, as described in the [material](@ref materials) manual.
- - @ref bs::CoreRenderer::renderAll "Renderer::renderAll" - This is a method called from the simulation thread that executes the rendering. It is called once per frame. In this method you should queue your actual rendering method for execution on the core thread.
- - @ref bs::CoreRenderer::notifyCameraAdded "Renderer::notifyCameraAdded" - Called on the core thread whenever a new @ref bs::Camera "Camera" is created (i.e. when a @ref bs::CCamera "CCamera" component is added to the scene). Also called when camera's properties change (camera is removed, then re-added).
- - @ref bs::CoreRenderer::notifyCameraUpdated "Renderer::notifyCameraUpdated" - Called on the core thread whenever a @ref bs::Camera "Camera's" position or rotation changes.
- - @ref bs::CoreRenderer::notifyCameraRemoved "Renderer::notifyCameraRemoved" - Called on the core thread whenever a @ref bs::Camera "Camera" is destroyed. Also called when camera's properties change (camera is removed, then re-added).
- - @ref bs::Renderer::notifyRenderableAdded "Renderer::notifyRenderableAdded" - Called on the core thread whenever a new @ref bs::Renderable "Renderable" is created (e.g. when a @ref bs::CRenderable "CRenderable" component is added to the scene).
- - @ref bs::Renderer::notifyRenderableUpdated "Renderer::notifyRenderableUpdated" - Called whenever @ref bs::Renderable "Renderable" properties change, e.g. when a scene object a renderable is attached to moves.
- - @ref bs::Renderer::notifyRenderableRemoved "Renderer::notifyRenderableRemoved" - Called whenever a @ref bs::Renderable "Renderable" is destroyed.
- - @ref bs::Renderer::notifyLightAdded "Renderer::notifyLightAdded" - Called whenever a new @ref bs::Light "Light" is created (e.g. when a @ref bs::CLight "CLight" component is added to the scene).
- - @ref bs::Renderer::notifyLightUpdated "Renderer::notifyLightUpdated" - Called whenever @ref bs::Light "Light" properties change, e.g. when a scene object a light is attached to moves.
- - @ref bs::Renderer::notifyLightRemoved "Renderer::notifyLightRemoved" - Called whenever @ref bs::Light "Light" is destroyed.
+The @ref bs::ct::Renderer "ct::Renderer" interface requires you to implement the following methods:
+ - @ref bs::ct::CoreRenderer::getName "ct::Renderer::getName" - Returns a unique name of the renderer. This can be used by shader techniques to identify which renderer is active and when they should run, as described in the [material](@ref materials) manual.
+ - @ref bs::ct::CoreRenderer::renderAll "ct::Renderer::renderAll" - This is a method called from the simulation thread that executes the rendering. It is called once per frame. In this method you should queue your actual rendering method for execution on the core thread.
+ - @ref bs::ct::CoreRenderer::notifyCameraAdded "ct::Renderer::notifyCameraAdded" - Called on the core thread whenever a new @ref bs::Camera "Camera" is created (i.e. when a @ref bs::CCamera "CCamera" component is added to the scene). Also called when camera's properties change (camera is removed, then re-added).
+ - @ref bs::ct::CoreRenderer::notifyCameraUpdated "ct::Renderer::notifyCameraUpdated" - Called on the core thread whenever a @ref bs::Camera "Camera's" position or rotation changes.
+ - @ref bs::ct::CoreRenderer::notifyCameraRemoved "ct::Renderer::notifyCameraRemoved" - Called on the core thread whenever a @ref bs::Camera "Camera" is destroyed. Also called when camera's properties change (camera is removed, then re-added).
+ - @ref bs::ct::Renderer::notifyRenderableAdded "ct::Renderer::notifyRenderableAdded" - Called on the core thread whenever a new @ref bs::Renderable "Renderable" is created (e.g. when a @ref bs::CRenderable "CRenderable" component is added to the scene).
+ - @ref bs::ct::Renderer::notifyRenderableUpdated "ct::Renderer::notifyRenderableUpdated" - Called whenever @ref bs::Renderable "Renderable" properties change, e.g. when a scene object a renderable is attached to moves.
+ - @ref bs::ct::Renderer::notifyRenderableRemoved "ct::Renderer::notifyRenderableRemoved" - Called whenever a @ref bs::Renderable "Renderable" is destroyed.
+ - @ref bs::ct::Renderer::notifyLightAdded "ct::Renderer::notifyLightAdded" - Called whenever a new @ref bs::Light "Light" is created (e.g. when a @ref bs::CLight "CLight" component is added to the scene).
+ - @ref bs::ct::Renderer::notifyLightUpdated "ct::Renderer::notifyLightUpdated" - Called whenever @ref bs::Light "Light" properties change, e.g. when a scene object a light is attached to moves.
+ - @ref bs::ct::Renderer::notifyLightRemoved "ct::Renderer::notifyLightRemoved" - Called whenever @ref bs::Light "Light" is destroyed.
  
 Implementing these methods should give you all the information you need to render your scene. You will have the required render target and projection/view matrices from the @ref bs::Camera "Camera", mesh/material/world transform from @ref bs::Renderable "Renderable" objects, and lighting information from @ref bs::Light "Light". Use the information provided in the [render API](@ref renderAPI) manual to learn how to render using those objects.
 
-Aside from rendering scene objects, the renderer should also take care of rendering everything else, like GUI, debug information and similar. This is handled in a general manner via callbacks. Every external system (like GUI) can register itself with the renderer by calling @ref bs::CoreRenderer::registerRenderCallback "Renderer::registerRenderCallback". This method accepts a few parameters:
+Aside from rendering scene objects, the renderer should also take care of rendering everything else, like GUI, debug information and similar. This is handled in a general manner via callbacks. Every external system (like GUI) can register itself with the renderer by calling @ref bs::ct::CoreRenderer::registerRenderCallback "ct::Renderer::registerRenderCallback". This method accepts a few parameters:
  - Pointer to a @ref bs::Camera "Camera" for which the callback is valid. The renderer should call the callback when rendering onto that camera.
  - Index that indicated the priority. Callbacks with indices lower than zero should be executed before scene object rendering, and indices equal to or higher than zero should be executed after scene object rendering.
  - Callback to execute. Other systems will usually call @ref bs::RenderAPI "RenderAPI" methods in such callback to perform rendering manually.
@@ -112,16 +112,16 @@ While this is enough to create a custom renderer, a variety of useful utilities
 These systems aren't critical for renderer creation, but instead provide an easier way to perform commonly required functions.
 
 ### Render queue {#renderer_b_a_a}
-@ref bs::RenderQueue "RenderQueue" allows you to sort and group scene objects for rendering. For example transparent objects might need to be sorted back to front based on their distance from the camera. It is also often useful to group objects if they share the same material, to reduce state switching which can improve performance.
+@ref bs::ct::RenderQueue "ct::RenderQueue" allows you to sort and group scene objects for rendering. For example transparent objects might need to be sorted back to front based on their distance from the camera. It is also often useful to group objects if they share the same material, to reduce state switching which can improve performance.
 
-Use @ref bs::RenderQueue::add "RenderQueue::add" to add new objects to the queue. It expects a @ref bs::RenderableElement "RenderableElement" which you can create from information provided by @ref bs::Renderable "Renderable" when @ref bs::Renderer::notifyRenderableAdded "Renderer::notifyRenderableAdded" is called. Normally you wish to have a single @ref bs::RenderableElement "RenderableElement" for each sub-mesh present in the renderable object's mesh.
+Use @ref bs::ct::RenderQueue::add "ct::RenderQueue::add" to add new objects to the queue. It expects a @ref bs::ct::RenderableElement "ct::RenderableElement" which you can create from information provided by @ref bs::Renderable "Renderable" when @ref bs::ct::Renderer::notifyRenderableAdded "ct::Renderer::notifyRenderableAdded" is called. Normally you wish to have a single @ref bs::ct::RenderableElement "ct::RenderableElement" for each sub-mesh present in the renderable object's mesh.
 
-Once all elements are in the queue, you can call @ref bs::RenderQueue::setStateReduction "RenderQueue::setStateReduction" to select how to sort the objects:
- - @ref bs::StateReduction::None "StateReduction::None" - There will be no sorting, based either by distance or material.
- - @ref bs::StateReduction::Material "StateReduction::Material" - Elements will be sorted by material first, then by distance.
- - @ref bs::StateReduction::Distance "StateReduction::Distance" - Elements will be sorted by distance first, then by material.
+Once all elements are in the queue, you can call @ref bs::ct::RenderQueue::setStateReduction "ct::RenderQueue::setStateReduction" to select how to sort the objects:
+ - @ref bs::ct::StateReduction::None "ct::StateReduction::None" - There will be no sorting, based either by distance or material.
+ - @ref bs::ct::StateReduction::Material "ct::StateReduction::Material" - Elements will be sorted by material first, then by distance.
+ - @ref bs::ct::StateReduction::Distance "ct::StateReduction::Distance" - Elements will be sorted by distance first, then by material.
  
-Once the state reduction mode is set call @ref bs::RenderQueue::sort "RenderQueue::sort", and then @ref bs::RenderQueue::getSortedElements "RenderQueue::getSortedElements" to retrieve a sorted list of render elements. The returned list contains a list of @ref bs::RenderQueueElement "RenderQueueElement" which lets you know exactly which render element to render using which pass, and also tells you when a new pass needs to be applied (if multiple elements in a row use the same pass, it doesn't need to be re-applied).
+Once the state reduction mode is set call @ref bs::ct::RenderQueue::sort "ct::RenderQueue::sort", and then @ref bs::ct::RenderQueue::getSortedElements "ct::RenderQueue::getSortedElements" to retrieve a sorted list of render elements. The returned list contains a list of @ref bs::ct::RenderQueueElement "ct::RenderQueueElement" which lets you know exactly which render element to render using which pass, and also tells you when a new pass needs to be applied (if multiple elements in a row use the same pass, it doesn't need to be re-applied).
 
 For example:
 ~~~~~~~~~~~~~{.cpp}
@@ -140,7 +140,7 @@ const Vector<RenderQueueElement>& sortedElements = queue->getSortedElements();
 ~~~~~~~~~~~~~
 
 ### Renderer material {#renderer_b_a_b}
-Often the renderer needs to use special shaders for various effects (e.g. post-processing effects like FXAA). Unlike shaders and materials used by users, these shaders are built-in into the engine. Since we know they'll always be there we can make it easier for the renderer to load and use them by implementing the @ref bs::RendererMaterial "RendererMaterial" interface:
+Often the renderer needs to use special shaders for various effects (e.g. post-processing effects like FXAA). Unlike shaders and materials used by users, these shaders are built-in into the engine. Since we know they'll always be there we can make it easier for the renderer to load and use them by implementing the @ref bs::ct::RendererMaterial "ct::RendererMaterial" interface:
 ~~~~~~~~~~~~~{.cpp}
 // Set up a post-processing material
 class DownsampleMat : public RendererMaterial<DownsampleMat>
@@ -157,7 +157,7 @@ public:
 	}
 
 	// Set up parameters and render a full screen quad using the material
-	void execute(const SPtr<TextureCore>& input)
+	void execute(const SPtr<Texture>& input)
 	{
 		// Actually assign parameters before rendering
 		mInputTexture.set(input);
@@ -171,8 +171,8 @@ public:
 		... render using the material ...
 	}
 private:
-	MaterialParamVec2Core mInvTexSize;
-	MaterialParamTextureCore mInputTexture;
+	MaterialParamVec2 mInvTexSize;
+	MaterialParamTexture mInputTexture;
 };
 
 // Method defined in RMAT_DEF
@@ -184,7 +184,7 @@ void DirectionalLightMat::_initDefines(ShaderDefines& defines)
 
 ~~~~~~~~~~~~~
 
-Renderer material implementation starts by deriving from @ref bs::RendererMaterial<T> "RendererMaterial<T>". This is followed by a declaration of the @ref RMAT_DEF macro, which contains a path to the shader file. The shader file should be located in "Data/Raw/Engine/Shaders/" folder.
+Renderer material implementation starts by deriving from @ref bs::ct::RendererMaterial<T> "ct::RendererMaterial<T>". This is followed by a declaration of the @ref RMAT_DEF macro, which contains a path to the shader file. The shader file should be located in "Data/Raw/Engine/Shaders/" folder.
 
 You must also implement `_initDefines` method, which allows you to modify the compilation environment. It can be empty if not required, but it is useful if your shader has different settings in the form of \#ifdef blocks, in which case different renderer materials can reference the same file, but yield different results depending on what is set in this method. Be aware that all built-in shaders are pre-processed by the @ref bs::BuiltinResources "BuiltinResources" manager. If you are changing define options you should delete the "Data/Engine/Timestamp.asset" file, which will force the manager to rebuild all shaders (and actually apply the new defines).
 
@@ -211,7 +211,7 @@ cbuffer PerCamera
 
 While you could assign these parameters using the standard way as described in the [material](@ref materials) manual:
 ~~~~~~~~~~~~~{.cpp}
-MaterialParamVec3Core viewDirParam = mMaterial->getParamVec3("gViewDir");
+MaterialParamVec3 viewDirParam = mMaterial->getParamVec3("gViewDir");
 viewDirParam.set(Vector3(0.707.0, 0.707f, 0.0f));
 // Or just simply:
 // mMaterial->setVec3("gViewDir", Vector3(0.707.0, 0.707f, 0.0f));
@@ -240,13 +240,13 @@ Once your parameter block definition is created, you can instantiate a parameter
 PerCameraParamBlockDef def; // Normally you want to make this global
 
 // Instantiates a new parameter block from the definition
-SPtr<GpuParamBlockBufferCore> paramBlock = def.createBuffer(); 
+SPtr<GpuParamBlockBuffer> paramBlock = def.createBuffer(); 
 
 // Assign a value to the gViewDir parameter of the parameter block
 def.gViewDir.set(paramBlock, Vector3(0.707.0, 0.707f, 0.0f));
 ... set other parameters in block ...
 
-SPtr<MaterialCore> material = ...;
+SPtr<Material> material = ...;
 material->setParamBlockBuffer("PerCamera", paramBlock);
 
 ... render using the material ...
@@ -263,8 +263,8 @@ For example:
 ~~~~~~~~~~~~~{.cpp}
 StringID RPS_ViewProjTfrm = "VP"; // Define semantic identifier
 
-SPtr<MaterialCore> material = ...;
-SPtr<ShaderCore> shader = material->getShader();
+SPtr<Material> material = ...;
+SPtr<Shader> shader = material->getShader();
 auto& dataParams = shader->getDataParams();
 for (auto& entry : texParams)
 {
@@ -281,19 +281,19 @@ You can choose to implement semantics in your renderer, but they aren't required
 
 ### RendererUtility {#renderer_b_a_e}
 
-@ref bs::RendererUtility "RendererUtility" provides some commonly required functionality for rendering. For the most part these are just wrappers around @ref bs::RenderAPI "RenderAPI" methods, so you don't have to set things like vertex/index buffers manually, as described in [render API](@ref renderAPI) manual.
- - @ref bs::RendererUtility::setPass "RendererUtility::setPass" - Binds a pass from a specific @ref bs::Material "Material" for rendering. Any further draw calls will be rendered using this pass.
- - @ref bs::RendererUtility::setPassParams "RendererUtility::setPassParams" - Binds parameters (textures, samplers, etc.) from a @ref bs::Material "Material". Any further draw calls will be rendered using these parameters.
- - @ref bs::RendererUtility::draw "RendererUtility::draw" - Draws a specific sub-mesh of the provided @ref bs::MeshCore "Mesh", using the currently bound pass.
- - @ref bs::RendererUtility::blit "RendererUtility::blit" - Copies the contents of the provided texture into the currently bound render target.
- - @ref bs::RendererUtility::drawScreenQuad "RendererUtility::drawScreenQuad" - Draws a quad using the currently bound pass.
+@ref bs::ct::RendererUtility "ct::RendererUtility" provides some commonly required functionality for rendering. For the most part these are just wrappers around @ref bs::RenderAPI "RenderAPI" methods, so you don't have to set things like vertex/index buffers manually, as described in [render API](@ref renderAPI) manual.
+ - @ref bs::ct::RendererUtility::setPass "ct::RendererUtility::setPass" - Binds a pass from a specific @ref bs::Material "Material" for rendering. Any further draw calls will be rendered using this pass.
+ - @ref bs::ct::RendererUtility::setPassParams "ct::RendererUtility::setPassParams" - Binds parameters (textures, samplers, etc.) from a @ref bs::Material "Material". Any further draw calls will be rendered using these parameters.
+ - @ref bs::ct::RendererUtility::draw "ct::RendererUtility::draw" - Draws a specific sub-mesh of the provided @ref bs::ct::Mesh "ct::Mesh", using the currently bound pass.
+ - @ref bs::ct::RendererUtility::blit "ct::RendererUtility::blit" - Copies the contents of the provided texture into the currently bound render target.
+ - @ref bs::ct::RendererUtility::drawScreenQuad "ct::RendererUtility::drawScreenQuad" - Draws a quad using the currently bound pass.
  
-Use @ref bs::gRendererUtility "gRendererUtility" to access the @ref bs::RendererUtility "RendererUtility" more easily.
+Use @ref bs::ct::gRendererUtility() "ct::gRendererUtility()" to access the @ref bs::ct::RendererUtility "ct::RendererUtility" more easily.
  
-Binding a material and rendering using @ref bs::RendererUtility "RendererUtility":
+Binding a material and rendering using @ref bs::ct::RendererUtility "ct::RendererUtility":
 ~~~~~~~~~~~~~{.cpp}
-SPtr<MaterialCore> material = ...;
-SPtr<MeshCore> mesh = ...;
+SPtr<Material> material = ...;
+SPtr<Mesh> mesh = ...;
 
 gRendererUtility().setPass(material);
 ... set material parameters ...
@@ -302,26 +302,26 @@ gRendererUtility().draw(mesh, mesh->getProperties().getSubMesh(0));
 ~~~~~~~~~~~~~
  
 ### RenderTexturePool {#renderer_b_a_f}
-Although you can create render textures manually as described in the [render target](@ref renderTargets) manual, @ref bs::RenderTexturePool "RenderTexturePool" provides a simpler and more efficient way of doing it. It will keep alive any referenced render textures, so that other systems may re-use them if their size/formats match. This can improve performance when using many temporary/intermediary render textures (like in post-processing).
+Although you can create render textures manually as described in the [render target](@ref renderTargets) manual, @ref bs::ct::RenderTexturePool "ct::RenderTexturePool" provides a simpler and more efficient way of doing it. It will keep alive any referenced render textures, so that other systems may re-use them if their size/formats match. This can improve performance when using many temporary/intermediary render textures (like in post-processing).
 
-To request a render texture, first populate the @ref bs::POOLED_RENDER_TEXTURE_DESC "POOLED_RENDER_TEXTURE_DESC" descriptor, by calling either @ref bs::POOLED_RENDER_TEXTURE_DESC::create2D "POOLED_RENDER_TEXTURE_DESC::create2D", @ref bs::POOLED_RENDER_TEXTURE_DESC::create3D "POOLED_RENDER_TEXTURE_DESC::create3D" or @ref bs::POOLED_RENDER_TEXTURE_DESC::createCube "POOLED_RENDER_TEXTURE_DESC::createCube".
+To request a render texture, first populate the @ref bs::ct::POOLED_RENDER_TEXTURE_DESC "ct::POOLED_RENDER_TEXTURE_DESC" descriptor, by calling either @ref bs::ct::POOLED_RENDER_TEXTURE_DESC::create2D "ct::POOLED_RENDER_TEXTURE_DESC::create2D", @ref bs::ct::POOLED_RENDER_TEXTURE_DESC::create3D "ct::POOLED_RENDER_TEXTURE_DESC::create3D" or @ref bs::ct::POOLED_RENDER_TEXTURE_DESC::createCube "ct::POOLED_RENDER_TEXTURE_DESC::createCube".
 
-Then call @ref bs::RenderTexturePool::get "RenderTexturePool::get" which will either create a new render texture, or return one from the pool. The returned object is @ref bs::PooledRenderTexture "PooledRenderTexture" from which you can access the actual render texture.
+Then call @ref bs::ct::RenderTexturePool::get "ct::RenderTexturePool::get" which will either create a new render texture, or return one from the pool. The returned object is @ref bs::ct::PooledRenderTexture "ct::PooledRenderTexture" from which you can access the actual render texture.
 
-Once you are done using the texture, call @ref bs::RenderTexturePool::release "RenderTexturePool::release" to return the texture to the pool, and make it available for other systems. If you plan on using this texture again, make sure to keep a reference to the @ref bs::PooledRenderTexture "PooledRenderTexture". This will prevent the pool from fully destroying the texture so it may be reused.
+Once you are done using the texture, call @ref bs::ct::RenderTexturePool::release "ct::RenderTexturePool::release" to return the texture to the pool, and make it available for other systems. If you plan on using this texture again, make sure to keep a reference to the @ref bs::ct::PooledRenderTexture "ct::PooledRenderTexture". This will prevent the pool from fully destroying the texture so it may be reused.
 
 For example:
 ~~~~~~~~~~~~~{.cpp}
 POOLED_RENDER_TEXTURE_DESC desc = POOLED_RENDER_TEXTURE_DESC::create2D(PF_R8G8B8A8, 1024, 1024);
 SPtr<PooledRenderTexture> pooledRT = RenderTexturePool::instance().get(desc);
 
-RenderAPICore::instance().setRenderTarget(pooledRT->renderTexture);
+RenderAPI::instance().setRenderTarget(pooledRT->renderTexture);
 ... render to target ...
 RenderTexturePool::instance().release(pooledRT);
 // Keep a reference to pooledRT if we plan on re-using it, then next time just call get() using the same descriptor
 ~~~~~~~~~~~~~
 
 ### Renderer options {#renderer_b_a_g}
-You can customize your rendering at runtime by implementing the @ref bs::CoreRendererOptions "RendererOptions" class. Your @ref bs::CoreRendererOptions "RendererOptions" implementation can then be assigned to the renderer by calling @ref bs::CoreRenderer::setOptions "Renderer::setOptions", and accessed within the renderer via the `mOptions` field. No default options are provided and it's up to your renderer to decide what it requires.
+You can customize your rendering at runtime by implementing the @ref bs::ct::CoreRendererOptions "ct::RendererOptions" class. Your @ref bs::ct::CoreRendererOptions "ct::RendererOptions" implementation can then be assigned to the renderer by calling @ref bs::ct::CoreRenderer::setOptions "ct::Renderer::setOptions", and accessed within the renderer via the `mOptions` field. No default options are provided and it's up to your renderer to decide what it requires.
 
 Be aware that options are set from the simulation thread, and if you want to use them on the core thread to either properly synchronize the access, or send a copy of the options to the core thread.

Documentation/Manuals/Native/textures.md

@@ -2,7 +2,7 @@ Textures									{#textures}
 ===============
 [TOC]
 
-Textures in Banshee are represented with the @ref bs::Texture "Texture" and @ref bs::TextureCore "TextureCore" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
+Textures in Banshee are represented with the @ref bs::Texture "Texture" and @ref bs::ct::Texture "ct::Texture" classes. Both of these provide almost equivalent functionality, but the former is for use on the simulation thread, and the latter is for use on the core thread. If you are confused by the dual nature of the objects, read the [core thread](@ref coreThread) manual. 
 
 We're going to focus on the simulation thread implementation in this manual, and then note the differences in the core thread version at the end.
 
@@ -60,11 +60,11 @@ To use a texture for rendering you need to either:
 A texture is a @ref bs::Resource "Resource" and can be saved/loaded like any other. See the [resource](@ref resources) manual.
 
 # Core thread textures {#textures_f}
-So far we have only talked about the simulation thread @ref bs::Texture "Texture" but have ignored the core thread @ref bs::TextureCore "TextureCore". The functionality between the two is mostly the same, with the major difference being that the core thread version doesn't have asychronous write/read methods, and those operations are instead performed immediately.
+So far we have only talked about the simulation thread @ref bs::Texture "Texture" but have ignored the core thread @ref bs::ct::Texture "ct::Texture". The functionality between the two is mostly the same, with the major difference being that the core thread version doesn't have asychronous write/read methods, and those operations are instead performed immediately.
 
-You can also use @ref bs::TextureCore::lock "TextureCore::lock" and @ref bs::TextureCore::unlock "TextureCore::unlock" to get access to the texture buffer, which allows you to only read/write from/to portions of it, instead of always writing to the entire buffer.
+You can also use @ref bs::ct::Texture::lock "ct::Texture::lock" and @ref bs::ct::Texture::unlock "ct::Texture::unlock" to get access to the texture buffer, which allows you to only read/write from/to portions of it, instead of always writing to the entire buffer.
 
-And finally @ref bs::TextureCore::copy "TextureCore::copy" method can be used for quickly copying a contents of one texture to another texture. This method will also resolve multi-sampled surface in the case the source is multi-sampled but the destination is not.
+And finally @ref bs::ct::Texture::copy "ct::Texture::copy" method can be used for quickly copying a contents of one texture to another texture. This method will also resolve multi-sampled surface in the case the source is multi-sampled but the destination is not.
 
 # Load-store textures {#textures_g}
 Load-store textures are a special type of textures that can be written to by the GPU. This is opposed to normal textures which are read only. They are particularily useful for compute operations which cannot use render targets for output, or for GPU operations that which to write to arbitrary locations rather than just to their own pixel location.

Source/BansheeCore/Include/BsBlendState.h

@@ -139,7 +139,7 @@ namespace bs
 
 	protected:
 		friend class BlendState;
-		friend class ct::BlendStateCore;
+		friend class ct::BlendState;
 		friend class BlendStateRTTI;
 
 		BLEND_STATE_DESC mData;
@@ -161,7 +161,7 @@ namespace bs
 		const BlendProperties& getProperties() const;
 
 		/** Retrieves a core implementation of the sampler state usable only from the core thread. */
-		SPtr<ct::BlendStateCore> getCore() const;
+		SPtr<ct::BlendState> getCore() const;
 
 		/**	Creates a new blend state using the specified blend state description structure. */
 		static SPtr<BlendState> create(const BLEND_STATE_DESC& desc);
@@ -202,14 +202,14 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of BlendState.
+	 * Core thread version of bs::BlendState.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT BlendStateCore : public CoreObject
+	class BS_CORE_EXPORT BlendState : public CoreObject
 	{
 	public:
-		virtual ~BlendStateCore();
+		virtual ~BlendState();
 
 		/** Returns information about the blend state. */
 		const BlendProperties& getProperties() const;
@@ -218,15 +218,15 @@ namespace bs
 		UINT32 getId() const { return mId; }
 
 		/**	Creates a new blend state using the specified blend state description structure. */
-		static SPtr<BlendStateCore> create(const BLEND_STATE_DESC& desc);
+		static SPtr<BlendState> create(const BLEND_STATE_DESC& desc);
 
 		/**	Returns the default blend state that you may use when no other is available. */
-		static const SPtr<BlendStateCore>& getDefault();
+		static const SPtr<BlendState>& getDefault();
 
 	protected:
 		friend class RenderStateManager;
 
-		BlendStateCore(const BLEND_STATE_DESC& desc, UINT32 id);
+		BlendState(const BLEND_STATE_DESC& desc, UINT32 id);
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;

Source/BansheeCore/Include/BsCamera.h

@@ -552,7 +552,7 @@ namespace bs
 		void setMain(bool main) { mMain = main; }
 
 		/** Retrieves an implementation of a camera handler usable only from the core thread. */
-		SPtr<ct::CameraCore> getCore() const;
+		SPtr<ct::Camera> getCore() const;
 
 		/**	Creates a new camera that renders to the specified portion of the provided render target. */
 		static SPtr<Camera> create(SPtr<RenderTarget> target = nullptr,
@@ -608,21 +608,21 @@ namespace bs
 	namespace ct
 	{
 	/** @copydoc CameraBase */
-	class BS_CORE_EXPORT CameraCore : public CoreObject, public TCamera<true>
+	class BS_CORE_EXPORT Camera : public CoreObject, public TCamera<true>
 	{
 	public:
-		~CameraCore();
+		~Camera();
 
 		/**	Returns the viewport used by the camera. */	
-		SPtr<ViewportCore> getViewport() const { return mViewport; }
+		SPtr<Viewport> getViewport() const { return mViewport; }
 
 	protected:
-		friend class Camera;
+		friend class bs::Camera;
 
-		CameraCore(SPtr<RenderTargetCore> target = nullptr,
+		Camera(SPtr<RenderTarget> target = nullptr,
 			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
 
-		CameraCore(const SPtr<ViewportCore>& viewport);
+		Camera(const SPtr<Viewport>& viewport);
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
@@ -633,7 +633,7 @@ namespace bs
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;
 
-		SPtr<ViewportCore> mViewport;
+		SPtr<Viewport> mViewport;
 	};
 	}
 

Source/BansheeCore/Include/BsCommonTypes.h

@@ -603,7 +603,7 @@ namespace bs
 
 	template<bool Core> struct TMeshType {};
 	template<> struct TMeshType < false > { typedef HMesh Type; };
-	template<> struct TMeshType < true > { typedef SPtr<ct::MeshCore> Type; };
+	template<> struct TMeshType < true > { typedef SPtr<ct::Mesh> Type; };
 
 	template<bool Core> struct TMaterialPtrType {};
 	template<> struct TMaterialPtrType < false > { typedef HMaterial Type; };
@@ -611,7 +611,7 @@ namespace bs
 
 	template<bool Core> struct TTextureType {};
 	template<> struct TTextureType < false > { typedef HTexture Type; };
-	template<> struct TTextureType < true > { typedef SPtr<ct::TextureCore> Type; };
+	template<> struct TTextureType < true > { typedef SPtr<ct::Texture> Type; };
 
 	/** @cond SPECIALIZATIONS */
 	BS_ALLOW_MEMCPY_SERIALIZATION(TextureSurface);

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -400,41 +400,41 @@ namespace bs
 	{
 		class CoreRenderer;
 		class VertexData;
-		class SamplerStateCore;
-		class IndexBufferCore;
-		class VertexBufferCore;
+		class SamplerState;
+		class IndexBuffer;
+		class VertexBuffer;
 		class RenderAPI;
-		class RenderTargetCore;
-		class RenderTextureCore;
-		class RenderWindowCore;
-		class DepthStencilStateCore;
-		class RasterizerStateCore;
-		class BlendStateCore;
+		class RenderTarget;
+		class RenderTexture;
+		class RenderWindow;
+		class DepthStencilState;
+		class RasterizerState;
+		class BlendState;
 		class CoreObject;
-		class CameraCore;
-		class MeshCoreBase;
-		class MeshCore;
-		class TransientMeshCore;
-		class TextureCore;
-		class MeshHeapCore;
-		class VertexDeclarationCore;
-		class GpuBufferCore;
-		class GpuParamBlockBufferCore;
-		class GpuParamsCore;
+		class Camera;
+		class MeshBase;
+		class Mesh;
+		class TransientMesh;
+		class Texture;
+		class MeshHeap;
+		class VertexDeclaration;
+		class GpuBuffer;
+		class GpuParamBlockBuffer;
+		class GpuParams;
 		class Shader;
-		class ViewportCore;
+		class Viewport;
 		class Pass;
 		class GpuParamsSet;
 		class Technique;
 		class Material;
-		class GpuProgramCore;
-		class LightCore;
-		class ComputePipelineStateCore;
-		class GraphicsPipelineStateCore;
-		class CameraCore;
+		class GpuProgram;
+		class Light;
+		class ComputePipelineState;
+		class GraphicsPipelineState;
+		class Camera;
 		class GpuParamsSet;
 		class MaterialParams;
-		class GpuPipelineParamInfoCore;
+		class GpuPipelineParamInfo;
 		class CommandBuffer;
 		class EventQuery;
 		class TimerQuery;

Source/BansheeCore/Include/BsCoreRenderer.h

@@ -83,7 +83,7 @@ namespace bs
 		 *
 		 * @note	Core thread.
 		 */
-		virtual void notifyCameraAdded(const ct::CameraCore* camera) { }
+		virtual void notifyCameraAdded(const ct::Camera* camera) { }
 
 		/**
 		 * Called whenever a camera's position or rotation is updated.
@@ -93,14 +93,14 @@ namespace bs
 		 *
 		 * @note	Core thread.
 		 */
-		virtual void notifyCameraUpdated(const ct::CameraCore* camera, UINT32 updateFlag) { }
+		virtual void notifyCameraUpdated(const ct::Camera* camera, UINT32 updateFlag) { }
 
 		/**
 		 * Called whenever a camera is destroyed.
 		 *
 		 * @note	Core thread.
 		 */
-		virtual void notifyCameraRemoved(const ct::CameraCore* camera) { }
+		virtual void notifyCameraRemoved(const ct::Camera* camera) { }
 
 		/**
 		 * Creates a new empty renderer mesh data.

Source/BansheeCore/Include/BsDepthStencilState.h

@@ -130,7 +130,7 @@ namespace bs
 
 	protected:
 		friend class DepthStencilState;
-		friend class DepthStencilStateCore;
+		friend class ct::DepthStencilState;
 		friend class DepthStencilStateRTTI;
 
 		DEPTH_STENCIL_STATE_DESC mData;
@@ -152,7 +152,7 @@ namespace bs
 		const DepthStencilProperties& getProperties() const;
 
 		/**	Retrieves a core implementation of a sampler state usable only from the core thread. */
-		SPtr<ct::DepthStencilStateCore> getCore() const;
+		SPtr<ct::DepthStencilState> getCore() const;
 
 		/**	Creates a new depth stencil state using the specified depth stencil state description structure. */
 		static SPtr<DepthStencilState> create(const DEPTH_STENCIL_STATE_DESC& desc);
@@ -193,14 +193,14 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of DepthStencilState.
+	 * Core thread version of bs::DepthStencilState.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT DepthStencilStateCore : public CoreObject
+	class BS_CORE_EXPORT DepthStencilState : public CoreObject
 	{
 	public:
-		virtual ~DepthStencilStateCore();
+		virtual ~DepthStencilState();
 
 		/**	Returns information about the depth stencil state. */
 		const DepthStencilProperties& getProperties() const;
@@ -209,15 +209,15 @@ namespace bs
 		UINT32 getId() const { return mId; }
 
 		/**	Creates a new depth stencil state using the specified depth stencil state description structure. */
-		static SPtr<DepthStencilStateCore> create(const DEPTH_STENCIL_STATE_DESC& desc);
+		static SPtr<DepthStencilState> create(const DEPTH_STENCIL_STATE_DESC& desc);
 
 		/**	Returns the default depth stencil state that you may use when no other is available. */
-		static const SPtr<DepthStencilStateCore>& getDefault();
+		static const SPtr<DepthStencilState>& getDefault();
 
 	protected:
 		friend class RenderStateManager;
 
-		DepthStencilStateCore(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id);
+		DepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id);
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;

Source/BansheeCore/Include/BsGpuBuffer.h

@@ -108,7 +108,7 @@ namespace bs
 		const GpuBufferProperties& getProperties() const { return mProperties; }
 
 		/** Retrieves a core implementation of a GPU buffer usable only from the core thread. */
-		SPtr<ct::GpuBufferCore> getCore() const;
+		SPtr<ct::GpuBuffer> getCore() const;
 
 		/** Returns the size of a single element in the buffer, of the provided format, in bytes. */
 		static UINT32 getFormatSize(GpuBufferFormat format);
@@ -136,23 +136,23 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of a GpuBuffer.
+	 * Core thread version of a bs::GpuBuffer.
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT GpuBufferCore : public CoreObject, public HardwareBuffer
+	class BS_CORE_EXPORT GpuBuffer : public CoreObject, public HardwareBuffer
 	{
 	public:
-		virtual ~GpuBufferCore();
+		virtual ~GpuBuffer();
 
 		/** Returns properties describing the buffer. */
 		const GpuBufferProperties& getProperties() const { return mProperties; }
 
 		/** @copydoc HardwareBufferManager::createGpuBuffer */
-		static SPtr<GpuBufferCore> create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<GpuBuffer> create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		GpuBufferCore(const GPU_BUFFER_DESC& desc, UINT32 deviceMask);
+		GpuBuffer(const GPU_BUFFER_DESC& desc, UINT32 deviceMask);
 
 		GpuBufferProperties mProperties;
 	};

Source/BansheeCore/Include/BsGpuParam.h

@@ -20,23 +20,23 @@ namespace bs
 
 	template<bool Core> struct TGpuParamsPtrType { };
 	template<> struct TGpuParamsPtrType<false> { typedef SPtr<GpuParams> Type; };
-	template<> struct TGpuParamsPtrType<true> { typedef SPtr<ct::GpuParamsCore> Type; };
+	template<> struct TGpuParamsPtrType<true> { typedef SPtr<ct::GpuParams> Type; };
 
 	template<bool Core> struct TGpuParamTextureType { };
 	template<> struct TGpuParamTextureType < false > { typedef HTexture Type; };
-	template<> struct TGpuParamTextureType < true > { typedef SPtr<ct::TextureCore> Type; };
+	template<> struct TGpuParamTextureType < true > { typedef SPtr<ct::Texture> Type; };
 
 	template<bool Core> struct TGpuParamSamplerStateType { };
 	template<> struct TGpuParamSamplerStateType < false > { typedef SPtr<SamplerState> Type; };
-	template<> struct TGpuParamSamplerStateType < true > { typedef SPtr<ct::SamplerStateCore> Type; };
+	template<> struct TGpuParamSamplerStateType < true > { typedef SPtr<ct::SamplerState> Type; };
 
 	template<bool Core> struct TGpuParamBufferType { };
 	template<> struct TGpuParamBufferType < false > { typedef SPtr<GpuParamBlockBuffer> Type; };
-	template<> struct TGpuParamBufferType < true > { typedef SPtr<ct::GpuParamBlockBufferCore> Type; };
+	template<> struct TGpuParamBufferType < true > { typedef SPtr<ct::GpuParamBlockBuffer> Type; };
 
 	template<bool Core> struct TGpuBufferType { };
 	template<> struct TGpuBufferType < false > { typedef SPtr<GpuBuffer> Type; };
-	template<> struct TGpuBufferType < true > { typedef SPtr<ct::GpuBufferCore> Type; };
+	template<> struct TGpuBufferType < true > { typedef SPtr<ct::GpuBuffer> Type; };
 
 	/**
 	 * Policy class that allows us to re-use this template class for matrices which might need transposing, and other 
@@ -172,7 +172,7 @@ namespace bs
 	{
 	private:
 		friend class GpuParams;
-		friend class GpuParamsCore;
+		friend class ct::GpuParams;
 
 		typedef typename TGpuParamsPtrType<Core>::Type GpuParamsType;
 		typedef typename TGpuParamTextureType<Core>::Type TextureType;
@@ -207,7 +207,7 @@ namespace bs
 	{
 	private:
 		friend class GpuParams;
-		friend class GpuParamsCore;
+		friend class ct::GpuParams;
 
 		typedef typename TGpuParamsPtrType<Core>::Type GpuParamsType;
 		typedef typename TGpuParamTextureType<Core>::Type TextureType;
@@ -242,7 +242,7 @@ namespace bs
 	{
 	private:
 		friend class GpuParams;
-		friend class GpuParamsCore;
+		friend class ct::GpuParams;
 
 		typedef typename TGpuParamsPtrType<Core>::Type GpuParamsType;
 		typedef typename TGpuBufferType<Core>::Type BufferType;
@@ -277,7 +277,7 @@ namespace bs
 	{
 	private:
 		friend class GpuParams;
-		friend class GpuParamsCore;
+		friend class ct::GpuParams;
 
 		typedef typename TGpuParamsPtrType<Core>::Type GpuParamsType;
 		typedef typename TGpuParamSamplerStateType<Core>::Type SamplerStateType;

Source/BansheeCore/Include/BsGpuParamBlockBuffer.h

@@ -53,7 +53,7 @@ namespace bs
 		UINT32 getSize() const { return mSize; }
 
 		/**	Retrieves a core implementation of a GPU param block buffer usable only from the core thread. */
-		SPtr<ct::GpuParamBlockBufferCore> getCore() const;
+		SPtr<ct::GpuParamBlockBuffer> getCore() const;
 
 		/** @copydoc HardwareBufferManager::createGpuParamBlockBuffer */
 		static SPtr<GpuParamBlockBuffer> create(UINT32 size, GpuParamBlockUsage usage = GPBU_DYNAMIC);
@@ -79,15 +79,15 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of a GpuParamBlockBuffer.
+	 * Core thread version of a bs::GpuParamBlockBuffer.
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT GpuParamBlockBufferCore : public CoreObject
+	class BS_CORE_EXPORT GpuParamBlockBuffer : public CoreObject
 	{
 	public:
-		GpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
-		virtual ~GpuParamBlockBufferCore();
+		GpuParamBlockBuffer(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
+		virtual ~GpuParamBlockBuffer();
 
 		/** 
 		 * Writes all of the specified data to the buffer. Data size must be the same size as the buffer. 
@@ -131,7 +131,7 @@ namespace bs
 		UINT32 getSize() const { return mSize; }
 
 		/** @copydoc HardwareBufferManager::createGpuParamBlockBuffer */
-		static SPtr<GpuParamBlockBufferCore> create(UINT32 size, GpuParamBlockUsage usage = GPBU_DYNAMIC,
+		static SPtr<GpuParamBlockBuffer> create(UINT32 size, GpuParamBlockUsage usage = GPBU_DYNAMIC,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:

Source/BansheeCore/Include/BsGpuParams.h

@@ -108,11 +108,11 @@ namespace bs
 
 	template<> struct TGpuParamsTypes < true >
 	{
-		typedef ct::GpuParamsCore GpuParamsType;
-		typedef SPtr<ct::TextureCore> TextureType;
-		typedef SPtr<ct::GpuBufferCore> BufferType;
-		typedef SPtr<ct::SamplerStateCore> SamplerType;
-		typedef SPtr<ct::GpuParamBlockBufferCore> ParamsBufferType;
+		typedef ct::GpuParams GpuParamsType;
+		typedef SPtr<ct::Texture> TextureType;
+		typedef SPtr<ct::GpuBuffer> BufferType;
+		typedef SPtr<ct::SamplerState> SamplerType;
+		typedef SPtr<ct::GpuParamBlockBuffer> ParamsBufferType;
 	};
 
 	/** Templated version of GpuParams that contains functionality for both sim and core thread versions of stored data. */
@@ -243,7 +243,7 @@ namespace bs
 		~GpuParams() { }
 
 		/** Retrieves a core implementation of a mesh usable only from the core thread. */
-		SPtr<ct::GpuParamsCore> getCore() const;
+		SPtr<ct::GpuParams> getCore() const;
 
 		/**
 		 * Creates new GpuParams object that can serve for changing the GPU program parameters on the specified pipeline.
@@ -310,44 +310,44 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of GpuParams.
+	 * Core thread version of bs::GpuParams.
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT GpuParamsCore : public CoreObject, public TGpuParams<true>
+	class BS_CORE_EXPORT GpuParams : public CoreObject, public TGpuParams<true>
 	{
 	public:
-		virtual ~GpuParamsCore() { }
+		virtual ~GpuParams() { }
 
 		/** 
-		 * @copydoc GpuParams::create(const SPtr<GraphicsPipelineState>&)
+		 * @copydoc bs::GpuParams::create(const SPtr<GraphicsPipelineState>&)
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the buffer be created on.
 		 */
-		static SPtr<GpuParamsCore> create(const SPtr<GraphicsPipelineStateCore>& pipelineState,
+		static SPtr<GpuParams> create(const SPtr<GraphicsPipelineState>& pipelineState,
 										  GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc GpuParams::create(const SPtr<ComputePipelineState>&) 
+		 * @copydoc bs::GpuParams::create(const SPtr<ComputePipelineState>&) 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the buffer be created on.
 		 */
-		static SPtr<GpuParamsCore> create(const SPtr<ComputePipelineStateCore>& pipelineState,
+		static SPtr<GpuParams> create(const SPtr<ComputePipelineState>& pipelineState,
 										  GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc GpuParams::create(const SPtr<GpuPipelineParamInfo>&)
+		 * @copydoc bs::GpuParams::create(const SPtr<GpuPipelineParamInfo>&)
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the buffer be created on.
 		 */
-		static SPtr<GpuParamsCore> create(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
+		static SPtr<GpuParams> create(const SPtr<GpuPipelineParamInfo>& paramInfo,
 										  GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		friend class GpuParams;
+		friend class bs::GpuParams;
 		friend class HardwareBufferManager;
 
-		GpuParamsCore(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask);
+		GpuParams(const SPtr<GpuPipelineParamInfo>& paramInfo, GpuDeviceFlags deviceMask);
 
 		/** @copydoc CoreObject::getThisPtr */
-		SPtr<GpuParamsCore> _getThisPtr() const override;
+		SPtr<GpuParams> _getThisPtr() const override;
 
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;

Source/BansheeCore/Include/BsGpuParamsSet.h

@@ -15,7 +15,7 @@ namespace bs
 
 	template<bool Core> struct TGpuParamsType { };
 	template<> struct TGpuParamsType<false> { typedef GpuParams Type; };
-	template<> struct TGpuParamsType<true> { typedef ct::GpuParamsCore Type; };
+	template<> struct TGpuParamsType<true> { typedef ct::GpuParams Type; };
 
 	/** Contains a set of GpuParams used for a single technique within a Material. */
 	template<bool Core>

Source/BansheeCore/Include/BsGpuPipelineParamInfo.h

@@ -99,7 +99,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::GpuPipelineParamInfoCore> getCore() const;
+		SPtr<ct::GpuPipelineParamInfo> getCore() const;
 
 		/** 
 		 * Constructs the object using the provided GPU parameter descriptors. 
@@ -117,23 +117,23 @@ namespace bs
 
 	namespace ct
 	{
-	/** Core thread version of a GpuPipelineParamInfo. */
-	class BS_CORE_EXPORT GpuPipelineParamInfoCore : public CoreObject, public GpuPipelineParamInfoBase
+	/** Core thread version of a bs::GpuPipelineParamInfo. */
+	class BS_CORE_EXPORT GpuPipelineParamInfo : public CoreObject, public GpuPipelineParamInfoBase
 	{
 	public:
-		virtual ~GpuPipelineParamInfoCore() { }
+		virtual ~GpuPipelineParamInfo() { }
 
 		/** 
-		 * @copydoc GpuPipelineParamInfo::create 
+		 * @copydoc bs::GpuPipelineParamInfo::create 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the buffer be created on.
 		 */
-		static SPtr<GpuPipelineParamInfoCore> create(const GPU_PIPELINE_PARAMS_DESC& desc,
+		static SPtr<GpuPipelineParamInfo> create(const GPU_PIPELINE_PARAMS_DESC& desc,
 													 GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
 		friend class RenderStateManager;
 
-		GpuPipelineParamInfoCore(const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask);
+		GpuPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask);
 	};
 	}
 

Source/BansheeCore/Include/BsGpuPipelineState.h

@@ -36,15 +36,15 @@ namespace bs
 	/** Descriptor structure used for initializing a GPU pipeline state. */
 	struct PIPELINE_STATE_DESC
 	{
-		SPtr<BlendStateCore> blendState;
-		SPtr<RasterizerStateCore> rasterizerState;
-		SPtr<DepthStencilStateCore> depthStencilState;
-
-		SPtr<GpuProgramCore> vertexProgram;
-		SPtr<GpuProgramCore> fragmentProgram;
-		SPtr<GpuProgramCore> geometryProgram;
-		SPtr<GpuProgramCore> hullProgram;
-		SPtr<GpuProgramCore> domainProgram;
+		SPtr<BlendState> blendState;
+		SPtr<RasterizerState> rasterizerState;
+		SPtr<DepthStencilState> depthStencilState;
+
+		SPtr<GpuProgram> vertexProgram;
+		SPtr<GpuProgram> fragmentProgram;
+		SPtr<GpuProgram> geometryProgram;
+		SPtr<GpuProgram> hullProgram;
+		SPtr<GpuProgram> domainProgram;
 	};
 
 	/** @} */
@@ -73,11 +73,11 @@ namespace bs
 	template<>
 	struct TGpuPipelineStateTypes < true >
 	{
-		typedef SPtr<ct::BlendStateCore> BlendStateType;
-		typedef SPtr<ct::RasterizerStateCore> RasterizerStateType;
-		typedef SPtr<ct::DepthStencilStateCore> DepthStencilStateType;
-		typedef SPtr<ct::GpuProgramCore> GpuProgramType;
-		typedef ct::GpuPipelineParamInfoCore GpuPipelineParamInfoType;
+		typedef SPtr<ct::BlendState> BlendStateType;
+		typedef SPtr<ct::RasterizerState> RasterizerStateType;
+		typedef SPtr<ct::DepthStencilState> DepthStencilStateType;
+		typedef SPtr<ct::GpuProgram> GpuProgramType;
+		typedef ct::GpuPipelineParamInfo GpuPipelineParamInfoType;
 		typedef ct::PIPELINE_STATE_DESC StateDescType;
 	};
 
@@ -172,7 +172,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::GraphicsPipelineStateCore> getCore() const;
+		SPtr<ct::GraphicsPipelineState> getCore() const;
 
 		/** @copydoc RenderStateManager::createGraphicsPipelineState */
 		static SPtr<GraphicsPipelineState> create(const PIPELINE_STATE_DESC& desc);
@@ -200,7 +200,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::ComputePipelineStateCore> getCore() const;
+		SPtr<ct::ComputePipelineState> getCore() const;
 
 		/** @copydoc RenderStateManager::createComputePipelineState */
 		static SPtr<ComputePipelineState> create(const SPtr<GpuProgram>& program);
@@ -221,36 +221,36 @@ namespace bs
 	 *  @{
 	 */
 
-	/** Core thread version of a GraphicsPipelineState. */
-	class BS_CORE_EXPORT GraphicsPipelineStateCore : public CoreObject, public TGraphicsPipelineState<true>
+	/** Core thread version of a bs::GraphicsPipelineState. */
+	class BS_CORE_EXPORT GraphicsPipelineState : public CoreObject, public TGraphicsPipelineState<true>
 	{
 	public:
-		GraphicsPipelineStateCore(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask);
-		virtual ~GraphicsPipelineStateCore() { }
+		GraphicsPipelineState(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask);
+		virtual ~GraphicsPipelineState() { }
 
 		/** @copydoc CoreObject::initialize() */
 		void initialize() override;
 
 		/** @copydoc RenderStateManager::createGraphicsPipelineState */
-		static SPtr<GraphicsPipelineStateCore> create(const PIPELINE_STATE_DESC& desc, 
+		static SPtr<GraphicsPipelineState> create(const PIPELINE_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
 		GpuDeviceFlags mDeviceMask;
 	};
 
-	/** Core thread version of a ComputePipelineState. */
-	class BS_CORE_EXPORT ComputePipelineStateCore : public CoreObject, public TComputePipelineState<true>
+	/** Core thread version of a bs::ComputePipelineState. */
+	class BS_CORE_EXPORT ComputePipelineState : public CoreObject, public TComputePipelineState<true>
 	{
 	public:
-		ComputePipelineStateCore(const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask);
-		virtual ~ComputePipelineStateCore() { }
+		ComputePipelineState(const SPtr<GpuProgram>& program, GpuDeviceFlags deviceMask);
+		virtual ~ComputePipelineState() { }
 
 		/** @copydoc CoreObject::initialize() */
 		void initialize() override;
 
 		/** @copydoc RenderStateManager::createComputePipelineState */
-		static SPtr<ComputePipelineStateCore> create(const SPtr<GpuProgramCore>& program,
+		static SPtr<ComputePipelineState> create(const SPtr<GpuProgram>& program,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:

Source/BansheeCore/Include/BsGpuProgram.h

@@ -112,7 +112,7 @@ namespace bs
 		SPtr<GpuParamDesc> getParamDesc() const;
 
 		/** Retrieves a core implementation of a gpu program usable only from the core thread. */
-		SPtr<ct::GpuProgramCore> getCore() const;
+		SPtr<ct::GpuProgram> getCore() const;
 
 		/** Returns properties that contain information about the GPU program. */
 		const GpuProgramProperties& getProperties() const { return mProperties; }
@@ -156,14 +156,14 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of a GpuProgram.
+	 * Core thread version of a bs::GpuProgram.
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT GpuProgramCore : public CoreObject
+	class BS_CORE_EXPORT GpuProgram : public CoreObject
 	{
 	public:
-		virtual ~GpuProgramCore() { }
+		virtual ~GpuProgram() { }
 
 		/** Returns whether this program can be supported on the current renderer and hardware. */
         virtual bool isSupported() const;
@@ -188,23 +188,23 @@ namespace bs
 		 */
 		virtual bool isAdjacencyInfoRequired() const { return mNeedsAdjacencyInfo; }
 
-		/** @copydoc GpuProgram::getParamDesc */
+		/** @copydoc bs::GpuProgram::getParamDesc */
 		SPtr<GpuParamDesc> getParamDesc() const { return mParametersDesc; }
 
 		/**	Returns GPU program input declaration. Only relevant for vertex programs. */
-		SPtr<VertexDeclarationCore> getInputDeclaration() const { return mInputDeclaration; }
+		SPtr<VertexDeclaration> getInputDeclaration() const { return mInputDeclaration; }
 
 		/**	Returns properties that contain information about the GPU program. */
 		const GpuProgramProperties& getProperties() const { return mProperties; }
 
 		/** 
-		 * @copydoc GpuProgram::create 
+		 * @copydoc bs::GpuProgram::create 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<GpuProgram> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		GpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
+		GpuProgram(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/** Returns whether required capabilities for this program is supported. */
 		bool isRequiredCapabilitiesSupported() const;
@@ -215,10 +215,10 @@ namespace bs
 		String mCompileError;
 
 		SPtr<GpuParamDesc> mParametersDesc;
-		SPtr<VertexDeclarationCore> mInputDeclaration;
+		SPtr<VertexDeclaration> mInputDeclaration;
 		GpuProgramProperties mProperties;
 	};
 
 	/** @} */
-		}
+	}
 }

Source/BansheeCore/Include/BsGpuProgramManager.h

@@ -44,11 +44,11 @@ namespace bs
 		/**	Returns GPU program language this factory is capable creating GPU programs from. */
 		virtual const String& getLanguage() const = 0;
 
-		/** @copydoc GpuProgramCore::create */
-		virtual SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
+		/** @copydoc GpuProgram::create */
+		virtual SPtr<GpuProgram> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc bs::GpuProgramManager::createEmpty */
-		virtual SPtr<GpuProgramCore> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
+		virtual SPtr<GpuProgram> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 	};
 
 	/**
@@ -78,18 +78,18 @@ namespace bs
 		/** Query if a GPU program language is supported (for example "hlsl", "glsl"). */
 		bool isLanguageSupported(const String& lang);
 
-		/** @copydoc GpuProgramCore::create */
-		SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		/** @copydoc GpuProgram::create */
+		SPtr<GpuProgram> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		friend class GpuProgram;
+		friend class bs::GpuProgram;
 
 		/**
 		 * Creates a GPU program without initializing it.
 		 *
 		 * @see		create
 		 */
-		SPtr<GpuProgramCore> createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		SPtr<GpuProgram> createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** Attempts to find a factory for the specified language. Returns null if it cannot find one. */
 		GpuProgramFactory* getFactory(const String& language);

Source/BansheeCore/Include/BsHardwareBufferManager.h

@@ -90,19 +90,19 @@ namespace bs
 		 * @copydoc bs::HardwareBufferManager::createVertexBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<VertexBufferCore> createVertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		SPtr<VertexBuffer> createVertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
 		 * @copydoc bs::HardwareBufferManager::createIndexBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<IndexBufferCore> createIndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		SPtr<IndexBuffer> createIndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
 		 * @copydoc bs::HardwareBufferManager::createVertexDeclaration 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<VertexDeclarationCore> createVertexDeclaration(const SPtr<VertexDataDesc>& desc,
+		SPtr<VertexDeclaration> createVertexDeclaration(const SPtr<VertexDataDesc>& desc,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**
@@ -111,34 +111,34 @@ namespace bs
 		 * @param[in]	elements		List of elements to initialize the declaration with.
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<VertexDeclarationCore> createVertexDeclaration(const List<VertexElement>& elements, 
+		SPtr<VertexDeclaration> createVertexDeclaration(const List<VertexElement>& elements, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
 		 * @copydoc bs::HardwareBufferManager::createGpuParamBlockBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBuffer(UINT32 size, 
+		SPtr<GpuParamBlockBuffer> createGpuParamBlockBuffer(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
 		 * @copydoc bs::HardwareBufferManager::createGpuBuffer
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<GpuBufferCore> createGpuBuffer(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		SPtr<GpuBuffer> createGpuBuffer(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
-		/** @copydoc GpuParamsCore::create(const SPtr<GpuPipelineParamInfoCore>&, GpuDeviceFlags) */
-		SPtr<GpuParamsCore> createGpuParams(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
+		/** @copydoc GpuParams::create(const SPtr<GpuPipelineParamInfo>&, GpuDeviceFlags) */
+		SPtr<GpuParams> createGpuParams(const SPtr<GpuPipelineParamInfo>& paramInfo,
 											GpuDeviceFlags deviceMask = GDF_DEFAULT);
 	protected:
+		friend class bs::IndexBuffer;
 		friend class IndexBuffer;
-		friend class IndexBufferCore;
+		friend class bs::VertexBuffer;
 		friend class VertexBuffer;
-		friend class VertexBufferCore;
-		friend class VertexDeclaration;
-		friend class GpuParamBlockBuffer;
+		friend class bs::VertexDeclaration;
+		friend class bs::GpuParamBlockBuffer;
+		friend class bs::GpuBuffer;
 		friend class GpuBuffer;
-		friend class GpuBufferCore;
 
 		/** Key for use in the vertex declaration map. */
 		struct VertexDeclarationKey
@@ -161,30 +161,30 @@ namespace bs
 		};
 
 		/** @copydoc createVertexBuffer */
-		virtual SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
+		virtual SPtr<VertexBuffer> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc createIndexBuffer */
-		virtual SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
+		virtual SPtr<IndexBuffer> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc createGpuParamBlockBuffer */
-		virtual SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
+		virtual SPtr<GpuParamBlockBuffer> createGpuParamBlockBufferInternal(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc createGpuBuffer */
-		virtual SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc, 
+		virtual SPtr<GpuBuffer> createGpuBufferInternal(const GPU_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc createVertexDeclaration(const List<VertexElement>&, GpuDeviceFlags) */
-		virtual SPtr<VertexDeclarationCore> createVertexDeclarationInternal(const List<VertexElement>& elements,
+		virtual SPtr<VertexDeclaration> createVertexDeclarationInternal(const List<VertexElement>& elements,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** @copydoc createGpuParams */
-		virtual SPtr<GpuParamsCore> createGpuParamsInternal(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
+		virtual SPtr<GpuParams> createGpuParamsInternal(const SPtr<GpuPipelineParamInfo>& paramInfo,
 															GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
-		typedef UnorderedMap<VertexDeclarationKey, SPtr<VertexDeclarationCore>, 
+		typedef UnorderedMap<VertexDeclarationKey, SPtr<VertexDeclaration>, 
 			VertexDeclarationKey::HashFunction, VertexDeclarationKey::EqualFunction> DeclarationMap;
 
 		DeclarationMap mCachedDeclarations;

Source/BansheeCore/Include/BsIndexBuffer.h

@@ -37,7 +37,7 @@ namespace bs
 
 	protected:
 		friend class IndexBuffer;
-		friend class ct::IndexBufferCore;
+		friend class ct::IndexBuffer;
 
 		IndexType mIndexType;
 		UINT32 mNumIndices;
@@ -58,7 +58,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::IndexBufferCore> getCore() const;
+		SPtr<ct::IndexBuffer> getCore() const;
 
 		/** @copydoc HardwareBufferManager::createIndexBuffer */
 		static SPtr<IndexBuffer> create(const INDEX_BUFFER_DESC& desc);
@@ -83,18 +83,18 @@ namespace bs
 	 *  @{
 	 */
 
-	/** Core thread specific implementation of an IndexBuffer. */
-	class BS_CORE_EXPORT IndexBufferCore : public CoreObject, public HardwareBuffer
+	/** Core thread specific implementation of an bs::IndexBuffer. */
+	class BS_CORE_EXPORT IndexBuffer : public CoreObject, public HardwareBuffer
 	{
 	public:
-		IndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
-		virtual ~IndexBufferCore() { }
+		IndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		virtual ~IndexBuffer() { }
 
 		/**	Returns information about the index buffer. */
 		const IndexBufferProperties& getProperties() const { return mProperties; }
 
 		/** @copydoc HardwareBufferManager::createIndexBuffer */
-		static SPtr<IndexBufferCore> create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<IndexBuffer> create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
 		IndexBufferProperties mProperties;

Source/BansheeCore/Include/BsMaterial.h

@@ -22,11 +22,11 @@ namespace bs
 
 	template<bool Core> struct TGpuParamBlockBufferPtrType { };
 	template<> struct TGpuParamBlockBufferPtrType<false> { typedef SPtr<GpuParamBlockBuffer> Type; };
-	template<> struct TGpuParamBlockBufferPtrType<true> { typedef SPtr<ct::GpuParamBlockBufferCore> Type; };
+	template<> struct TGpuParamBlockBufferPtrType<true> { typedef SPtr<ct::GpuParamBlockBuffer> Type; };
 
 	template<bool Core> struct TGpuProgramType { };
 	template<> struct TGpuProgramType<false> { typedef SPtr<GpuProgram> Type; };
-	template<> struct TGpuProgramType<true> { typedef SPtr<ct::GpuProgramCore> Type; };
+	template<> struct TGpuProgramType<true> { typedef SPtr<ct::GpuProgram> Type; };
 
 	template<bool Core> struct TShaderType {};
 	template<> struct TShaderType < false > { typedef HShader Type; };
@@ -34,7 +34,7 @@ namespace bs
 
 	template<bool Core> struct TGpuParamBlockBufferType {};
 	template<> struct TGpuParamBlockBufferType < false > { typedef GpuParamBlockBuffer Type; };
-	template<> struct TGpuParamBlockBufferType < true > { typedef ct::GpuParamBlockBufferCore Type; };
+	template<> struct TGpuParamBlockBufferType < true > { typedef ct::GpuParamBlockBuffer Type; };
 	
 	template<bool Core> struct TGpuParamsSetType {};
 	template<> struct TGpuParamsSetType < false > { typedef GpuParamsSet Type; };

Source/BansheeCore/Include/BsMaterialParams.h

@@ -260,7 +260,7 @@ namespace bs
 	class BS_CORE_EXPORT MaterialParamTextureDataCore
 	{
 	public:
-		SPtr<ct::TextureCore> value;
+		SPtr<ct::Texture> value;
 		bool isLoadStore;
 		TextureSurface surface;
 	};
@@ -282,7 +282,7 @@ namespace bs
 	class BS_CORE_EXPORT MaterialParamBufferDataCore
 	{
 	public:
-		SPtr<ct::GpuBufferCore> value;
+		SPtr<ct::GpuBuffer> value;
 	};
 
 	/** Data for a single buffer parameter. */
@@ -296,7 +296,7 @@ namespace bs
 	class BS_CORE_EXPORT MaterialParamSamplerStateDataCore
 	{
 	public:
-		SPtr<ct::SamplerStateCore> value;
+		SPtr<ct::SamplerState> value;
 	};
 
 	/** Data for a single sampler state parameter. */
@@ -324,11 +324,11 @@ namespace bs
 
 	template<> struct TMaterialParamsTypes < true >
 	{
-		typedef ct::GpuParamsCore GpuParamsType;
-		typedef SPtr<ct::TextureCore> TextureType;
-		typedef SPtr<ct::GpuBufferCore> BufferType;
-		typedef SPtr<ct::SamplerStateCore> SamplerType;
-		typedef SPtr<ct::GpuParamBlockBufferCore> ParamsBufferType;
+		typedef ct::GpuParams GpuParamsType;
+		typedef SPtr<ct::Texture> TextureType;
+		typedef SPtr<ct::GpuBuffer> BufferType;
+		typedef SPtr<ct::SamplerState> SamplerType;
+		typedef SPtr<ct::GpuParamBlockBuffer> ParamsBufferType;
 		typedef MaterialParamStructDataCore StructParamDataType;
 		typedef MaterialParamTextureDataCore TextureParamDataType;
 		typedef MaterialParamBufferDataCore BufferParamDataType;

Source/BansheeCore/Include/BsMesh.h

@@ -126,7 +126,7 @@ namespace bs
 		SPtr<MorphShapes> getMorphShapes() const { return mMorphShapes; }
 
 		/** Retrieves a core implementation of a mesh usable only from the core thread. */
-		SPtr<ct::MeshCore> getCore() const;
+		SPtr<ct::Mesh> getCore() const;
 
 		/**	Returns a dummy mesh, containing just one triangle. Don't modify the returned mesh. */
 		static HMesh dummy();
@@ -270,27 +270,27 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread portion of a Mesh.
+	 * Core thread portion of a bs::Mesh.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT MeshCore : public MeshCoreBase
+	class BS_CORE_EXPORT Mesh : public MeshBase
 	{
 	public:
-		MeshCore(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask);
+		Mesh(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask);
 
-		~MeshCore();
+		~Mesh();
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
 
-		/** @copydoc MeshCoreBase::getVertexData */
+		/** @copydoc MeshBase::getVertexData */
 		SPtr<VertexData> getVertexData() const override;
 
-		/** @copydoc MeshCoreBase::getIndexBuffer */
-		SPtr<IndexBufferCore> getIndexBuffer() const override;
+		/** @copydoc MeshBase::getIndexBuffer */
+		SPtr<IndexBuffer> getIndexBuffer() const override;
 
-		/** @copydoc MeshCoreBase::getVertexDesc */
+		/** @copydoc MeshBase::getVertexDesc */
 		SPtr<VertexDataDesc> getVertexDesc() const override;
 
 		/** Returns a skeleton that can be used for animating the mesh. */
@@ -342,7 +342,7 @@ namespace bs
 		 *								go over the number of vertices limited by the size.
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<MeshCore> create(UINT32 numVertices, UINT32 numIndices, const SPtr<VertexDataDesc>& vertexDesc, 
+		static SPtr<Mesh> create(UINT32 numVertices, UINT32 numIndices, const SPtr<VertexDataDesc>& vertexDesc, 
 			int usage = MU_STATIC, DrawOperationType drawOp = DOT_TRIANGLE_LIST, IndexType indexType = IT_32BIT, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
@@ -352,7 +352,7 @@ namespace bs
 		 * @param[in]	desc			Descriptor containing the properties of the mesh to create.
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<MeshCore> create(const MESH_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<Mesh> create(const MESH_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**
 		 * Creates a new mesh from an existing mesh data. Created mesh will match the vertex and index buffers described
@@ -364,7 +364,7 @@ namespace bs
 		 *								mesh data instead.
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<MeshCore> create(const SPtr<MeshData>& initialData, const MESH_DESC& desc, 
+		static SPtr<Mesh> create(const SPtr<MeshData>& initialData, const MESH_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**
@@ -377,17 +377,17 @@ namespace bs
 		 *								option is a triangle strip, where three indices represent a single triangle.
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<MeshCore> create(const SPtr<MeshData>& initialData, int usage = MU_STATIC,
+		static SPtr<Mesh> create(const SPtr<MeshData>& initialData, int usage = MU_STATIC,
 			DrawOperationType drawOp = DOT_TRIANGLE_LIST, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		friend class Mesh;
+		friend class bs::Mesh;
 
 		/** Updates bounds by calculating them from the vertices in the provided mesh data object. */
 		void updateBounds(const MeshData& meshData);
 
 		SPtr<VertexData> mVertexData;
-		SPtr<IndexBufferCore> mIndexBuffer;
+		SPtr<IndexBuffer> mIndexBuffer;
 
 		SPtr<VertexDataDesc> mVertexDesc;
 		int mUsage;

Source/BansheeCore/Include/BsMeshBase.h

@@ -53,11 +53,11 @@ namespace bs
 
 	protected:
 		friend class MeshBase;
-		friend class ct::MeshCoreBase;
+		friend class ct::MeshBase;
 		friend class Mesh;
-		friend class ct::MeshCore;
+		friend class ct::Mesh;
 		friend class TransientMesh;
-		friend class ct::TransientMeshCore;
+		friend class ct::TransientMesh;
 		friend class MeshBaseRTTI;
 
 		Vector<SubMesh> mSubMeshes;
@@ -108,7 +108,7 @@ namespace bs
 		const MeshProperties& getProperties() const { return mProperties; }
 
 		/**	Retrieves a core implementation of a mesh usable only from the core thread. */
-		SPtr<ct::MeshCoreBase> getCore() const;
+		SPtr<ct::MeshBase> getCore() const;
 
 	protected:
 		/** @copydoc CoreObject::syncToCore */
@@ -133,21 +133,21 @@ namespace bs
 	/**
 	 * Core version of a class used as a basis for all implemenations of meshes.
 	 *
-	 * @see		MeshBase
+	 * @see		bs::MeshBase
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT MeshCoreBase : public CoreObject
+	class BS_CORE_EXPORT MeshBase : public CoreObject
 	{
 	public:
-		MeshCoreBase(UINT32 numVertices, UINT32 numIndices, const Vector<SubMesh>& subMeshes);
-		virtual ~MeshCoreBase() { }
+		MeshBase(UINT32 numVertices, UINT32 numIndices, const Vector<SubMesh>& subMeshes);
+		virtual ~MeshBase() { }
 
 		/**	Get vertex data used for rendering. */
 		virtual SPtr<VertexData> getVertexData() const = 0;
 
 		/**	Get index data used for rendering. */
-		virtual SPtr<IndexBufferCore> getIndexBuffer() const = 0;
+		virtual SPtr<IndexBuffer> getIndexBuffer() const = 0;
 
 		/**
 		 * Returns an offset into the vertex buffers that is returned by getVertexData() that signifies where this meshes

Source/BansheeCore/Include/BsMeshData.h

@@ -279,9 +279,9 @@ namespace bs
 
 	private:
 		friend class Mesh;
-		friend class ct::MeshCore;
+		friend class ct::Mesh;
 		friend class MeshHeap;
-		friend class ct::MeshHeapCore;
+		friend class ct::MeshHeap;
 
 		UINT32 mDescBuilding;
 

Source/BansheeCore/Include/BsMeshHeap.h

@@ -44,7 +44,7 @@ namespace bs
 		void dealloc(const SPtr<TransientMesh>& mesh);
 
 		/** Retrieves a core implementation of a mesh heap usable only from the core thread. */
-		SPtr<ct::MeshHeapCore> getCore() const;
+		SPtr<ct::MeshHeap> getCore() const;
 
 		/**
 		 * Creates a new mesh heap.
@@ -85,11 +85,11 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of MeshHeap.
+	 * Core thread version of bs::MeshHeap.
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT MeshHeapCore : public CoreObject
+	class BS_CORE_EXPORT MeshHeap : public CoreObject
 	{
 		/**	Signifies how is a data chunk used. */
 		enum class UseFlags
@@ -114,7 +114,7 @@ namespace bs
 
 			UseFlags useFlags;
 			UINT32 eventQueryIdx;
-			SPtr<TransientMeshCore> mesh;
+			SPtr<TransientMesh> mesh;
 		};
 
 		/**	Data about a GPU query. */
@@ -125,14 +125,14 @@ namespace bs
 		};
 
 	public:
-		~MeshHeapCore();
+		~MeshHeap();
 
 	private:
-		friend class MeshHeap;
+		friend class bs::MeshHeap;
+		friend class bs::TransientMesh;
 		friend class TransientMesh;
-		friend class TransientMeshCore;
 
-		MeshHeapCore(UINT32 numVertices, UINT32 numIndices, 
+		MeshHeap(UINT32 numVertices, UINT32 numIndices, 
 			const SPtr<VertexDataDesc>& vertexDesc, IndexType indexType, GpuDeviceFlags deviceMask);
 
 		/** @copydoc CoreObject::initialize() */
@@ -144,10 +144,10 @@ namespace bs
 		 * @param[in]	mesh		Mesh for which we are allocating the data.
 		 * @param[in]	meshData	Data to initialize the new mesh with.
 		 */
-		void alloc(SPtr<TransientMeshCore> mesh, const SPtr<MeshData>& meshData);
+		void alloc(SPtr<TransientMesh> mesh, const SPtr<MeshData>& meshData);
 
 		/** Deallocates the provided mesh. Freed memory will be re-used as soon as the GPU is done with the mesh. */
-		void dealloc(SPtr<TransientMeshCore> mesh);
+		void dealloc(SPtr<TransientMesh> mesh);
 
 		/** Resizes the vertex buffers so they max contain the provided number of vertices. */
 		void growVertexBuffer(UINT32 numVertices);
@@ -168,7 +168,7 @@ namespace bs
 		SPtr<VertexData> getVertexData() const;
 
 		/**	Gets internal index data for all the meshes. */
-		SPtr<IndexBufferCore> getIndexBuffer() const;
+		SPtr<IndexBuffer> getIndexBuffer() const;
 
 		/** Returns a structure that describes how are the vertices stored in the mesh's vertex buffer. */
 		SPtr<VertexDataDesc> getVertexDesc() const;
@@ -190,7 +190,7 @@ namespace bs
 		 * Called by an GPU event query when GPU processes the query. Normally signals the heap that the GPU is done with 
 		 * the mesh.
 		 */
-		static void queryTriggered(SPtr<MeshHeapCore> thisPtr, UINT32 meshId, UINT32 queryId);
+		static void queryTriggered(SPtr<MeshHeap> thisPtr, UINT32 meshId, UINT32 queryId);
 
 		/**
 		 * Attempts to reorganize the vertex and index buffer chunks in order to in order to make free memory contigous.
@@ -208,7 +208,7 @@ namespace bs
 		UINT8* mCPUIndexData;
 
 		SPtr<VertexData> mVertexData;
-		SPtr<IndexBufferCore> mIndexBuffer;
+		SPtr<IndexBuffer> mIndexBuffer;
 
 		Map<UINT32, AllocatedData> mMeshAllocData;
 

Source/BansheeCore/Include/BsParamBlocks.h

@@ -26,13 +26,13 @@ namespace bs { namespace ct
 		 * Sets the parameter in the provided parameter block buffer. Caller is responsible for ensuring the param block
 		 * buffer contains this parameter. 
 		 */
-		void set(const SPtr<GpuParamBlockBufferCore>& paramBlock, const T& value, UINT32 arrayIdx = 0) const;
+		void set(const SPtr<GpuParamBlockBuffer>& paramBlock, const T& value, UINT32 arrayIdx = 0) const;
 
 		/** 
 		 * Gets the parameter in the provided parameter block buffer. Caller is responsible for ensuring the param block
 		 * buffer contains this parameter. 
 		 */
-		T get(const SPtr<GpuParamBlockBufferCore>& paramBlock, UINT32 arrayIdx = 0) const;
+		T get(const SPtr<GpuParamBlockBuffer>& paramBlock, UINT32 arrayIdx = 0) const;
 
 	protected:
 		GpuParamDataDesc mParamDesc;
@@ -77,7 +77,7 @@ namespace bs { namespace ct
 			ParamBlockManager::registerBlock(this);																			\
 		}																													\
 																															\
-		SPtr<GpuParamBlockBufferCore> createBuffer() const { return GpuParamBlockBufferCore::create(mBlockSize); }			\
+		SPtr<GpuParamBlockBuffer> createBuffer() const { return GpuParamBlockBuffer::create(mBlockSize); }					\
 																															\
 	private:																												\
 		friend class ParamBlockManager;																						\

Source/BansheeCore/Include/BsPass.h

@@ -40,17 +40,17 @@ namespace bs
 	/** Descriptor structure used for initializing a core thread variant of a shader pass. */
 	struct PASS_DESC
 	{
-		SPtr<BlendStateCore> blendState;
-		SPtr<RasterizerStateCore> rasterizerState;
-		SPtr<DepthStencilStateCore> depthStencilState;
+		SPtr<BlendState> blendState;
+		SPtr<RasterizerState> rasterizerState;
+		SPtr<DepthStencilState> depthStencilState;
 		UINT32 stencilRefValue;
 
-		SPtr<GpuProgramCore> vertexProgram;
-		SPtr<GpuProgramCore> fragmentProgram;
-		SPtr<GpuProgramCore> geometryProgram;
-		SPtr<GpuProgramCore> hullProgram;
-		SPtr<GpuProgramCore> domainProgram;
-		SPtr<GpuProgramCore> computeProgram;
+		SPtr<GpuProgram> vertexProgram;
+		SPtr<GpuProgram> fragmentProgram;
+		SPtr<GpuProgram> geometryProgram;
+		SPtr<GpuProgram> hullProgram;
+		SPtr<GpuProgram> domainProgram;
+		SPtr<GpuProgram> computeProgram;
 	};
 
 	/** @} */
@@ -80,12 +80,12 @@ namespace bs
 	template<>
 	struct TPassTypes < true >
 	{
-		typedef SPtr<ct::BlendStateCore> BlendStateType;
-		typedef SPtr<ct::RasterizerStateCore> RasterizerStateType;
-		typedef SPtr<ct::DepthStencilStateCore> DepthStencilStateType;
-		typedef SPtr<ct::GpuProgramCore> GpuProgramType;
-		typedef SPtr<ct::GraphicsPipelineStateCore> GraphicsPipelineStateType;
-		typedef SPtr<ct::ComputePipelineStateCore> ComputePipelineStateType;
+		typedef SPtr<ct::BlendState> BlendStateType;
+		typedef SPtr<ct::RasterizerState> RasterizerStateType;
+		typedef SPtr<ct::DepthStencilState> DepthStencilStateType;
+		typedef SPtr<ct::GpuProgram> GpuProgramType;
+		typedef SPtr<ct::GraphicsPipelineState> GraphicsPipelineStateType;
+		typedef SPtr<ct::ComputePipelineState> ComputePipelineStateType;
 		typedef ct::PASS_DESC PassDescType;
 	};
 
@@ -228,8 +228,8 @@ namespace bs
 
 		Pass() { }
 		Pass(const PASS_DESC& desc);
-		Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState);
-		Pass(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState);
+		Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineState>& pipelineState);
+		Pass(const PASS_DESC& desc, const SPtr<ComputePipelineState>& pipelineState);
 
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;

Source/BansheeCore/Include/BsPlatform.h

@@ -282,7 +282,7 @@ namespace bs
 		 * All provided areas are relative to the specified window. Mostly useful for frameless windows that don't have 
 		 * typical caption bar.
 		 */
-		static void setCaptionNonClientAreas(const ct::RenderWindowCore& window, const Vector<Rect2I>& nonClientAreas);
+		static void setCaptionNonClientAreas(const ct::RenderWindow& window, const Vector<Rect2I>& nonClientAreas);
 
 		/**
 		 * Sets custom non client areas for the specified window. Using custom client areas will override window resize 
@@ -294,14 +294,14 @@ namespace bs
 		 * All provided areas are relative to the specified window. Mostly useful for frameless windows that don't have 
 		 * typical border.
 		 */
-		static void setResizeNonClientAreas(const ct::RenderWindowCore& window, const Vector<NonClientResizeArea>& nonClientAreas);
+		static void setResizeNonClientAreas(const ct::RenderWindow& window, const Vector<NonClientResizeArea>& nonClientAreas);
 
 		/**
 		 * Resets the non client areas for the specified windows and allows the platform to use the default values.
 		 *
 		 * @note	Thread safe.
 		 */
-		static void resetNonClientAreas(const ct::RenderWindowCore& window);
+		static void resetNonClientAreas(const ct::RenderWindow& window);
 
 		/** 
 		 * Causes the current thread to pause execution for the specified amount of time.
@@ -379,7 +379,7 @@ namespace bs
 		 *
 		 * @note	Sim thread only.
 		 */
-		static Event<void(ct::RenderWindowCore*)> onMouseLeftWindow;
+		static Event<void(ct::RenderWindow*)> onMouseLeftWindow;
 
 		/**
 		 * Triggered whenever the pointer moves.

Source/BansheeCore/Include/BsRasterizerState.h

@@ -111,7 +111,7 @@ namespace bs
 
 	protected:
 		friend class RasterizerState;
-		friend class RasterizerStateCore;
+		friend class ct::RasterizerState;
 		friend class RasterizerStateRTTI;
 
 		RASTERIZER_STATE_DESC mData;
@@ -133,7 +133,7 @@ namespace bs
 		const RasterizerProperties& getProperties() const;
 
 		/** Retrieves a core implementation of the rasterizer state usable only from the core thread. */
-		SPtr<ct::RasterizerStateCore> getCore() const;
+		SPtr<ct::RasterizerState> getCore() const;
 
 		/** Creates a new rasterizer state using the specified rasterizer state descriptor structure. */
 		static SPtr<RasterizerState> create(const RASTERIZER_STATE_DESC& desc);
@@ -174,14 +174,14 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of RasterizerState.
+	 * Core thread version of bs::RasterizerState.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT RasterizerStateCore : public CoreObject
+	class BS_CORE_EXPORT RasterizerState : public CoreObject
 	{
 	public:
-		virtual ~RasterizerStateCore();
+		virtual ~RasterizerState();
 
 		/** Returns information about the rasterizer state. */
 		const RasterizerProperties& getProperties() const;
@@ -190,15 +190,15 @@ namespace bs
 		UINT32 getId() const { return mId; }
 
 		/** Creates a new rasterizer state using the specified rasterizer state descriptor structure. */
-		static SPtr<RasterizerStateCore> create(const RASTERIZER_STATE_DESC& desc);
+		static SPtr<RasterizerState> create(const RASTERIZER_STATE_DESC& desc);
 
 		/** Returns the default rasterizer state. */
-		static const SPtr<RasterizerStateCore>& getDefault();
+		static const SPtr<RasterizerState>& getDefault();
 
 	protected:
 		friend class RenderStateManager;
 
-		RasterizerStateCore(const RASTERIZER_STATE_DESC& desc, UINT32 id);
+		RasterizerState(const RASTERIZER_STATE_DESC& desc, UINT32 id);
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;

Source/BansheeCore/Include/BsRenderAPI.h

@@ -279,7 +279,7 @@ namespace bs
 		 * like textures, samplers, or uniform buffers. Caller is expected to ensure the provided parameters actually
 		 * match the currently bound programs.
 		 */
-		virtual void setGpuParams(const SPtr<GpuParamsCore>& gpuParams, 
+		virtual void setGpuParams(const SPtr<GpuParams>& gpuParams, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -292,7 +292,7 @@ namespace bs
 		 *
 		 * @see		GraphicsPipelineState
 		 */
-		virtual void setGraphicsPipeline(const SPtr<GraphicsPipelineStateCore>& pipelineState,
+		virtual void setGraphicsPipeline(const SPtr<GraphicsPipelineState>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -303,7 +303,7 @@ namespace bs
 		 *									is executed immediately. Otherwise it is executed when executeCommands() is 
 		 *									called. Buffer must support graphics operations.
 		 */
-		virtual void setComputePipeline(const SPtr<ComputePipelineStateCore>& pipelineState,
+		virtual void setComputePipeline(const SPtr<ComputePipelineState>& pipelineState,
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -352,7 +352,7 @@ namespace bs
 		 *								is executed immediately. Otherwise it is executed when executeCommands() is called.
 		 *								Buffer must support graphics operations.
 		 */
-		virtual void setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers, 
+		virtual void setVertexBuffers(UINT32 index, SPtr<VertexBuffer>* buffers, UINT32 numBuffers, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -364,7 +364,7 @@ namespace bs
 		 *								is executed immediately. Otherwise it is executed when executeCommands() is called.
 		 *								Buffer must support graphics operations.
 		 */
-		virtual void setIndexBuffer(const SPtr<IndexBufferCore>& buffer, 
+		virtual void setIndexBuffer(const SPtr<IndexBuffer>& buffer, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -376,7 +376,7 @@ namespace bs
 		 *									is executed immediately. Otherwise it is executed when executeCommands() is 
 		 *									called. Buffer must support graphics operations.
 		 */
-		virtual void setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration, 
+		virtual void setVertexDeclaration(const SPtr<VertexDeclaration>& vertexDeclaration, 
 			const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/** 
@@ -444,7 +444,7 @@ namespace bs
 		 *							related to the provided render target, you can exclude them from the sync mask for
 		 *							potentially better performance. You can use CommandSyncMask to generate a valid sync mask.
 		 */
-		virtual void swapBuffers(const SPtr<RenderTargetCore>& target, UINT32 syncMask = 0xFFFFFFFF) = 0;
+		virtual void swapBuffers(const SPtr<RenderTarget>& target, UINT32 syncMask = 0xFFFFFFFF) = 0;
 
 		/**
 		 * Change the render target into which we want to draw.
@@ -464,7 +464,7 @@ namespace bs
 		 *										is executed immediately. Otherwise it is executed when executeCommands() is
 		 *										called. Buffer must support graphics operations.
 		 */
-        virtual void setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil = false,
+        virtual void setRenderTarget(const SPtr<RenderTarget>& target, bool readOnlyDepthStencil = false,
 			RenderSurfaceMask loadMask = RT_NONE, const SPtr<CommandBuffer>& commandBuffer = nullptr) = 0;
 
 		/**
@@ -582,7 +582,7 @@ namespace bs
 		 *
 		 * @note Sim thread only.
 		 */
-		SPtr<RenderWindow> initialize(const RENDER_WINDOW_DESC& primaryWindowDesc);
+		SPtr<bs::RenderWindow> initialize(const RENDER_WINDOW_DESC& primaryWindowDesc);
 
 		/** Initializes the render API system. Called before the primary render window is created. */
 		virtual void initialize();
@@ -591,7 +591,7 @@ namespace bs
 		 * Performs (optional) secondary initialization of the render API system. Called after the render window is 
 		 * created.
 		 */
-		virtual void initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow);
+		virtual void initializeWithWindow(const SPtr<RenderWindow>& primaryWindow);
 
 		/**
 		 * Shuts down the render API system and cleans up all resources.
@@ -612,7 +612,7 @@ namespace bs
 	protected:
 		friend class RenderAPIManager;
 
-		SPtr<RenderTargetCore> mActiveRenderTarget;
+		SPtr<RenderTarget> mActiveRenderTarget;
 
 		RenderAPICapabilities* mCurrentCapabilities;
 		UINT32 mNumDevices;

Source/BansheeCore/Include/BsRenderStateManager.h

@@ -110,7 +110,7 @@ namespace bs
 				:id(id)
 			{ }
 
-			std::weak_ptr<BlendStateCore> state;
+			std::weak_ptr<BlendState> state;
 			UINT32 id;
 		};
 
@@ -125,7 +125,7 @@ namespace bs
 				:id(id)
 			{ }
 
-			std::weak_ptr<RasterizerStateCore> state;
+			std::weak_ptr<RasterizerState> state;
 			UINT32 id;
 		};
 
@@ -140,7 +140,7 @@ namespace bs
 				:id(id)
 			{ }
 
-			std::weak_ptr<DepthStencilStateCore> state;
+			std::weak_ptr<DepthStencilState> state;
 			UINT32 id;
 		};
 
@@ -151,101 +151,101 @@ namespace bs
 		 * @copydoc bs::RenderStateManager::createSamplerState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<SamplerStateCore> createSamplerState(const SAMPLER_STATE_DESC& desc, 
+		SPtr<SamplerState> createSamplerState(const SAMPLER_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** @copydoc bs::RenderStateManager::createDepthStencilState */
-		SPtr<DepthStencilStateCore> createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const;
+		SPtr<DepthStencilState> createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const;
 
 		/** @copydoc bs::RenderStateManager::createRasterizerState */
-		SPtr<RasterizerStateCore> createRasterizerState(const RASTERIZER_STATE_DESC& desc) const;
+		SPtr<RasterizerState> createRasterizerState(const RASTERIZER_STATE_DESC& desc) const;
 
 		/** @copydoc bs::RenderStateManager::createBlendState */
-		SPtr<BlendStateCore> createBlendState(const BLEND_STATE_DESC& desc) const;
+		SPtr<BlendState> createBlendState(const BLEND_STATE_DESC& desc) const;
 
 		/** 
 		 * @copydoc bs::RenderStateManager::createGraphicsPipelineState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<GraphicsPipelineStateCore> createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
+		SPtr<GraphicsPipelineState> createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** 
 		 * @copydoc bs::RenderStateManager::createComputePipelineState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<ComputePipelineStateCore> createComputePipelineState(const SPtr<GpuProgramCore>& program,
+		SPtr<ComputePipelineState> createComputePipelineState(const SPtr<GpuProgram>& program,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
-		/** @copydoc GpuPipelineParamInfoCore::create */
-		SPtr<GpuPipelineParamInfoCore> createPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc,
+		/** @copydoc GpuPipelineParamInfo::create */
+		SPtr<GpuPipelineParamInfo> createPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc,
 															   GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** Creates an uninitialized sampler state. Requires manual initialization after creation. */
-		SPtr<SamplerStateCore> _createSamplerState(const SAMPLER_STATE_DESC& desc, 
+		SPtr<SamplerState> _createSamplerState(const SAMPLER_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** Creates an uninitialized depth-stencil state. Requires manual initialization after creation. */
-		SPtr<DepthStencilStateCore> _createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const;
+		SPtr<DepthStencilState> _createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const;
 
 		/** Creates an uninitialized rasterizer state. Requires manual initialization after creation. */
-		SPtr<RasterizerStateCore> _createRasterizerState(const RASTERIZER_STATE_DESC& desc) const;
+		SPtr<RasterizerState> _createRasterizerState(const RASTERIZER_STATE_DESC& desc) const;
 
 		/** Creates an uninitialized blend state. Requires manual initialization after creation. */
-		SPtr<BlendStateCore> _createBlendState(const BLEND_STATE_DESC& desc) const;
+		SPtr<BlendState> _createBlendState(const BLEND_STATE_DESC& desc) const;
 
 		/**	Creates an uninitialized GraphicsPipelineState. Requires manual initialization after creation. */
-		virtual SPtr<GraphicsPipelineStateCore> _createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
+		virtual SPtr<GraphicsPipelineState> _createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/**	Creates an uninitialized ComputePipelineState. Requires manual initialization after creation. */
-		virtual SPtr<ComputePipelineStateCore> _createComputePipelineState(const SPtr<GpuProgramCore>& program,
+		virtual SPtr<ComputePipelineState> _createComputePipelineState(const SPtr<GpuProgram>& program,
 																		   GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
-		/**	Creates an uninitialized GpuPipelineParamInfoCore. Requires manual initialization after creation. */
-		virtual SPtr<GpuPipelineParamInfoCore> _createPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc,
+		/**	Creates an uninitialized GpuPipelineParamInfo. Requires manual initialization after creation. */
+		virtual SPtr<GpuPipelineParamInfo> _createPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc,
 																		GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** Gets a sampler state initialized with default options. */
-		const SPtr<SamplerStateCore>& getDefaultSamplerState() const;
+		const SPtr<SamplerState>& getDefaultSamplerState() const;
 
 		/**	Gets a blend state initialized with default options. */
-		const SPtr<BlendStateCore>& getDefaultBlendState() const;
+		const SPtr<BlendState>& getDefaultBlendState() const;
 
 		/**	Gets a rasterizer state initialized with default options. */
-		const SPtr<RasterizerStateCore>& getDefaultRasterizerState() const;
+		const SPtr<RasterizerState>& getDefaultRasterizerState() const;
 
 		/**	Gets a depth stencil state initialized with default options. */
-		const SPtr<DepthStencilStateCore>& getDefaultDepthStencilState() const;
+		const SPtr<DepthStencilState>& getDefaultDepthStencilState() const;
 
 	protected:
+		friend class bs::SamplerState;
+		friend class bs::BlendState;
+		friend class bs::RasterizerState;
+		friend class bs::DepthStencilState;
 		friend class SamplerState;
 		friend class BlendState;
 		friend class RasterizerState;
 		friend class DepthStencilState;
-		friend class SamplerStateCore;
-		friend class BlendStateCore;
-		friend class RasterizerStateCore;
-		friend class DepthStencilStateCore;
 
 		/** @copydoc Module::onShutDown */
 		void onShutDown() override;
 
 		/** @copydoc createSamplerState */
-		virtual SPtr<SamplerStateCore> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const;
+		virtual SPtr<SamplerState> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const;
 
 		/** @copydoc createBlendState */
-		virtual SPtr<BlendStateCore> createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const;
+		virtual SPtr<BlendState> createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const;
 
 		/** @copydoc createRasterizerState */
-		virtual SPtr<RasterizerStateCore> createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const;
+		virtual SPtr<RasterizerState> createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const;
 
 		/** @copydoc createDepthStencilState */
-		virtual SPtr<DepthStencilStateCore> createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const;
+		virtual SPtr<DepthStencilState> createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const;
 
 	private:
 		/**	Triggered when a new sampler state is created. */
-		void notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerStateCore>& state) const;
+		void notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerState>& state) const;
 
 		/**	Triggered when a new sampler state is created. */
 		void notifyBlendStateCreated(const BLEND_STATE_DESC& desc, const CachedBlendState& state) const;
@@ -266,31 +266,31 @@ namespace bs
 		 * Attempts to find a cached sampler state corresponding to the provided descriptor. Returns null if one doesn't 
 		 * exist.
 		 */
-		SPtr<SamplerStateCore> findCachedState(const SAMPLER_STATE_DESC& desc) const;
+		SPtr<SamplerState> findCachedState(const SAMPLER_STATE_DESC& desc) const;
 
 		/**
 		 * Attempts to find a cached blend state corresponding to the provided descriptor. Returns null if one doesn't exist.
 		 */
-		SPtr<BlendStateCore> findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const;
+		SPtr<BlendState> findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const;
 
 		/**
 		 * Attempts to find a cached rasterizer state corresponding to the provided descriptor. Returns null if one doesn't 
 		 * exist.
 		 */
-		SPtr<RasterizerStateCore> findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const;
+		SPtr<RasterizerState> findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const;
 
 		/**
 		 * Attempts to find a cached depth-stencil state corresponding to the provided descriptor. Returns null if one 
 		 * doesn't exist.
 		 */
-		SPtr<DepthStencilStateCore> findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const;
+		SPtr<DepthStencilState> findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const;
 
-		mutable SPtr<SamplerStateCore> mDefaultSamplerState;
-		mutable SPtr<BlendStateCore> mDefaultBlendState;
-		mutable SPtr<RasterizerStateCore> mDefaultRasterizerState;
-		mutable SPtr<DepthStencilStateCore> mDefaultDepthStencilState;
+		mutable SPtr<SamplerState> mDefaultSamplerState;
+		mutable SPtr<BlendState> mDefaultBlendState;
+		mutable SPtr<RasterizerState> mDefaultRasterizerState;
+		mutable SPtr<DepthStencilState> mDefaultDepthStencilState;
 
-		mutable UnorderedMap<SAMPLER_STATE_DESC, std::weak_ptr<SamplerStateCore>> mCachedSamplerStates;
+		mutable UnorderedMap<SAMPLER_STATE_DESC, std::weak_ptr<SamplerState>> mCachedSamplerStates;
 		mutable UnorderedMap<BLEND_STATE_DESC, CachedBlendState> mCachedBlendStates;
 		mutable UnorderedMap<RASTERIZER_STATE_DESC, CachedRasterizerState> mCachedRasterizerStates;
 		mutable UnorderedMap<DEPTH_STENCIL_STATE_DESC, CachedDepthStencilState> mCachedDepthStencilStates;

Source/BansheeCore/Include/BsRenderTarget.h

@@ -45,7 +45,7 @@ namespace bs
 	{
 		RENDER_SURFACE_DESC() { }
 
-		SPtr<TextureCore> texture;
+		SPtr<Texture> texture;
 
 		/** First face of the texture to bind (array index in texture arrays, or Z slice in 3D textures). */
 		UINT32 face = 0; 
@@ -122,7 +122,7 @@ namespace bs
 		bool requiresTextureFlipping() const { return mRequiresTextureFlipping; }
 
 	protected:
-		friend class ct::RenderTargetCore;
+		friend class ct::RenderTarget;
 		friend class RenderTarget;
 
 		UINT32 mWidth = 0;
@@ -158,7 +158,7 @@ namespace bs
 		virtual void getCustomAttribute(const String& name, void* pData) const;
 
 		/** 
-		 * @copydoc ct::RenderTargetCore::setPriority 
+		 * @copydoc ct::RenderTarget::setPriority 
 		 *
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
@@ -172,7 +172,7 @@ namespace bs
 		const RenderTargetProperties& getProperties() const;
 
 		/** Retrieves a core implementation of a render target usable only from the core thread. */
-		SPtr<ct::RenderTargetCore> getCore() const;
+		SPtr<ct::RenderTarget> getCore() const;
 
 		/**
 		 * Event that gets triggered whenever the render target is resized.
@@ -182,7 +182,7 @@ namespace bs
 		mutable Event<void()> onResized;
 
     protected:
-		friend class ct::RenderTargetCore;
+		friend class ct::RenderTarget;
 
 		/**	Returns properties that describe the render target. */
 		virtual const RenderTargetProperties& getPropertiesInternal() const = 0;
@@ -201,7 +201,7 @@ namespace bs
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT RenderTargetCore : public CoreObject
+	class BS_CORE_EXPORT RenderTarget : public CoreObject
 	{
 	public:
 		/** Frame buffer type when double-buffering is used. */
@@ -212,8 +212,8 @@ namespace bs
 			FB_AUTO
 		};
 
-		RenderTargetCore();
-		virtual ~RenderTargetCore() { }
+		RenderTarget();
+		virtual ~RenderTarget() { }
 
 		/**
 		 * Sets a priority that determines in which orders the render targets the processed.

Source/BansheeCore/Include/BsRenderTexture.h

@@ -32,7 +32,7 @@ namespace bs
 	private:
 		void construct(const TextureProperties* textureProps, UINT32 numSlices, bool requiresFlipping);
 
-		friend class RenderTextureCore;
+		friend class ct::RenderTexture;
 		friend class RenderTexture;
 	};
 
@@ -73,7 +73,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::RenderTextureCore> getCore() const;
+		SPtr<ct::RenderTexture> getCore() const;
 
 		/**	Returns properties that describe the render texture. */
 		const RenderTextureProperties& getProperties() const;
@@ -120,31 +120,31 @@ namespace bs
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT RenderTextureCore : public RenderTargetCore
+	class BS_CORE_EXPORT RenderTexture : public RenderTarget
 	{
 	public:
-		RenderTextureCore(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx);
-		virtual ~RenderTextureCore();
+		RenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx);
+		virtual ~RenderTexture();
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
 
 		/** @copydoc TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC&, UINT32) */
-		static SPtr<RenderTextureCore> create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);
+		static SPtr<RenderTexture> create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);
 
 		/**
 		 * Returns a color surface texture you may bind as an input to an GPU program.
 		 *
 		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
 		 */
-		SPtr<TextureCore> getColorTexture(UINT32 idx) const { return mDesc.colorSurfaces[idx].texture; }
+		SPtr<Texture> getColorTexture(UINT32 idx) const { return mDesc.colorSurfaces[idx].texture; }
 
 		/**
 		 * Returns a depth/stencil surface texture you may bind as an input to an GPU program.
 		 *
 		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
 		 */
-		SPtr<TextureCore> getDepthStencilTexture() const { return mDesc.depthStencilSurface.texture; }
+		SPtr<Texture> getDepthStencilTexture() const { return mDesc.depthStencilSurface.texture; }
 
 		/**	Returns properties that describe the render texture. */
 		const RenderTextureProperties& getProperties() const;
@@ -158,7 +158,7 @@ namespace bs
 		void throwIfBuffersDontMatch() const;
 
 	protected:
-		friend class RenderTexture;
+		friend class bs::RenderTexture;
 
 		SPtr<TextureView> mColorSurfaces[BS_MAX_MULTIPLE_RENDER_TARGETS];
 		SPtr<TextureView> mDepthStencilSurface;

Source/BansheeCore/Include/BsRenderWindow.h

@@ -74,7 +74,7 @@ namespace bs
 		bool isMaximized() const { return mIsMaximized; }
 
 	protected:
-		friend class ct::RenderWindowCore;
+		friend class ct::RenderWindow;
 		friend class RenderWindow;
 
 		bool mIsFullScreen = false;
@@ -134,49 +134,49 @@ namespace bs
 		void show();
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::minimize  
+		 * @copydoc ct::RenderWindow::minimize  
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void minimize();
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::maximize 
+		 * @copydoc ct::RenderWindow::maximize 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void maximize();
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::restore  
+		 * @copydoc ct::RenderWindow::restore  
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void restore();
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::setFullscreen(UINT32, UINT32, float, UINT32) 
+		 * @copydoc ct::RenderWindow::setFullscreen(UINT32, UINT32, float, UINT32) 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void setFullscreen(UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0);
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::setFullscreen(const VideoMode&) 
+		 * @copydoc ct::RenderWindow::setFullscreen(const VideoMode&) 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void setFullscreen(const VideoMode& videoMode);
 
 		/** 
-		 * @copydoc ct::RenderWindowCore::setWindowed 
+		 * @copydoc ct::RenderWindow::setWindowed 
 		 * 
 		 * @note This is an @ref asyncMethod "asynchronous method".
 		 */
 		void setWindowed(UINT32 width, UINT32 height);
 
 		/**	Retrieves a core implementation of a render window usable only from the core thread. */
-		SPtr<ct::RenderWindowCore> getCore() const;
+		SPtr<ct::RenderWindow> getCore() const;
 
 		/**	Returns properties that describe the render window. */
 		const RenderWindowProperties& getProperties() const;
@@ -217,12 +217,12 @@ namespace bs
 	 *  @{
 	 */
 
-	/** Core thread counterpart of RenderWindow. */
-	class BS_CORE_EXPORT RenderWindowCore : public RenderTargetCore
+	/** Core thread counterpart of bs::RenderWindow. */
+	class BS_CORE_EXPORT RenderWindow : public RenderTarget
 	{
 	public:
-		RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
-		virtual ~RenderWindowCore();
+		RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
+		virtual ~RenderWindow();
 
 		/** 
 		 * Switches the window to fullscreen mode. Child windows cannot go into fullscreen mode.

Source/BansheeCore/Include/BsRenderWindowManager.h

@@ -41,16 +41,16 @@ namespace bs
 		void notifyWindowDestroyed(RenderWindow* window);
 
 		/**	Called by the core thread when window receives focus. */
-		void notifyFocusReceived(ct::RenderWindowCore* window);
+		void notifyFocusReceived(ct::RenderWindow* window);
 
 		/**	Called by the core thread when window loses focus. */
-		void notifyFocusLost(ct::RenderWindowCore* window);
+		void notifyFocusLost(ct::RenderWindow* window);
 
 		/**	Called by the core thread when window is moved or resized. */
-		void notifyMovedOrResized(ct::RenderWindowCore* window);
+		void notifyMovedOrResized(ct::RenderWindow* window);
 
 		/**	Called by the sim thread when window properties change. */
-		void notifySyncDataDirty(ct::RenderWindowCore* coreWindow);
+		void notifySyncDataDirty(ct::RenderWindow* coreWindow);
 
 		/**	Returns a list of all open render windows. */
 		Vector<RenderWindow*> getRenderWindows() const;
@@ -67,10 +67,10 @@ namespace bs
 		friend class RenderWindow;
 
 		/**	Called by the core thread when mouse leaves a window. */
-		void windowMouseLeft(ct::RenderWindowCore* window);
+		void windowMouseLeft(ct::RenderWindow* window);
 
 		/**	Finds a sim thread equivalent of the provided core thread window implementation. */
-		RenderWindow* getNonCore(const ct::RenderWindowCore* window) const;
+		RenderWindow* getNonCore(const ct::RenderWindow* window) const;
 
 		/** @copydoc create */
 		virtual SPtr<RenderWindow> createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const SPtr<RenderWindow>& parentWindow) = 0;
@@ -99,34 +99,34 @@ namespace bs
 		RenderWindowManager();
 
 		/** Creates a new render window using the specified options. */
-		SPtr<RenderWindowCore> create(RENDER_WINDOW_DESC& desc);
+		SPtr<RenderWindow> create(RENDER_WINDOW_DESC& desc);
 
 		/** Called once per frame. Dispatches events. */
 		void _update();
 
 		/**	Called by the core thread when window properties change. */
-		void notifySyncDataDirty(RenderWindowCore* window);
+		void notifySyncDataDirty(RenderWindow* window);
 
 		/**	Returns a list of all open render windows. */
-		Vector<RenderWindowCore*> getRenderWindows() const;
+		Vector<RenderWindow*> getRenderWindows() const;
 
 	protected:
-		friend class RenderWindowCore;
+		friend class RenderWindow;
 		friend class bs::RenderWindow;
 		friend class bs::RenderWindowManager;
 
 		/** @copydoc create */
-		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) = 0;
+		virtual SPtr<RenderWindow> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) = 0;
 
 		/**	Called whenever a window is created. */
-		void windowCreated(RenderWindowCore* window);
+		void windowCreated(RenderWindow* window);
 
 		/**	Called by the core thread when window is destroyed. */
-		void windowDestroyed(RenderWindowCore* window);
+		void windowDestroyed(RenderWindow* window);
 
 		mutable Mutex mWindowMutex;
-		Vector<RenderWindowCore*> mCreatedWindows;
-		UnorderedSet<RenderWindowCore*> mDirtyProperties;
+		Vector<RenderWindow*> mCreatedWindows;
+		UnorderedSet<RenderWindow*> mDirtyProperties;
 		std::atomic_uint mNextWindowId;
 	};
 	}

Source/BansheeCore/Include/BsRendererExtension.h

@@ -72,14 +72,14 @@ namespace bs
 		virtual void destroy() {}
 
 		/** Returns true if the render() method should be called for the provided camera. */
-		virtual bool check(const ct::CameraCore& camera) = 0;
+		virtual bool check(const ct::Camera& camera) = 0;
 
 		/** 
 		 * Called at the point at which rendering should be performed for the provided camera. Relevant render targets
 		 * are guaranteed to be already bound to the render API, depending on the RenderLocation. Note that actual structure
 		 * of the render targets depends on the active renderer.
 		 */
-		virtual void render(const ct::CameraCore& camera) = 0;
+		virtual void render(const ct::Camera& camera) = 0;
 
 		/** 
 		 * Determines when will the render() method execute, compared to other plugins using the same RenderLocation. 

Source/BansheeCore/Include/BsSamplerState.h

@@ -116,7 +116,7 @@ namespace bs
 
 	protected:
 		friend class SamplerState;
-		friend class ct::SamplerStateCore;
+		friend class ct::SamplerState;
 		friend class SamplerStateRTTI;
 
 		SAMPLER_STATE_DESC mData;
@@ -141,7 +141,7 @@ namespace bs
 		const SamplerProperties& getProperties() const;
 
 		/**	Retrieves a core implementation of the sampler state usable only from the core thread. */
-		SPtr<ct::SamplerStateCore> getCore() const;
+		SPtr<ct::SamplerState> getCore() const;
 
 		/**	Creates a new sampler state using the provided descriptor structure. */
 		static SPtr<SamplerState> create(const SAMPLER_STATE_DESC& desc);
@@ -181,28 +181,28 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of SamplerState.
+	 * Core thread version of bs::SamplerState.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT SamplerStateCore : public CoreObject
+	class BS_CORE_EXPORT SamplerState : public CoreObject
 	{
 	public:
-		virtual ~SamplerStateCore();
+		virtual ~SamplerState();
 
 		/**	Returns information about the sampler state. */
 		const SamplerProperties& getProperties() const;
 
 		/**	@copydoc RenderStateManager::createSamplerState */
-		static SPtr<SamplerStateCore> create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<SamplerState> create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**	Returns the default sampler state. */
-		static const SPtr<SamplerStateCore>& getDefault();
+		static const SPtr<SamplerState>& getDefault();
 
 	protected:
 		friend class RenderStateManager;
 
-		SamplerStateCore(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask);
+		SamplerState(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;

Source/BansheeCore/Include/BsShader.h

@@ -61,7 +61,7 @@ namespace bs
 
 	template<bool Core> struct TSamplerStateType {};
 	template<> struct TSamplerStateType < false > { typedef SPtr<SamplerState> Type; };
-	template<> struct TSamplerStateType < true > { typedef SPtr<ct::SamplerStateCore> Type; };
+	template<> struct TSamplerStateType < true > { typedef SPtr<ct::SamplerState> Type; };
 
 	/** Structure used for initializing a shader. */
 	template<bool Core>

Source/BansheeCore/Include/BsTexture.h

@@ -208,7 +208,7 @@ namespace bs
 		const TextureProperties& getProperties() const { return mProperties; }
 
 		/**	Retrieves a core implementation of a texture usable only from the core thread. */
-		SPtr<ct::TextureCore> getCore() const;
+		SPtr<ct::Texture> getCore() const;
 
 		/************************************************************************/
 		/* 								STATICS		                     		*/
@@ -302,15 +302,15 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread version of a Texture.
+	 * Core thread version of a bs::Texture.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT TextureCore : public CoreObject
+	class BS_CORE_EXPORT Texture : public CoreObject
 	{
 	public:
-		TextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initData, GpuDeviceFlags deviceMask);
-		virtual ~TextureCore() {}
+		Texture(const TEXTURE_DESC& desc, const SPtr<PixelData>& initData, GpuDeviceFlags deviceMask);
+		virtual ~Texture() {}
 
 
 		/** @copydoc CoreObject::initialize */
@@ -354,7 +354,7 @@ namespace bs
 		 * @param[in]	dstMipLevel			Mip level to copy to.
 		 * @param[in]	queueIdx			Device queue to perform the copy operation on. See @ref queuesDoc.
 		 */
-		void copy(const SPtr<TextureCore>& target, UINT32 srcFace = 0, UINT32 srcMipLevel = 0, UINT32 dstFace = 0,
+		void copy(const SPtr<Texture>& target, UINT32 srcFace = 0, UINT32 srcMipLevel = 0, UINT32 dstFace = 0,
 			UINT32 dstMipLevel = 0, UINT32 queueIdx = 0);
 
 		/**
@@ -391,16 +391,16 @@ namespace bs
 		/************************************************************************/
 
 		/** 
-		 * @copydoc Texture::create(const TEXTURE_DESC&) 
+		 * @copydoc bs::Texture::create(const TEXTURE_DESC&) 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<TextureCore> create(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<Texture> create(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc Texture::create(const SPtr<PixelData>&, int, bool) 
+		 * @copydoc bs::Texture::create(const SPtr<PixelData>&, int, bool) 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		static SPtr<TextureCore> create(const SPtr<PixelData>& pixelData, int usage = TU_DEFAULT, 
+		static SPtr<Texture> create(const SPtr<PixelData>& pixelData, int usage = TU_DEFAULT, 
 			bool hwGammaCorrection = false, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/************************************************************************/
@@ -413,7 +413,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		static SPtr<TextureView> requestView(const SPtr<TextureCore>& texture, UINT32 mostDetailMip, UINT32 numMips,
+		static SPtr<TextureView> requestView(const SPtr<Texture>& texture, UINT32 mostDetailMip, UINT32 numMips,
 			UINT32 firstArraySlice, UINT32 numArraySlices, GpuViewUsage usage);
 
 		/**
@@ -424,13 +424,13 @@ namespace bs
 		static void releaseView(const SPtr<TextureView>& view);
 
 		/** Returns a plain white texture. */
-		static SPtr<TextureCore> WHITE;
+		static SPtr<Texture> WHITE;
 
 		/** Returns a plain black texture. */
-		static SPtr<TextureCore> BLACK;
+		static SPtr<Texture> BLACK;
 
 		/** Returns a plain normal map texture with normal pointing up (in Y direction). */
-		static SPtr<TextureCore> NORMAL;
+		static SPtr<Texture> NORMAL;
 	protected:
 		/** @copydoc lock */
 		virtual PixelData lockImpl(GpuLockOptions options, UINT32 mipLevel = 0, UINT32 face = 0, UINT32 deviceIdx = 0,
@@ -441,7 +441,7 @@ namespace bs
 
 		/** @copydoc copy */
 		virtual void copyImpl(UINT32 srcFace, UINT32 srcMipLevel, UINT32 dstFace, UINT32 dstMipLevel, 
-			const SPtr<TextureCore>& target, UINT32 queueIdx = 0) = 0;
+			const SPtr<Texture>& target, UINT32 queueIdx = 0) = 0;
 
 		/** @copydoc readData */
 		virtual void readDataImpl(PixelData& dest, UINT32 mipLevel = 0, UINT32 face = 0, UINT32 deviceIdx = 0,
@@ -456,7 +456,7 @@ namespace bs
 		/************************************************************************/
 
 		/**	Creates a new empty/undefined texture view. */
-		virtual SPtr<TextureView> createView(const SPtr<TextureCore>& texture, const TEXTURE_VIEW_DESC& desc);
+		virtual SPtr<TextureView> createView(const SPtr<Texture>& texture, const TEXTURE_VIEW_DESC& desc);
 
 		/**
 		 * Releases all internal texture view references. Views won't get destroyed if there are external references still 

Source/BansheeCore/Include/BsTextureManager.h

@@ -101,28 +101,28 @@ namespace bs
 		 * @copydoc	bs::TextureManager::createTexture(const TEXTURE_DESC&)
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
-		SPtr<TextureCore> createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		SPtr<Texture> createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**
 		 * @copydoc bs::TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC&) 
 		 * @param[in]	deviceIdx		Index of the GPU device to create the object on.
 		 */
-		SPtr<RenderTextureCore> createRenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);
+		SPtr<RenderTexture> createRenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);
 
 	protected:
+		friend class bs::Texture;
 		friend class Texture;
-		friend class TextureCore;
-		friend class RenderTexture;
+		friend class bs::RenderTexture;
 
 		/**
 		 * Creates an empty and uninitialized texture of a specific type. This is to be implemented	by render systems with
 		 * their own implementations.
 		 */
-		virtual SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc, 
+		virtual SPtr<Texture> createTextureInternal(const TEXTURE_DESC& desc, 
 			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
 		/** @copydoc createRenderTexture */
-		virtual SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
+		virtual SPtr<RenderTexture> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
 			UINT32 deviceIdx = 0) = 0;
     };
 		}

Source/BansheeCore/Include/BsTextureView.h

@@ -84,16 +84,16 @@ namespace bs
 		const TEXTURE_VIEW_DESC& getDesc() const { return mDesc; }
 
 		/**	Gets the owner texture the view is referencing. */
-		SPtr<TextureCore> getTexture() const { return mOwnerTexture; }
+		SPtr<Texture> getTexture() const { return mOwnerTexture; }
 
 	protected:
-		TextureView(const SPtr<TextureCore>& texture, const TEXTURE_VIEW_DESC& _desc);
+		TextureView(const SPtr<Texture>& texture, const TEXTURE_VIEW_DESC& _desc);
 
 	protected:
-		friend class TextureCore;
+		friend class Texture;
 
 		TEXTURE_VIEW_DESC mDesc;
-		SPtr<TextureCore> mOwnerTexture;
+		SPtr<Texture> mOwnerTexture;
 	};
 
 	/** @} */

Source/BansheeCore/Include/BsTransientMesh.h

@@ -25,7 +25,7 @@ namespace bs
 		virtual ~TransientMesh();
 
 		/** Retrieves a core implementation of a mesh usable only from the core thread. */
-		SPtr<ct::TransientMeshCore> getCore() const;
+		SPtr<ct::TransientMesh> getCore() const;
 
 	protected:
 		friend class MeshHeap;
@@ -41,7 +41,7 @@ namespace bs
 		/** Marks the mesh as destroyed so we know that we don't need to destroy it ourselves. */
 		void markAsDestroyed() { mIsDestroyed = true; }
 
-		/** @copydoc RenderTarget::createCore */
+		/** @copydoc MeshBase::createCore */
 		SPtr<ct::CoreObject> createCore() const override;
 
 	protected:
@@ -59,41 +59,41 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread portion of a TransientMesh.
+	 * Core thread portion of a bs::TransientMesh.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT TransientMeshCore : public MeshCoreBase
+	class BS_CORE_EXPORT TransientMesh : public MeshBase
 	{
 	public:
-		TransientMeshCore(const SPtr<MeshHeapCore>& parentHeap, UINT32 id, UINT32 numVertices,
+		TransientMesh(const SPtr<MeshHeap>& parentHeap, UINT32 id, UINT32 numVertices,
 			UINT32 numIndices, const Vector<SubMesh>& subMeshes);
 
-		/** @copydoc MeshCoreBase::getVertexData */
+		/** @copydoc MeshBase::getVertexData */
 		SPtr<VertexData> getVertexData() const override;
 
-		 /** @copydoc MeshCoreBase::getIndexBuffer */
-		SPtr<IndexBufferCore> getIndexBuffer() const override;
+		 /** @copydoc MeshBase::getIndexBuffer */
+		SPtr<IndexBuffer> getIndexBuffer() const override;
 
-		/** @copydoc MeshCoreBase::getVertexDesc */
+		/** @copydoc MeshBase::getVertexDesc */
 		SPtr<VertexDataDesc> getVertexDesc() const override;
 
 		/**	Returns the ID that uniquely identifies this mesh in the parent heap. */
 		UINT32 getMeshHeapId() const { return mId; }
 
-		/** @copydoc MeshCoreBase::getVertexOffset */
+		/** @copydoc MeshBase::getVertexOffset */
 		UINT32 getVertexOffset() const override;
 
-		 /** @copydoc MeshCoreBase::getIndexOffset */
+		 /** @copydoc MeshBase::getIndexOffset */
 		UINT32 getIndexOffset() const override;
 
-		 /** @copydoc MeshCoreBase::_notifyUsedOnGPU */
+		 /** @copydoc MeshBase::_notifyUsedOnGPU */
 		void _notifyUsedOnGPU() override;
 
 	protected:
-		friend class TransientMesh;
+		friend class bs::TransientMesh;
 
-		SPtr<MeshHeapCore> mParentHeap;
+		SPtr<MeshHeap> mParentHeap;
 		UINT32 mId;
 	};
 

Source/BansheeCore/Include/BsVertexBuffer.h

@@ -35,7 +35,7 @@ namespace bs
 
 	protected:
 		friend class VertexBuffer;
-		friend class ct::VertexBufferCore;
+		friend class ct::VertexBuffer;
 
 		UINT32 mNumVertices;
 		UINT32 mVertexSize;
@@ -52,7 +52,7 @@ namespace bs
 		 *
 		 * @note	Core thread only.
 		 */
-		SPtr<ct::VertexBufferCore> getCore() const;
+		SPtr<ct::VertexBuffer> getCore() const;
 
 		/** @copydoc HardwareBufferManager::createVertexBuffer */
 		static SPtr<VertexBuffer> create(const VERTEX_BUFFER_DESC& desc);
@@ -80,18 +80,18 @@ namespace bs
 	 *  @{
 	 */
 
-	/** Core thread specific implementation of a VertexBuffer. */
-	class BS_CORE_EXPORT VertexBufferCore : public CoreObject, public HardwareBuffer
+	/** Core thread specific implementation of a bs::VertexBuffer. */
+	class BS_CORE_EXPORT VertexBuffer : public CoreObject, public HardwareBuffer
 	{
 	public:
-		VertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
-		virtual ~VertexBufferCore() { }
+		VertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		virtual ~VertexBuffer() { }
 
 		/**	Returns information about the vertex buffer. */
 		const VertexBufferProperties& getProperties() const { return mProperties; }
 
 		/** @copydoc HardwareBufferManager::createVertexBuffer */
-		static SPtr<VertexBufferCore> create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<VertexBuffer> create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
 		VertexBufferProperties mProperties;

Source/BansheeCore/Include/BsVertexData.h

@@ -24,13 +24,13 @@ namespace bs { namespace ct
         ~VertexData();
 
 		/**	Assigns a new vertex buffer to the specified index. */
-		void setBuffer(UINT32 index, SPtr<VertexBufferCore> buffer);
+		void setBuffer(UINT32 index, SPtr<VertexBuffer> buffer);
 
 		/**	Retrieves a vertex buffer from the specified index. */
-		SPtr<VertexBufferCore> getBuffer(UINT32 index) const;
+		SPtr<VertexBuffer> getBuffer(UINT32 index) const;
 
 		/**	Returns a list of all bound vertex buffers. */
-		const UnorderedMap<UINT32, SPtr<VertexBufferCore>>& getBuffers() const { return mVertexBuffers; }
+		const UnorderedMap<UINT32, SPtr<VertexBuffer>>& getBuffers() const { return mVertexBuffers; }
 
 		/**	Checks if there is a buffer at the specified index. */
 		bool isBufferBound(UINT32 index) const;
@@ -42,7 +42,7 @@ namespace bs { namespace ct
 		UINT32 getMaxBufferIndex() const { return mMaxBufferIdx; }
 
 		/**	Declaration used for the contained vertex buffers. */
-		SPtr<VertexDeclarationCore> vertexDeclaration;
+		SPtr<VertexDeclaration> vertexDeclaration;
 
 		/**	Number of vertices to use. */
 		UINT32 vertexCount;
@@ -50,7 +50,7 @@ namespace bs { namespace ct
 	private:
 		void recalculateMaxIndex();
 
-		UnorderedMap<UINT32, SPtr<VertexBufferCore>> mVertexBuffers;
+		UnorderedMap<UINT32, SPtr<VertexBuffer>> mVertexBuffers;
 		UINT32 mMaxBufferIdx = 0;
 	};
 

Source/BansheeCore/Include/BsVertexDataDesc.h

@@ -72,9 +72,9 @@ namespace bs
 
 	private:
 		friend class Mesh;
-		friend class ct::MeshCore;
+		friend class ct::Mesh;
 		friend class MeshHeap;
-		friend class ct::MeshHeapCore;
+		friend class ct::MeshHeap;
 
 		/**	Returns the largest stream index of all the stored vertex elements. */
 		UINT32 getMaxStreamIdx() const;

Source/BansheeCore/Include/BsVertexDeclaration.h

@@ -146,13 +146,13 @@ namespace bs
 		/**
 		 * Attempts to find an element by the given semantic and semantic index. If no element can be found null is returned.
 		 */
-		virtual const VertexElement* findElementBySemantic(VertexElementSemantic sem, UINT16 index = 0) const;
+		const VertexElement* findElementBySemantic(VertexElementSemantic sem, UINT16 index = 0) const;
 
 		/**	Returns a list of all elements that use the provided source index. */
-		virtual List<VertexElement> findElementsBySource(UINT16 source) const;
+		List<VertexElement> findElementsBySource(UINT16 source) const;
 
 		/**	Returns the total size of all vertex elements using the provided source index. */
-		virtual UINT32 getVertexSize(UINT16 source) const;
+		UINT32 getVertexSize(UINT16 source) const;
 
 	protected:
 		friend class VertexDeclaration;
@@ -175,7 +175,7 @@ namespace bs
 		const VertexDeclarationProperties& getProperties() const { return mProperties; }
 
 		/**	Retrieves a core implementation of a vertex declaration usable only from the core thread. */
-		SPtr<ct::VertexDeclarationCore> getCore() const;
+		SPtr<ct::VertexDeclaration> getCore() const;
 
 		/** @copydoc HardwareBufferManager::createVertexDeclaration */
 		static SPtr<VertexDeclaration> create(const SPtr<VertexDataDesc>& desc);
@@ -215,14 +215,14 @@ namespace bs
 	 */
 
 	/**
-	 * Core thread portion of a VertexDeclaration.
+	 * Core thread portion of a bs::VertexDeclaration.
 	 *
 	 * @note	Core thread.
 	 */
-	class BS_CORE_EXPORT VertexDeclarationCore : public CoreObject
+	class BS_CORE_EXPORT VertexDeclaration : public CoreObject
     {
 	public:
-		virtual ~VertexDeclarationCore() { }
+		virtual ~VertexDeclaration() { }
 
 		/** @copydoc CoreObject::initialize */
 		void initialize() override;
@@ -237,21 +237,21 @@ namespace bs
 		 * Checks can a vertex buffer declared with this declaration be bound to a shader defined with the provided 
 		 * declaration.
 		 */
-		bool isCompatible(const SPtr<VertexDeclarationCore>& shaderDecl);
+		bool isCompatible(const SPtr<VertexDeclaration>& shaderDecl);
 
 		/**
 		 * Returns a list of vertex elements that the provided shader's vertex declaration expects but aren't present in 
 		 * this vertex declaration.
 		 */
-		Vector<VertexElement> getMissingElements(const SPtr<VertexDeclarationCore>& shaderDecl);
+		Vector<VertexElement> getMissingElements(const SPtr<VertexDeclaration>& shaderDecl);
 
 		/** @copydoc HardwareBufferManager::createVertexDeclaration */
-		static SPtr<VertexDeclarationCore> create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
+		static SPtr<VertexDeclaration> create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
     protected:
 		friend class HardwareBufferManager;
 
-		VertexDeclarationCore(const List<VertexElement>& elements, GpuDeviceFlags deviceMask);
+		VertexDeclaration(const List<VertexElement>& elements, GpuDeviceFlags deviceMask);
 
 		VertexDeclarationProperties mProperties;
 		UINT32 mId;

Source/BansheeCore/Include/BsViewport.h

@@ -138,7 +138,7 @@ namespace bs
 		void setTarget(const SPtr<RenderTarget>& target);
 
 		/**	Retrieves a core implementation of a viewport usable only from the core thread. */
-		SPtr<ct::ViewportCore> getCore() const;
+		SPtr<ct::Viewport> getCore() const;
 
 	    /**
          * Creates a new viewport.
@@ -193,23 +193,23 @@ namespace bs
 	 */
 
 	/** @copydoc ViewportBase */
-	class BS_CORE_EXPORT ViewportCore : public CoreObject, public ViewportBase
+	class BS_CORE_EXPORT Viewport : public CoreObject, public ViewportBase
     {
     public:       
         /**	Returns the render target the viewport is associated with. */
-		SPtr<RenderTargetCore> getTarget() const { return mTarget; }
+		SPtr<RenderTarget> getTarget() const { return mTarget; }
 
 		/**	Sets the render target the viewport will be associated with. */
-		void setTarget(const SPtr<RenderTargetCore>& target) { mTarget = target; }
+		void setTarget(const SPtr<RenderTarget>& target) { mTarget = target; }
 
-		/** @copydoc Viewport::create() */
-		static SPtr<ViewportCore> create(const SPtr<RenderTargetCore>& target, float x = 0.0f, float y = 0.0f, 
+		/** @copydoc bs::Viewport::create() */
+		static SPtr<Viewport> create(const SPtr<RenderTarget>& target, float x = 0.0f, float y = 0.0f, 
 			float width = 1.0f, float height = 1.0f);
 
     protected:
-		friend class Viewport;
+		friend class bs::Viewport;
 
-		ViewportCore(const SPtr<RenderTargetCore>& target, float x = 0.0f, float y = 0.0f, float width = 1.0f, float height = 1.0f);
+		Viewport(const SPtr<RenderTarget>& target, float x = 0.0f, float y = 0.0f, float width = 1.0f, float height = 1.0f);
 
 		/** @copydoc ViewportBase::getTargetWidth */
 		UINT32 getTargetWidth() const override;
@@ -220,7 +220,7 @@ namespace bs
 		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;
 
-		SPtr<RenderTargetCore> mTarget;
+		SPtr<RenderTarget> mTarget;
     };
 
 	/** @} */

Source/BansheeCore/Include/Win32/BSWin32PlatformData.h

@@ -29,7 +29,7 @@ namespace bs
 		bool mIsCursorHidden = false;
 		NativeCursorData mCursor;
 		bool mUsingCustomCursor = false;
-		Map<const ct::RenderWindowCore*, WindowNonClientAreaData> mNonClientAreas;
+		Map<const ct::RenderWindow*, WindowNonClientAreaData> mNonClientAreas;
 
 		bool mIsTrackingMouse = false;
 		NativeDropTargetData mDropTargets;

Source/BansheeCore/Source/BsBlendState.cpp

@@ -105,14 +105,14 @@ namespace bs
 
 	}
 
-	SPtr<ct::BlendStateCore> BlendState::getCore() const
+	SPtr<ct::BlendState> BlendState::getCore() const
 	{
-		return std::static_pointer_cast<ct::BlendStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::BlendState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> BlendState::createCore() const
 	{
-		SPtr<ct::BlendStateCore> core = ct::RenderStateManager::instance()._createBlendState(mProperties.mData);
+		SPtr<ct::BlendState> core = ct::RenderStateManager::instance()._createBlendState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -170,18 +170,18 @@ namespace bs
 
 	namespace ct
 	{
-	BlendStateCore::BlendStateCore(const BLEND_STATE_DESC& desc, UINT32 id)
+	BlendState::BlendState(const BLEND_STATE_DESC& desc, UINT32 id)
 		:mProperties(desc), mId(id)
 	{
 
 	}
 
-	BlendStateCore::~BlendStateCore()
+	BlendState::~BlendState()
 	{
 
 	}
 
-	void BlendStateCore::initialize()
+	void BlendState::initialize()
 	{
 		// Since we cache states it's possible this object was already initialized
 		// (i.e. multiple sim-states can share a single core-state)
@@ -192,17 +192,17 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	const BlendProperties& BlendStateCore::getProperties() const
+	const BlendProperties& BlendState::getProperties() const
 	{
 		return mProperties;
 	}
 
-	SPtr<BlendStateCore> BlendStateCore::create(const BLEND_STATE_DESC& desc)
+	SPtr<BlendState> BlendState::create(const BLEND_STATE_DESC& desc)
 	{
 		return RenderStateManager::instance().createBlendState(desc);
 	}
 
-	const SPtr<BlendStateCore>& BlendStateCore::getDefault()
+	const SPtr<BlendState>& BlendState::getDefault()
 	{
 		return RenderStateManager::instance().getDefaultBlendState();
 	}

Source/BansheeCore/Source/BsCamera.cpp

@@ -730,9 +730,9 @@ namespace bs
 		mViewport = Viewport::create(target, left, top, width, height);
 	}
 
-	SPtr<ct::CameraCore> Camera::getCore() const
+	SPtr<ct::Camera> Camera::getCore() const
 	{
-		return std::static_pointer_cast<ct::CameraCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Camera>(mCoreSpecific);
 	}
 
 	SPtr<Camera> Camera::create(SPtr<RenderTarget> target, float left, float top, float width, float height)
@@ -756,8 +756,8 @@ namespace bs
 
 	SPtr<ct::CoreObject> Camera::createCore() const
 	{
-		ct::CameraCore* handler = new (bs_alloc<ct::CameraCore>()) ct::CameraCore(mViewport->getCore());
-		SPtr<ct::CameraCore> handlerPtr = bs_shared_ptr<ct::CameraCore>(handler);
+		ct::Camera* handler = new (bs_alloc<ct::Camera>()) ct::Camera(mViewport->getCore());
+		SPtr<ct::Camera> handlerPtr = bs_shared_ptr<ct::Camera>(handler);
 		handlerPtr->_setThisPtr(handlerPtr);
 
 		return handlerPtr;
@@ -772,7 +772,7 @@ namespace bs
 	{
 		UINT32 dirtyFlag = getCoreDirtyFlags();
 
-		SPtr<ct::TextureCore> skyTexture;
+		SPtr<ct::Texture> skyTexture;
 		if (mSkyTexture.isLoaded())
 			skyTexture = mSkyTexture->getCore();
 
@@ -798,7 +798,7 @@ namespace bs
 			size += rttiGetElemSize(mCameraFlags);
 			size += rttiGetElemSize(mIsActive);
 			size += rttiGetElemSize(mMSAA);
-			size += sizeof(SPtr<ct::TextureCore>);
+			size += sizeof(SPtr<ct::Texture>);
 			size += sizeof(UINT32);
 
 			if(mPPSettings != nullptr)
@@ -832,7 +832,7 @@ namespace bs
 			dataPtr = rttiWriteElem(mIsActive, dataPtr);
 			dataPtr = rttiWriteElem(mMSAA, dataPtr);
 
-			SPtr<ct::TextureCore>* skyTexDest = new (dataPtr) SPtr<ct::TextureCore>();
+			SPtr<ct::Texture>* skyTexDest = new (dataPtr) SPtr<ct::Texture>();
 			*skyTexDest = skyTexture;
 			dataPtr += sizeof(skyTexture);
 
@@ -869,34 +869,34 @@ namespace bs
 
 	namespace ct
 	{
-	CameraCore::~CameraCore()
+	Camera::~Camera()
 	{
 		RendererManager::instance().getActive()->notifyCameraRemoved(this);
 	}
 
-	CameraCore::CameraCore(SPtr<RenderTargetCore> target, float left, float top, float width, float height)
+	Camera::Camera(SPtr<RenderTarget> target, float left, float top, float width, float height)
 	{
-		mViewport = ViewportCore::create(target, left, top, width, height);
+		mViewport = Viewport::create(target, left, top, width, height);
 	}
 
-	CameraCore::CameraCore(const SPtr<ViewportCore>& viewport)
+	Camera::Camera(const SPtr<Viewport>& viewport)
 	{
 		mViewport = viewport;
 	}
 
-	void CameraCore::initialize()
+	void Camera::initialize()
 	{
 		RendererManager::instance().getActive()->notifyCameraAdded(this);
 
 		CoreObject::initialize();
 	}
 
-	Rect2I CameraCore::getViewportRect() const
+	Rect2I Camera::getViewportRect() const
 	{
 		return mViewport->getArea();
 	}
 
-	void CameraCore::syncToCore(const CoreSyncData& data)
+	void Camera::syncToCore(const CoreSyncData& data)
 	{
 		char* dataPtr = (char*)data.getBuffer();
 
@@ -926,10 +926,10 @@ namespace bs
 			dataPtr = rttiReadElem(mIsActive, dataPtr);
 			dataPtr = rttiReadElem(mMSAA, dataPtr);
 
-			SPtr<TextureCore>* skyTexture = (SPtr<TextureCore>*)dataPtr;
+			SPtr<Texture>* skyTexture = (SPtr<Texture>*)dataPtr;
 			mSkyTexture = *skyTexture;
-			skyTexture->~SPtr<TextureCore>();
-			dataPtr += sizeof(SPtr<TextureCore>);
+			skyTexture->~SPtr<Texture>();
+			dataPtr += sizeof(SPtr<Texture>);
 
 			UINT32 ppSize = 0;
 			dataPtr = rttiReadElem(ppSize, dataPtr);

Source/BansheeCore/Source/BsDepthStencilState.cpp

@@ -44,14 +44,14 @@ namespace bs
 
 	}
 
-	SPtr<ct::DepthStencilStateCore> DepthStencilState::getCore() const
+	SPtr<ct::DepthStencilState> DepthStencilState::getCore() const
 	{
-		return std::static_pointer_cast<ct::DepthStencilStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::DepthStencilState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> DepthStencilState::createCore() const
 	{
-		SPtr<ct::DepthStencilStateCore> core = ct::RenderStateManager::instance()._createDepthStencilState(mProperties.mData);
+		SPtr<ct::DepthStencilState> core = ct::RenderStateManager::instance()._createDepthStencilState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -109,18 +109,18 @@ namespace bs
 
 	namespace ct
 	{
-	DepthStencilStateCore::DepthStencilStateCore(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id)
+	DepthStencilState::DepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id)
 		: mProperties(desc), mId(id)
 	{
 
 	}
 
-	DepthStencilStateCore::~DepthStencilStateCore()
+	DepthStencilState::~DepthStencilState()
 	{
 
 	}
 
-	void DepthStencilStateCore::initialize()
+	void DepthStencilState::initialize()
 	{
 		// Since we cache states it's possible this object was already initialized
 		// (i.e. multiple sim-states can share a single core-state)
@@ -131,17 +131,17 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	const DepthStencilProperties& DepthStencilStateCore::getProperties() const
+	const DepthStencilProperties& DepthStencilState::getProperties() const
 	{
 		return mProperties;
 	}
 
-	SPtr<DepthStencilStateCore> DepthStencilStateCore::create(const DEPTH_STENCIL_STATE_DESC& desc)
+	SPtr<DepthStencilState> DepthStencilState::create(const DEPTH_STENCIL_STATE_DESC& desc)
 	{
 		return RenderStateManager::instance().createDepthStencilState(desc);
 	}
 
-	const SPtr<DepthStencilStateCore>& DepthStencilStateCore::getDefault()
+	const SPtr<DepthStencilState>& DepthStencilState::getDefault()
 	{
 		return RenderStateManager::instance().getDefaultDepthStencilState();
 	}

Source/BansheeCore/Source/BsGpuBuffer.cpp

@@ -31,9 +31,9 @@ namespace bs
 	{  
 	}
 
-	SPtr<ct::GpuBufferCore> GpuBuffer::getCore() const
+	SPtr<ct::GpuBuffer> GpuBuffer::getCore() const
 	{
-		return std::static_pointer_cast<ct::GpuBufferCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GpuBuffer>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GpuBuffer::createCore() const
@@ -98,18 +98,18 @@ namespace bs
 
 	namespace ct
 	{
-	GpuBufferCore::GpuBufferCore(const GPU_BUFFER_DESC& desc, UINT32 deviceMask)
+	GpuBuffer::GpuBuffer(const GPU_BUFFER_DESC& desc, UINT32 deviceMask)
 		:HardwareBuffer(getBufferSize(desc)), mProperties(desc)
 	{
 	}
 
-	GpuBufferCore::~GpuBufferCore()
+	GpuBuffer::~GpuBuffer()
 	{
 		// Make sure that derived classes call clearBufferViews
 		// I can't call it here since it needs a virtual method call
 	}
 
-	SPtr<GpuBufferCore> GpuBufferCore::create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuBuffer> GpuBuffer::create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createGpuBuffer(desc, deviceMask);
 	}

Source/BansheeCore/Source/BsGpuParamBlockBuffer.cpp

@@ -65,9 +65,9 @@ namespace bs
 		markCoreDirty();
 	}
 
-	SPtr<ct::GpuParamBlockBufferCore> GpuParamBlockBuffer::getCore() const
+	SPtr<ct::GpuParamBlockBuffer> GpuParamBlockBuffer::getCore() const
 	{
-		return std::static_pointer_cast<ct::GpuParamBlockBufferCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GpuParamBlockBuffer>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GpuParamBlockBuffer::createCore() const
@@ -90,7 +90,7 @@ namespace bs
 
 	namespace ct
 	{
-	GpuParamBlockBufferCore::GpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
+	GpuParamBlockBuffer::GpuParamBlockBuffer(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
 		:mUsage(usage), mSize(size), mCachedData(nullptr), mGPUBufferDirty(false)
 	{
 		if (mSize > 0)
@@ -99,13 +99,13 @@ namespace bs
 		memset(mCachedData, 0, mSize);
 	}
 
-	GpuParamBlockBufferCore::~GpuParamBlockBufferCore()
+	GpuParamBlockBuffer::~GpuParamBlockBuffer()
 	{
 		if (mCachedData != nullptr)
 			bs_free(mCachedData);
 	}
 
-	void GpuParamBlockBufferCore::write(UINT32 offset, const void* data, UINT32 size)
+	void GpuParamBlockBuffer::write(UINT32 offset, const void* data, UINT32 size)
 	{
 #if BS_DEBUG_MODE
 		if ((offset + size) > mSize)
@@ -120,7 +120,7 @@ namespace bs
 		mGPUBufferDirty = true;
 	}
 
-	void GpuParamBlockBufferCore::read(UINT32 offset, void* data, UINT32 size)
+	void GpuParamBlockBuffer::read(UINT32 offset, void* data, UINT32 size)
 	{
 #if BS_DEBUG_MODE
 		if ((offset + size) > mSize)
@@ -134,7 +134,7 @@ namespace bs
 		memcpy(data, mCachedData + offset, size);
 	}
 
-	void GpuParamBlockBufferCore::zeroOut(UINT32 offset, UINT32 size)
+	void GpuParamBlockBuffer::zeroOut(UINT32 offset, UINT32 size)
 	{
 #if BS_DEBUG_MODE
 		if ((offset + size) > mSize)
@@ -149,7 +149,7 @@ namespace bs
 		mGPUBufferDirty = true;
 	}
 
-	void GpuParamBlockBufferCore::flushToGPU(UINT32 queueIdx)
+	void GpuParamBlockBuffer::flushToGPU(UINT32 queueIdx)
 	{
 		if (mGPUBufferDirty)
 		{
@@ -158,14 +158,14 @@ namespace bs
 		}
 	}
 
-	void GpuParamBlockBufferCore::syncToCore(const CoreSyncData& data)
+	void GpuParamBlockBuffer::syncToCore(const CoreSyncData& data)
 	{
 		assert(mSize == data.getBufferSize());
 
 		write(0, data.getBuffer(), data.getBufferSize());
 	}
 
-	SPtr<GpuParamBlockBufferCore> GpuParamBlockBufferCore::create(UINT32 size, GpuParamBlockUsage usage, 
+	SPtr<GpuParamBlockBuffer> GpuParamBlockBuffer::create(UINT32 size, GpuParamBlockUsage usage, 
 		GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createGpuParamBlockBuffer(size, usage, deviceMask);

Source/BansheeCore/Source/BsGpuParams.cpp

@@ -557,9 +557,9 @@ namespace bs
 		return std::static_pointer_cast<GpuParams>(getThisPtr());
 	}
 
-	SPtr<ct::GpuParamsCore> GpuParams::getCore() const
+	SPtr<ct::GpuParams> GpuParams::getCore() const
 	{
-		return std::static_pointer_cast<ct::GpuParamsCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GpuParams>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GpuParams::createCore() const
@@ -603,11 +603,11 @@ namespace bs
 		UINT32 numSamplers = mParamInfo->getNumElements(GpuPipelineParamInfo::ParamType::SamplerState);
 
 		UINT32 loadStoreSurfacesSize = numStorageTextures * sizeof(TextureSurface);
-		UINT32 paramBufferSize = numParamBlocks * sizeof(SPtr<ct::GpuParamBlockBufferCore>);
-		UINT32 textureArraySize = numTextures * sizeof(SPtr<ct::TextureCore>);
-		UINT32 loadStoreTextureArraySize = numStorageTextures * sizeof(SPtr<ct::TextureCore>);
-		UINT32 bufferArraySize = numBuffers * sizeof(SPtr<ct::GpuBufferCore>);
-		UINT32 samplerArraySize = numSamplers * sizeof(SPtr<ct::SamplerStateCore>);
+		UINT32 paramBufferSize = numParamBlocks * sizeof(SPtr<ct::GpuParamBlockBuffer>);
+		UINT32 textureArraySize = numTextures * sizeof(SPtr<ct::Texture>);
+		UINT32 loadStoreTextureArraySize = numStorageTextures * sizeof(SPtr<ct::Texture>);
+		UINT32 bufferArraySize = numBuffers * sizeof(SPtr<ct::GpuBuffer>);
+		UINT32 samplerArraySize = numSamplers * sizeof(SPtr<ct::SamplerState>);
 
 		UINT32 totalSize = loadStoreSurfacesSize + paramBufferSize + textureArraySize + loadStoreTextureArraySize 
 			+ bufferArraySize + samplerArraySize;
@@ -622,16 +622,16 @@ namespace bs
 		UINT8* data = allocator->alloc(totalSize);
 
 		TextureSurface* loadStoreSurfaces = (TextureSurface*)(data + textureInfoOffset);
-		SPtr<ct::GpuParamBlockBufferCore>* paramBuffers = (SPtr<ct::GpuParamBlockBufferCore>*)(data + paramBufferOffset);
-		SPtr<ct::TextureCore>* textures = (SPtr<ct::TextureCore>*)(data + textureArrayOffset);
-		SPtr<ct::TextureCore>* loadStoreTextures = (SPtr<ct::TextureCore>*)(data + loadStoreTextureArrayOffset);
-		SPtr<ct::GpuBufferCore>* buffers = (SPtr<ct::GpuBufferCore>*)(data + bufferArrayOffset);
-		SPtr<ct::SamplerStateCore>* samplers = (SPtr<ct::SamplerStateCore>*)(data + samplerArrayOffset);
+		SPtr<ct::GpuParamBlockBuffer>* paramBuffers = (SPtr<ct::GpuParamBlockBuffer>*)(data + paramBufferOffset);
+		SPtr<ct::Texture>* textures = (SPtr<ct::Texture>*)(data + textureArrayOffset);
+		SPtr<ct::Texture>* loadStoreTextures = (SPtr<ct::Texture>*)(data + loadStoreTextureArrayOffset);
+		SPtr<ct::GpuBuffer>* buffers = (SPtr<ct::GpuBuffer>*)(data + bufferArrayOffset);
+		SPtr<ct::SamplerState>* samplers = (SPtr<ct::SamplerState>*)(data + samplerArrayOffset);
 
 		// Construct & copy
 		for (UINT32 i = 0; i < numParamBlocks; i++)
 		{
-			new (&paramBuffers[i]) SPtr<ct::GpuParamBlockBufferCore>();
+			new (&paramBuffers[i]) SPtr<ct::GpuParamBlockBuffer>();
 
 			if (mParamBlockBuffers[i] != nullptr)
 				paramBuffers[i] = mParamBlockBuffers[i]->getCore();
@@ -639,7 +639,7 @@ namespace bs
 
 		for (UINT32 i = 0; i < numTextures; i++)
 		{
-			new (&textures[i]) SPtr<ct::TextureCore>();
+			new (&textures[i]) SPtr<ct::Texture>();
 
 			if (mTextures[i].isLoaded())
 				textures[i] = mTextures[i]->getCore();
@@ -652,7 +652,7 @@ namespace bs
 			new (&loadStoreSurfaces[i]) TextureSurface();
 			loadStoreSurfaces[i] = mLoadStoreSurfaces[i];
 
-			new (&loadStoreTextures[i]) SPtr<ct::TextureCore>();
+			new (&loadStoreTextures[i]) SPtr<ct::Texture>();
 
 			if (mLoadStoreTextures[i].isLoaded())
 				loadStoreTextures[i] = mLoadStoreTextures[i]->getCore();
@@ -662,7 +662,7 @@ namespace bs
 
 		for (UINT32 i = 0; i < numBuffers; i++)
 		{
-			new (&buffers[i]) SPtr<ct::GpuBufferCore>();
+			new (&buffers[i]) SPtr<ct::GpuBuffer>();
 
 			if (mBuffers[i] != nullptr)
 				buffers[i] = mBuffers[i]->getCore();
@@ -672,7 +672,7 @@ namespace bs
 
 		for (UINT32 i = 0; i < numSamplers; i++)
 		{
-			new (&samplers[i]) SPtr<ct::SamplerStateCore>();
+			new (&samplers[i]) SPtr<ct::SamplerState>();
 
 			if (mSamplerStates[i] != nullptr)
 				samplers[i] = mSamplerStates[i]->getCore();
@@ -703,18 +703,18 @@ namespace bs
 
 	namespace ct
 	{
-	GpuParamsCore::GpuParamsCore(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
+	GpuParams::GpuParams(const SPtr<GpuPipelineParamInfo>& paramInfo, GpuDeviceFlags deviceMask)
 		: TGpuParams(paramInfo)
 	{
 
 	}
 
-	SPtr<GpuParamsCore> GpuParamsCore::_getThisPtr() const
+	SPtr<GpuParams> GpuParams::_getThisPtr() const
 	{
-		return std::static_pointer_cast<GpuParamsCore>(getThisPtr());
+		return std::static_pointer_cast<GpuParams>(getThisPtr());
 	}
 
-	void GpuParamsCore::syncToCore(const CoreSyncData& data)
+	void GpuParams::syncToCore(const CoreSyncData& data)
 	{
 		UINT32 numParamBlocks = mParamInfo->getNumElements(GpuPipelineParamInfo::ParamType::ParamBlock);
 		UINT32 numTextures = mParamInfo->getNumElements(GpuPipelineParamInfo::ParamType::Texture);
@@ -723,11 +723,11 @@ namespace bs
 		UINT32 numSamplers = mParamInfo->getNumElements(GpuPipelineParamInfo::ParamType::SamplerState);
 
 		UINT32 loadStoreSurfacesSize = numStorageTextures * sizeof(TextureSurface);
-		UINT32 paramBufferSize = numParamBlocks * sizeof(SPtr<GpuParamBlockBufferCore>);
-		UINT32 textureArraySize = numTextures * sizeof(SPtr<TextureCore>);
-		UINT32 loadStoreTextureArraySize = numStorageTextures * sizeof(SPtr<TextureCore>);
-		UINT32 bufferArraySize = numBuffers * sizeof(SPtr<GpuBufferCore>);
-		UINT32 samplerArraySize = numSamplers * sizeof(SPtr<SamplerStateCore>);
+		UINT32 paramBufferSize = numParamBlocks * sizeof(SPtr<GpuParamBlockBuffer>);
+		UINT32 textureArraySize = numTextures * sizeof(SPtr<Texture>);
+		UINT32 loadStoreTextureArraySize = numStorageTextures * sizeof(SPtr<Texture>);
+		UINT32 bufferArraySize = numBuffers * sizeof(SPtr<GpuBuffer>);
+		UINT32 samplerArraySize = numSamplers * sizeof(SPtr<SamplerState>);
 
 		UINT32 totalSize = loadStoreSurfacesSize + paramBufferSize + textureArraySize + loadStoreTextureArraySize
 			+ bufferArraySize + samplerArraySize;
@@ -744,23 +744,23 @@ namespace bs
 		UINT8* dataPtr = data.getBuffer();
 
 		TextureSurface* loadStoreSurfaces = (TextureSurface*)(dataPtr + textureInfoOffset);
-		SPtr<GpuParamBlockBufferCore>* paramBuffers = (SPtr<GpuParamBlockBufferCore>*)(dataPtr + paramBufferOffset);
-		SPtr<TextureCore>* textures = (SPtr<TextureCore>*)(dataPtr + textureArrayOffset);
-		SPtr<TextureCore>* loadStoreTextures = (SPtr<TextureCore>*)(dataPtr + loadStoreTextureArrayOffset);
-		SPtr<GpuBufferCore>* buffers = (SPtr<GpuBufferCore>*)(dataPtr + bufferArrayOffset);
-		SPtr<SamplerStateCore>* samplers = (SPtr<SamplerStateCore>*)(dataPtr + samplerArrayOffset);
+		SPtr<GpuParamBlockBuffer>* paramBuffers = (SPtr<GpuParamBlockBuffer>*)(dataPtr + paramBufferOffset);
+		SPtr<Texture>* textures = (SPtr<Texture>*)(dataPtr + textureArrayOffset);
+		SPtr<Texture>* loadStoreTextures = (SPtr<Texture>*)(dataPtr + loadStoreTextureArrayOffset);
+		SPtr<GpuBuffer>* buffers = (SPtr<GpuBuffer>*)(dataPtr + bufferArrayOffset);
+		SPtr<SamplerState>* samplers = (SPtr<SamplerState>*)(dataPtr + samplerArrayOffset);
 
 		// Copy & destruct
 		for (UINT32 i = 0; i < numParamBlocks; i++)
 		{
 			mParamBlockBuffers[i] = paramBuffers[i];
-			paramBuffers[i].~SPtr<GpuParamBlockBufferCore>();
+			paramBuffers[i].~SPtr<GpuParamBlockBuffer>();
 		}
 
 		for (UINT32 i = 0; i < numTextures; i++)
 		{
 			mTextures[i] = textures[i];
-			textures[i].~SPtr<TextureCore>();
+			textures[i].~SPtr<Texture>();
 		}
 
 		for (UINT32 i = 0; i < numStorageTextures; i++)
@@ -769,33 +769,33 @@ namespace bs
 			loadStoreSurfaces[i].~TextureSurface();
 
 			mLoadStoreTextures[i] = loadStoreTextures[i];
-			loadStoreTextures[i].~SPtr<TextureCore>();
+			loadStoreTextures[i].~SPtr<Texture>();
 		}
 
 		for (UINT32 i = 0; i < numBuffers; i++)
 		{
 			mBuffers[i] = buffers[i];
-			buffers[i].~SPtr<GpuBufferCore>();
+			buffers[i].~SPtr<GpuBuffer>();
 		}
 
 		for (UINT32 i = 0; i < numSamplers; i++)
 		{
 			mSamplerStates[i] = samplers[i];
-			samplers[i].~SPtr<SamplerStateCore>();
+			samplers[i].~SPtr<SamplerState>();
 		}
 	}
 
-	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<GraphicsPipelineStateCore>& pipelineState, GpuDeviceFlags deviceMask)
+	SPtr<GpuParams> GpuParams::create(const SPtr<GraphicsPipelineState>& pipelineState, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
 	}
 
-	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<ComputePipelineStateCore>& pipelineState, GpuDeviceFlags deviceMask)
+	SPtr<GpuParams> GpuParams::create(const SPtr<ComputePipelineState>& pipelineState, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
 	}
 
-	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
+	SPtr<GpuParams> GpuParams::create(const SPtr<GpuPipelineParamInfo>& paramInfo, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createGpuParams(paramInfo, deviceMask);
 	}

Source/BansheeCore/Source/BsGpuParamsSet.cpp

@@ -133,27 +133,27 @@ namespace bs
 		{
 			SPtr<ct::Pass> curPass = technique->getPass(i);
 
-			SPtr<ct::GpuProgramCore> vertProgram = curPass->getVertexProgram();
+			SPtr<ct::GpuProgram> vertProgram = curPass->getVertexProgram();
 			if (vertProgram)
 				allParamDescs.push_back(vertProgram->getParamDesc());
 
-			SPtr<ct::GpuProgramCore> fragProgram = curPass->getFragmentProgram();
+			SPtr<ct::GpuProgram> fragProgram = curPass->getFragmentProgram();
 			if (fragProgram)
 				allParamDescs.push_back(fragProgram->getParamDesc());
 
-			SPtr<ct::GpuProgramCore> geomProgram = curPass->getGeometryProgram();
+			SPtr<ct::GpuProgram> geomProgram = curPass->getGeometryProgram();
 			if (geomProgram)
 				allParamDescs.push_back(geomProgram->getParamDesc());
 
-			SPtr<ct::GpuProgramCore> hullProgram = curPass->getHullProgram();
+			SPtr<ct::GpuProgram> hullProgram = curPass->getHullProgram();
 			if (hullProgram)
 				allParamDescs.push_back(hullProgram->getParamDesc());
 
-			SPtr<ct::GpuProgramCore> domainProgram = curPass->getDomainProgram();
+			SPtr<ct::GpuProgram> domainProgram = curPass->getDomainProgram();
 			if (domainProgram)
 				allParamDescs.push_back(domainProgram->getParamDesc());
 
-			SPtr<ct::GpuProgramCore> computeProgram = curPass->getComputeProgram();
+			SPtr<ct::GpuProgram> computeProgram = curPass->getComputeProgram();
 			if (computeProgram)
 				allParamDescs.push_back(computeProgram->getParamDesc());
 		}

Source/BansheeCore/Source/BsGpuPipelineParamInfo.cpp

@@ -230,9 +230,9 @@ namespace bs
 		return paramInfo;
 	}
 
-	SPtr<ct::GpuPipelineParamInfoCore> GpuPipelineParamInfo::getCore() const
+	SPtr<ct::GpuPipelineParamInfo> GpuPipelineParamInfo::getCore() const
 	{
-		return std::static_pointer_cast<ct::GpuPipelineParamInfoCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GpuPipelineParamInfo>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GpuPipelineParamInfo::createCore() const
@@ -250,11 +250,11 @@ namespace bs
 
 	namespace ct
 	{
-	GpuPipelineParamInfoCore::GpuPipelineParamInfoCore(const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask)
+	GpuPipelineParamInfo::GpuPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask)
 		:GpuPipelineParamInfoBase(desc)
 	{ }
 
-	SPtr<GpuPipelineParamInfoCore> GpuPipelineParamInfoCore::create(const GPU_PIPELINE_PARAMS_DESC& desc, 
+	SPtr<GpuPipelineParamInfo> GpuPipelineParamInfo::create(const GPU_PIPELINE_PARAMS_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
 		return RenderStateManager::instance().createPipelineParamInfo(desc, deviceMask);

Source/BansheeCore/Source/BsGpuPipelineState.cpp

@@ -73,9 +73,9 @@ namespace bs
 		mParamInfo = GpuPipelineParamInfo::create(paramsDesc);
 	}
 
-	SPtr<ct::GraphicsPipelineStateCore> GraphicsPipelineState::getCore() const
+	SPtr<ct::GraphicsPipelineState> GraphicsPipelineState::getCore() const
 	{
-		return std::static_pointer_cast<ct::GraphicsPipelineStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GraphicsPipelineState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GraphicsPipelineState::createCore() const
@@ -113,9 +113,9 @@ namespace bs
 		mParamInfo = GpuPipelineParamInfo::create(paramsDesc);
 	}
 
-	SPtr<ct::ComputePipelineStateCore> ComputePipelineState::getCore() const
+	SPtr<ct::ComputePipelineState> ComputePipelineState::getCore() const
 	{
-		return std::static_pointer_cast<ct::ComputePipelineStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::ComputePipelineState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> ComputePipelineState::createCore() const
@@ -130,11 +130,11 @@ namespace bs
 
 	namespace ct
 	{
-	GraphicsPipelineStateCore::GraphicsPipelineStateCore(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask)
+	GraphicsPipelineState::GraphicsPipelineState(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 		:TGraphicsPipelineState(desc), mDeviceMask(deviceMask)
 	{ }
 
-	void GraphicsPipelineStateCore::initialize()
+	void GraphicsPipelineState::initialize()
 	{
 		GPU_PIPELINE_PARAMS_DESC paramsDesc;
 		if (mData.vertexProgram != nullptr)
@@ -152,31 +152,31 @@ namespace bs
 		if (mData.domainProgram != nullptr)
 			paramsDesc.domainParams = mData.domainProgram->getParamDesc();
 
-		mParamInfo = GpuPipelineParamInfoCore::create(paramsDesc, mDeviceMask);
+		mParamInfo = GpuPipelineParamInfo::create(paramsDesc, mDeviceMask);
 
 		CoreObject::initialize();
 	}
 
-	SPtr<GraphicsPipelineStateCore> GraphicsPipelineStateCore::create(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GraphicsPipelineState> GraphicsPipelineState::create(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return RenderStateManager::instance().createGraphicsPipelineState(desc, deviceMask);
 	}
 
-	ComputePipelineStateCore::ComputePipelineStateCore(const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask)
+	ComputePipelineState::ComputePipelineState(const SPtr<GpuProgram>& program, GpuDeviceFlags deviceMask)
 		:TComputePipelineState(program), mDeviceMask(deviceMask)
 	{ }
 
-	void ComputePipelineStateCore::initialize()
+	void ComputePipelineState::initialize()
 	{
 		GPU_PIPELINE_PARAMS_DESC paramsDesc;
 		paramsDesc.computeParams = mProgram->getParamDesc();
 
-		mParamInfo = GpuPipelineParamInfoCore::create(paramsDesc, mDeviceMask);
+		mParamInfo = GpuPipelineParamInfo::create(paramsDesc, mDeviceMask);
 
 		CoreObject::initialize();
 	}
 
-	SPtr<ComputePipelineStateCore> ComputePipelineStateCore::create(const SPtr<GpuProgramCore>& program, 
+	SPtr<ComputePipelineState> ComputePipelineState::create(const SPtr<GpuProgram>& program, 
 		GpuDeviceFlags deviceMask)
 	{
 		return RenderStateManager::instance().createComputePipelineState(program, deviceMask);

Source/BansheeCore/Source/BsGpuProgram.cpp

@@ -36,9 +36,9 @@ namespace bs
 		return getCore()->getParamDesc();
 	}
 
-	SPtr<ct::GpuProgramCore> GpuProgram::getCore() const
+	SPtr<ct::GpuProgram> GpuProgram::getCore() const
 	{
-		return std::static_pointer_cast<ct::GpuProgramCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::GpuProgram>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> GpuProgram::createCore() const
@@ -73,14 +73,14 @@ namespace bs
 
 	namespace ct
 	{
-	GpuProgramCore::GpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	GpuProgram::GpuProgram(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 		:mNeedsAdjacencyInfo(desc.requiresAdjacency), mIsCompiled(false), mProperties(desc.source, desc.entryPoint, 
 			desc.type)
 	{
 		mParametersDesc = bs_shared_ptr_new<GpuParamDesc>();
 	}
 
-	bool GpuProgramCore::isSupported() const
+	bool GpuProgram::isSupported() const
     {
 		if (!isRequiredCapabilitiesSupported())
 			return false;
@@ -88,12 +88,12 @@ namespace bs
 		return true;
     }
 
-	bool GpuProgramCore::isRequiredCapabilitiesSupported() const
+	bool GpuProgram::isRequiredCapabilitiesSupported() const
 	{
 		return true;
 	}
 
-	SPtr<GpuProgramCore> GpuProgramCore::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuProgram> GpuProgram::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return GpuProgramManager::instance().create(desc, deviceMask);
 	}

Source/BansheeCore/Source/BsGpuProgramManager.cpp

@@ -33,14 +33,14 @@ namespace bs
 	String sNullLang = "null";
 
 	/** Null GPU program used in place of GPU programs we cannot create. Null programs don't do anything. */
-	class NullProgramCore : public GpuProgramCore
+	class NullProgram : public GpuProgram
 	{
 	public:
-		NullProgramCore()
-			:GpuProgramCore(GPU_PROGRAM_DESC(), GDF_DEFAULT)
+		NullProgram()
+			:GpuProgram(GPU_PROGRAM_DESC(), GDF_DEFAULT)
 		{ }
 
-		~NullProgramCore() { }
+		~NullProgram() { }
 
 		bool isSupported() const { return false; }
 		const String& getLanguage() const { return sNullLang; }
@@ -63,17 +63,17 @@ namespace bs
 			return sNullLang;
 		}
 
-		SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask) override
+		SPtr<GpuProgram> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask) override
 		{
-			SPtr<NullProgramCore> ret = bs_shared_ptr_new<NullProgramCore>();
+			SPtr<NullProgram> ret = bs_shared_ptr_new<NullProgram>();
 			ret->_setThisPtr(ret);
 
 			return ret;
 		}
 
-		SPtr<GpuProgramCore> create(GpuProgramType type, GpuDeviceFlags deviceMask) override
+		SPtr<GpuProgram> create(GpuProgramType type, GpuDeviceFlags deviceMask) override
 		{
-			SPtr<NullProgramCore> ret = bs_shared_ptr_new<NullProgramCore>();
+			SPtr<NullProgram> ret = bs_shared_ptr_new<NullProgram>();
 			ret->_setThisPtr(ret);
 
 			return ret;
@@ -122,18 +122,18 @@ namespace bs
 		return i != mFactories.end();
 	}
 
-	SPtr<GpuProgramCore> GpuProgramManager::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuProgram> GpuProgramManager::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
     {
-		SPtr<GpuProgramCore> ret = createInternal(desc, deviceMask);
+		SPtr<GpuProgram> ret = createInternal(desc, deviceMask);
 		ret->initialize();
 
         return ret;
     }
 
-	SPtr<GpuProgramCore> GpuProgramManager::createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuProgram> GpuProgramManager::createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		GpuProgramFactory* factory = getFactory(desc.language);
-		SPtr<GpuProgramCore> ret = factory->create(desc, deviceMask);
+		SPtr<GpuProgram> ret = factory->create(desc, deviceMask);
 
 		return ret;
 	}

Source/BansheeCore/Source/BsHardwareBufferManager.cpp

@@ -111,24 +111,24 @@ namespace bs
 		return true;
 	}
 
-	SPtr<IndexBufferCore> HardwareBufferManager::createIndexBuffer(const INDEX_BUFFER_DESC& desc, 
+	SPtr<IndexBuffer> HardwareBufferManager::createIndexBuffer(const INDEX_BUFFER_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
-		SPtr<IndexBufferCore> ibuf = createIndexBufferInternal(desc, deviceMask);
+		SPtr<IndexBuffer> ibuf = createIndexBufferInternal(desc, deviceMask);
 		ibuf->initialize();
 		return ibuf;
 
 	}
 
-	SPtr<VertexBufferCore> HardwareBufferManager::createVertexBuffer(const VERTEX_BUFFER_DESC& desc, 
+	SPtr<VertexBuffer> HardwareBufferManager::createVertexBuffer(const VERTEX_BUFFER_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
-		SPtr<VertexBufferCore> vbuf = createVertexBufferInternal(desc, deviceMask);
+		SPtr<VertexBuffer> vbuf = createVertexBufferInternal(desc, deviceMask);
 		vbuf->initialize();
 		return vbuf;
 	}
 
-	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclaration(const SPtr<VertexDataDesc>& desc, 
+	SPtr<VertexDeclaration> HardwareBufferManager::createVertexDeclaration(const SPtr<VertexDataDesc>& desc, 
 		GpuDeviceFlags deviceMask)
 	{
 		List<VertexElement> elements = desc->createElements();
@@ -136,16 +136,16 @@ namespace bs
 		return createVertexDeclaration(elements, deviceMask);
 	}
 
-	SPtr<GpuParamsCore> HardwareBufferManager::createGpuParams(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
+	SPtr<GpuParams> HardwareBufferManager::createGpuParams(const SPtr<GpuPipelineParamInfo>& paramInfo,
 																   GpuDeviceFlags deviceMask)
     {
-		SPtr<GpuParamsCore> params = createGpuParamsInternal(paramInfo, deviceMask);
+		SPtr<GpuParams> params = createGpuParamsInternal(paramInfo, deviceMask);
 		params->initialize();
 
 		return params;
     }
 
-	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclaration(const List<VertexElement>& elements,
+	SPtr<VertexDeclaration> HardwareBufferManager::createVertexDeclaration(const List<VertexElement>& elements,
 		GpuDeviceFlags deviceMask)
 	{
 		VertexDeclarationKey key(elements);
@@ -154,47 +154,47 @@ namespace bs
 		if (iterFind != mCachedDeclarations.end())
 			return iterFind->second;
 
-		SPtr<VertexDeclarationCore> declPtr = createVertexDeclarationInternal(elements, deviceMask);
+		SPtr<VertexDeclaration> declPtr = createVertexDeclarationInternal(elements, deviceMask);
 		declPtr->initialize();
 
 		mCachedDeclarations[key] = declPtr;
 		return declPtr;
 	}
 
-	SPtr<GpuParamBlockBufferCore> HardwareBufferManager::createGpuParamBlockBuffer(UINT32 size, 
+	SPtr<GpuParamBlockBuffer> HardwareBufferManager::createGpuParamBlockBuffer(UINT32 size, 
 		GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
 	{
-		SPtr<GpuParamBlockBufferCore> paramBlockPtr = createGpuParamBlockBufferInternal(size, usage, deviceMask);
+		SPtr<GpuParamBlockBuffer> paramBlockPtr = createGpuParamBlockBufferInternal(size, usage, deviceMask);
 		paramBlockPtr->initialize();
 
 		return paramBlockPtr;
 	}
 
-	SPtr<GpuBufferCore> HardwareBufferManager::createGpuBuffer(const GPU_BUFFER_DESC& desc,
+	SPtr<GpuBuffer> HardwareBufferManager::createGpuBuffer(const GPU_BUFFER_DESC& desc,
 		GpuDeviceFlags deviceMask)
 	{
-		SPtr<GpuBufferCore> gbuf = createGpuBufferInternal(desc, deviceMask);
+		SPtr<GpuBuffer> gbuf = createGpuBufferInternal(desc, deviceMask);
 		gbuf->initialize();
 
 		return gbuf;
 	}
 
-	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclarationInternal(
+	SPtr<VertexDeclaration> HardwareBufferManager::createVertexDeclarationInternal(
 		const List<VertexElement>& elements, GpuDeviceFlags deviceMask)
 	{
-		VertexDeclarationCore* decl = new (bs_alloc<VertexDeclarationCore>()) VertexDeclarationCore(elements, deviceMask);
+		VertexDeclaration* decl = new (bs_alloc<VertexDeclaration>()) VertexDeclaration(elements, deviceMask);
 
-		SPtr<VertexDeclarationCore> ret = bs_shared_ptr<VertexDeclarationCore>(decl);
+		SPtr<VertexDeclaration> ret = bs_shared_ptr<VertexDeclaration>(decl);
 		ret->_setThisPtr(ret);
 
 		return ret;
 	}
 
-	SPtr<GpuParamsCore> HardwareBufferManager::createGpuParamsInternal(
-		const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
+	SPtr<GpuParams> HardwareBufferManager::createGpuParamsInternal(
+		const SPtr<GpuPipelineParamInfo>& paramInfo, GpuDeviceFlags deviceMask)
     {
-		GpuParamsCore* params = new (bs_alloc<GpuParamsCore>()) GpuParamsCore(paramInfo, deviceMask);
-		SPtr<GpuParamsCore> paramsPtr = bs_shared_ptr<GpuParamsCore>(params);
+		GpuParams* params = new (bs_alloc<GpuParams>()) GpuParams(paramInfo, deviceMask);
+		SPtr<GpuParams> paramsPtr = bs_shared_ptr<GpuParams>(params);
 		paramsPtr->_setThisPtr(paramsPtr);
 
 		return paramsPtr;

Source/BansheeCore/Source/BsIndexBuffer.cpp

@@ -28,9 +28,9 @@ namespace bs
 
 	}
 
-	SPtr<ct::IndexBufferCore> IndexBuffer::getCore() const
+	SPtr<ct::IndexBuffer> IndexBuffer::getCore() const
 	{
-		return std::static_pointer_cast<ct::IndexBufferCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::IndexBuffer>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> IndexBuffer::createCore() const
@@ -50,11 +50,11 @@ namespace bs
 
 	namespace ct
 	{
-	IndexBufferCore::IndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	IndexBuffer::IndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 		:HardwareBuffer(calcIndexSize(desc.indexType) * desc.numIndices), mProperties(desc.indexType, desc.numIndices)
 	{ }
 
-	SPtr<IndexBufferCore> IndexBufferCore::create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<IndexBuffer> IndexBuffer::create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createIndexBuffer(desc, deviceMask);
 	}

Source/BansheeCore/Source/BsMaterialParams.cpp

@@ -731,7 +731,7 @@ namespace bs
 			case ParamType::Texture:
 			{
 				HTexture texture = params->mTextureParams[param.index].value;
-				SPtr<TextureCore> textureCore;
+				SPtr<Texture> textureCore;
 				if (texture.isLoaded())
 					textureCore = texture->getCore();
 
@@ -742,8 +742,8 @@ namespace bs
 				break;
 			case ParamType::Buffer:
 			{
-				SPtr<GpuBuffer> buffer = params->mBufferParams[param.index].value;
-				SPtr<GpuBufferCore> bufferCore;
+				SPtr<bs::GpuBuffer> buffer = params->mBufferParams[param.index].value;
+				SPtr<GpuBuffer> bufferCore;
 				if (buffer != nullptr)
 					bufferCore = buffer->getCore();
 
@@ -752,8 +752,8 @@ namespace bs
 				break;
 			case ParamType::Sampler:
 			{
-				SPtr<SamplerState> sampState = params->mSamplerStateParams[param.index].value;
-				SPtr<SamplerStateCore> sampStateCore;
+				SPtr<bs::SamplerState> sampState = params->mSamplerStateParams[param.index].value;
+				SPtr<SamplerState> sampStateCore;
 				if (sampState != nullptr)
 					sampStateCore = sampState->getCore();
 
@@ -789,7 +789,7 @@ namespace bs
 			param.version = mParamVersion;
 
 			UINT32 arraySize = param.arraySize > 1 ? param.arraySize : 1;
-			const GpuParamDataTypeInfo& typeInfo = GpuParams::PARAM_SIZES.lookup[(int)param.type];
+			const GpuParamDataTypeInfo& typeInfo = bs::GpuParams::PARAM_SIZES.lookup[(int)param.type];
 			UINT32 paramSize = typeInfo.numColumns * typeInfo.numRows * typeInfo.baseTypeSize;
 
 			UINT32 dataParamSize = arraySize * paramSize;

Source/BansheeCore/Source/BsMesh.cpp

@@ -50,8 +50,8 @@ namespace bs
 
 		data->_lock();
 
-		std::function<void(const SPtr<ct::MeshCore>&, const SPtr<MeshData>&, bool, AsyncOp&)> func =
-			[&](const SPtr<ct::MeshCore>& mesh, const SPtr<MeshData>& _meshData, bool _discardEntireBuffer, AsyncOp& asyncOp)
+		std::function<void(const SPtr<ct::Mesh>&, const SPtr<MeshData>&, bool, AsyncOp&)> func =
+			[&](const SPtr<ct::Mesh>& mesh, const SPtr<MeshData>& _meshData, bool _discardEntireBuffer, AsyncOp& asyncOp)
 		{
 			mesh->writeData(*_meshData, _discardEntireBuffer, false);
 			_meshData->_unlock();
@@ -67,8 +67,8 @@ namespace bs
 	{
 		data->_lock();
 
-		std::function<void(const SPtr<ct::MeshCore>&, const SPtr<MeshData>&, AsyncOp&)> func =
-			[&](const SPtr<ct::MeshCore>& mesh, const SPtr<MeshData>& _meshData, AsyncOp& asyncOp)
+		std::function<void(const SPtr<ct::Mesh>&, const SPtr<MeshData>&, AsyncOp&)> func =
+			[&](const SPtr<ct::Mesh>& mesh, const SPtr<MeshData>& _meshData, AsyncOp& asyncOp)
 		{
 			// Make sure any queued command start executing before reading
 			ct::RenderAPI::instance().submitCommandBuffer(nullptr);
@@ -108,9 +108,9 @@ namespace bs
 		markCoreDirty();
 	}
 
-	SPtr<ct::MeshCore> Mesh::getCore() const
+	SPtr<ct::Mesh> Mesh::getCore() const
 	{
-		return std::static_pointer_cast<ct::MeshCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Mesh>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> Mesh::createCore() const
@@ -125,9 +125,9 @@ namespace bs
 		desc.skeleton = mSkeleton;
 		desc.morphShapes = mMorphShapes;
 
-		ct::MeshCore* obj = new (bs_alloc<ct::MeshCore>()) ct::MeshCore(mCPUData, desc, GDF_DEFAULT);
+		ct::Mesh* obj = new (bs_alloc<ct::Mesh>()) ct::Mesh(mCPUData, desc, GDF_DEFAULT);
 
-		SPtr<ct::CoreObject> meshCore = bs_shared_ptr<ct::MeshCore>(obj);
+		SPtr<ct::CoreObject> meshCore = bs_shared_ptr<ct::Mesh>(obj);
 		meshCore->_setThisPtr(meshCore);
 
 		if ((mUsage & MU_CPUCACHED) == 0)
@@ -293,14 +293,14 @@ namespace bs
 
 	namespace ct
 	{
-	MeshCore::MeshCore(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask)
-		: MeshCoreBase(desc.numVertices, desc.numIndices, desc.subMeshes), mVertexData(nullptr), mIndexBuffer(nullptr)
+	Mesh::Mesh(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask)
+		: MeshBase(desc.numVertices, desc.numIndices, desc.subMeshes), mVertexData(nullptr), mIndexBuffer(nullptr)
 		, mVertexDesc(desc.vertexDesc), mUsage(desc.usage), mIndexType(desc.indexType), mDeviceMask(deviceMask)
 		, mTempInitialMeshData(initialMeshData), mSkeleton(desc.skeleton), mMorphShapes(desc.morphShapes)
 		
 	{ }
 
-	MeshCore::~MeshCore()
+	Mesh::~Mesh()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -310,7 +310,7 @@ namespace bs
 		mTempInitialMeshData = nullptr;
 	}
 
-	void MeshCore::initialize()
+	void Mesh::initialize()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -322,12 +322,12 @@ namespace bs
 		ibDesc.numIndices = mProperties.mNumIndices;
 		ibDesc.usage = (GpuBufferUsage)usage;
 
-		mIndexBuffer = IndexBufferCore::create(ibDesc, mDeviceMask);
+		mIndexBuffer = IndexBuffer::create(ibDesc, mDeviceMask);
 
 		mVertexData = SPtr<VertexData>(bs_new<VertexData>());
 
 		mVertexData->vertexCount = mProperties.mNumVertices;
-		mVertexData->vertexDeclaration = VertexDeclarationCore::create(mVertexDesc, mDeviceMask);
+		mVertexData->vertexDeclaration = VertexDeclaration::create(mVertexDesc, mDeviceMask);
 
 		for (UINT32 i = 0; i <= mVertexDesc->getMaxStreamIdx(); i++)
 		{
@@ -339,7 +339,7 @@ namespace bs
 			vbDesc.numVerts = mVertexData->vertexCount;
 			vbDesc.usage = (GpuBufferUsage)usage;
 
-			SPtr<VertexBufferCore> vertexBuffer = VertexBufferCore::create(vbDesc, mDeviceMask);
+			SPtr<VertexBuffer> vertexBuffer = VertexBuffer::create(vbDesc, mDeviceMask);
 			mVertexData->setBuffer(i, vertexBuffer);
 		}
 
@@ -351,31 +351,31 @@ namespace bs
 			mTempInitialMeshData = nullptr;
 		}
 
-		MeshCoreBase::initialize();
+		MeshBase::initialize();
 	}
 
-	SPtr<VertexData> MeshCore::getVertexData() const
+	SPtr<VertexData> Mesh::getVertexData() const
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		return mVertexData;
 	}
 
-	SPtr<IndexBufferCore> MeshCore::getIndexBuffer() const
+	SPtr<IndexBuffer> Mesh::getIndexBuffer() const
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		return mIndexBuffer;
 	}
 
-	SPtr<VertexDataDesc> MeshCore::getVertexDesc() const
+	SPtr<VertexDataDesc> Mesh::getVertexDesc() const
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		return mVertexDesc;
 	}
 
-	void MeshCore::writeData(const MeshData& meshData, bool discardEntireBuffer, bool performUpdateBounds, UINT32 queueIdx)
+	void Mesh::writeData(const MeshData& meshData, bool discardEntireBuffer, bool performUpdateBounds, UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -438,7 +438,7 @@ namespace bs
 				continue;
 			}
 
-			SPtr<VertexBufferCore> vertexBuffer = mVertexData->getBuffer(i);
+			SPtr<VertexBuffer> vertexBuffer = mVertexData->getBuffer(i);
 
 			UINT32 bufferSize = meshData.getStreamSize(i);
 			UINT8* srcVertBufferData = meshData.getStreamData(i);
@@ -455,7 +455,7 @@ namespace bs
 				memcpy(bufferCopy, srcVertBufferData, bufferSize); // TODO Low priority - Attempt to avoid this copy
 
 				UINT32 vertexStride = meshData.getVertexDesc()->getVertexStride(i);
-				for (INT32 semanticIdx = 0; semanticIdx < VertexBuffer::MAX_SEMANTIC_IDX; semanticIdx++)
+				for (INT32 semanticIdx = 0; semanticIdx < bs::VertexBuffer::MAX_SEMANTIC_IDX; semanticIdx++)
 				{
 					if (!meshData.getVertexDesc()->hasElement(VES_COLOR, semanticIdx, i))
 						continue;
@@ -486,7 +486,7 @@ namespace bs
 			updateBounds(meshData);
 	}
 
-	void MeshCore::readData(MeshData& meshData, UINT32 deviceIdx, UINT32 queueIdx)
+	void Mesh::readData(MeshData& meshData, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -539,7 +539,7 @@ namespace bs
 				if (!meshData.getVertexDesc()->hasStream(streamIdx))
 					continue;
 
-				SPtr<VertexBufferCore> vertexBuffer = iter->second;
+				SPtr<VertexBuffer> vertexBuffer = iter->second;
 				const VertexBufferProperties& vbProps = vertexBuffer->getProperties();
 
 				// Ensure both have the same sized vertices
@@ -574,14 +574,14 @@ namespace bs
 		}
 	}
 
-	void MeshCore::updateBounds(const MeshData& meshData)
+	void Mesh::updateBounds(const MeshData& meshData)
 	{
 		mProperties.mBounds = meshData.calculateBounds();
 		
 		// TODO - Sync this to sim-thread possibly?
 	}
 
-	SPtr<MeshCore> MeshCore::create(UINT32 numVertices, UINT32 numIndices, const SPtr<VertexDataDesc>& vertexDesc,
+	SPtr<Mesh> Mesh::create(UINT32 numVertices, UINT32 numIndices, const SPtr<VertexDataDesc>& vertexDesc,
 		int usage, DrawOperationType drawOp, IndexType indexType, GpuDeviceFlags deviceMask)
 	{
 		MESH_DESC desc;
@@ -592,16 +592,16 @@ namespace bs
 		desc.usage = usage;
 		desc.indexType = indexType;
 
-		SPtr<MeshCore> mesh = bs_shared_ptr<MeshCore>(new (bs_alloc<MeshCore>()) MeshCore(nullptr, desc, deviceMask));
+		SPtr<Mesh> mesh = bs_shared_ptr<Mesh>(new (bs_alloc<Mesh>()) Mesh(nullptr, desc, deviceMask));
 		mesh->_setThisPtr(mesh);
 		mesh->initialize();
 
 		return mesh;
 	}
 
-	SPtr<MeshCore> MeshCore::create(const MESH_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<Mesh> Mesh::create(const MESH_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		SPtr<MeshCore> mesh = bs_shared_ptr<MeshCore>(new (bs_alloc<MeshCore>()) MeshCore(nullptr, desc, deviceMask));
+		SPtr<Mesh> mesh = bs_shared_ptr<Mesh>(new (bs_alloc<Mesh>()) Mesh(nullptr, desc, deviceMask));
 
 		mesh->_setThisPtr(mesh);
 		mesh->initialize();
@@ -609,7 +609,7 @@ namespace bs
 		return mesh;
 	}
 
-	SPtr<MeshCore> MeshCore::create(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<Mesh> Mesh::create(const SPtr<MeshData>& initialMeshData, const MESH_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		MESH_DESC descCopy = desc;
 		descCopy.numVertices = initialMeshData->getNumVertices();
@@ -617,8 +617,8 @@ namespace bs
 		descCopy.vertexDesc = initialMeshData->getVertexDesc();
 		descCopy.indexType = initialMeshData->getIndexType();
 
-		SPtr<MeshCore> mesh = 
-			bs_shared_ptr<MeshCore>(new (bs_alloc<MeshCore>()) MeshCore(initialMeshData, descCopy, deviceMask));
+		SPtr<Mesh> mesh = 
+			bs_shared_ptr<Mesh>(new (bs_alloc<Mesh>()) Mesh(initialMeshData, descCopy, deviceMask));
 
 		mesh->_setThisPtr(mesh);
 		mesh->initialize();
@@ -626,7 +626,7 @@ namespace bs
 		return mesh;
 	}
 
-	SPtr<MeshCore> MeshCore::create(const SPtr<MeshData>& initialMeshData, int usage, DrawOperationType drawOp, 
+	SPtr<Mesh> Mesh::create(const SPtr<MeshData>& initialMeshData, int usage, DrawOperationType drawOp, 
 		GpuDeviceFlags deviceMask)
 	{
 		MESH_DESC desc;
@@ -637,8 +637,8 @@ namespace bs
 		desc.subMeshes.push_back(SubMesh(0, initialMeshData->getNumIndices(), drawOp));
 		desc.usage = usage;
 
-		SPtr<MeshCore> mesh = 
-			bs_shared_ptr<MeshCore>(new (bs_alloc<MeshCore>()) MeshCore(initialMeshData, desc, deviceMask));
+		SPtr<Mesh> mesh = 
+			bs_shared_ptr<Mesh>(new (bs_alloc<Mesh>()) Mesh(initialMeshData, desc, deviceMask));
 
 		mesh->_setThisPtr(mesh);
 		mesh->initialize();

Source/BansheeCore/Source/BsMeshBase.cpp

@@ -61,9 +61,9 @@ namespace bs
 		return CoreSyncData(buffer, size);
 	}
 
-	SPtr<ct::MeshCoreBase> MeshBase::getCore() const
+	SPtr<ct::MeshBase> MeshBase::getCore() const
 	{
-		return std::static_pointer_cast<ct::MeshCoreBase>(mCoreSpecific);
+		return std::static_pointer_cast<ct::MeshBase>(mCoreSpecific);
 	}
 
 	/************************************************************************/
@@ -82,11 +82,11 @@ namespace bs
 
 	namespace ct
 	{
-	MeshCoreBase::MeshCoreBase(UINT32 numVertices, UINT32 numIndices, const Vector<SubMesh>& subMeshes)
+	MeshBase::MeshBase(UINT32 numVertices, UINT32 numIndices, const Vector<SubMesh>& subMeshes)
 		:mProperties(numVertices, numIndices, subMeshes)
 	{ }
 
-	void MeshCoreBase::syncToCore(const CoreSyncData& data)
+	void MeshBase::syncToCore(const CoreSyncData& data)
 	{
 		mProperties.mBounds = data.getData<Bounds>();
 	}

Source/BansheeCore/Source/BsMeshHeap.cpp

@@ -45,7 +45,7 @@ namespace bs
 
 		mMeshes[meshIdx] = transientMeshPtr;
 
-		queueGpuCommand(getCore(), std::bind(&ct::MeshHeapCore::alloc, getCore().get(), transientMeshPtr->getCore(), meshData));
+		queueGpuCommand(getCore(), std::bind(&ct::MeshHeap::alloc, getCore().get(), transientMeshPtr->getCore(), meshData));
 
 		return transientMeshPtr;
 	}
@@ -59,20 +59,20 @@ namespace bs
 		mesh->markAsDestroyed();
 		mMeshes.erase(iterFind);
 
-		queueGpuCommand(getCore(), std::bind(&ct::MeshHeapCore::dealloc, getCore().get(), mesh->getCore()));
+		queueGpuCommand(getCore(), std::bind(&ct::MeshHeap::dealloc, getCore().get(), mesh->getCore()));
 	}
 
-	SPtr<ct::MeshHeapCore> MeshHeap::getCore() const
+	SPtr<ct::MeshHeap> MeshHeap::getCore() const
 	{
-		return std::static_pointer_cast<ct::MeshHeapCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::MeshHeap>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> MeshHeap::createCore() const
 	{
-		ct::MeshHeapCore* obj = new (bs_alloc<ct::MeshHeapCore>()) ct::MeshHeapCore(mNumVertices, mNumIndices,
+		ct::MeshHeap* obj = new (bs_alloc<ct::MeshHeap>()) ct::MeshHeap(mNumVertices, mNumIndices,
 			mVertexDesc, mIndexType, GDF_DEFAULT);
 
-		SPtr<ct::MeshHeapCore> corePtr = bs_shared_ptr<ct::MeshHeapCore>(obj);
+		SPtr<ct::MeshHeap> corePtr = bs_shared_ptr<ct::MeshHeap>(obj);
 		obj->_setThisPtr(corePtr);
 
 		return corePtr;
@@ -80,9 +80,9 @@ namespace bs
 
 	namespace ct
 	{
-	const float MeshHeapCore::GrowPercent = 1.5f;
+	const float MeshHeap::GrowPercent = 1.5f;
 
-	MeshHeapCore::MeshHeapCore(UINT32 numVertices, UINT32 numIndices,
+	MeshHeap::MeshHeap(UINT32 numVertices, UINT32 numIndices,
 		const SPtr<VertexDataDesc>& vertexDesc, IndexType indexType, GpuDeviceFlags deviceMask)
 		: mNumVertices(numVertices), mNumIndices(numIndices), mCPUIndexData(nullptr), mVertexDesc(vertexDesc)
 		, mIndexType(indexType), mNextQueryId(0), mDeviceMask(deviceMask)
@@ -93,7 +93,7 @@ namespace bs
 		}
 	}
 
-	MeshHeapCore::~MeshHeapCore()
+	MeshHeap::~MeshHeap()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -108,7 +108,7 @@ namespace bs
 		mVertexDesc = nullptr;
 	}
 
-	void MeshHeapCore::initialize()
+	void MeshHeap::initialize()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -118,7 +118,7 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	void MeshHeapCore::alloc(SPtr<TransientMeshCore> mesh, const SPtr<MeshData>& meshData)
+	void MeshHeap::alloc(SPtr<TransientMesh> mesh, const SPtr<MeshData>& meshData)
 	{
 		// Find free vertex chunk and grow if needed
 		UINT32 smallestVertFit = 0;
@@ -290,7 +290,7 @@ namespace bs
 					toString(vertSize) + ". Got: " + toString(otherVertSize));
 			}
 
-			SPtr<VertexBufferCore> vertexBuffer = mVertexData->getBuffer(i);
+			SPtr<VertexBuffer> vertexBuffer = mVertexData->getBuffer(i);
 
 			UINT8* vertDest = mCPUVertexData[i] + vertChunkStart * vertSize;
 			memcpy(vertDest, meshData->getStreamData(i), meshData->getNumVertices() * vertSize);
@@ -298,7 +298,7 @@ namespace bs
 			if (RenderAPI::instance().getAPIInfo().getVertexColorFlipRequired())
 			{
 				UINT32 vertexStride = mVertexDesc->getVertexStride(i);
-				for (INT32 semanticIdx = 0; semanticIdx < VertexBuffer::MAX_SEMANTIC_IDX; semanticIdx++)
+				for (INT32 semanticIdx = 0; semanticIdx < bs::VertexBuffer::MAX_SEMANTIC_IDX; semanticIdx++)
 				{
 					if (!mVertexDesc->hasElement(VES_COLOR, semanticIdx, i))
 						continue;
@@ -334,7 +334,7 @@ namespace bs
 		mIndexBuffer->writeData(idxChunkStart * idxSize, meshData->getNumIndices() * idxSize, idxDest, BTW_NO_OVERWRITE);
 	}
 
-	void MeshHeapCore::dealloc(SPtr<TransientMeshCore> mesh)
+	void MeshHeap::dealloc(SPtr<TransientMesh> mesh)
 	{
 		auto findIter = mMeshAllocData.find(mesh->getMeshHeapId());
 		assert(findIter != mMeshAllocData.end());
@@ -356,13 +356,13 @@ namespace bs
 			allocData.useFlags = UseFlags::CPUFree;
 	}
 
-	void MeshHeapCore::growVertexBuffer(UINT32 numVertices)
+	void MeshHeap::growVertexBuffer(UINT32 numVertices)
 	{
 		mNumVertices = numVertices;
 		mVertexData = SPtr<VertexData>(bs_new<VertexData>());
 
 		mVertexData->vertexCount = mNumVertices;
-		mVertexData->vertexDeclaration = VertexDeclarationCore::create(mVertexDesc, mDeviceMask);
+		mVertexData->vertexDeclaration = VertexDeclaration::create(mVertexDesc, mDeviceMask);
 
 		// Create buffers and copy data
 		for (UINT32 i = 0; i <= mVertexDesc->getMaxStreamIdx(); i++)
@@ -377,7 +377,7 @@ namespace bs
 			desc.numVerts = mVertexData->vertexCount;
 			desc.usage = GBU_DYNAMIC;
 
-			SPtr<VertexBufferCore> vertexBuffer = VertexBufferCore::create(desc, mDeviceMask);
+			SPtr<VertexBuffer> vertexBuffer = VertexBuffer::create(desc, mDeviceMask);
 			mVertexData->setBuffer(i, vertexBuffer);
 
 			// Copy all data to the new buffer
@@ -443,7 +443,7 @@ namespace bs
 			mEmptyVertChunks.pop();
 	}
 
-	void MeshHeapCore::growIndexBuffer(UINT32 numIndices)
+	void MeshHeap::growIndexBuffer(UINT32 numIndices)
 	{
 		mNumIndices = numIndices;
 
@@ -452,7 +452,7 @@ namespace bs
 		ibDesc.numIndices = mNumIndices;
 		ibDesc.usage = GBU_DYNAMIC;
 
-		mIndexBuffer = IndexBufferCore::create(ibDesc, mDeviceMask);
+		mIndexBuffer = IndexBuffer::create(ibDesc, mDeviceMask);
 
 		const IndexBufferProperties& ibProps = mIndexBuffer->getProperties();
 
@@ -520,7 +520,7 @@ namespace bs
 			mEmptyIdxChunks.pop();
 	}
 
-	UINT32 MeshHeapCore::createEventQuery()
+	UINT32 MeshHeap::createEventQuery()
 	{
 		UINT32 idx = 0;
 		if (mFreeEventQueries.size() > 0)
@@ -541,29 +541,29 @@ namespace bs
 		return idx;
 	}
 
-	void MeshHeapCore::freeEventQuery(UINT32 idx)
+	void MeshHeap::freeEventQuery(UINT32 idx)
 	{
 		mEventQueries[idx].query->onTriggered.clear();
 		mEventQueries[idx].queryId = 0;
 		mFreeEventQueries.push(idx);
 	}
 
-	SPtr<VertexData> MeshHeapCore::getVertexData() const
+	SPtr<VertexData> MeshHeap::getVertexData() const
 	{
 		return mVertexData;
 	}
 
-	SPtr<IndexBufferCore> MeshHeapCore::getIndexBuffer() const
+	SPtr<IndexBuffer> MeshHeap::getIndexBuffer() const
 	{
 		return mIndexBuffer;
 	}
 
-	SPtr<VertexDataDesc> MeshHeapCore::getVertexDesc() const
+	SPtr<VertexDataDesc> MeshHeap::getVertexDesc() const
 	{
 		return mVertexDesc;
 	}
 
-	UINT32 MeshHeapCore::getVertexOffset(UINT32 meshId) const
+	UINT32 MeshHeap::getVertexOffset(UINT32 meshId) const
 	{
 		auto findIter = mMeshAllocData.find(meshId);
 		assert(findIter != mMeshAllocData.end());
@@ -572,7 +572,7 @@ namespace bs
 		return mVertChunks[chunkIdx].start;
 	}
 
-	UINT32 MeshHeapCore::getIndexOffset(UINT32 meshId) const
+	UINT32 MeshHeap::getIndexOffset(UINT32 meshId) const
 	{
 		auto findIter = mMeshAllocData.find(meshId);
 		assert(findIter != mMeshAllocData.end());
@@ -581,7 +581,7 @@ namespace bs
 		return mIdxChunks[chunkIdx].start;
 	}
 
-	void MeshHeapCore::notifyUsedOnGPU(UINT32 meshId)
+	void MeshHeap::notifyUsedOnGPU(UINT32 meshId)
 	{
 		auto findIter = mMeshAllocData.find(meshId);
 		assert(findIter != mMeshAllocData.end());
@@ -592,17 +592,17 @@ namespace bs
 		if (allocData.useFlags == UseFlags::GPUFree)
 			allocData.useFlags = UseFlags::Used;
 
-		SPtr<MeshHeapCore> thisPtr = std::static_pointer_cast<MeshHeapCore>(getThisPtr());
+		SPtr<MeshHeap> thisPtr = std::static_pointer_cast<MeshHeap>(getThisPtr());
 
 		QueryData& queryData = mEventQueries[allocData.eventQueryIdx];
 		queryData.queryId = mNextQueryId++;
 		queryData.query->onTriggered.clear();
-		queryData.query->onTriggered.connect(std::bind(&MeshHeapCore::queryTriggered, thisPtr, meshId, queryData.queryId));
+		queryData.query->onTriggered.connect(std::bind(&MeshHeap::queryTriggered, thisPtr, meshId, queryData.queryId));
 		queryData.query->begin();
 	}
 
 	// Note: Need to use a shared ptr here to ensure MeshHeap doesn't get deallocated sometime during this callback
-	void MeshHeapCore::queryTriggered(SPtr<MeshHeapCore> thisPtr, UINT32 meshId, UINT32 queryId)
+	void MeshHeap::queryTriggered(SPtr<MeshHeap> thisPtr, UINT32 meshId, UINT32 queryId)
 	{
 		auto findIter = thisPtr->mMeshAllocData.find(meshId);
 		assert(findIter != thisPtr->mMeshAllocData.end());
@@ -635,7 +635,7 @@ namespace bs
 		queryData.query->onTriggered.clear();
 	}
 
-	void MeshHeapCore::mergeWithNearbyChunks(UINT32 chunkVertIdx, UINT32 chunkIdxIdx)
+	void MeshHeap::mergeWithNearbyChunks(UINT32 chunkVertIdx, UINT32 chunkIdxIdx)
 	{
 		// Merge vertex chunks
 		ChunkData& vertChunk = mVertChunks[chunkVertIdx];

Source/BansheeCore/Source/BsParamBlocks.cpp

@@ -11,7 +11,7 @@ namespace bs { namespace ct
 	{ }
 
 	template<class T>
-	void ParamBlockParam<T>::set(const SPtr<GpuParamBlockBufferCore>& paramBlock, const T& value, UINT32 arrayIdx) const
+	void ParamBlockParam<T>::set(const SPtr<GpuParamBlockBuffer>& paramBlock, const T& value, UINT32 arrayIdx) const
 	{
 #if BS_DEBUG_MODE
 		if (arrayIdx >= mParamDesc.arraySize)
@@ -45,7 +45,7 @@ namespace bs { namespace ct
 	}
 
 	template<class T>
-	T ParamBlockParam<T>::get(const SPtr<GpuParamBlockBufferCore>& paramBlock, UINT32 arrayIdx) const
+	T ParamBlockParam<T>::get(const SPtr<GpuParamBlockBuffer>& paramBlock, UINT32 arrayIdx) const
 	{
 #if BS_DEBUG_MODE
 		if (arrayIdx >= mParamDesc.arraySize)

Source/BansheeCore/Source/BsPass.cpp

@@ -112,12 +112,12 @@ namespace bs
 		ct::Pass* pass;
 		if(mComputePipelineState != nullptr)
 		{
-			SPtr<ct::ComputePipelineStateCore> corePipeline = mComputePipelineState->getCore();
+			SPtr<ct::ComputePipelineState> corePipeline = mComputePipelineState->getCore();
 			pass = new (bs_alloc<ct::Pass>()) ct::Pass(desc, corePipeline);
 		}
 		else
 		{
-			SPtr<ct::GraphicsPipelineStateCore> corePipeline;
+			SPtr<ct::GraphicsPipelineState> corePipeline;
 			if (mGraphicsPipelineState != nullptr)
 				corePipeline = mGraphicsPipelineState->getCore();
 
@@ -224,14 +224,14 @@ namespace bs
 		:TPass(desc)
 	{ }
 
-	Pass::Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineStateCore>& pipelineState)
+	Pass::Pass(const PASS_DESC& desc, const SPtr<GraphicsPipelineState>& pipelineState)
 		:TPass(desc)
 	{
 		mGraphicsPipelineState = pipelineState;
 	}
 
 
-	Pass::Pass(const PASS_DESC& desc, const SPtr<ComputePipelineStateCore>& pipelineState)
+	Pass::Pass(const PASS_DESC& desc, const SPtr<ComputePipelineState>& pipelineState)
 		:TPass(desc)
 	{
 		mComputePipelineState = pipelineState;
@@ -242,7 +242,7 @@ namespace bs
 		if(hasComputeProgram())
 		{
 			if(mComputePipelineState == nullptr)
-				mComputePipelineState = ComputePipelineStateCore::create(getComputeProgram());
+				mComputePipelineState = ComputePipelineState::create(getComputeProgram());
 		}
 		else
 		{
@@ -251,7 +251,7 @@ namespace bs
 				PIPELINE_STATE_DESC desc;
 				convertPassDesc(mData, desc);
 
-				mGraphicsPipelineState = GraphicsPipelineStateCore::create(desc);
+				mGraphicsPipelineState = GraphicsPipelineState::create(desc);
 			}
 		}
 

Source/BansheeCore/Source/BsRasterizerState.cpp

@@ -36,14 +36,14 @@ namespace bs
 
 	}
 
-	SPtr<ct::RasterizerStateCore> RasterizerState::getCore() const
+	SPtr<ct::RasterizerState> RasterizerState::getCore() const
 	{
-		return std::static_pointer_cast<ct::RasterizerStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::RasterizerState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> RasterizerState::createCore() const
 	{
-		SPtr<ct::RasterizerStateCore> core = ct::RenderStateManager::instance()._createRasterizerState(mProperties.mData);
+		SPtr<ct::RasterizerState> core = ct::RenderStateManager::instance()._createRasterizerState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -96,18 +96,18 @@ namespace bs
 
 	namespace ct
 	{
-	RasterizerStateCore::RasterizerStateCore(const RASTERIZER_STATE_DESC& desc, UINT32 id)
+	RasterizerState::RasterizerState(const RASTERIZER_STATE_DESC& desc, UINT32 id)
 		: mProperties(desc), mId(id)
 	{
 
 	}
 
-	RasterizerStateCore::~RasterizerStateCore()
+	RasterizerState::~RasterizerState()
 	{
 
 	}
 
-	void RasterizerStateCore::initialize()
+	void RasterizerState::initialize()
 	{
 		// Since we cache states it's possible this object was already initialized
 		// (i.e. multiple sim-states can share a single core-state)
@@ -118,17 +118,17 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	const RasterizerProperties& RasterizerStateCore::getProperties() const
+	const RasterizerProperties& RasterizerState::getProperties() const
 	{
 		return mProperties;
 	}
 
-	SPtr<RasterizerStateCore> RasterizerStateCore::create(const RASTERIZER_STATE_DESC& desc)
+	SPtr<RasterizerState> RasterizerState::create(const RASTERIZER_STATE_DESC& desc)
 	{
 		return RenderStateManager::instance().createRasterizerState(desc);
 	}
 
-	const SPtr<RasterizerStateCore>& RasterizerStateCore::getDefault()
+	const SPtr<RasterizerState>& RasterizerState::getDefault()
 	{
 		return RenderStateManager::instance().getDefaultRasterizerState();
 	}

Source/BansheeCore/Source/BsRenderAPI.cpp

@@ -37,14 +37,14 @@ namespace bs
 
 	void RenderAPI::setVertexBuffers(UINT32 index, const Vector<SPtr<VertexBuffer>>& buffers)
 	{
-		Vector<SPtr<ct::VertexBufferCore>> coreBuffers(buffers.size());
+		Vector<SPtr<ct::VertexBuffer>> coreBuffers(buffers.size());
 		for (UINT32 i = 0; i < (UINT32)buffers.size(); i++)
 			coreBuffers[i] = buffers[i] != nullptr ? buffers[i]->getCore() : nullptr;
 
-		std::function<void(ct::RenderAPI*, UINT32, const Vector<SPtr<ct::VertexBufferCore>>&)> resizeFunc =
-			[](ct::RenderAPI* rs, UINT32 idx, const Vector<SPtr<ct::VertexBufferCore>>& _buffers)
+		std::function<void(ct::RenderAPI*, UINT32, const Vector<SPtr<ct::VertexBuffer>>&)> resizeFunc =
+			[](ct::RenderAPI* rs, UINT32 idx, const Vector<SPtr<ct::VertexBuffer>>& _buffers)
 		{
-			rs->setVertexBuffers(idx, (SPtr<ct::VertexBufferCore>*)_buffers.data(), (UINT32)_buffers.size());
+			rs->setVertexBuffers(idx, (SPtr<ct::VertexBuffer>*)_buffers.data(), (UINT32)_buffers.size());
 		};
 
 		gCoreThread().queueCommand(std::bind(resizeFunc, ct::RenderAPI::instancePtr(), index, coreBuffers));
@@ -159,13 +159,13 @@ namespace bs
 		mCurrentCapabilities = nullptr;
     }
 
-	SPtr<RenderWindow> RenderAPI::initialize(const RENDER_WINDOW_DESC& primaryWindowDesc)
+	SPtr<bs::RenderWindow> RenderAPI::initialize(const RENDER_WINDOW_DESC& primaryWindowDesc)
 	{
 		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);
+		SPtr<bs::RenderWindow> renderWindow = bs::RenderWindow::create(windowDesc, nullptr);
 
 		gCoreThread().queueCommand(std::bind(&RenderAPI::initializeWithWindow, this, renderWindow->getCore()), 
 			CTQF_InternalQueue | CTQF_BlockUntilComplete);
@@ -178,7 +178,7 @@ namespace bs
 		// Do nothing
 	}
 
-	void RenderAPI::initializeWithWindow(const SPtr<RenderWindowCore>& primaryWindow)
+	void RenderAPI::initializeWithWindow(const SPtr<RenderWindow>& primaryWindow)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 	}

Source/BansheeCore/Source/BsRenderStateManager.cpp

@@ -146,10 +146,10 @@ namespace bs
 		
 	}
 
-	SPtr<SamplerStateCore> RenderStateManager::createSamplerState(const SAMPLER_STATE_DESC& desc, 
+	SPtr<SamplerState> RenderStateManager::createSamplerState(const SAMPLER_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
-		SPtr<SamplerStateCore> state = findCachedState(desc);
+		SPtr<SamplerState> state = findCachedState(desc);
 		if (state == nullptr)
 		{
 			state = createSamplerStateInternal(desc, deviceMask);
@@ -161,10 +161,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateManager::createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
+	SPtr<DepthStencilState> RenderStateManager::createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<DepthStencilStateCore> state = findCachedState(desc, id);
+		SPtr<DepthStencilState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createDepthStencilStateInternal(desc, id);
@@ -179,10 +179,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateManager::createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
+	SPtr<RasterizerState> RenderStateManager::createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<RasterizerStateCore> state = findCachedState(desc, id);
+		SPtr<RasterizerState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createRasterizerStateInternal(desc, id);
@@ -197,10 +197,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateManager::createBlendState(const BLEND_STATE_DESC& desc) const
+	SPtr<BlendState> RenderStateManager::createBlendState(const BLEND_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<BlendStateCore> state = findCachedState(desc, id);
+		SPtr<BlendState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createBlendStateInternal(desc, id);
@@ -215,37 +215,37 @@ namespace bs
 		return state;
 	}
 
-	SPtr<GraphicsPipelineStateCore> RenderStateManager::createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
+	SPtr<GraphicsPipelineState> RenderStateManager::createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
-		SPtr<GraphicsPipelineStateCore> state = _createGraphicsPipelineState(desc, deviceMask);
+		SPtr<GraphicsPipelineState> state = _createGraphicsPipelineState(desc, deviceMask);
 		state->initialize();
 
 		return state;
 	}
 
-	SPtr<ComputePipelineStateCore> RenderStateManager::createComputePipelineState(const SPtr<GpuProgramCore>& program,
+	SPtr<ComputePipelineState> RenderStateManager::createComputePipelineState(const SPtr<GpuProgram>& program,
 																					  GpuDeviceFlags deviceMask) const
 	{
-		SPtr<ComputePipelineStateCore> state = _createComputePipelineState(program, deviceMask);
+		SPtr<ComputePipelineState> state = _createComputePipelineState(program, deviceMask);
 		state->initialize();
 
 		return state;
 	}
 
-	SPtr<GpuPipelineParamInfoCore> RenderStateManager::createPipelineParamInfo(
+	SPtr<GpuPipelineParamInfo> RenderStateManager::createPipelineParamInfo(
 		const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
-		SPtr<GpuPipelineParamInfoCore> paramInfo = _createPipelineParamInfo(desc, deviceMask);
+		SPtr<GpuPipelineParamInfo> paramInfo = _createPipelineParamInfo(desc, deviceMask);
 		paramInfo->initialize();
 
 		return paramInfo;
 	}
 
-	SPtr<SamplerStateCore> RenderStateManager::_createSamplerState(const SAMPLER_STATE_DESC& desc, 
+	SPtr<SamplerState> RenderStateManager::_createSamplerState(const SAMPLER_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
-		SPtr<SamplerStateCore> state = findCachedState(desc);
+		SPtr<SamplerState> state = findCachedState(desc);
 		if (state == nullptr)
 		{
 			state = createSamplerStateInternal(desc, deviceMask);
@@ -256,10 +256,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateManager::_createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
+	SPtr<DepthStencilState> RenderStateManager::_createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<DepthStencilStateCore> state = findCachedState(desc, id);
+		SPtr<DepthStencilState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createDepthStencilStateInternal(desc, id);
@@ -273,10 +273,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateManager::_createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
+	SPtr<RasterizerState> RenderStateManager::_createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<RasterizerStateCore> state = findCachedState(desc, id);
+		SPtr<RasterizerState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createRasterizerStateInternal(desc, id);
@@ -290,10 +290,10 @@ namespace bs
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateManager::_createBlendState(const BLEND_STATE_DESC& desc) const
+	SPtr<BlendState> RenderStateManager::_createBlendState(const BLEND_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
-		SPtr<BlendStateCore> state = findCachedState(desc, id);
+		SPtr<BlendState> state = findCachedState(desc, id);
 		if (state == nullptr)
 		{
 			state = createBlendStateInternal(desc, id);
@@ -307,36 +307,36 @@ namespace bs
 		return state;
 	}
 
-	SPtr<GraphicsPipelineStateCore> RenderStateManager::_createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
+	SPtr<GraphicsPipelineState> RenderStateManager::_createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
 		GpuDeviceFlags deviceMask) const
 	{
-		SPtr<GraphicsPipelineStateCore> pipelineState =
-			bs_shared_ptr<GraphicsPipelineStateCore>(new (bs_alloc<GraphicsPipelineStateCore>()) 
-			GraphicsPipelineStateCore(desc, deviceMask));
+		SPtr<GraphicsPipelineState> pipelineState =
+			bs_shared_ptr<GraphicsPipelineState>(new (bs_alloc<GraphicsPipelineState>()) 
+			GraphicsPipelineState(desc, deviceMask));
 
 		pipelineState->_setThisPtr(pipelineState);
 
 		return pipelineState;
 	}
 
-	SPtr<ComputePipelineStateCore> RenderStateManager::_createComputePipelineState(const SPtr<GpuProgramCore>& program,
+	SPtr<ComputePipelineState> RenderStateManager::_createComputePipelineState(const SPtr<GpuProgram>& program,
 																					   GpuDeviceFlags deviceMask) const
 	{
-		SPtr<ComputePipelineStateCore> pipelineState =
-			bs_shared_ptr<ComputePipelineStateCore>(new (bs_alloc<ComputePipelineStateCore>()) 
-			ComputePipelineStateCore(program, deviceMask));
+		SPtr<ComputePipelineState> pipelineState =
+			bs_shared_ptr<ComputePipelineState>(new (bs_alloc<ComputePipelineState>()) 
+			ComputePipelineState(program, deviceMask));
 
 		pipelineState->_setThisPtr(pipelineState);
 
 		return pipelineState;
 	}
 
-	SPtr<GpuPipelineParamInfoCore> RenderStateManager::_createPipelineParamInfo(
+	SPtr<GpuPipelineParamInfo> RenderStateManager::_createPipelineParamInfo(
 		const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
-		SPtr<GpuPipelineParamInfoCore> paramInfo =
-			bs_shared_ptr<GpuPipelineParamInfoCore>(new (bs_alloc<GpuPipelineParamInfoCore>())
-													GpuPipelineParamInfoCore(desc, deviceMask));
+		SPtr<GpuPipelineParamInfo> paramInfo =
+			bs_shared_ptr<GpuPipelineParamInfo>(new (bs_alloc<GpuPipelineParamInfo>())
+													GpuPipelineParamInfo(desc, deviceMask));
 
 		paramInfo->_setThisPtr(paramInfo);
 
@@ -351,7 +351,7 @@ namespace bs
 		mDefaultSamplerState = nullptr;
 	}
 
-	const SPtr<SamplerStateCore>& RenderStateManager::getDefaultSamplerState() const
+	const SPtr<SamplerState>& RenderStateManager::getDefaultSamplerState() const
 	{
 		if (mDefaultSamplerState == nullptr)
 			mDefaultSamplerState = createSamplerState(SAMPLER_STATE_DESC());
@@ -359,7 +359,7 @@ namespace bs
 		return mDefaultSamplerState;
 	}
 
-	const SPtr<BlendStateCore>& RenderStateManager::getDefaultBlendState() const
+	const SPtr<BlendState>& RenderStateManager::getDefaultBlendState() const
 	{
 		if (mDefaultBlendState == nullptr)
 			mDefaultBlendState = createBlendState(BLEND_STATE_DESC());
@@ -367,7 +367,7 @@ namespace bs
 		return mDefaultBlendState;
 	}
 
-	const SPtr<RasterizerStateCore>& RenderStateManager::getDefaultRasterizerState() const
+	const SPtr<RasterizerState>& RenderStateManager::getDefaultRasterizerState() const
 	{
 		if (mDefaultRasterizerState == nullptr)
 			mDefaultRasterizerState = createRasterizerState(RASTERIZER_STATE_DESC());
@@ -375,7 +375,7 @@ namespace bs
 		return mDefaultRasterizerState;
 	}
 
-	const SPtr<DepthStencilStateCore>& RenderStateManager::getDefaultDepthStencilState() const
+	const SPtr<DepthStencilState>& RenderStateManager::getDefaultDepthStencilState() const
 	{
 		if (mDefaultDepthStencilState == nullptr)
 			mDefaultDepthStencilState = createDepthStencilState(DEPTH_STENCIL_STATE_DESC());
@@ -383,7 +383,7 @@ namespace bs
 		return mDefaultDepthStencilState;
 	}
 
-	void RenderStateManager::notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerStateCore>& state) const
+	void RenderStateManager::notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerState>& state) const
 	{
 		Lock lock(mMutex);
 
@@ -418,7 +418,7 @@ namespace bs
 		mCachedSamplerStates.erase(desc);
 	}
 
-	SPtr<SamplerStateCore> RenderStateManager::findCachedState(const SAMPLER_STATE_DESC& desc) const
+	SPtr<SamplerState> RenderStateManager::findCachedState(const SAMPLER_STATE_DESC& desc) const
 	{
 		Lock lock(mMutex);
 
@@ -429,7 +429,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<BlendStateCore> RenderStateManager::findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const
+	SPtr<BlendState> RenderStateManager::findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -450,7 +450,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateManager::findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const
+	SPtr<RasterizerState> RenderStateManager::findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -471,7 +471,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateManager::findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const
+	SPtr<DepthStencilState> RenderStateManager::findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -492,34 +492,34 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<SamplerStateCore> RenderStateManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const
+	SPtr<SamplerState> RenderStateManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
-		SPtr<SamplerStateCore> state = 
-			bs_shared_ptr<SamplerStateCore>(new (bs_alloc<SamplerStateCore>()) SamplerStateCore(desc, deviceMask));
+		SPtr<SamplerState> state = 
+			bs_shared_ptr<SamplerState>(new (bs_alloc<SamplerState>()) SamplerState(desc, deviceMask));
 		state->_setThisPtr(state);
 
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateManager::createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const
+	SPtr<DepthStencilState> RenderStateManager::createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const
 	{
-		SPtr<DepthStencilStateCore> state = bs_shared_ptr<DepthStencilStateCore>(new (bs_alloc<DepthStencilStateCore>()) DepthStencilStateCore(desc, id));
+		SPtr<DepthStencilState> state = bs_shared_ptr<DepthStencilState>(new (bs_alloc<DepthStencilState>()) DepthStencilState(desc, id));
 		state->_setThisPtr(state);
 
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateManager::createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const
+	SPtr<RasterizerState> RenderStateManager::createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const
 	{
-		SPtr<RasterizerStateCore> state = bs_shared_ptr<RasterizerStateCore>(new (bs_alloc<RasterizerStateCore>()) RasterizerStateCore(desc, id));
+		SPtr<RasterizerState> state = bs_shared_ptr<RasterizerState>(new (bs_alloc<RasterizerState>()) RasterizerState(desc, id));
 		state->_setThisPtr(state);
 
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateManager::createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const
+	SPtr<BlendState> RenderStateManager::createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const
 	{
-		SPtr<BlendStateCore> state = bs_shared_ptr<BlendStateCore>(new (bs_alloc<BlendStateCore>()) BlendStateCore(desc, id));
+		SPtr<BlendState> state = bs_shared_ptr<BlendState>(new (bs_alloc<BlendState>()) BlendState(desc, id));
 		state->_setThisPtr(state);
 
 		return state;

Source/BansheeCore/Source/BsRenderTarget.cpp

@@ -17,8 +17,8 @@ namespace bs
 
 	void RenderTarget::setPriority(INT32 priority)
 	{
-		std::function<void(SPtr<ct::RenderTargetCore>, INT32)> windowedFunc =
-			[](SPtr<ct::RenderTargetCore> renderTarget, INT32 priority)
+		std::function<void(SPtr<ct::RenderTarget>, INT32)> windowedFunc =
+			[](SPtr<ct::RenderTarget> renderTarget, INT32 priority)
 		{
 			renderTarget->setPriority(priority);
 		};
@@ -26,9 +26,9 @@ namespace bs
 		gCoreThread().queueCommand(std::bind(windowedFunc, getCore(), priority));
 	}
 
-	SPtr<ct::RenderTargetCore> RenderTarget::getCore() const
+	SPtr<ct::RenderTarget> RenderTarget::getCore() const
 	{
-		return std::static_pointer_cast<ct::RenderTargetCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::RenderTarget>(mCoreSpecific);
 	}
 
 	const RenderTargetProperties& RenderTarget::getProperties() const
@@ -45,24 +45,24 @@ namespace bs
 
 	namespace ct
 	{
-		RenderTargetCore::RenderTargetCore()
+		RenderTarget::RenderTarget()
 		{
 
 		}
 
-		void RenderTargetCore::setPriority(INT32 priority)
+		void RenderTarget::setPriority(INT32 priority)
 		{
 			RenderTargetProperties& props = const_cast<RenderTargetProperties&>(getProperties());
 
 			props.mPriority = priority;
 		}
 
-		const RenderTargetProperties& RenderTargetCore::getProperties() const
+		const RenderTargetProperties& RenderTarget::getProperties() const
 		{
 			return getPropertiesInternal();
 		}
 
-		void RenderTargetCore::getCustomAttribute(const String& name, void* pData) const
+		void RenderTarget::getCustomAttribute(const String& name, void* pData) const
 		{
 			BS_EXCEPT(InvalidParametersException, "Attribute not found.");
 		}

Source/BansheeCore/Source/BsRenderTexture.cpp

@@ -30,7 +30,7 @@ namespace bs
 	{
 		for (UINT32 i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)
 		{
-			SPtr<ct::TextureCore> texture = desc.colorSurfaces[i].texture;
+			SPtr<ct::Texture> texture = desc.colorSurfaces[i].texture;
 
 			if (texture != nullptr)
 			{
@@ -70,9 +70,9 @@ namespace bs
 		return TextureManager::instance().createRenderTexture(desc);
 	}
 
-	SPtr<ct::RenderTextureCore> RenderTexture::getCore() const
+	SPtr<ct::RenderTexture> RenderTexture::getCore() const
 	{ 
-		return std::static_pointer_cast<ct::RenderTextureCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::RenderTexture>(mCoreSpecific);
 	}
 
 	RenderTexture::RenderTexture(const RENDER_TEXTURE_DESC& desc)
@@ -133,71 +133,71 @@ namespace bs
 
 	namespace ct
 	{
-	RenderTextureCore::RenderTextureCore(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
+	RenderTexture::RenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
 		:mDesc(desc)
 	{ }
 
-	RenderTextureCore::~RenderTextureCore()
+	RenderTexture::~RenderTexture()
 	{ 
 		for (UINT32 i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)
 		{
 			if (mColorSurfaces[i] != nullptr)
-				TextureCore::releaseView(mColorSurfaces[i]);
+				Texture::releaseView(mColorSurfaces[i]);
 		}
 
 		if (mDepthStencilSurface != nullptr)
-			TextureCore::releaseView(mDepthStencilSurface);
+			Texture::releaseView(mDepthStencilSurface);
 	}
 
-	void RenderTextureCore::initialize()
+	void RenderTexture::initialize()
 	{
-		RenderTargetCore::initialize();
+		RenderTarget::initialize();
 
 		for (UINT32 i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)
 		{
 			if (mDesc.colorSurfaces[i].texture != nullptr)
 			{
-				SPtr<TextureCore> texture = mDesc.colorSurfaces[i].texture;
+				SPtr<Texture> texture = mDesc.colorSurfaces[i].texture;
 
 				if ((texture->getProperties().getUsage() & TU_RENDERTARGET) == 0)
 					BS_EXCEPT(InvalidParametersException, "Provided texture is not created with render target usage.");
 
-				mColorSurfaces[i] = TextureCore::requestView(texture, mDesc.colorSurfaces[i].mipLevel, 1,
+				mColorSurfaces[i] = Texture::requestView(texture, mDesc.colorSurfaces[i].mipLevel, 1,
 					mDesc.colorSurfaces[i].face, mDesc.colorSurfaces[i].numFaces, GVU_RENDERTARGET);
 			}
 		}
 
 		if (mDesc.depthStencilSurface.texture != nullptr)
 		{
-			SPtr<TextureCore> texture = mDesc.depthStencilSurface.texture;
+			SPtr<Texture> texture = mDesc.depthStencilSurface.texture;
 
 			if ((texture->getProperties().getUsage() & TU_DEPTHSTENCIL) == 0)
 				BS_EXCEPT(InvalidParametersException, "Provided texture is not created with depth stencil usage.");
 
-			mDepthStencilSurface = TextureCore::requestView(texture, mDesc.depthStencilSurface.mipLevel, 1,
+			mDepthStencilSurface = Texture::requestView(texture, mDesc.depthStencilSurface.mipLevel, 1,
 				mDesc.depthStencilSurface.face, 0, GVU_DEPTHSTENCIL);
 		}
 
 		throwIfBuffersDontMatch();
 	}
 
-	SPtr<RenderTextureCore> RenderTextureCore::create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
+	SPtr<RenderTexture> RenderTexture::create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
 	{
 		return TextureManager::instance().createRenderTexture(desc, deviceIdx);
 	}
 
-	void RenderTextureCore::syncToCore(const CoreSyncData& data)
+	void RenderTexture::syncToCore(const CoreSyncData& data)
 	{
 		RenderTextureProperties& props = const_cast<RenderTextureProperties&>(getProperties());
 		props = data.getData<RenderTextureProperties>();
 	}
 
-	const RenderTextureProperties& RenderTextureCore::getProperties() const
+	const RenderTextureProperties& RenderTexture::getProperties() const
 	{
 		return static_cast<const RenderTextureProperties&>(getPropertiesInternal());
 	}
 
-	void RenderTextureCore::throwIfBuffersDontMatch() const
+	void RenderTexture::throwIfBuffersDontMatch() const
 	{
 		SPtr<TextureView> firstSurfaceDesc = nullptr;
 		for (UINT32 i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)

Source/BansheeCore/Source/BsRenderWindow.cpp

@@ -41,8 +41,8 @@ namespace bs
 
 	void RenderWindow::resize(UINT32 width, UINT32 height)
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>, UINT32, UINT32)> resizeFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow, UINT32 width, UINT32 height)
+		std::function<void(SPtr<ct::RenderWindow>, UINT32, UINT32)> resizeFunc =
+			[](SPtr<ct::RenderWindow> renderWindow, UINT32 width, UINT32 height)
 		{
 			renderWindow->resize(width, height);
 		};
@@ -64,8 +64,8 @@ namespace bs
 
 	void RenderWindow::move(INT32 left, INT32 top)
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>, INT32, INT32)> moveFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow, INT32 left, INT32 top)
+		std::function<void(SPtr<ct::RenderWindow>, INT32, INT32)> moveFunc =
+			[](SPtr<ct::RenderWindow> renderWindow, INT32 left, INT32 top)
 		{
 			renderWindow->move(left, top);
 		};
@@ -85,8 +85,8 @@ namespace bs
 
 	void RenderWindow::hide()
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>)> hideFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow)
+		std::function<void(SPtr<ct::RenderWindow>)> hideFunc =
+			[](SPtr<ct::RenderWindow> renderWindow)
 		{
 			renderWindow->setHidden(true);
 		};
@@ -103,8 +103,8 @@ namespace bs
 
 	void RenderWindow::show()
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>)> showFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow)
+		std::function<void(SPtr<ct::RenderWindow>)> showFunc =
+			[](SPtr<ct::RenderWindow> renderWindow)
 		{
 			renderWindow->setHidden(false);
 		};
@@ -121,8 +121,8 @@ namespace bs
 
 	void RenderWindow::minimize()
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>)> minimizeFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow)
+		std::function<void(SPtr<ct::RenderWindow>)> minimizeFunc =
+			[](SPtr<ct::RenderWindow> renderWindow)
 		{
 			renderWindow->minimize();
 		};
@@ -139,8 +139,8 @@ namespace bs
 
 	void RenderWindow::maximize()
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>)> maximizeFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow)
+		std::function<void(SPtr<ct::RenderWindow>)> maximizeFunc =
+			[](SPtr<ct::RenderWindow> renderWindow)
 		{
 			renderWindow->maximize();
 		};
@@ -157,8 +157,8 @@ namespace bs
 
 	void RenderWindow::restore()
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>)> restoreFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow)
+		std::function<void(SPtr<ct::RenderWindow>)> restoreFunc =
+			[](SPtr<ct::RenderWindow> renderWindow)
 		{
 			renderWindow->restore();
 		};
@@ -175,8 +175,8 @@ namespace bs
 
 	void RenderWindow::setFullscreen(UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>, UINT32, UINT32, float, UINT32)> fullscreenFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow, UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
+		std::function<void(SPtr<ct::RenderWindow>, UINT32, UINT32, float, UINT32)> fullscreenFunc =
+			[](SPtr<ct::RenderWindow> renderWindow, UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
 		{
 			renderWindow->setFullscreen(width, height, refreshRate, monitorIdx);
 		};
@@ -186,8 +186,8 @@ namespace bs
 
 	void RenderWindow::setFullscreen(const VideoMode& mode)
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>, const VideoMode&)> fullscreenFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow, const VideoMode& mode)
+		std::function<void(SPtr<ct::RenderWindow>, const VideoMode&)> fullscreenFunc =
+			[](SPtr<ct::RenderWindow> renderWindow, const VideoMode& mode)
 		{
 			renderWindow->setFullscreen(mode);
 		};
@@ -197,8 +197,8 @@ namespace bs
 
 	void RenderWindow::setWindowed(UINT32 width, UINT32 height)
 	{
-		std::function<void(SPtr<ct::RenderWindowCore>, UINT32, UINT32)> windowedFunc =
-			[](SPtr<ct::RenderWindowCore> renderWindow, UINT32 width, UINT32 height)
+		std::function<void(SPtr<ct::RenderWindow>, UINT32, UINT32)> windowedFunc =
+			[](SPtr<ct::RenderWindow> renderWindow, UINT32 width, UINT32 height)
 		{
 			renderWindow->setWindowed(width, height);
 		};
@@ -206,9 +206,9 @@ namespace bs
 		gCoreThread().queueCommand(std::bind(windowedFunc, getCore(), width, height));
 	}
 
-	SPtr<ct::RenderWindowCore> RenderWindow::getCore() const
+	SPtr<ct::RenderWindow> RenderWindow::getCore() const
 	{
-		return std::static_pointer_cast<ct::RenderWindowCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::RenderWindow>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> RenderWindow::createCore() const
@@ -234,20 +234,20 @@ namespace bs
 
 	namespace ct
 	{
-	RenderWindowCore::RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
+	RenderWindow::RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
 		:mDesc(desc), mWindowId(windowId)
 	{
 
 	}
 
-	RenderWindowCore::~RenderWindowCore()
+	RenderWindow::~RenderWindow()
 	{
 		Platform::resetNonClientAreas(*this);
 
 		RenderWindowManager::instance().windowDestroyed(this);
 	}
 
-	void RenderWindowCore::setHidden(bool hidden)
+	void RenderWindow::setHidden(bool hidden)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -262,7 +262,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	void RenderWindowCore::setActive(bool state)
+	void RenderWindow::setActive(bool state)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -277,7 +277,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	void RenderWindowCore::_windowMovedOrResized()
+	void RenderWindow::_windowMovedOrResized()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -294,7 +294,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifyMovedOrResized(this);
 	}
 
-	void RenderWindowCore::_windowFocusReceived()
+	void RenderWindow::_windowFocusReceived()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -309,7 +309,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifyFocusReceived(this);
 	}
 
-	void RenderWindowCore::_windowFocusLost()
+	void RenderWindow::_windowFocusLost()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -324,7 +324,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifyFocusLost(this);
 	}
 
-	void RenderWindowCore::_notifyMaximized()
+	void RenderWindow::_notifyMaximized()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -339,7 +339,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	void RenderWindowCore::_notifyMinimized()
+	void RenderWindow::_notifyMinimized()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -354,7 +354,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	void RenderWindowCore::_notifyRestored()
+	void RenderWindow::_notifyRestored()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -369,7 +369,7 @@ namespace bs
 		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	const RenderWindowProperties& RenderWindowCore::getProperties() const
+	const RenderWindowProperties& RenderWindow::getProperties() const
 	{
 		return static_cast<const RenderWindowProperties&>(getPropertiesInternal());
 	}

Source/BansheeCore/Source/BsRenderWindowManager.cpp

@@ -55,7 +55,7 @@ namespace bs
 		}
 	}
 
-	void RenderWindowManager::notifyFocusReceived(ct::RenderWindowCore* coreWindow)
+	void RenderWindowManager::notifyFocusReceived(ct::RenderWindow* coreWindow)
 	{
 		Lock lock(mWindowMutex);
 
@@ -63,14 +63,14 @@ namespace bs
 		mNewWindowInFocus = window;
 	}
 
-	void RenderWindowManager::notifyFocusLost(ct::RenderWindowCore* coreWindow)
+	void RenderWindowManager::notifyFocusLost(ct::RenderWindow* coreWindow)
 	{
 		Lock lock(mWindowMutex);
 
 		mNewWindowInFocus = nullptr;
 	}
 
-	void RenderWindowManager::notifyMovedOrResized(ct::RenderWindowCore* coreWindow)
+	void RenderWindowManager::notifyMovedOrResized(ct::RenderWindow* coreWindow)
 	{
 		Lock lock(mWindowMutex);
 
@@ -103,7 +103,7 @@ namespace bs
 		moveResizeData->height = props.getHeight();
 	}
 
-	void RenderWindowManager::notifySyncDataDirty(ct::RenderWindowCore* coreWindow)
+	void RenderWindowManager::notifySyncDataDirty(ct::RenderWindow* coreWindow)
 	{
 		Lock lock(mWindowMutex);
 
@@ -113,7 +113,7 @@ namespace bs
 			mDirtyProperties.insert(window);
 	}
 
-	void RenderWindowManager::windowMouseLeft(ct::RenderWindowCore* coreWindow)
+	void RenderWindowManager::windowMouseLeft(ct::RenderWindow* coreWindow)
 	{
 		Lock lock(mWindowMutex);
 
@@ -194,7 +194,7 @@ namespace bs
 		return windows;
 	}
 
-	RenderWindow* RenderWindowManager::getNonCore(const ct::RenderWindowCore* window) const
+	RenderWindow* RenderWindowManager::getNonCore(const ct::RenderWindow* window) const
 	{
 		auto iterFind = mWindows.find(window->mWindowId);
 
@@ -212,11 +212,11 @@ namespace bs
 		mNextWindowId = 0;
 	}
 
-	SPtr<RenderWindowCore> RenderWindowManager::create(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindow> RenderWindowManager::create(RENDER_WINDOW_DESC& desc)
 	{
 		UINT32 id = mNextWindowId.fetch_add(1, std::memory_order_relaxed);
 
-		SPtr<RenderWindowCore> renderWindow = createInternal(desc, id);
+		SPtr<RenderWindow> renderWindow = createInternal(desc, id);
 		renderWindow->initialize();
 
 		return renderWindow;
@@ -232,14 +232,14 @@ namespace bs
 		mDirtyProperties.clear();
 	}
 
-	void RenderWindowManager::windowCreated(RenderWindowCore* window)
+	void RenderWindowManager::windowCreated(RenderWindow* window)
 	{
 		Lock lock(mWindowMutex);
 
 		mCreatedWindows.push_back(window);
 	}
 
-	void RenderWindowManager::windowDestroyed(RenderWindowCore* window)
+	void RenderWindowManager::windowDestroyed(RenderWindow* window)
 	{
 		{
 			Lock lock(mWindowMutex);
@@ -254,14 +254,14 @@ namespace bs
 		}
 	}
 
-	Vector<RenderWindowCore*> RenderWindowManager::getRenderWindows() const
+	Vector<RenderWindow*> RenderWindowManager::getRenderWindows() const
 	{
 		Lock lock(mWindowMutex);
 
 		return mCreatedWindows;
 	}
 
-	void RenderWindowManager::notifySyncDataDirty(RenderWindowCore* window)
+	void RenderWindowManager::notifySyncDataDirty(RenderWindow* window)
 	{
 		Lock lock(mWindowMutex);
 

Source/BansheeCore/Source/BsSamplerState.cpp

@@ -55,9 +55,9 @@ namespace bs
 
 	}
 
-	SPtr<ct::SamplerStateCore> SamplerState::getCore() const
+	SPtr<ct::SamplerState> SamplerState::getCore() const
 	{
-		return std::static_pointer_cast<ct::SamplerStateCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::SamplerState>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> SamplerState::createCore() const
@@ -116,18 +116,18 @@ namespace bs
 	namespace ct 
 	{
 
-	SamplerStateCore::SamplerStateCore(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
+	SamplerState::SamplerState(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 		:mProperties(desc)
 	{
 
 	}
 
-	SamplerStateCore::~SamplerStateCore()
+	SamplerState::~SamplerState()
 	{
 		RenderStateManager::instance().notifySamplerStateDestroyed(mProperties.mData);
 	}
 
-	void SamplerStateCore::initialize()
+	void SamplerState::initialize()
 	{
 		// Since we cache states it's possible this object was already initialized
 		// (i.e. multiple sim-states can share a single core-state)
@@ -138,17 +138,17 @@ namespace bs
 		CoreObject::initialize();
 	}
 
-	const SamplerProperties& SamplerStateCore::getProperties() const
+	const SamplerProperties& SamplerState::getProperties() const
 	{
 		return mProperties;
 	}
 
-	SPtr<SamplerStateCore> SamplerStateCore::create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<SamplerState> SamplerState::create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return RenderStateManager::instance().createSamplerState(desc, deviceMask);
 	}
 
-	const SPtr<SamplerStateCore>& SamplerStateCore::getDefault()
+	const SPtr<SamplerState>& SamplerState::getDefault()
 	{
 		return RenderStateManager::instance().getDefaultSamplerState();
 	}

Source/BansheeCore/Source/BsTexture.cpp

@@ -123,8 +123,8 @@ namespace bs
 
 		data->_lock();
 
-		std::function<void(const SPtr<ct::TextureCore>&, UINT32, UINT32, const SPtr<PixelData>&, bool, AsyncOp&)> func =
-			[&](const SPtr<ct::TextureCore>& texture, UINT32 _face, UINT32 _mipLevel, const SPtr<PixelData>& _pixData,
+		std::function<void(const SPtr<ct::Texture>&, UINT32, UINT32, const SPtr<PixelData>&, bool, AsyncOp&)> func =
+			[&](const SPtr<ct::Texture>& texture, UINT32 _face, UINT32 _mipLevel, const SPtr<PixelData>& _pixData,
 				bool _discardEntireBuffer, AsyncOp& asyncOp)
 		{
 			texture->writeData(*_pixData, _mipLevel, _face, _discardEntireBuffer);
@@ -141,8 +141,8 @@ namespace bs
 	{
 		data->_lock();
 
-		std::function<void(const SPtr<ct::TextureCore>&, UINT32, UINT32, const SPtr<PixelData>&, AsyncOp&)> func =
-			[&](const SPtr<ct::TextureCore>& texture, UINT32 _face, UINT32 _mipLevel, const SPtr<PixelData>& _pixData,
+		std::function<void(const SPtr<ct::Texture>&, UINT32, UINT32, const SPtr<PixelData>&, AsyncOp&)> func =
+			[&](const SPtr<ct::Texture>& texture, UINT32 _face, UINT32 _mipLevel, const SPtr<PixelData>& _pixData,
 				AsyncOp& asyncOp)
 		{
 			// Make sure any queued command start executing before reading
@@ -267,9 +267,9 @@ namespace bs
 		}
 	}
 
-	SPtr<ct::TextureCore> Texture::getCore() const
+	SPtr<ct::Texture> Texture::getCore() const
 	{
-		return std::static_pointer_cast<ct::TextureCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Texture>(mCoreSpecific);
 	}
 
 	/************************************************************************/
@@ -324,15 +324,15 @@ namespace bs
 
 	namespace ct
 	{
-	SPtr<TextureCore> TextureCore::WHITE;
-	SPtr<TextureCore> TextureCore::BLACK;
-	SPtr<TextureCore> TextureCore::NORMAL;
+	SPtr<Texture> Texture::WHITE;
+	SPtr<Texture> Texture::BLACK;
+	SPtr<Texture> Texture::NORMAL;
 
-	TextureCore::TextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initData, GpuDeviceFlags deviceMask)
+	Texture::Texture(const TEXTURE_DESC& desc, const SPtr<PixelData>& initData, GpuDeviceFlags deviceMask)
 		:mProperties(desc), mInitData(initData)
 	{ }
 
-	void TextureCore::initialize()
+	void Texture::initialize()
 	{
 		if (mInitData != nullptr)
 		{
@@ -342,7 +342,7 @@ namespace bs
 		}
 	}
 
-	void TextureCore::writeData(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardEntireBuffer,
+	void Texture::writeData(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardEntireBuffer,
 		UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
@@ -359,7 +359,7 @@ namespace bs
 		writeDataImpl(src, mipLevel, face, discardEntireBuffer, queueIdx);
 	}
 
-	void TextureCore::readData(PixelData& dest, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
+	void Texture::readData(PixelData& dest, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -379,7 +379,7 @@ namespace bs
 		readDataImpl(pixelData, mipLevel, face, deviceIdx, queueIdx);
 	}
 
-	PixelData TextureCore::lock(GpuLockOptions options, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
+	PixelData Texture::lock(GpuLockOptions options, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -398,14 +398,14 @@ namespace bs
 		return lockImpl(options, mipLevel, face, deviceIdx, queueIdx);
 	}
 
-	void TextureCore::unlock()
+	void Texture::unlock()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		unlockImpl();
 	}
 
-	void TextureCore::copy(const SPtr<TextureCore>& target, UINT32 srcFace, UINT32 srcMipLevel, UINT32 dstFace,
+	void Texture::copy(const SPtr<Texture>& target, UINT32 srcFace, UINT32 srcMipLevel, UINT32 dstFace,
 						   UINT32 dstMipLevel, UINT32 queueIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
@@ -473,17 +473,17 @@ namespace bs
 	/* 								TEXTURE VIEW                      		*/
 	/************************************************************************/
 
-	SPtr<TextureView> TextureCore::createView(const SPtr<TextureCore>& texture, const TEXTURE_VIEW_DESC& desc)
+	SPtr<TextureView> Texture::createView(const SPtr<Texture>& texture, const TEXTURE_VIEW_DESC& desc)
 	{
 		return bs_shared_ptr<TextureView>(new (bs_alloc<TextureView>()) TextureView(texture, desc));
 	}
 
-	void TextureCore::clearBufferViews()
+	void Texture::clearBufferViews()
 	{
 		mTextureViews.clear();
 	}
 
-	SPtr<TextureView> TextureCore::requestView(const SPtr<TextureCore>& texture, UINT32 mostDetailMip, UINT32 numMips,
+	SPtr<TextureView> Texture::requestView(const SPtr<Texture>& texture, UINT32 mostDetailMip, UINT32 numMips,
 											   UINT32 firstArraySlice, UINT32 numArraySlices, GpuViewUsage usage)
 	{
 		THROW_IF_NOT_CORE_THREAD;
@@ -515,13 +515,13 @@ namespace bs
 		return iterFind->second->view;
 	}
 
-	void TextureCore::releaseView(const SPtr<TextureView>& view)
+	void Texture::releaseView(const SPtr<TextureView>& view)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		assert(view != nullptr);
 
-		SPtr<TextureCore> texture = view->getTexture();
+		SPtr<Texture> texture = view->getTexture();
 
 		auto iterFind = texture->mTextureViews.find(view->getDesc());
 		if (iterFind == texture->mTextureViews.end())
@@ -544,12 +544,12 @@ namespace bs
 	/************************************************************************/
 	/* 								STATICS	                      			*/
 	/************************************************************************/
-	SPtr<TextureCore> TextureCore::create(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<Texture> Texture::create(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return TextureManager::instance().createTexture(desc, deviceMask);
 	}
 
-	SPtr<TextureCore> TextureCore::create(const SPtr<PixelData>& pixelData, int usage, bool hwGammaCorrection, 
+	SPtr<Texture> Texture::create(const SPtr<PixelData>& pixelData, int usage, bool hwGammaCorrection, 
 		GpuDeviceFlags deviceMask)
 	{
 		TEXTURE_DESC desc;

Source/BansheeCore/Source/BsTextureManager.cpp

@@ -94,7 +94,7 @@ namespace bs
 		desc.usage = TU_STATIC;
 
 		// White built-in texture
-		SPtr<TextureCore> whiteTexture = createTexture(desc);
+		SPtr<Texture> whiteTexture = createTexture(desc);
 
 		SPtr<PixelData> whitePixelData = PixelData::create(2, 2, 1, PF_R8G8B8A8);
 		whitePixelData->setColorAt(Color::White, 0, 0);
@@ -103,10 +103,10 @@ namespace bs
 		whitePixelData->setColorAt(Color::White, 1, 1);
 
 		whiteTexture->writeData(*whitePixelData);
-		TextureCore::WHITE = whiteTexture;
+		Texture::WHITE = whiteTexture;
 
 		// Black built-in texture
-		SPtr<TextureCore> blackTexture = createTexture(desc);
+		SPtr<Texture> blackTexture = createTexture(desc);
 
 		SPtr<PixelData> blackPixelData = PixelData::create(2, 2, 1, PF_R8G8B8A8);
 		blackPixelData->setColorAt(Color::Black, 0, 0);
@@ -115,10 +115,10 @@ namespace bs
 		blackPixelData->setColorAt(Color::Black, 1, 1);
 
 		blackTexture->writeData(*blackPixelData);
-		TextureCore::BLACK = blackTexture;
+		Texture::BLACK = blackTexture;
 
 		// Normal (Y = Up) built-in texture
-		SPtr<TextureCore> normalTexture = createTexture(desc);
+		SPtr<Texture> normalTexture = createTexture(desc);
 		SPtr<PixelData> normalPixelData = PixelData::create(2, 2, 1, PF_R8G8B8A8);
 
 		Color encodedNormal(0.5f, 0.5f, 1.0f);
@@ -128,29 +128,29 @@ namespace bs
 		normalPixelData->setColorAt(encodedNormal, 1, 1);
 
 		normalTexture->writeData(*normalPixelData);
-		TextureCore::NORMAL = normalTexture;
+		Texture::NORMAL = normalTexture;
     }
 
 	void TextureManager::onShutDown()
     {
 		// Need to make sure these are freed while still on the core thread
-		TextureCore::WHITE = nullptr;
-		TextureCore::BLACK = nullptr;
-		TextureCore::NORMAL = nullptr;
+		Texture::WHITE = nullptr;
+		Texture::BLACK = nullptr;
+		Texture::NORMAL = nullptr;
     }
 
-	SPtr<TextureCore> TextureManager::createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<Texture> TextureManager::createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		SPtr<TextureCore> newRT = createTextureInternal(desc, nullptr, deviceMask);
+		SPtr<Texture> newRT = createTextureInternal(desc, nullptr, deviceMask);
 		newRT->initialize();
 
 		return newRT;
 	}
 
-	SPtr<RenderTextureCore> TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC& desc, 
+	SPtr<RenderTexture> TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC& desc, 
 																	UINT32 deviceIdx)
 	{
-		SPtr<RenderTextureCore> newRT = createRenderTextureInternal(desc, deviceIdx);
+		SPtr<RenderTexture> newRT = createRenderTextureInternal(desc, deviceIdx);
 		newRT->initialize();
 
 		return newRT;

Source/BansheeCore/Source/BsTextureView.cpp

@@ -27,7 +27,7 @@ namespace bs { namespace ct
 	TextureView::~TextureView()
 	{ }
 
-	TextureView::TextureView(const SPtr<TextureCore>& texture, const TEXTURE_VIEW_DESC& desc)
+	TextureView::TextureView(const SPtr<Texture>& texture, const TEXTURE_VIEW_DESC& desc)
 		:mDesc(desc), mOwnerTexture(texture)
 	{
 

Source/BansheeCore/Source/BsTransientMesh.cpp

@@ -23,17 +23,17 @@ namespace bs
 		}
 	}
 
-	SPtr<ct::TransientMeshCore> TransientMesh::getCore() const
+	SPtr<ct::TransientMesh> TransientMesh::getCore() const
 	{
-		return std::static_pointer_cast<ct::TransientMeshCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::TransientMesh>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> TransientMesh::createCore() const
 	{
-		ct::TransientMeshCore* core = new (bs_alloc<ct::TransientMeshCore>()) ct::TransientMeshCore(
+		ct::TransientMesh* core = new (bs_alloc<ct::TransientMesh>()) ct::TransientMesh(
 			mParentHeap->getCore(), mId, mProperties.mNumVertices, mProperties.mNumIndices, mProperties.mSubMeshes);
 
-		SPtr<ct::CoreObject> meshCore = bs_shared_ptr<ct::TransientMeshCore>(core);
+		SPtr<ct::CoreObject> meshCore = bs_shared_ptr<ct::TransientMesh>(core);
 		meshCore->_setThisPtr(meshCore);
 
 		return meshCore;
@@ -41,39 +41,39 @@ namespace bs
 
 	namespace ct
 	{
-	TransientMeshCore::TransientMeshCore(const SPtr<MeshHeapCore>& parentHeap, UINT32 id, 
+	TransientMesh::TransientMesh(const SPtr<MeshHeap>& parentHeap, UINT32 id, 
 		UINT32 numVertices, UINT32 numIndices, const Vector<SubMesh>& subMeshes)
-		:MeshCoreBase(numVertices, numIndices, subMeshes), mParentHeap(parentHeap), mId(id)
+		:MeshBase(numVertices, numIndices, subMeshes), mParentHeap(parentHeap), mId(id)
 	{
 
 	}
 
-	SPtr<VertexData> TransientMeshCore::getVertexData() const
+	SPtr<VertexData> TransientMesh::getVertexData() const
 	{
 		return mParentHeap->getVertexData();
 	}
 
-	SPtr<IndexBufferCore> TransientMeshCore::getIndexBuffer() const
+	SPtr<IndexBuffer> TransientMesh::getIndexBuffer() const
 	{
 		return mParentHeap->getIndexBuffer();
 	}
 
-	UINT32 TransientMeshCore::getVertexOffset() const
+	UINT32 TransientMesh::getVertexOffset() const
 	{
 		return mParentHeap->getVertexOffset(mId);
 	}
 
-	UINT32 TransientMeshCore::getIndexOffset() const
+	UINT32 TransientMesh::getIndexOffset() const
 	{
 		return mParentHeap->getIndexOffset(mId);
 	}
 
-	SPtr<VertexDataDesc> TransientMeshCore::getVertexDesc() const
+	SPtr<VertexDataDesc> TransientMesh::getVertexDesc() const
 	{
 		return mParentHeap->getVertexDesc();
 	}
 
-	void TransientMeshCore::_notifyUsedOnGPU()
+	void TransientMesh::_notifyUsedOnGPU()
 	{
 		mParentHeap->notifyUsedOnGPU(mId);
 	}

Source/BansheeCore/Source/BsVertexBuffer.cpp

@@ -26,9 +26,9 @@ namespace bs
 		return ct::HardwareBufferManager::instance().createVertexBufferInternal(desc);
 	}
 
-	SPtr<ct::VertexBufferCore> VertexBuffer::getCore() const
+	SPtr<ct::VertexBuffer> VertexBuffer::getCore() const
 	{
-		return std::static_pointer_cast<ct::VertexBufferCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::VertexBuffer>(mCoreSpecific);
 	}
 
 	SPtr<VertexBuffer> VertexBuffer::create(const VERTEX_BUFFER_DESC& desc)
@@ -38,11 +38,11 @@ namespace bs
 
 	namespace ct
 	{
-	VertexBufferCore::VertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	VertexBuffer::VertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 		:HardwareBuffer(desc.vertexSize * desc.numVerts), mProperties(desc.numVerts, desc.vertexSize)
 	{ }
 
-	SPtr<VertexBufferCore> VertexBufferCore::create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<VertexBuffer> VertexBuffer::create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createVertexBuffer(desc, deviceMask);
 	}

Source/BansheeCore/Source/BsVertexData.cpp

@@ -19,14 +19,14 @@ namespace bs { namespace ct
 	{
 	}
 
-	void VertexData::setBuffer(UINT32 index, SPtr<VertexBufferCore> buffer)
+	void VertexData::setBuffer(UINT32 index, SPtr<VertexBuffer> buffer)
 	{
 		mVertexBuffers[index] = buffer;
 
 		recalculateMaxIndex();
 	}
 
-	SPtr<VertexBufferCore> VertexData::getBuffer(UINT32 index) const
+	SPtr<VertexBuffer> VertexData::getBuffer(UINT32 index) const
 	{
 		auto iterFind = mVertexBuffers.find(index);
 		if(iterFind != mVertexBuffers.end())

Source/BansheeCore/Source/BsVertexDeclaration.cpp

@@ -254,9 +254,9 @@ namespace bs
 
 	}
 
-	SPtr<ct::VertexDeclarationCore> VertexDeclaration::getCore() const
+	SPtr<ct::VertexDeclaration> VertexDeclaration::getCore() const
 	{
-		return std::static_pointer_cast<ct::VertexDeclarationCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::VertexDeclaration>(mCoreSpecific);
 	}
 
 	SPtr<ct::CoreObject> VertexDeclaration::createCore() const
@@ -318,26 +318,26 @@ namespace bs
 
 	namespace ct
 	{
-	UINT32 VertexDeclarationCore::NextFreeId = 0;
+	UINT32 VertexDeclaration::NextFreeId = 0;
 
-	VertexDeclarationCore::VertexDeclarationCore(const List<VertexElement>& elements, GpuDeviceFlags deviceMask)
+	VertexDeclaration::VertexDeclaration(const List<VertexElement>& elements, GpuDeviceFlags deviceMask)
 		:mProperties(elements)
 	{
 		
 	}
 
-	void VertexDeclarationCore::initialize()
+	void VertexDeclaration::initialize()
 	{
 		mId = NextFreeId++;
 		CoreObject::initialize();
 	}
 
-	SPtr<VertexDeclarationCore> VertexDeclarationCore::create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask)
+	SPtr<VertexDeclaration> VertexDeclaration::create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask)
 	{
 		return HardwareBufferManager::instance().createVertexDeclaration(desc, deviceMask);
 	}
 
-	bool VertexDeclarationCore::isCompatible(const SPtr<VertexDeclarationCore>& shaderDecl)
+	bool VertexDeclaration::isCompatible(const SPtr<VertexDeclaration>& shaderDecl)
 	{
 		const List<VertexElement>& shaderElems = shaderDecl->getProperties().getElements();
 		const List<VertexElement>& bufferElems = getProperties().getElements();
@@ -361,7 +361,7 @@ namespace bs
 		return true;
 	}
 
-	Vector<VertexElement> VertexDeclarationCore::getMissingElements(const SPtr<VertexDeclarationCore>& shaderDecl)
+	Vector<VertexElement> VertexDeclaration::getMissingElements(const SPtr<VertexDeclaration>& shaderDecl)
 	{
 		Vector<VertexElement> missingElements;
 

Source/BansheeCore/Source/BsViewport.cpp

@@ -99,9 +99,9 @@ namespace bs
 		_markCoreDirty();
 	}
 
-	SPtr<ct::ViewportCore> Viewport::getCore() const
+	SPtr<ct::Viewport> Viewport::getCore() const
 	{
-		return std::static_pointer_cast<ct::ViewportCore>(mCoreSpecific);
+		return std::static_pointer_cast<ct::Viewport>(mCoreSpecific);
 	}
 
 	void Viewport::_markCoreDirty()
@@ -127,14 +127,14 @@ namespace bs
 
 	SPtr<ct::CoreObject> Viewport::createCore() const
 	{
-		SPtr<ct::RenderTargetCore> targetCore;
+		SPtr<ct::RenderTarget> targetCore;
 		if (mTarget != nullptr)
 			targetCore = mTarget->getCore();
 
-		ct::ViewportCore* viewport = new (bs_alloc<ct::ViewportCore>())
-			ct::ViewportCore(targetCore, mNormArea.x, mNormArea.y, mNormArea.width, mNormArea.height);
+		ct::Viewport* viewport = new (bs_alloc<ct::Viewport>())
+			ct::Viewport(targetCore, mNormArea.x, mNormArea.y, mNormArea.width, mNormArea.height);
 
-		SPtr<ct::ViewportCore> viewportPtr = bs_shared_ptr<ct::ViewportCore>(viewport);
+		SPtr<ct::Viewport> viewportPtr = bs_shared_ptr<ct::Viewport>(viewport);
 		viewportPtr->_setThisPtr(viewportPtr);
 
 		return viewportPtr;
@@ -150,7 +150,7 @@ namespace bs
 		size += rttiGetElemSize(mClearColor);
 		size += rttiGetElemSize(mDepthClearValue);
 		size += rttiGetElemSize(mStencilClearValue);
-		size += sizeof(SPtr<ct::RenderTargetCore>);
+		size += sizeof(SPtr<ct::RenderTarget>);
 
 		UINT8* buffer = allocator->alloc(size);
 
@@ -163,7 +163,7 @@ namespace bs
 		dataPtr = rttiWriteElem(mDepthClearValue, dataPtr);
 		dataPtr = rttiWriteElem(mStencilClearValue, dataPtr);
 
-		SPtr<ct::RenderTargetCore>* rtPtr = new (dataPtr) SPtr<ct::RenderTargetCore>();
+		SPtr<ct::RenderTarget>* rtPtr = new (dataPtr) SPtr<ct::RenderTarget>();
 		if (mTarget != nullptr)
 			*rtPtr = mTarget->getCore();
 		else
@@ -209,24 +209,24 @@ namespace bs
 
 	namespace ct
 	{
-	ViewportCore::ViewportCore(const SPtr<RenderTargetCore>& target, float x, float y, float width, float height)
+	Viewport::Viewport(const SPtr<RenderTarget>& target, float x, float y, float width, float height)
 		:ViewportBase(x, y, width, height), mTarget(target)
 	{
 
 	}
 
-	SPtr<ViewportCore> ViewportCore::create(const SPtr<RenderTargetCore>& target, float x, float y, float width, float height)
+	SPtr<Viewport> Viewport::create(const SPtr<RenderTarget>& target, float x, float y, float width, float height)
 	{
-		ViewportCore* viewport = new (bs_alloc<Viewport>()) ViewportCore(target, x, y, width, height);
+		Viewport* viewport = new (bs_alloc<Viewport>()) Viewport(target, x, y, width, height);
 
-		SPtr<ViewportCore> viewportPtr = bs_shared_ptr<ViewportCore>(viewport);
+		SPtr<Viewport> viewportPtr = bs_shared_ptr<Viewport>(viewport);
 		viewportPtr->_setThisPtr(viewportPtr);
 		viewportPtr->initialize();
 
 		return viewportPtr;
 	}
 
-	UINT32 ViewportCore::getTargetWidth() const
+	UINT32 Viewport::getTargetWidth() const
 	{
 		if (mTarget != nullptr)
 			return mTarget->getProperties().getWidth();
@@ -234,7 +234,7 @@ namespace bs
 		return 0;
 	}
 
-	UINT32 ViewportCore::getTargetHeight() const
+	UINT32 Viewport::getTargetHeight() const
 	{
 		if (mTarget != nullptr)
 			return mTarget->getProperties().getHeight();
@@ -242,7 +242,7 @@ namespace bs
 		return 0;
 	}
 
-	void ViewportCore::syncToCore(const CoreSyncData& data)
+	void Viewport::syncToCore(const CoreSyncData& data)
 	{
 		char* dataPtr = (char*)data.getBuffer();
 		dataPtr = rttiReadElem(mNormArea, dataPtr);
@@ -253,10 +253,10 @@ namespace bs
 		dataPtr = rttiReadElem(mDepthClearValue, dataPtr);
 		dataPtr = rttiReadElem(mStencilClearValue, dataPtr);
 
-		SPtr<RenderTargetCore>* rtPtr = (SPtr<RenderTargetCore>*)dataPtr;
+		SPtr<RenderTarget>* rtPtr = (SPtr<RenderTarget>*)dataPtr;
 		mTarget = *rtPtr;
 
-		rtPtr->~SPtr<RenderTargetCore>();
+		rtPtr->~SPtr<RenderTarget>();
 	}
 	}
 }

Source/BansheeCore/Source/Win32/BsWin32Platform.cpp

@@ -22,7 +22,7 @@ namespace bs
 	Event<void(float)> Platform::onMouseWheelScrolled;
 	Event<void(UINT32)> Platform::onCharInput;
 
-	Event<void(ct::RenderWindowCore*)> Platform::onMouseLeftWindow;
+	Event<void(ct::RenderWindow*)> Platform::onMouseLeftWindow;
 	Event<void()> Platform::onMouseCaptureChanged;
 
 	Platform::Pimpl* Platform::mData = bs_new<Platform::Pimpl>();
@@ -222,21 +222,21 @@ namespace bs
 		PostMessage((HWND)hwnd, WM_SETICON, WPARAM(ICON_BIG), (LPARAM)icon);
 	}
 
-	void Platform::setCaptionNonClientAreas(const ct::RenderWindowCore& window, const Vector<Rect2I>& nonClientAreas)
+	void Platform::setCaptionNonClientAreas(const ct::RenderWindow& window, const Vector<Rect2I>& nonClientAreas)
 	{
 		Lock lock(mData->mSync);
 
 		mData->mNonClientAreas[&window].moveAreas = nonClientAreas;
 	}
 
-	void Platform::setResizeNonClientAreas(const ct::RenderWindowCore& window, const Vector<NonClientResizeArea>& nonClientAreas)
+	void Platform::setResizeNonClientAreas(const ct::RenderWindow& window, const Vector<NonClientResizeArea>& nonClientAreas)
 	{
 		Lock lock(mData->mSync);
 
 		mData->mNonClientAreas[&window].resizeAreas = nonClientAreas;
 	}
 
-	void Platform::resetNonClientAreas(const ct::RenderWindowCore& window)
+	void Platform::resetNonClientAreas(const ct::RenderWindow& window)
 	{
 		Lock lock(mData->mSync);
 
@@ -496,7 +496,7 @@ namespace bs
 		{	// Store pointer to Win32Window in user data area
 			SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
 
-			ct::RenderWindowCore* newWindow = (ct::RenderWindowCore*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
+			ct::RenderWindow* newWindow = (ct::RenderWindow*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
 			if (newWindow != nullptr)
 			{
 				const RenderWindowProperties& props = newWindow->getProperties();
@@ -509,7 +509,7 @@ namespace bs
 			return 0;
 		}
 
-		ct::RenderWindowCore* win = (ct::RenderWindowCore*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
+		ct::RenderWindow* win = (ct::RenderWindow*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
 		if (!win)
 			return DefWindowProc(hWnd, uMsg, wParam, lParam);
 

Source/BansheeD3D11RenderAPI/Include/BsD3D11BlendState.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/** DirectX 11 implementation of a blend state. Corresponds directly with a DX11 blend state object. */
-	class BS_D3D11_EXPORT D3D11BlendState : public BlendStateCore
+	class BS_D3D11_EXPORT D3D11BlendState : public BlendState
 	{
 	public:
 		~D3D11BlendState();
@@ -25,7 +25,7 @@ namespace bs { namespace ct
 
 		D3D11BlendState(const BLEND_STATE_DESC& desc, UINT32 id);
 
-		/** @copydoc BlendStateCore::createInternal */
+		/** @copydoc BlendState::createInternal */
 		void createInternal() override;
 
 		ID3D11BlendState* mBlendState;

Source/BansheeD3D11RenderAPI/Include/BsD3D11DepthStencilState.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/** DirectX 11 implementation of a depth stencil state. Corresponds directly with a DX11 depth stencil state object. */
-	class BS_D3D11_EXPORT D3D11DepthStencilState : public DepthStencilStateCore
+	class BS_D3D11_EXPORT D3D11DepthStencilState : public DepthStencilState
 	{
 	public:
 		~D3D11DepthStencilState();
@@ -25,7 +25,7 @@ namespace bs { namespace ct
 
 		D3D11DepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id);
 
-		/** @copydoc DepthStencilStateCore::createInternal() */
+		/** @copydoc DepthStencilState::createInternal() */
 		void createInternal() override;
 
 		ID3D11DepthStencilState* mDepthStencilState;

Source/BansheeD3D11RenderAPI/Include/BsD3D11GpuBuffer.h

@@ -13,26 +13,26 @@ namespace bs { namespace ct
 	 */
 
 	/**	DirectX 11 implementation of a generic GPU buffer. */
-	class BS_D3D11_EXPORT D3D11GpuBuffer : public GpuBufferCore
+	class BS_D3D11_EXPORT D3D11GpuBuffer : public GpuBuffer
     {
     public:
 		~D3D11GpuBuffer();
 
-		/** @copydoc GpuBufferCore::lock */
+		/** @copydoc GpuBuffer::lock */
 		void* lock(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx = 0,
 				   UINT32 queueIdx = 0) override;
 
-		/** @copydoc GpuBufferCore::unlock */
+		/** @copydoc GpuBuffer::unlock */
 		void unlock() override;
 
-		/** @copydoc GpuBufferCore::readData */
+		/** @copydoc GpuBuffer::readData */
 		void readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx = 0, UINT32 queueIdx = 0) override;
 
-		/** @copydoc GpuBufferCore::writeData */
+		/** @copydoc GpuBuffer::writeData */
         void writeData(UINT32 offset, UINT32 length, const void* source,
 			BufferWriteType writeFlags = BWT_NORMAL, UINT32 queueIdx = 0) override;
 
-		/** @copydoc GpuBufferCore::copyData */
+		/** @copydoc GpuBuffer::copyData */
 		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
 			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false, UINT32 queueIdx = 0) override;
 
@@ -77,7 +77,7 @@ namespace bs { namespace ct
 		/**	Destroys all buffer views regardless if their reference count is zero or not. */
 		void clearBufferViews();
 
-		/** @copydoc GpuBufferCore::initialize */
+		/** @copydoc GpuBuffer::initialize */
 		void initialize() override;
 
 	private:

Source/BansheeD3D11RenderAPI/Include/BsD3D11GpuParamBlockBuffer.h

@@ -12,19 +12,19 @@ namespace bs { namespace ct
 	 */
 
 	/**	DirectX 11 implementation of a parameter block buffer (constant buffer in DX11 lingo). */
-	class BS_D3D11_EXPORT D3D11GpuParamBlockBuffer : public GpuParamBlockBufferCore
+	class BS_D3D11_EXPORT D3D11GpuParamBlockBuffer : public GpuParamBlockBuffer
 	{
 	public:
 		D3D11GpuParamBlockBuffer(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
 		~D3D11GpuParamBlockBuffer();
 
-		/** @copydoc GpuParamBlockBufferCore::writeToGPU */
+		/** @copydoc GpuParamBlockBuffer::writeToGPU */
 		void writeToGPU(const UINT8* data, UINT32 queueIdx = 0) override;
 
 		/**	Returns internal DX11 buffer object. */
 		ID3D11Buffer* getD3D11Buffer() const;
 	protected:
-		/** @copydoc GpuParamBlockBufferCore::initialize */
+		/** @copydoc GpuParamBlockBuffer::initialize */
 		void initialize() override;
 
 	private:

Source/BansheeD3D11RenderAPI/Include/BsD3D11GpuProgram.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/**	Abstraction of a DirectX 11 shader object. */
-	class BS_D3D11_EXPORT D3D11GpuProgram : public GpuProgramCore
+	class BS_D3D11_EXPORT D3D11GpuProgram : public GpuProgram
 	{
 	public:
 		virtual ~D3D11GpuProgram();
@@ -26,7 +26,7 @@ namespace bs { namespace ct
 	protected:
 		D3D11GpuProgram(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
 
-		/** @copydoc GpuProgramCore::initialize */
+		/** @copydoc GpuProgram::initialize */
 		void initialize() override;
 
 		/**	Loads the shader from microcode. */

Source/BansheeD3D11RenderAPI/Include/BsD3D11HLSLProgramFactory.h

@@ -22,10 +22,10 @@ namespace bs { namespace ct
 		const String& getLanguage() const override;
 
 		/** @copydoc GpuProgramFactory::create(const GPU_PROGRAM_DESC&, GpuDeviceFlags) */
-		SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+		SPtr<GpuProgram> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 		/** @copydoc GpuProgramFactory::create(GpuProgramType, GpuDeviceFlags) */
-		SPtr<GpuProgramCore> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+		SPtr<GpuProgram> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 	protected:
 		static const String LANGUAGE_NAME;

Source/BansheeD3D11RenderAPI/Include/BsD3D11HardwareBufferManager.h

@@ -19,19 +19,19 @@ namespace bs { namespace ct
 
 	protected:     
 		/** @copydoc HardwareBufferManager::createVertexBufferInternal */
-		SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
+		SPtr<VertexBuffer> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 		/** @copydoc HardwareBufferManager::createIndexBufferInternal */
-		SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
+		SPtr<IndexBuffer> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 		/** @copydoc HardwareBufferManager::createGpuParamBlockBufferInternal  */
-		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
+		SPtr<GpuParamBlockBuffer> createGpuParamBlockBufferInternal(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 		/** @copydoc HardwareBufferManager::createGpuBufferInternal */
-		SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
+		SPtr<GpuBuffer> createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
 		D3D11Device& mDevice;

Source/BansheeD3D11RenderAPI/Include/BsD3D11IndexBuffer.h

@@ -13,21 +13,21 @@ namespace bs { namespace ct
 	 */
 
 	/**	DirectX 11 implementation of an index buffer. */
-	class BS_D3D11_EXPORT D3D11IndexBuffer : public IndexBufferCore
+	class BS_D3D11_EXPORT D3D11IndexBuffer : public IndexBuffer
 	{
 	public:
 		D3D11IndexBuffer(D3D11Device& device, const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
 
 		~D3D11IndexBuffer();
 
-		/** @copydoc IndexBufferCore::readData */
+		/** @copydoc IndexBuffer::readData */
 		void readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx = 0, UINT32 queueIdx = 0) override;
 
-		/** @copydoc IndexBufferCore::writeData */
+		/** @copydoc IndexBuffer::writeData */
 		void writeData(UINT32 offset, UINT32 length, const void* source, 
 			BufferWriteType writeFlags = BWT_NORMAL, UINT32 queueIdx = 0) override;
 
-		/** @copydoc IndexBufferCore::copyData */
+		/** @copydoc IndexBuffer::copyData */
 		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, UINT32 dstOffset, UINT32 length, 
 			bool discardWholeBuffer = false, UINT32 queueIdx = 0) override;
 
@@ -35,13 +35,13 @@ namespace bs { namespace ct
 		ID3D11Buffer* getD3DIndexBuffer() const { return mBuffer->getD3DBuffer(); }		
 
 	protected:
-		/** @copydoc IndexBufferCore::map */
+		/** @copydoc IndexBuffer::map */
 		void* map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx) override;
 
-		/** @copydoc IndexBufferCore::unmap */
+		/** @copydoc IndexBuffer::unmap */
 		void unmap() override;
 
-		/** @copydoc IndexBufferCore::initialize */
+		/** @copydoc IndexBuffer::initialize */
 		void initialize() override;
 
 		D3D11HardwareBuffer* mBuffer;

Source/BansheeD3D11RenderAPI/Include/BsD3D11InputLayoutManager.h

@@ -60,12 +60,12 @@ namespace bs { namespace ct
 		 *
 		 * @note	Error will be thrown if the vertex buffer doesn't provide all the necessary data that the shader expects.
 		 */
-		ID3D11InputLayout* retrieveInputLayout(const SPtr<VertexDeclarationCore>& vertexShaderDecl,
-			const SPtr<VertexDeclarationCore>& vertexBufferDecl, D3D11GpuProgram& vertexProgram);
+		ID3D11InputLayout* retrieveInputLayout(const SPtr<VertexDeclaration>& vertexShaderDecl,
+			const SPtr<VertexDeclaration>& vertexBufferDecl, D3D11GpuProgram& vertexProgram);
 
 	private:
 		/**	Creates a new input layout using the specified parameters and stores it in the input layout map. */
-		void addNewInputLayout(const SPtr<VertexDeclarationCore>& vertexShaderDecl, const SPtr<VertexDeclarationCore>& vertexBufferDecl,
+		void addNewInputLayout(const SPtr<VertexDeclaration>& vertexShaderDecl, const SPtr<VertexDeclaration>& vertexBufferDecl,
 			D3D11GpuProgram& vertexProgram);
 
 		/**	Destroys least used input layout. */