From 60e2f63e18fddac735439c9f1555f36156af49d9 Mon Sep 17 00:00:00 2001 From: turanszkij Date: Sun, 20 Mar 2016 14:29:50 +0100 Subject: [PATCH] Graphics API decouple part5 --- WickedEngine/DeferredRenderableComponent.cpp | 8 +- WickedEngine/ForwardRenderableComponent.cpp | 2 + WickedEngine/Renderable2DComponent.cpp | 2 + WickedEngine/Renderable3DComponent.cpp | 26 +- WickedEngine/Texture_BindLua.cpp | 2 + WickedEngine/Texture_BindLua.h | 4 +- WickedEngine/wiBackLog.cpp | 2 + WickedEngine/wiBackLog.h | 4 +- WickedEngine/wiCube.cpp | 2 + WickedEngine/wiCube.h | 4 +- WickedEngine/wiDepthTarget.cpp | 67 +- WickedEngine/wiDepthTarget.h | 8 +- WickedEngine/wiEmittedParticle.cpp | 12 +- WickedEngine/wiEmittedParticle.h | 18 +- WickedEngine/wiFont.cpp | 6 +- WickedEngine/wiFont.h | 18 +- WickedEngine/wiGraphicsAPI.h | 992 +++++++++++-------- WickedEngine/wiGraphicsAPI_DX11.cpp | 380 ++++++- WickedEngine/wiGraphicsAPI_DX11.h | 783 +++++++-------- WickedEngine/wiHairParticle.cpp | 8 +- WickedEngine/wiHairParticle.h | 18 +- WickedEngine/wiImage.cpp | 2 + WickedEngine/wiImage.h | 22 +- WickedEngine/wiImageEffects.h | 8 +- WickedEngine/wiLensFlare.cpp | 3 +- WickedEngine/wiLensFlare.h | 18 +- WickedEngine/wiLines.cpp | 2 + WickedEngine/wiLines.h | 2 +- WickedEngine/wiLoader.cpp | 1 + WickedEngine/wiLoader.h | 30 +- WickedEngine/wiRenderTarget.cpp | 10 +- WickedEngine/wiRenderTarget.h | 19 +- WickedEngine/wiRenderer.cpp | 40 +- WickedEngine/wiRenderer.h | 54 +- WickedEngine/wiRenderer_BindLua.cpp | 2 + WickedEngine/wiResourceManager.cpp | 2 + WickedEngine/wiResourceManager.h | 2 +- WickedEngine/wiResourceManager_BindLua.cpp | 1 + WickedEngine/wiSprite.cpp | 2 + WickedEngine/wiSprite.h | 8 +- WickedEngine/wiTextureHelper.cpp | 2 +- WickedEngine/wiTextureHelper.h | 44 +- 42 files changed, 1546 insertions(+), 1094 deletions(-) diff --git a/WickedEngine/DeferredRenderableComponent.cpp b/WickedEngine/DeferredRenderableComponent.cpp index 6af75f00e..1058a4b0f 100644 --- a/WickedEngine/DeferredRenderableComponent.cpp +++ b/WickedEngine/DeferredRenderableComponent.cpp @@ -7,6 +7,8 @@ #include "wiSprite.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + DeferredRenderableComponent::DeferredRenderableComponent(){ Renderable3DComponent::setProperties(); @@ -24,15 +26,15 @@ void DeferredRenderableComponent::Initialize() rtGBuffer.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() , 3, true, 1, 0 - , DXGI_FORMAT_R16G16B16A16_FLOAT + , FORMAT_R16G16B16A16_FLOAT ); rtDeferred.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT, 0); + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT, 0); rtLight.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() , 1, false, 1, 0 - , DXGI_FORMAT_R11G11B10_FLOAT + , FORMAT_R11G11B10_FLOAT ); Renderable2DComponent::Initialize(); diff --git a/WickedEngine/ForwardRenderableComponent.cpp b/WickedEngine/ForwardRenderableComponent.cpp index 9ad853665..28ee596d0 100644 --- a/WickedEngine/ForwardRenderableComponent.cpp +++ b/WickedEngine/ForwardRenderableComponent.cpp @@ -4,6 +4,8 @@ #include "wiImageEffects.h" #include "wiHelper.h" +using namespace wiGraphicsTypes; + ForwardRenderableComponent::ForwardRenderableComponent(){ Renderable3DComponent::setProperties(); diff --git a/WickedEngine/Renderable2DComponent.cpp b/WickedEngine/Renderable2DComponent.cpp index 6e87c4498..233acbbdd 100644 --- a/WickedEngine/Renderable2DComponent.cpp +++ b/WickedEngine/Renderable2DComponent.cpp @@ -4,6 +4,8 @@ #include "wiFont.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; + Renderable2DComponent::Renderable2DComponent() { setSpriteSpeed(1.f); diff --git a/WickedEngine/Renderable3DComponent.cpp b/WickedEngine/Renderable3DComponent.cpp index 68621897b..9136a91a6 100644 --- a/WickedEngine/Renderable3DComponent.cpp +++ b/WickedEngine/Renderable3DComponent.cpp @@ -7,6 +7,8 @@ #include "wiLoader.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + Renderable3DComponent::Renderable3DComponent() { _needToUpdateRenderData.store(true); @@ -64,30 +66,30 @@ void Renderable3DComponent::Initialize() rtSSR.Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()) - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT); + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT); rtMotionBlur.Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()) - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT); + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT); rtLinearDepth.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R32_FLOAT + , 1, false, 1, 0, FORMAT_R32_FLOAT ); rtParticle.Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth()*getAlphaParticleDownSample()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()*getAlphaParticleDownSample()) - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT ); rtParticleAdditive.Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth()*getAdditiveParticleDownSample()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()*getAdditiveParticleDownSample()) - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT ); rtWaterRipple.Initialize( wiRenderer::GetDevice()->GetScreenWidth() , wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R8G8B8A8_SNORM + , 1, false, 1, 0, FORMAT_R8G8B8A8_SNORM ); rtTransparent.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT ); rtVolumeLight.Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() @@ -96,11 +98,11 @@ void Renderable3DComponent::Initialize() rtReflection.Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth() * getReflectionQuality()) , (UINT)(wiRenderer::GetDevice()->GetScreenHeight() * getReflectionQuality()) - , 1, true, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT + , 1, true, 1, 0, FORMAT_R16G16B16A16_FLOAT ); rtFinal[0].Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT); + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT); rtFinal[1].Initialize( wiRenderer::GetDevice()->GetScreenWidth(), wiRenderer::GetDevice()->GetScreenHeight() , 1, false); @@ -123,13 +125,13 @@ void Renderable3DComponent::Initialize() for (unsigned int i = 0; iGetScreenWidth()*getSSAOQuality()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()*getSSAOQuality()) - , 1, false, 1, 0, DXGI_FORMAT_R8_UNORM + , 1, false, 1, 0, FORMAT_R8_UNORM ); rtSSS.resize(3); for (int i = 0; i < 3; ++i) rtSSS[i].Initialize( (UINT)(wiRenderer::GetDevice()->GetScreenWidth()), (UINT)(wiRenderer::GetDevice()->GetScreenHeight()) - , 1, false, 1, 0, DXGI_FORMAT_R16G16B16A16_FLOAT); + , 1, false, 1, 0, FORMAT_R16G16B16A16_FLOAT); rtSun.resize(2); @@ -149,7 +151,7 @@ void Renderable3DComponent::Initialize() rtBloom[0].Initialize( wiRenderer::GetDevice()->GetScreenWidth() , wiRenderer::GetDevice()->GetScreenHeight() - , 1, false, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0 + , 1, false, 1, 0, FORMAT_R8G8B8A8_UNORM, 0 ); for (unsigned int i = 1; i::FunctionType Texture_BindLua::methods[] = { diff --git a/WickedEngine/Texture_BindLua.h b/WickedEngine/Texture_BindLua.h index 2b81aa603..bb767f845 100644 --- a/WickedEngine/Texture_BindLua.h +++ b/WickedEngine/Texture_BindLua.h @@ -6,13 +6,13 @@ class Texture_BindLua { public: - Texture2D* texture; + wiGraphicsTypes::Texture2D* texture; static const char className[]; static Luna::FunctionType methods[]; static Luna::PropertyType properties[]; - Texture_BindLua(Texture2D* texture = nullptr); + Texture_BindLua(wiGraphicsTypes::Texture2D* texture = nullptr); Texture_BindLua(lua_State *L); ~Texture_BindLua(); diff --git a/WickedEngine/wiBackLog.cpp b/WickedEngine/wiBackLog.cpp index 7119d8868..e2c066a2c 100644 --- a/WickedEngine/wiBackLog.cpp +++ b/WickedEngine/wiBackLog.cpp @@ -5,6 +5,8 @@ #include "wiRenderer.h" #include "wiTextureHelper.h" +using namespace wiGraphicsTypes; + deque wiBackLog::stream; deque wiBackLog::history; mutex wiBackLog::logMutex; diff --git a/WickedEngine/wiBackLog.h b/WickedEngine/wiBackLog.h index 18ffcba67..0514999e2 100644 --- a/WickedEngine/wiBackLog.h +++ b/WickedEngine/wiBackLog.h @@ -45,9 +45,9 @@ public: static bool isActive(){return state==IDLE;} - static void setBackground(Texture2D* texture); + static void setBackground(wiGraphicsTypes::Texture2D* texture); - static Texture2D* backgroundTex; + static wiGraphicsTypes::Texture2D* backgroundTex; static wiFont font; }; diff --git a/WickedEngine/wiCube.cpp b/WickedEngine/wiCube.cpp index bf276340b..235e3d80e 100644 --- a/WickedEngine/wiCube.cpp +++ b/WickedEngine/wiCube.cpp @@ -1,6 +1,8 @@ #include "wiCube.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; + BufferResource Cube::vertexBuffer; BufferResource Cube::indexBuffer; diff --git a/WickedEngine/wiCube.h b/WickedEngine/wiCube.h index b70eb510b..94ec35d3d 100644 --- a/WickedEngine/wiCube.h +++ b/WickedEngine/wiCube.h @@ -41,8 +41,8 @@ public: Description desc; - static BufferResource vertexBuffer; - static BufferResource indexBuffer; + static wiGraphicsTypes::BufferResource vertexBuffer; + static wiGraphicsTypes::BufferResource indexBuffer; static void LoadStatic(); static void CleanUpStatic(); diff --git a/WickedEngine/wiDepthTarget.cpp b/WickedEngine/wiDepthTarget.cpp index 9a853b422..81c9c84e0 100644 --- a/WickedEngine/wiDepthTarget.cpp +++ b/WickedEngine/wiDepthTarget.cpp @@ -1,12 +1,10 @@ #include "wiDepthTarget.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; wiDepthTarget::wiDepthTarget() { - //texture2D = NULL; - //depthTarget = NULL; - //shaderResource = NULL; texture = nullptr; textureCube = nullptr; isCube = false; @@ -34,7 +32,7 @@ void wiDepthTarget::Initialize(int width, int height, UINT MSAAC, UINT MSAAQ) depthBufferDesc.Height = height; depthBufferDesc.MipLevels = 1; depthBufferDesc.ArraySize = 1; - depthBufferDesc.Format = DXGI_FORMAT_R24G8_TYPELESS; + depthBufferDesc.Format = FORMAT_R24G8_TYPELESS; depthBufferDesc.SampleDesc.Count = MSAAC; depthBufferDesc.SampleDesc.Quality = MSAAQ; depthBufferDesc.Usage = USAGE_DEFAULT; @@ -43,31 +41,6 @@ void wiDepthTarget::Initialize(int width, int height, UINT MSAAC, UINT MSAAQ) depthBufferDesc.MiscFlags = 0; wiRenderer::GetDevice()->CreateTexture2D(&depthBufferDesc, nullptr, &texture); - - //HRESULT hr; - //// Create the texture for the depth buffer using the filled out description. - //hr=wiRenderer::GetDevice()->CreateTexture2D(&depthBufferDesc, nullptr, &texture2D); - - //DepthStencilViewDesc depthStencilViewDesc; - //ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); - //depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; - //depthStencilViewDesc.ViewDimension = (MSAAQ==0 ? RESOURCE_DIMENSION_TEXTURE2D : RESOURCE_DIMENSION_TEXTURE2DMS); - ////depthStencilViewDesc.Texture2D.MipSlice = 0; - //depthStencilViewDesc.Flags = 0; - - //// Create the depth stencil view. - //hr=wiRenderer::GetDevice()->CreateDepthStencilView(texture2D, &depthStencilViewDesc, &depthTarget); - - ////Create Depth ShaderResource - ////ShaderResourceViewDesc shaderResourceViewDesc; - //ZeroMemory(&shaderResourceViewDesc, sizeof(shaderResourceViewDesc)); - //shaderResourceViewDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - //shaderResourceViewDesc.ViewDimension = (MSAAQ==0 ? RESOURCE_DIMENSION_TEXTURE2D : RESOURCE_DIMENSION_TEXTURE2DMS); - ////shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; - ////shaderResourceViewDesc.Texture2D.MipLevels = 1; - //shaderResourceViewDesc.mipLevels = 1; - - //wiRenderer::GetDevice()->CreateShaderResourceView(texture2D, &shaderResourceViewDesc, &shaderResource); } void wiDepthTarget::InitializeCube(int size) { @@ -84,7 +57,7 @@ void wiDepthTarget::InitializeCube(int size) depthBufferDesc.Height = size; depthBufferDesc.MipLevels = 1; depthBufferDesc.ArraySize = 6; - depthBufferDesc.Format = DXGI_FORMAT_R32_TYPELESS; + depthBufferDesc.Format = FORMAT_R32_TYPELESS; depthBufferDesc.SampleDesc.Count = 1; depthBufferDesc.SampleDesc.Quality = 0; depthBufferDesc.Usage = USAGE_DEFAULT; @@ -93,34 +66,6 @@ void wiDepthTarget::InitializeCube(int size) depthBufferDesc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; wiRenderer::GetDevice()->CreateTextureCube(&depthBufferDesc, nullptr, &textureCube); - - //HRESULT hr; - //// Create the texture for the depth buffer using the filled out description. - //hr=wiRenderer::GetDevice()->CreateTexture2D(&depthBufferDesc, NULL, &texture2D); - - //DepthStencilViewDesc depthStencilViewDesc; - //ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); - //depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT; - //depthStencilViewDesc.ViewDimension = RESOURCE_DIMENSION_TEXTURE2DARRAY; - //// depthStencilViewDesc.Texture2DArray.FirstArraySlice = 0; - ////depthStencilViewDesc.Texture2DArray.ArraySize = 6; - //// depthStencilViewDesc.Texture2DArray.MipSlice = 0; - //depthStencilViewDesc.ArraySize = 6; - //depthStencilViewDesc.Flags = 0; - - //// Create the depth stencil view. - //hr=wiRenderer::GetDevice()->CreateDepthStencilView(texture2D, &depthStencilViewDesc, &depthTarget); - - ////Create Depth ShaderResource - ////ShaderResourceViewDesc shaderResourceViewDesc; - //ZeroMemory(&shaderResourceViewDesc, sizeof(shaderResourceViewDesc)); - //shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT; - //shaderResourceViewDesc.ViewDimension = RESOURCE_DIMENSION_TEXTURECUBE; - ////shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; - ////shaderResourceViewDesc.Texture2D.MipLevels = 1; - //shaderResourceViewDesc.mipLevels = 1; - - //wiRenderer::GetDevice()->CreateShaderResourceView(texture2D, &shaderResourceViewDesc, &shaderResource); } void wiDepthTarget::Clear(GRAPHICSTHREAD threadID) @@ -129,12 +74,6 @@ void wiDepthTarget::Clear(GRAPHICSTHREAD threadID) } void wiDepthTarget::CopyFrom(const wiDepthTarget& from, GRAPHICSTHREAD threadID) { - //if(shaderResource) shaderResource->Release(); - ////static ShaderResourceViewDesc desc; - ////from.shaderResource->GetDesc(&desc); - //wiRenderer::GetDevice()->CopyResource(texture2D,from.texture2D); - //HRESULT r = wiRenderer::GetDevice()->CreateShaderResourceView(texture2D,&from.shaderResourceViewDesc,&shaderResource); - wiRenderer::GetDevice()->CopyTexture2D(GetTexture(), from.GetTexture(), threadID); } diff --git a/WickedEngine/wiDepthTarget.h b/WickedEngine/wiDepthTarget.h index 294ec3c76..9371ed49b 100644 --- a/WickedEngine/wiDepthTarget.h +++ b/WickedEngine/wiDepthTarget.h @@ -5,8 +5,8 @@ class wiDepthTarget { private: - Texture2D* texture; - TextureCube* textureCube; + wiGraphicsTypes::Texture2D* texture; + wiGraphicsTypes::TextureCube* textureCube; bool isCube; public: //Texture2D texture2D; @@ -24,7 +24,7 @@ public: void Clear(GRAPHICSTHREAD threadID); void CopyFrom(const wiDepthTarget&, GRAPHICSTHREAD threadID); - Texture2D* GetTexture() const { return(isCube ? textureCube : texture); } - Texture2DDesc GetDesc() const { return GetTexture()->desc; } + wiGraphicsTypes::Texture2D* GetTexture() const { return(isCube ? textureCube : texture); } + wiGraphicsTypes::Texture2DDesc GetDesc() const { return GetTexture()->desc; } }; diff --git a/WickedEngine/wiEmittedParticle.cpp b/WickedEngine/wiEmittedParticle.cpp index 6e3bd66b5..9968f3410 100644 --- a/WickedEngine/wiEmittedParticle.cpp +++ b/WickedEngine/wiEmittedParticle.cpp @@ -7,6 +7,8 @@ #include "wiRandom.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + //ID3D11Buffer *wiEmittedParticle::vertexBuffer; VertexLayout wiEmittedParticle::vertexLayout; VertexShader wiEmittedParticle::vertexShader; @@ -306,11 +308,11 @@ void wiEmittedParticle::LoadShaders() { VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - //{ "TEXCOORD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "ROTATION", 0, DXGI_FORMAT_R32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "VELOCITY", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + //{ "TEXCOORD", 2, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "ROTATION", 0, FORMAT_R32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "VELOCITY", 0, FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); VertexShaderInfo* vsinfo = static_cast(wiResourceManager::GetShaderManager()->add(wiRenderer::SHADERPATH + "pointspriteVS.cso", wiResourceManager::VERTEXSHADER, layout, numElements)); diff --git a/WickedEngine/wiEmittedParticle.h b/WickedEngine/wiEmittedParticle.h index 2dd9827f9..5c28292a0 100644 --- a/WickedEngine/wiEmittedParticle.h +++ b/WickedEngine/wiEmittedParticle.h @@ -49,15 +49,15 @@ private: ALIGN_16 }; - BufferResource vertexBuffer; - static VertexLayout vertexLayout; - static VertexShader vertexShader; - static PixelShader pixelShader,simplestPS; - static GeometryShader geometryShader; - static BufferResource constantBuffer; - static BlendState blendStateAlpha,blendStateAdd; - static RasterizerState rasterizerState,wireFrameRS; - static DepthStencilState depthStencilState; + wiGraphicsTypes::BufferResource vertexBuffer; + static wiGraphicsTypes::VertexLayout vertexLayout; + static wiGraphicsTypes::VertexShader vertexShader; + static wiGraphicsTypes::PixelShader pixelShader,simplestPS; + static wiGraphicsTypes::GeometryShader geometryShader; + static wiGraphicsTypes::BufferResource constantBuffer; + static wiGraphicsTypes::BlendState blendStateAlpha,blendStateAdd; + static wiGraphicsTypes::RasterizerState rasterizerState,wireFrameRS; + static wiGraphicsTypes::DepthStencilState depthStencilState; public: static void LoadShaders(); diff --git a/WickedEngine/wiFont.cpp b/WickedEngine/wiFont.cpp index 1c9683321..695b7f4e4 100644 --- a/WickedEngine/wiFont.cpp +++ b/WickedEngine/wiFont.cpp @@ -5,6 +5,8 @@ #include "wiLoader.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + BufferResource wiFont::vertexBuffer,wiFont::indexBuffer; VertexLayout wiFont::vertexLayout; @@ -117,8 +119,8 @@ void wiFont::LoadShaders() VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); VertexShaderInfo* vsinfo = static_cast(wiResourceManager::GetShaderManager()->add(wiRenderer::SHADERPATH + "fontVS.cso", wiResourceManager::VERTEXSHADER, layout, numElements)); diff --git a/WickedEngine/wiFont.h b/WickedEngine/wiFont.h index 7a36b11e9..249bc538d 100644 --- a/WickedEngine/wiFont.h +++ b/WickedEngine/wiFont.h @@ -53,15 +53,15 @@ protected: ALIGN_16 }; - static BufferResource vertexBuffer,indexBuffer; + static wiGraphicsTypes::BufferResource vertexBuffer,indexBuffer; - static VertexLayout vertexLayout; - static VertexShader vertexShader; - static PixelShader pixelShader; - static BlendState blendState; - static BufferResource constantBuffer; - static RasterizerState rasterizerState; - static DepthStencilState depthStencilState; + static wiGraphicsTypes::VertexLayout vertexLayout; + static wiGraphicsTypes::VertexShader vertexShader; + static wiGraphicsTypes::PixelShader pixelShader; + static wiGraphicsTypes::BlendState blendState; + static wiGraphicsTypes::BufferResource constantBuffer; + static wiGraphicsTypes::RasterizerState rasterizerState; + static wiGraphicsTypes::DepthStencilState depthStencilState; static void SetUpStates(); static void SetUpCB(); @@ -76,7 +76,7 @@ private: struct wiFontStyle{ string name; - Texture2D* texture; + wiGraphicsTypes::Texture2D* texture; struct LookUp{ int code; diff --git a/WickedEngine/wiGraphicsAPI.h b/WickedEngine/wiGraphicsAPI.h index 9859900fd..18fd14e13 100644 --- a/WickedEngine/wiGraphicsAPI.h +++ b/WickedEngine/wiGraphicsAPI.h @@ -9,463 +9,591 @@ #include "ConstantBufferMapping.h" -typedef ID3D11RenderTargetView* RenderTargetView; -typedef ID3D11ShaderResourceView* ShaderResourceView; -typedef ID3D11Texture2D* APITexture2D; -typedef ID3D11SamplerState* Sampler; -typedef ID3D11Resource* APIResource; -typedef ID3D11Buffer* BufferResource; -typedef ID3D11VertexShader* VertexShader; -typedef ID3D11PixelShader* PixelShader; -typedef ID3D11GeometryShader* GeometryShader; -typedef ID3D11HullShader* HullShader; -typedef ID3D11DomainShader* DomainShader; -typedef ID3D11ComputeShader* ComputeShader; -typedef ID3D11InputLayout* VertexLayout; -typedef ID3D11BlendState* BlendState; -typedef ID3D11DepthStencilState* DepthStencilState; -typedef ID3D11DepthStencilView* DepthStencilView; -typedef ID3D11RasterizerState* RasterizerState; -typedef ID3D11ClassLinkage* ClassLinkage; +namespace wiGraphicsTypes +{ + + typedef ID3D11RenderTargetView* RenderTargetView; + typedef ID3D11ShaderResourceView* ShaderResourceView; + typedef ID3D11Texture2D* APITexture2D; + typedef ID3D11SamplerState* Sampler; + typedef ID3D11Resource* APIResource; + typedef ID3D11Buffer* BufferResource; + typedef ID3D11VertexShader* VertexShader; + typedef ID3D11PixelShader* PixelShader; + typedef ID3D11GeometryShader* GeometryShader; + typedef ID3D11HullShader* HullShader; + typedef ID3D11DomainShader* DomainShader; + typedef ID3D11ComputeShader* ComputeShader; + typedef ID3D11InputLayout* VertexLayout; + typedef ID3D11BlendState* BlendState; + typedef ID3D11DepthStencilState* DepthStencilState; + typedef ID3D11DepthStencilView* DepthStencilView; + typedef ID3D11RasterizerState* RasterizerState; + typedef ID3D11ClassLinkage* ClassLinkage; -enum PRIMITIVETOPOLOGY -{ - TRIANGLELIST, - TRIANGLESTRIP, - POINTLIST, - LINELIST, - PATCHLIST, -}; -enum COMPARISON_FUNC -{ - COMPARISON_NEVER, - COMPARISON_LESS, - COMPARISON_EQUAL, - COMPARISON_LESS_EQUAL, - COMPARISON_GREATER, - COMPARISON_NOT_EQUAL, - COMPARISON_GREATER_EQUAL, - COMPARISON_ALWAYS, -}; -enum DEPTH_WRITE_MASK -{ - DEPTH_WRITE_MASK_ZERO, - DEPTH_WRITE_MASK_ALL, -}; -enum STENCIL_OP -{ - STENCIL_OP_KEEP, - STENCIL_OP_ZERO, - STENCIL_OP_REPLACE, - STENCIL_OP_INCR_SAT, - STENCIL_OP_DECR_SAT, - STENCIL_OP_INVERT, - STENCIL_OP_INCR, - STENCIL_OP_DECR, -}; -enum BLEND -{ - BLEND_ZERO, - BLEND_ONE, - BLEND_SRC_COLOR, - BLEND_INV_SRC_COLOR, - BLEND_SRC_ALPHA, - BLEND_INV_SRC_ALPHA, - BLEND_DEST_ALPHA, - BLEND_INV_DEST_ALPHA, - BLEND_DEST_COLOR, - BLEND_INV_DEST_COLOR, - BLEND_SRC_ALPHA_SAT, - BLEND_BLEND_FACTOR, - BLEND_INV_BLEND_FACTOR, - BLEND_SRC1_COLOR, - BLEND_INV_SRC1_COLOR, - BLEND_SRC1_ALPHA, - BLEND_INV_SRC1_ALPHA, -}; -enum BLEND_OP -{ - BLEND_OP_ADD, - BLEND_OP_SUBTRACT, - BLEND_OP_REV_SUBTRACT, - BLEND_OP_MIN, - BLEND_OP_MAX, -}; -enum FILL_MODE -{ - FILL_WIREFRAME, - FILL_SOLID, -}; -enum CULL_MODE -{ - CULL_NONE, - CULL_FRONT, - CULL_BACK, -}; -enum INPUT_CLASSIFICATION -{ - INPUT_PER_VERTEX_DATA, - INPUT_PER_INSTANCE_DATA, -}; -enum USAGE -{ - USAGE_DEFAULT, - USAGE_IMMUTABLE, - USAGE_DYNAMIC, - USAGE_STAGING, -}; -enum TEXTURE_ADDRESS_MODE -{ - TEXTURE_ADDRESS_WRAP, - TEXTURE_ADDRESS_MIRROR, - TEXTURE_ADDRESS_CLAMP, - TEXTURE_ADDRESS_BORDER, - TEXTURE_ADDRESS_MIRROR_ONCE, -}; -enum FILTER -{ - FILTER_MIN_MAG_MIP_POINT, - FILTER_MIN_MAG_POINT_MIP_LINEAR, - FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT, - FILTER_MIN_POINT_MAG_MIP_LINEAR, - FILTER_MIN_LINEAR_MAG_MIP_POINT, - FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR, - FILTER_MIN_MAG_LINEAR_MIP_POINT, - FILTER_MIN_MAG_MIP_LINEAR, - FILTER_ANISOTROPIC, - FILTER_COMPARISON_MIN_MAG_MIP_POINT, - FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR, - FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT, - FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR, - FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT, - FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR, - FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT, - FILTER_COMPARISON_MIN_MAG_MIP_LINEAR, - FILTER_COMPARISON_ANISOTROPIC, - FILTER_MINIMUM_MIN_MAG_MIP_POINT, - FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR, - FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, - FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR, - FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT, - FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR, - FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT, - FILTER_MINIMUM_MIN_MAG_MIP_LINEAR, - FILTER_MINIMUM_ANISOTROPIC, - FILTER_MAXIMUM_MIN_MAG_MIP_POINT, - FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR, - FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, - FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR, - FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT, - FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR, - FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT, - FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR, - FILTER_MAXIMUM_ANISOTROPIC, -}; + enum PRIMITIVETOPOLOGY + { + TRIANGLELIST, + TRIANGLESTRIP, + POINTLIST, + LINELIST, + PATCHLIST, + }; + enum COMPARISON_FUNC + { + COMPARISON_NEVER, + COMPARISON_LESS, + COMPARISON_EQUAL, + COMPARISON_LESS_EQUAL, + COMPARISON_GREATER, + COMPARISON_NOT_EQUAL, + COMPARISON_GREATER_EQUAL, + COMPARISON_ALWAYS, + }; + enum DEPTH_WRITE_MASK + { + DEPTH_WRITE_MASK_ZERO, + DEPTH_WRITE_MASK_ALL, + }; + enum STENCIL_OP + { + STENCIL_OP_KEEP, + STENCIL_OP_ZERO, + STENCIL_OP_REPLACE, + STENCIL_OP_INCR_SAT, + STENCIL_OP_DECR_SAT, + STENCIL_OP_INVERT, + STENCIL_OP_INCR, + STENCIL_OP_DECR, + }; + enum BLEND + { + BLEND_ZERO, + BLEND_ONE, + BLEND_SRC_COLOR, + BLEND_INV_SRC_COLOR, + BLEND_SRC_ALPHA, + BLEND_INV_SRC_ALPHA, + BLEND_DEST_ALPHA, + BLEND_INV_DEST_ALPHA, + BLEND_DEST_COLOR, + BLEND_INV_DEST_COLOR, + BLEND_SRC_ALPHA_SAT, + BLEND_BLEND_FACTOR, + BLEND_INV_BLEND_FACTOR, + BLEND_SRC1_COLOR, + BLEND_INV_SRC1_COLOR, + BLEND_SRC1_ALPHA, + BLEND_INV_SRC1_ALPHA, + }; + enum BLEND_OP + { + BLEND_OP_ADD, + BLEND_OP_SUBTRACT, + BLEND_OP_REV_SUBTRACT, + BLEND_OP_MIN, + BLEND_OP_MAX, + }; + enum FILL_MODE + { + FILL_WIREFRAME, + FILL_SOLID, + }; + enum CULL_MODE + { + CULL_NONE, + CULL_FRONT, + CULL_BACK, + }; + enum INPUT_CLASSIFICATION + { + INPUT_PER_VERTEX_DATA, + INPUT_PER_INSTANCE_DATA, + }; + enum USAGE + { + USAGE_DEFAULT, + USAGE_IMMUTABLE, + USAGE_DYNAMIC, + USAGE_STAGING, + }; + enum TEXTURE_ADDRESS_MODE + { + TEXTURE_ADDRESS_WRAP, + TEXTURE_ADDRESS_MIRROR, + TEXTURE_ADDRESS_CLAMP, + TEXTURE_ADDRESS_BORDER, + TEXTURE_ADDRESS_MIRROR_ONCE, + }; + enum FILTER + { + FILTER_MIN_MAG_MIP_POINT, + FILTER_MIN_MAG_POINT_MIP_LINEAR, + FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT, + FILTER_MIN_POINT_MAG_MIP_LINEAR, + FILTER_MIN_LINEAR_MAG_MIP_POINT, + FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR, + FILTER_MIN_MAG_LINEAR_MIP_POINT, + FILTER_MIN_MAG_MIP_LINEAR, + FILTER_ANISOTROPIC, + FILTER_COMPARISON_MIN_MAG_MIP_POINT, + FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR, + FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT, + FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR, + FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT, + FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR, + FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT, + FILTER_COMPARISON_MIN_MAG_MIP_LINEAR, + FILTER_COMPARISON_ANISOTROPIC, + FILTER_MINIMUM_MIN_MAG_MIP_POINT, + FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR, + FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, + FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR, + FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT, + FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR, + FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT, + FILTER_MINIMUM_MIN_MAG_MIP_LINEAR, + FILTER_MINIMUM_ANISOTROPIC, + FILTER_MAXIMUM_MIN_MAG_MIP_POINT, + FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR, + FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, + FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR, + FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT, + FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR, + FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT, + FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR, + FILTER_MAXIMUM_ANISOTROPIC, + }; + enum FORMAT + { + FORMAT_UNKNOWN, + FORMAT_R32G32B32A32_TYPELESS, + FORMAT_R32G32B32A32_FLOAT, + FORMAT_R32G32B32A32_UINT, + FORMAT_R32G32B32A32_SINT, + FORMAT_R32G32B32_TYPELESS, + FORMAT_R32G32B32_FLOAT, + FORMAT_R32G32B32_UINT, + FORMAT_R32G32B32_SINT, + FORMAT_R16G16B16A16_TYPELESS, + FORMAT_R16G16B16A16_FLOAT, + FORMAT_R16G16B16A16_UNORM, + FORMAT_R16G16B16A16_UINT, + FORMAT_R16G16B16A16_SNORM, + FORMAT_R16G16B16A16_SINT, + FORMAT_R32G32_TYPELESS, + FORMAT_R32G32_FLOAT, + FORMAT_R32G32_UINT, + FORMAT_R32G32_SINT, + FORMAT_R32G8X24_TYPELESS, + FORMAT_D32_FLOAT_S8X24_UINT, + FORMAT_R32_FLOAT_X8X24_TYPELESS, + FORMAT_X32_TYPELESS_G8X24_UINT, + FORMAT_R10G10B10A2_TYPELESS, + FORMAT_R10G10B10A2_UNORM, + FORMAT_R10G10B10A2_UINT, + FORMAT_R11G11B10_FLOAT, + FORMAT_R8G8B8A8_TYPELESS, + FORMAT_R8G8B8A8_UNORM, + FORMAT_R8G8B8A8_UNORM_SRGB, + FORMAT_R8G8B8A8_UINT, + FORMAT_R8G8B8A8_SNORM, + FORMAT_R8G8B8A8_SINT, + FORMAT_R16G16_TYPELESS, + FORMAT_R16G16_FLOAT, + FORMAT_R16G16_UNORM, + FORMAT_R16G16_UINT, + FORMAT_R16G16_SNORM, + FORMAT_R16G16_SINT, + FORMAT_R32_TYPELESS, + FORMAT_D32_FLOAT, + FORMAT_R32_FLOAT, + FORMAT_R32_UINT, + FORMAT_R32_SINT, + FORMAT_R24G8_TYPELESS, + FORMAT_D24_UNORM_S8_UINT, + FORMAT_R24_UNORM_X8_TYPELESS, + FORMAT_X24_TYPELESS_G8_UINT, + FORMAT_R8G8_TYPELESS, + FORMAT_R8G8_UNORM, + FORMAT_R8G8_UINT, + FORMAT_R8G8_SNORM, + FORMAT_R8G8_SINT, + FORMAT_R16_TYPELESS, + FORMAT_R16_FLOAT, + FORMAT_D16_UNORM, + FORMAT_R16_UNORM, + FORMAT_R16_UINT, + FORMAT_R16_SNORM, + FORMAT_R16_SINT, + FORMAT_R8_TYPELESS, + FORMAT_R8_UNORM, + FORMAT_R8_UINT, + FORMAT_R8_SNORM, + FORMAT_R8_SINT, + FORMAT_A8_UNORM, + FORMAT_R1_UNORM, + FORMAT_R9G9B9E5_SHAREDEXP, + FORMAT_R8G8_B8G8_UNORM, + FORMAT_G8R8_G8B8_UNORM, + FORMAT_BC1_TYPELESS, + FORMAT_BC1_UNORM, + FORMAT_BC1_UNORM_SRGB, + FORMAT_BC2_TYPELESS, + FORMAT_BC2_UNORM, + FORMAT_BC2_UNORM_SRGB, + FORMAT_BC3_TYPELESS, + FORMAT_BC3_UNORM, + FORMAT_BC3_UNORM_SRGB, + FORMAT_BC4_TYPELESS, + FORMAT_BC4_UNORM, + FORMAT_BC4_SNORM, + FORMAT_BC5_TYPELESS, + FORMAT_BC5_UNORM, + FORMAT_BC5_SNORM, + FORMAT_B5G6R5_UNORM, + FORMAT_B5G5R5A1_UNORM, + FORMAT_B8G8R8A8_UNORM, + FORMAT_B8G8R8X8_UNORM, + FORMAT_R10G10B10_XR_BIAS_A2_UNORM, + FORMAT_B8G8R8A8_TYPELESS, + FORMAT_B8G8R8A8_UNORM_SRGB, + FORMAT_B8G8R8X8_TYPELESS, + FORMAT_B8G8R8X8_UNORM_SRGB, + FORMAT_BC6H_TYPELESS, + FORMAT_BC6H_UF16, + FORMAT_BC6H_SF16, + FORMAT_BC7_TYPELESS, + FORMAT_BC7_UNORM, + FORMAT_BC7_UNORM_SRGB, + FORMAT_AYUV, + FORMAT_Y410, + FORMAT_Y416, + FORMAT_NV12, + FORMAT_P010, + FORMAT_P016, + FORMAT_420_OPAQUE, + FORMAT_YUY2, + FORMAT_Y210, + FORMAT_Y216, + FORMAT_NV11, + FORMAT_AI44, + FORMAT_IA44, + FORMAT_P8, + FORMAT_A8P8, + FORMAT_B4G4R4A4_UNORM, + FORMAT_FORCE_UINT = 0xffffffff, + }; -// Flags //////////////////////////////////////////// -enum CLEAR_FLAG -{ - CLEAR_DEPTH = 0x1L, - CLEAR_STENCIL = 0x2L, -}; -enum BIND_FLAG -{ - BIND_VERTEX_BUFFER = 0x1L, - BIND_INDEX_BUFFER = 0x2L, - BIND_CONSTANT_BUFFER = 0x4L, - BIND_SHADER_RESOURCE = 0x8L, - BIND_STREAM_OUTPUT = 0x10L, - BIND_RENDER_TARGET = 0x20L, - BIND_DEPTH_STENCIL = 0x40L, - BIND_UNORDERED_ACCESS = 0x80L, -}; -enum CPU_ACCESS -{ - CPU_ACCESS_WRITE = 0x10000L, - CPU_ACCESS_READ = 0x20000L, -}; -enum RESOURCE_MISC_FLAG -{ - RESOURCE_MISC_GENERATE_MIPS = 0x1L, - RESOURCE_MISC_SHARED = 0x2L, - RESOURCE_MISC_TEXTURECUBE = 0x4L, - RESOURCE_MISC_BUFFER_STRUCTURED = 0x40L, - RESOURCE_MISC_TILED = 0x40000L, -}; + // Flags //////////////////////////////////////////// + enum CLEAR_FLAG + { + CLEAR_DEPTH = 0x1L, + CLEAR_STENCIL = 0x2L, + }; + enum BIND_FLAG + { + BIND_VERTEX_BUFFER = 0x1L, + BIND_INDEX_BUFFER = 0x2L, + BIND_CONSTANT_BUFFER = 0x4L, + BIND_SHADER_RESOURCE = 0x8L, + BIND_STREAM_OUTPUT = 0x10L, + BIND_RENDER_TARGET = 0x20L, + BIND_DEPTH_STENCIL = 0x40L, + BIND_UNORDERED_ACCESS = 0x80L, + }; + enum CPU_ACCESS + { + CPU_ACCESS_WRITE = 0x10000L, + CPU_ACCESS_READ = 0x20000L, + }; + enum RESOURCE_MISC_FLAG + { + RESOURCE_MISC_GENERATE_MIPS = 0x1L, + RESOURCE_MISC_SHARED = 0x2L, + RESOURCE_MISC_TEXTURECUBE = 0x4L, + RESOURCE_MISC_BUFFER_STRUCTURED = 0x40L, + RESOURCE_MISC_TILED = 0x40000L, + }; #define APPEND_ALIGNED_ELEMENT ( 0xffffffff ) #define FLOAT32_MAX ( 3.402823466e+38f ) #define DEFAULT_STENCIL_READ_MASK ( 0xff ) #define SO_NO_RASTERIZED_STREAM ( 0xffffffff ) -// Structs ///////////////////////////////////////////// + // Structs ///////////////////////////////////////////// -struct ViewPort -{ - FLOAT TopLeftX; - FLOAT TopLeftY; - FLOAT Width; - FLOAT Height; - FLOAT MinDepth; - FLOAT MaxDepth; -}; -struct VertexLayoutDesc -{ - LPCSTR SemanticName; - UINT SemanticIndex; - DXGI_FORMAT Format; - UINT InputSlot; - UINT AlignedByteOffset; - INPUT_CLASSIFICATION InputSlotClass; - UINT InstanceDataStepRate; -}; -struct StreamOutDeclaration -{ - UINT Stream; - LPCSTR SemanticName; - UINT SemanticIndex; - BYTE StartComponent; - BYTE ComponentCount; - BYTE OutputSlot; -}; -struct Texture2DDesc -{ - UINT Width; - UINT Height; - UINT MipLevels; - UINT ArraySize; - DXGI_FORMAT Format; - DXGI_SAMPLE_DESC SampleDesc; - USAGE Usage; - UINT BindFlags; - UINT CPUAccessFlags; - UINT MiscFlags; -}; -struct SamplerDesc -{ - FILTER Filter; - TEXTURE_ADDRESS_MODE AddressU; - TEXTURE_ADDRESS_MODE AddressV; - TEXTURE_ADDRESS_MODE AddressW; - FLOAT MipLODBias; - UINT MaxAnisotropy; - COMPARISON_FUNC ComparisonFunc; - FLOAT BorderColor[4]; - FLOAT MinLOD; - FLOAT MaxLOD; -}; -struct RasterizerDesc -{ - FILL_MODE FillMode; - CULL_MODE CullMode; - BOOL FrontCounterClockwise; - INT DepthBias; - FLOAT DepthBiasClamp; - FLOAT SlopeScaledDepthBias; - BOOL DepthClipEnable; - BOOL ScissorEnable; - BOOL MultisampleEnable; - BOOL AntialiasedLineEnable; -}; -struct DepthStencilOpDesc -{ - STENCIL_OP StencilFailOp; - STENCIL_OP StencilDepthFailOp; - STENCIL_OP StencilPassOp; - COMPARISON_FUNC StencilFunc; -}; -struct DepthStencilDesc -{ - BOOL DepthEnable; - DEPTH_WRITE_MASK DepthWriteMask; - COMPARISON_FUNC DepthFunc; - BOOL StencilEnable; - UINT8 StencilReadMask; - UINT8 StencilWriteMask; - DepthStencilOpDesc FrontFace; - DepthStencilOpDesc BackFace; -}; -struct RenderTargetBlendDesc -{ - BOOL BlendEnable; - BLEND SrcBlend; - BLEND DestBlend; - BLEND_OP BlendOp; - BLEND SrcBlendAlpha; - BLEND DestBlendAlpha; - BLEND_OP BlendOpAlpha; - UINT8 RenderTargetWriteMask; -}; -struct BlendDesc -{ - BOOL AlphaToCoverageEnable; - BOOL IndependentBlendEnable; - RenderTargetBlendDesc RenderTarget[8]; -}; -struct BufferDesc -{ - UINT ByteWidth; - USAGE Usage; - UINT BindFlags; - UINT CPUAccessFlags; - UINT MiscFlags; - UINT StructureByteStride; -}; -struct SubresourceData -{ - const void *pSysMem; - UINT SysMemPitch; - UINT SysMemSlicePitch; -}; - -struct VertexShaderInfo { - VertexShader vertexShader; - VertexLayout vertexLayout; - - VertexShaderInfo() { - vertexShader = nullptr; - vertexLayout = VertexLayout(); - } -}; - -class Texture -{ -public: - ShaderResourceView shaderResourceView; - RenderTargetView renderTargetView; - DepthStencilView depthStencilView; - - Texture() :shaderResourceView(nullptr), renderTargetView(nullptr), depthStencilView(nullptr) {} - virtual ~Texture() + struct ViewPort { - SAFE_RELEASE(shaderResourceView); - SAFE_RELEASE(renderTargetView); - SAFE_RELEASE(depthStencilView); - } -}; -class Texture2D : public Texture -{ -public: - APITexture2D texture2D; - Texture2DDesc desc; - - Texture2D() :Texture(), texture2D(nullptr) {} - virtual ~Texture2D() + FLOAT TopLeftX; + FLOAT TopLeftY; + FLOAT Width; + FLOAT Height; + FLOAT MinDepth; + FLOAT MaxDepth; + }; + struct VertexLayoutDesc { - SAFE_RELEASE(texture2D); - } -}; -class TextureCube : public Texture2D -{ -public: - TextureCube():Texture2D() {} - virtual ~TextureCube(){} -}; + LPCSTR SemanticName; + UINT SemanticIndex; + FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; + }; + struct StreamOutDeclaration + { + UINT Stream; + LPCSTR SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; + }; + struct SampleDesc + { + UINT Count; + UINT Quality; + }; + struct Texture2DDesc + { + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + FORMAT Format; + SampleDesc SampleDesc; + USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + }; + struct SamplerDesc + { + FILTER Filter; + TEXTURE_ADDRESS_MODE AddressU; + TEXTURE_ADDRESS_MODE AddressV; + TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[4]; + FLOAT MinLOD; + FLOAT MaxLOD; + }; + struct RasterizerDesc + { + FILL_MODE FillMode; + CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + }; + struct DepthStencilOpDesc + { + STENCIL_OP StencilFailOp; + STENCIL_OP StencilDepthFailOp; + STENCIL_OP StencilPassOp; + COMPARISON_FUNC StencilFunc; + }; + struct DepthStencilDesc + { + BOOL DepthEnable; + DEPTH_WRITE_MASK DepthWriteMask; + COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + DepthStencilOpDesc FrontFace; + DepthStencilOpDesc BackFace; + }; + struct RenderTargetBlendDesc + { + BOOL BlendEnable; + BLEND SrcBlend; + BLEND DestBlend; + BLEND_OP BlendOp; + BLEND SrcBlendAlpha; + BLEND DestBlendAlpha; + BLEND_OP BlendOpAlpha; + UINT8 RenderTargetWriteMask; + }; + struct BlendDesc + { + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + RenderTargetBlendDesc RenderTarget[8]; + }; + struct BufferDesc + { + UINT ByteWidth; + USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + UINT StructureByteStride; + }; + struct SubresourceData + { + const void *pSysMem; + UINT SysMemPitch; + UINT SysMemSlicePitch; + }; -class GraphicsDevice : public wiThreadSafeManager -{ -protected: - bool oddFrame; - bool VSYNC; - int SCREENWIDTH, SCREENHEIGHT; -public: - GraphicsDevice() :oddFrame(false), VSYNC(true), SCREENWIDTH(0), SCREENHEIGHT(0) {} + struct VertexShaderInfo { + VertexShader vertexShader; + VertexLayout vertexLayout; - virtual HRESULT CreateBuffer(const BufferDesc *pDesc, const SubresourceData* pInitialData, BufferResource *ppBuffer) = 0; - virtual HRESULT CreateTexture1D() = 0; - virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D) = 0; - virtual HRESULT CreateTexture3D() = 0; - virtual HRESULT CreateTextureCube(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, TextureCube **ppTextureCube) = 0; - virtual HRESULT CreateShaderResourceView(Texture2D* pTexture) = 0; - virtual HRESULT CreateRenderTargetView(Texture2D* pTexture) = 0; - virtual HRESULT CreateDepthStencilView(Texture2D* pTexture) = 0; - virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, - const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *ppInputLayout) = 0; - virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, VertexShader *ppVertexShader) = 0; - virtual HRESULT CreatePixelShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, PixelShader *ppPixelShader) = 0; - virtual HRESULT CreateGeometryShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader) = 0; - virtual HRESULT CreateGeometryShaderWithStreamOutput( const void *pShaderBytecode, SIZE_T BytecodeLength, const StreamOutDeclaration *pSODeclaration, - UINT NumEntries, const UINT *pBufferStrides, UINT NumStrides, UINT RasterizedStream, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader) = 0; - virtual HRESULT CreateHullShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, HullShader *ppHullShader) = 0; - virtual HRESULT CreateDomainShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, DomainShader *ppDomainShader) = 0; - virtual HRESULT CreateComputeShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, ComputeShader *ppComputeShader) = 0; - virtual HRESULT CreateBlendState(const BlendDesc *pBlendStateDesc, BlendState *ppBlendState) = 0; - virtual HRESULT CreateDepthStencilState(const DepthStencilDesc *pDepthStencilDesc, DepthStencilState *ppDepthStencilState) = 0; - virtual HRESULT CreateRasterizerState(const RasterizerDesc *pRasterizerDesc, RasterizerState *ppRasterizerState) = 0; - virtual HRESULT CreateSamplerState(const SamplerDesc *pSamplerDesc, Sampler *ppSamplerState) = 0; + VertexShaderInfo() { + vertexShader = nullptr; + vertexLayout = VertexLayout(); + } + }; - virtual void PresentBegin() = 0; - virtual void PresentEnd() = 0; + class Texture + { + public: + ShaderResourceView shaderResourceView; + RenderTargetView renderTargetView; + DepthStencilView depthStencilView; - virtual void ExecuteDeferredContexts() = 0; - virtual void FinishCommandList(GRAPHICSTHREAD thread) = 0; + Texture() :shaderResourceView(nullptr), renderTargetView(nullptr), depthStencilView(nullptr) {} + virtual ~Texture() + { + SAFE_RELEASE(shaderResourceView); + SAFE_RELEASE(renderTargetView); + SAFE_RELEASE(depthStencilView); + } + }; + class Texture2D : public Texture + { + public: + APITexture2D texture2D; + Texture2DDesc desc; - virtual bool GetMultithreadingSupport() = 0; + Texture2D() :Texture(), texture2D(nullptr) {} + virtual ~Texture2D() + { + SAFE_RELEASE(texture2D); + } + }; + class TextureCube : public Texture2D + { + public: + TextureCube() :Texture2D() {} + virtual ~TextureCube() {} + }; - bool GetVSyncEnabled() { return VSYNC; } - void SetVSyncEnabled(bool value) { VSYNC = value; } + class GraphicsDevice : public wiThreadSafeManager + { + protected: + bool oddFrame; + bool VSYNC; + int SCREENWIDTH, SCREENHEIGHT; + public: + GraphicsDevice() :oddFrame(false), VSYNC(true), SCREENWIDTH(0), SCREENHEIGHT(0) {} - int GetScreenWidth() { return SCREENWIDTH; } - int GetScreenHeight() { return SCREENHEIGHT; } + virtual HRESULT CreateBuffer(const BufferDesc *pDesc, const SubresourceData* pInitialData, BufferResource *ppBuffer) = 0; + virtual HRESULT CreateTexture1D() = 0; + virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D) = 0; + virtual HRESULT CreateTexture3D() = 0; + virtual HRESULT CreateTextureCube(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, TextureCube **ppTextureCube) = 0; + virtual HRESULT CreateShaderResourceView(Texture2D* pTexture) = 0; + virtual HRESULT CreateRenderTargetView(Texture2D* pTexture) = 0; + virtual HRESULT CreateDepthStencilView(Texture2D* pTexture) = 0; + virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, + const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *ppInputLayout) = 0; + virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, VertexShader *ppVertexShader) = 0; + virtual HRESULT CreatePixelShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, PixelShader *ppPixelShader) = 0; + virtual HRESULT CreateGeometryShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader) = 0; + virtual HRESULT CreateGeometryShaderWithStreamOutput(const void *pShaderBytecode, SIZE_T BytecodeLength, const StreamOutDeclaration *pSODeclaration, + UINT NumEntries, const UINT *pBufferStrides, UINT NumStrides, UINT RasterizedStream, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader) = 0; + virtual HRESULT CreateHullShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, HullShader *ppHullShader) = 0; + virtual HRESULT CreateDomainShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, DomainShader *ppDomainShader) = 0; + virtual HRESULT CreateComputeShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, ComputeShader *ppComputeShader) = 0; + virtual HRESULT CreateBlendState(const BlendDesc *pBlendStateDesc, BlendState *ppBlendState) = 0; + virtual HRESULT CreateDepthStencilState(const DepthStencilDesc *pDepthStencilDesc, DepthStencilState *ppDepthStencilState) = 0; + virtual HRESULT CreateRasterizerState(const RasterizerDesc *pRasterizerDesc, RasterizerState *ppRasterizerState) = 0; + virtual HRESULT CreateSamplerState(const SamplerDesc *pSamplerDesc, Sampler *ppSamplerState) = 0; - virtual void SetScreenWidth(int value) = 0; - virtual void SetScreenHeight(int value) = 0; + virtual void PresentBegin() = 0; + virtual void PresentEnd() = 0; - ///////////////Thread-sensitive//////////////////////// + virtual void ExecuteDeferredContexts() = 0; + virtual void FinishCommandList(GRAPHICSTHREAD thread) = 0; - virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindTexturePS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindTextureVS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindTextureGS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindTextureDS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindTextureHS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void UnbindTextures(int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplerPS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplersPS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplerVS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplersVS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplerGS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplersGS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplerHS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplersHS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplerDS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindSamplersDS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindConstantBufferPS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindConstantBufferVS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindConstantBufferGS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindConstantBufferDS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindConstantBufferHS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindVertexBuffer(BufferResource vertexBuffer, int slot, UINT stride, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindIndexBuffer(BufferResource indexBuffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindPrimitiveTopology(PRIMITIVETOPOLOGY type, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindVertexLayout(VertexLayout layout, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindBlendState(BlendState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindBlendStateEx(BlendState state, const XMFLOAT4& blendFactor = XMFLOAT4(1, 1, 1, 1), UINT sampleMask = 0xffffffff, - GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindDepthStencilState(DepthStencilState state, UINT stencilRef, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindRasterizerState(RasterizerState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindStreamOutTarget(BufferResource buffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindPS(PixelShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindVS(VertexShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindGS(GeometryShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindHS(HullShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindDS(DomainShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void Draw(int vertexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void DrawIndexed(int indexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void DrawIndexedInstanced(int indexCount, int instanceCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void GenerateMips(Texture* texture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void CopyResource(APIResource pDstResource, const APIResource pSrcResource, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void CopyTexture2D(Texture2D* pDst, const Texture2D* pSrc, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void UpdateBuffer(BufferResource& buffer, const void* data, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, int dataSize = -1) = 0; + virtual bool GetMultithreadingSupport() = 0; - virtual HRESULT CreateTextureFromFile(const wstring& fileName, Texture2D **ppTexture, bool mipMaps = true, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + bool GetVSyncEnabled() { return VSYNC; } + void SetVSyncEnabled(bool value) { VSYNC = value; } -}; + int GetScreenWidth() { return SCREENWIDTH; } + int GetScreenHeight() { return SCREENHEIGHT; } + virtual void SetScreenWidth(int value) = 0; + virtual void SetScreenHeight(int value) = 0; + ///////////////Thread-sensitive//////////////////////// + + virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindTexturePS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindTextureVS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindTextureGS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindTextureDS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindTextureHS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void UnbindTextures(int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplerPS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplersPS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplerVS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplersVS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplerGS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplersGS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplerHS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplersHS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplerDS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindSamplersDS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindConstantBufferPS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindConstantBufferVS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindConstantBufferGS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindConstantBufferDS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindConstantBufferHS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindVertexBuffer(BufferResource vertexBuffer, int slot, UINT stride, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindIndexBuffer(BufferResource indexBuffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindPrimitiveTopology(PRIMITIVETOPOLOGY type, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindVertexLayout(VertexLayout layout, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindBlendState(BlendState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindBlendStateEx(BlendState state, const XMFLOAT4& blendFactor = XMFLOAT4(1, 1, 1, 1), UINT sampleMask = 0xffffffff, + GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindDepthStencilState(DepthStencilState state, UINT stencilRef, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindRasterizerState(RasterizerState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindStreamOutTarget(BufferResource buffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindPS(PixelShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindVS(VertexShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindGS(GeometryShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindHS(HullShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void BindDS(DomainShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void Draw(int vertexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void DrawIndexed(int indexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void DrawIndexedInstanced(int indexCount, int instanceCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void GenerateMips(Texture* texture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void CopyResource(APIResource pDstResource, const APIResource pSrcResource, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void CopyTexture2D(Texture2D* pDst, const Texture2D* pSrc, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + virtual void UpdateBuffer(BufferResource& buffer, const void* data, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, int dataSize = -1) = 0; + + virtual HRESULT CreateTextureFromFile(const wstring& fileName, Texture2D **ppTexture, bool mipMaps = true, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; + + }; + +} diff --git a/WickedEngine/wiGraphicsAPI_DX11.cpp b/WickedEngine/wiGraphicsAPI_DX11.cpp index 3caf32054..f50ebe589 100644 --- a/WickedEngine/wiGraphicsAPI_DX11.cpp +++ b/WickedEngine/wiGraphicsAPI_DX11.cpp @@ -5,6 +5,9 @@ #include "Utility/WicTextureLoader.h" #include "Utility/DDSTextureLoader.h" +namespace wiGraphicsTypes +{ + #ifndef WINSTORE_SUPPORT GraphicsDevice_DX11::GraphicsDevice_DX11(HWND window, int screenW, int screenH, bool windowed) : GraphicsDevice() #else @@ -603,13 +606,365 @@ inline D3D11_INPUT_CLASSIFICATION _ConvertInputClassification(INPUT_CLASSIFICATI } return D3D11_INPUT_PER_VERTEX_DATA; } -inline DXGI_FORMAT _ConvertFormat(DXGI_FORMAT value) +inline DXGI_FORMAT _ConvertFormat(FORMAT value) { - return value; -} -inline DXGI_SAMPLE_DESC _ConvertSampleDesc(DXGI_SAMPLE_DESC value) -{ - return value; + switch (value) + { + case FORMAT_UNKNOWN: + return DXGI_FORMAT_UNKNOWN; + break; + case FORMAT_R32G32B32A32_TYPELESS: + return DXGI_FORMAT_R32G32B32A32_TYPELESS; + break; + case FORMAT_R32G32B32A32_FLOAT: + return DXGI_FORMAT_R32G32B32A32_FLOAT; + break; + case FORMAT_R32G32B32A32_UINT: + return DXGI_FORMAT_R32G32B32A32_UINT; + break; + case FORMAT_R32G32B32A32_SINT: + return DXGI_FORMAT_R32G32B32A32_SINT; + break; + case FORMAT_R32G32B32_TYPELESS: + return DXGI_FORMAT_R32G32B32_TYPELESS; + break; + case FORMAT_R32G32B32_FLOAT: + return DXGI_FORMAT_R32G32B32_FLOAT; + break; + case FORMAT_R32G32B32_UINT: + return DXGI_FORMAT_R32G32B32_UINT; + break; + case FORMAT_R32G32B32_SINT: + return DXGI_FORMAT_R32G32B32_SINT; + break; + case FORMAT_R16G16B16A16_TYPELESS: + return DXGI_FORMAT_R16G16B16A16_TYPELESS; + break; + case FORMAT_R16G16B16A16_FLOAT: + return DXGI_FORMAT_R16G16B16A16_FLOAT; + break; + case FORMAT_R16G16B16A16_UNORM: + return DXGI_FORMAT_R16G16B16A16_UNORM; + break; + case FORMAT_R16G16B16A16_UINT: + return DXGI_FORMAT_R16G16B16A16_UINT; + break; + case FORMAT_R16G16B16A16_SNORM: + return DXGI_FORMAT_R16G16B16A16_SNORM; + break; + case FORMAT_R16G16B16A16_SINT: + return DXGI_FORMAT_R16G16B16A16_SINT; + break; + case FORMAT_R32G32_TYPELESS: + return DXGI_FORMAT_R32G32_TYPELESS; + break; + case FORMAT_R32G32_FLOAT: + return DXGI_FORMAT_R32G32_FLOAT; + break; + case FORMAT_R32G32_UINT: + return DXGI_FORMAT_R32G32_UINT; + break; + case FORMAT_R32G32_SINT: + return DXGI_FORMAT_R32G32_SINT; + break; + case FORMAT_R32G8X24_TYPELESS: + return DXGI_FORMAT_R32G8X24_TYPELESS; + break; + case FORMAT_D32_FLOAT_S8X24_UINT: + return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; + break; + case FORMAT_R32_FLOAT_X8X24_TYPELESS: + return DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; + break; + case FORMAT_X32_TYPELESS_G8X24_UINT: + return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; + break; + case FORMAT_R10G10B10A2_TYPELESS: + return DXGI_FORMAT_R10G10B10A2_TYPELESS; + break; + case FORMAT_R10G10B10A2_UNORM: + return DXGI_FORMAT_R10G10B10A2_UNORM; + break; + case FORMAT_R10G10B10A2_UINT: + return DXGI_FORMAT_R10G10B10A2_UINT; + break; + case FORMAT_R11G11B10_FLOAT: + return DXGI_FORMAT_R11G11B10_FLOAT; + break; + case FORMAT_R8G8B8A8_TYPELESS: + return DXGI_FORMAT_R8G8B8A8_TYPELESS; + break; + case FORMAT_R8G8B8A8_UNORM: + return DXGI_FORMAT_R8G8B8A8_UNORM; + break; + case FORMAT_R8G8B8A8_UNORM_SRGB: + return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + break; + case FORMAT_R8G8B8A8_UINT: + return DXGI_FORMAT_R8G8B8A8_UINT; + break; + case FORMAT_R8G8B8A8_SNORM: + return DXGI_FORMAT_R8G8B8A8_SNORM; + break; + case FORMAT_R8G8B8A8_SINT: + return DXGI_FORMAT_R8G8B8A8_SINT; + break; + case FORMAT_R16G16_TYPELESS: + return DXGI_FORMAT_R16G16_TYPELESS; + break; + case FORMAT_R16G16_FLOAT: + return DXGI_FORMAT_R16G16_FLOAT; + break; + case FORMAT_R16G16_UNORM: + return DXGI_FORMAT_R16G16_UNORM; + break; + case FORMAT_R16G16_UINT: + return DXGI_FORMAT_R16G16_UINT; + break; + case FORMAT_R16G16_SNORM: + return DXGI_FORMAT_R16G16_SNORM; + break; + case FORMAT_R16G16_SINT: + return DXGI_FORMAT_R16G16_SINT; + break; + case FORMAT_R32_TYPELESS: + return DXGI_FORMAT_R32_TYPELESS; + break; + case FORMAT_D32_FLOAT: + return DXGI_FORMAT_D32_FLOAT; + break; + case FORMAT_R32_FLOAT: + return DXGI_FORMAT_R32_FLOAT; + break; + case FORMAT_R32_UINT: + return DXGI_FORMAT_R32_UINT; + break; + case FORMAT_R32_SINT: + return DXGI_FORMAT_R32_SINT; + break; + case FORMAT_R24G8_TYPELESS: + return DXGI_FORMAT_R24G8_TYPELESS; + break; + case FORMAT_D24_UNORM_S8_UINT: + return DXGI_FORMAT_D24_UNORM_S8_UINT; + break; + case FORMAT_R24_UNORM_X8_TYPELESS: + return DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + break; + case FORMAT_X24_TYPELESS_G8_UINT: + return DXGI_FORMAT_X24_TYPELESS_G8_UINT; + break; + case FORMAT_R8G8_TYPELESS: + return DXGI_FORMAT_R8G8_TYPELESS; + break; + case FORMAT_R8G8_UNORM: + return DXGI_FORMAT_R8G8_UNORM; + break; + case FORMAT_R8G8_UINT: + return DXGI_FORMAT_R8G8_UINT; + break; + case FORMAT_R8G8_SNORM: + return DXGI_FORMAT_R8G8_SNORM; + break; + case FORMAT_R8G8_SINT: + return DXGI_FORMAT_R8G8_SINT; + break; + case FORMAT_R16_TYPELESS: + return DXGI_FORMAT_R16_TYPELESS; + break; + case FORMAT_R16_FLOAT: + return DXGI_FORMAT_R16_FLOAT; + break; + case FORMAT_D16_UNORM: + return DXGI_FORMAT_D16_UNORM; + break; + case FORMAT_R16_UNORM: + return DXGI_FORMAT_R16_UNORM; + break; + case FORMAT_R16_UINT: + return DXGI_FORMAT_R16_UINT; + break; + case FORMAT_R16_SNORM: + return DXGI_FORMAT_R16_SNORM; + break; + case FORMAT_R16_SINT: + return DXGI_FORMAT_R16_SINT; + break; + case FORMAT_R8_TYPELESS: + return DXGI_FORMAT_R8_TYPELESS; + break; + case FORMAT_R8_UNORM: + return DXGI_FORMAT_R8_UNORM; + break; + case FORMAT_R8_UINT: + return DXGI_FORMAT_R8_UINT; + break; + case FORMAT_R8_SNORM: + return DXGI_FORMAT_R8_SNORM; + break; + case FORMAT_R8_SINT: + return DXGI_FORMAT_R8_SINT; + break; + case FORMAT_A8_UNORM: + return DXGI_FORMAT_A8_UNORM; + break; + case FORMAT_R1_UNORM: + return DXGI_FORMAT_R1_UNORM; + break; + case FORMAT_R9G9B9E5_SHAREDEXP: + return DXGI_FORMAT_R9G9B9E5_SHAREDEXP; + break; + case FORMAT_R8G8_B8G8_UNORM: + return DXGI_FORMAT_R8G8_B8G8_UNORM; + break; + case FORMAT_G8R8_G8B8_UNORM: + return DXGI_FORMAT_G8R8_G8B8_UNORM; + break; + case FORMAT_BC1_TYPELESS: + return DXGI_FORMAT_BC1_TYPELESS; + break; + case FORMAT_BC1_UNORM: + return DXGI_FORMAT_BC1_UNORM; + break; + case FORMAT_BC1_UNORM_SRGB: + return DXGI_FORMAT_BC1_UNORM_SRGB; + break; + case FORMAT_BC2_TYPELESS: + return DXGI_FORMAT_BC2_TYPELESS; + break; + case FORMAT_BC2_UNORM: + return DXGI_FORMAT_BC2_UNORM; + break; + case FORMAT_BC2_UNORM_SRGB: + return DXGI_FORMAT_BC2_UNORM_SRGB; + break; + case FORMAT_BC3_TYPELESS: + return DXGI_FORMAT_BC3_TYPELESS; + break; + case FORMAT_BC3_UNORM: + return DXGI_FORMAT_BC3_UNORM; + break; + case FORMAT_BC3_UNORM_SRGB: + return DXGI_FORMAT_BC3_UNORM_SRGB; + break; + case FORMAT_BC4_TYPELESS: + return DXGI_FORMAT_BC4_TYPELESS; + break; + case FORMAT_BC4_UNORM: + return DXGI_FORMAT_BC4_UNORM; + break; + case FORMAT_BC4_SNORM: + return DXGI_FORMAT_BC4_SNORM; + break; + case FORMAT_BC5_TYPELESS: + return DXGI_FORMAT_BC5_TYPELESS; + break; + case FORMAT_BC5_UNORM: + return DXGI_FORMAT_BC5_UNORM; + break; + case FORMAT_BC5_SNORM: + return DXGI_FORMAT_BC5_SNORM; + break; + case FORMAT_B5G6R5_UNORM: + return DXGI_FORMAT_B5G6R5_UNORM; + break; + case FORMAT_B5G5R5A1_UNORM: + return DXGI_FORMAT_B5G5R5A1_UNORM; + break; + case FORMAT_B8G8R8A8_UNORM: + return DXGI_FORMAT_B8G8R8A8_UNORM; + break; + case FORMAT_B8G8R8X8_UNORM: + return DXGI_FORMAT_B8G8R8X8_UNORM; + break; + case FORMAT_R10G10B10_XR_BIAS_A2_UNORM: + return DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM; + break; + case FORMAT_B8G8R8A8_TYPELESS: + return DXGI_FORMAT_B8G8R8A8_TYPELESS; + break; + case FORMAT_B8G8R8A8_UNORM_SRGB: + return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + break; + case FORMAT_B8G8R8X8_TYPELESS: + return DXGI_FORMAT_B8G8R8X8_TYPELESS; + break; + case FORMAT_B8G8R8X8_UNORM_SRGB: + return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB; + break; + case FORMAT_BC6H_TYPELESS: + return DXGI_FORMAT_BC6H_TYPELESS; + break; + case FORMAT_BC6H_UF16: + return DXGI_FORMAT_BC6H_UF16; + break; + case FORMAT_BC6H_SF16: + return DXGI_FORMAT_BC6H_SF16; + break; + case FORMAT_BC7_TYPELESS: + return DXGI_FORMAT_BC7_TYPELESS; + break; + case FORMAT_BC7_UNORM: + return DXGI_FORMAT_BC7_UNORM; + break; + case FORMAT_BC7_UNORM_SRGB: + return DXGI_FORMAT_BC7_UNORM_SRGB; + break; + case FORMAT_AYUV: + return DXGI_FORMAT_AYUV; + break; + case FORMAT_Y410: + return DXGI_FORMAT_Y410; + break; + case FORMAT_Y416: + return DXGI_FORMAT_Y416; + break; + case FORMAT_NV12: + return DXGI_FORMAT_NV12; + break; + case FORMAT_P010: + return DXGI_FORMAT_P010; + break; + case FORMAT_P016: + return DXGI_FORMAT_P016; + break; + case FORMAT_420_OPAQUE: + return DXGI_FORMAT_420_OPAQUE; + break; + case FORMAT_YUY2: + return DXGI_FORMAT_YUY2; + break; + case FORMAT_Y210: + return DXGI_FORMAT_Y210; + break; + case FORMAT_Y216: + return DXGI_FORMAT_Y216; + break; + case FORMAT_NV11: + return DXGI_FORMAT_NV11; + break; + case FORMAT_AI44: + return DXGI_FORMAT_AI44; + break; + case FORMAT_IA44: + return DXGI_FORMAT_IA44; + break; + case FORMAT_P8: + return DXGI_FORMAT_P8; + break; + case FORMAT_A8P8: + return DXGI_FORMAT_A8P8; + break; + case FORMAT_B4G4R4A4_UNORM: + return DXGI_FORMAT_B4G4R4A4_UNORM; + break; + case FORMAT_FORCE_UINT: + return DXGI_FORMAT_FORCE_UINT; + break; + default: + break; + } + return DXGI_FORMAT_UNKNOWN; } inline D3D11_TEXTURE2D_DESC _ConvertTexture2DDesc(const Texture2DDesc* pDesc) @@ -620,7 +975,8 @@ inline D3D11_TEXTURE2D_DESC _ConvertTexture2DDesc(const Texture2DDesc* pDesc) desc.MipLevels = pDesc->MipLevels; desc.ArraySize = pDesc->ArraySize; desc.Format = _ConvertFormat(pDesc->Format); - desc.SampleDesc = _ConvertSampleDesc(pDesc->SampleDesc); + desc.SampleDesc.Count = pDesc->SampleDesc.Count; + desc.SampleDesc.Quality = pDesc->SampleDesc.Quality; desc.Usage = _ConvertUsage(pDesc->Usage); desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); @@ -721,7 +1077,7 @@ HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture2D* pTexture) D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; if (pTexture->desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) { - shaderResourceViewDesc.Format = pTexture->desc.Format; + shaderResourceViewDesc.Format = _ConvertFormat(pTexture->desc.Format); if (pTexture->desc.BindFlags & D3D11_BIND_DEPTH_STENCIL) { shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT; @@ -732,7 +1088,7 @@ HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture2D* pTexture) } else { - shaderResourceViewDesc.Format = pTexture->desc.Format; + shaderResourceViewDesc.Format = _ConvertFormat(pTexture->desc.Format); if (pTexture->desc.BindFlags & D3D11_BIND_DEPTH_STENCIL) { shaderResourceViewDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; @@ -754,7 +1110,7 @@ HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture2D* pTexture) D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; if (pTexture->desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) { - renderTargetViewDesc.Format = pTexture->desc.Format; + renderTargetViewDesc.Format = _ConvertFormat(pTexture->desc.Format); renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; renderTargetViewDesc.Texture2DArray.FirstArraySlice = 0; renderTargetViewDesc.Texture2DArray.ArraySize = 6; @@ -762,7 +1118,7 @@ HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture2D* pTexture) } else { - renderTargetViewDesc.Format = pTexture->desc.Format; + renderTargetViewDesc.Format = _ConvertFormat(pTexture->desc.Format); renderTargetViewDesc.ViewDimension = (pTexture->desc.SampleDesc.Quality == 0 ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS); renderTargetViewDesc.Texture2D.MipSlice = 0; } @@ -1018,3 +1374,5 @@ HRESULT GraphicsDevice_DX11::CreateTextureFromFile(const wstring& fileName, Text return hr; } + +} diff --git a/WickedEngine/wiGraphicsAPI_DX11.h b/WickedEngine/wiGraphicsAPI_DX11.h index 39d90a6cd..a0747b4bf 100644 --- a/WickedEngine/wiGraphicsAPI_DX11.h +++ b/WickedEngine/wiGraphicsAPI_DX11.h @@ -2,415 +2,420 @@ #include "CommonInclude.h" #include "wiGraphicsAPI.h" -class GraphicsDevice_DX11 : public GraphicsDevice +namespace wiGraphicsTypes { -private: - ID3D11Device* device; - D3D_DRIVER_TYPE driverType; - D3D_FEATURE_LEVEL featureLevel; - IDXGISwapChain* swapChain; - ID3D11RenderTargetView* renderTargetView; - ViewPort viewPort; - ID3D11DeviceContext* deviceContexts[GRAPHICSTHREAD_COUNT]; - ID3D11CommandList* commandLists[GRAPHICSTHREAD_COUNT]; - bool DX11, DEFERREDCONTEXT_SUPPORT; -public: + class GraphicsDevice_DX11 : public GraphicsDevice + { + private: + ID3D11Device* device; + D3D_DRIVER_TYPE driverType; + D3D_FEATURE_LEVEL featureLevel; + IDXGISwapChain* swapChain; + ID3D11RenderTargetView* renderTargetView; + ViewPort viewPort; + ID3D11DeviceContext* deviceContexts[GRAPHICSTHREAD_COUNT]; + ID3D11CommandList* commandLists[GRAPHICSTHREAD_COUNT]; + bool DX11, DEFERREDCONTEXT_SUPPORT; + + public: #ifndef WINSTORE_SUPPORT - GraphicsDevice_DX11(HWND window, int screenW, int screenH, bool windowed); + GraphicsDevice_DX11(HWND window, int screenW, int screenH, bool windowed); #else - GraphicsDevice_DX11(Windows::UI::Core::CoreWindow^ window); + GraphicsDevice_DX11(Windows::UI::Core::CoreWindow^ window); #endif - ~GraphicsDevice_DX11(); + ~GraphicsDevice_DX11(); - virtual HRESULT CreateBuffer(const BufferDesc *pDesc, const SubresourceData* pInitialData, BufferResource *ppBuffer); - virtual HRESULT CreateTexture1D(); - virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D); - virtual HRESULT CreateTexture3D(); - virtual HRESULT CreateTextureCube(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, TextureCube **ppTextureCube); - virtual HRESULT CreateShaderResourceView(Texture2D* pTexture); - virtual HRESULT CreateRenderTargetView(Texture2D* pTexture); - virtual HRESULT CreateDepthStencilView(Texture2D* pTexture); - virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, - const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *ppInputLayout); - virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, VertexShader *ppVertexShader); - virtual HRESULT CreatePixelShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, PixelShader *ppPixelShader); - virtual HRESULT CreateGeometryShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader); - virtual HRESULT CreateGeometryShaderWithStreamOutput(const void *pShaderBytecode, SIZE_T BytecodeLength, const StreamOutDeclaration *pSODeclaration, - UINT NumEntries, const UINT *pBufferStrides, UINT NumStrides, UINT RasterizedStream, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader); - virtual HRESULT CreateHullShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, HullShader *ppHullShader); - virtual HRESULT CreateDomainShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, DomainShader *ppDomainShader); - virtual HRESULT CreateComputeShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, ComputeShader *ppComputeShader); - virtual HRESULT CreateBlendState(const BlendDesc *pBlendStateDesc, BlendState *ppBlendState); - virtual HRESULT CreateDepthStencilState(const DepthStencilDesc *pDepthStencilDesc, DepthStencilState *ppDepthStencilState); - virtual HRESULT CreateRasterizerState(const RasterizerDesc *pRasterizerDesc, RasterizerState *ppRasterizerState); - virtual HRESULT CreateSamplerState(const SamplerDesc *pSamplerDesc, Sampler *ppSamplerState); + virtual HRESULT CreateBuffer(const BufferDesc *pDesc, const SubresourceData* pInitialData, BufferResource *ppBuffer); + virtual HRESULT CreateTexture1D(); + virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D); + virtual HRESULT CreateTexture3D(); + virtual HRESULT CreateTextureCube(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, TextureCube **ppTextureCube); + virtual HRESULT CreateShaderResourceView(Texture2D* pTexture); + virtual HRESULT CreateRenderTargetView(Texture2D* pTexture); + virtual HRESULT CreateDepthStencilView(Texture2D* pTexture); + virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, + const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *ppInputLayout); + virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, VertexShader *ppVertexShader); + virtual HRESULT CreatePixelShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, PixelShader *ppPixelShader); + virtual HRESULT CreateGeometryShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader); + virtual HRESULT CreateGeometryShaderWithStreamOutput(const void *pShaderBytecode, SIZE_T BytecodeLength, const StreamOutDeclaration *pSODeclaration, + UINT NumEntries, const UINT *pBufferStrides, UINT NumStrides, UINT RasterizedStream, ClassLinkage pClassLinkage, GeometryShader *ppGeometryShader); + virtual HRESULT CreateHullShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, HullShader *ppHullShader); + virtual HRESULT CreateDomainShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, DomainShader *ppDomainShader); + virtual HRESULT CreateComputeShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage pClassLinkage, ComputeShader *ppComputeShader); + virtual HRESULT CreateBlendState(const BlendDesc *pBlendStateDesc, BlendState *ppBlendState); + virtual HRESULT CreateDepthStencilState(const DepthStencilDesc *pDepthStencilDesc, DepthStencilState *ppDepthStencilState); + virtual HRESULT CreateRasterizerState(const RasterizerDesc *pRasterizerDesc, RasterizerState *ppRasterizerState); + virtual HRESULT CreateSamplerState(const SamplerDesc *pSamplerDesc, Sampler *ppSamplerState); - virtual void PresentBegin(); - virtual void PresentEnd(); + virtual void PresentBegin(); + virtual void PresentEnd(); - virtual void ExecuteDeferredContexts(); - virtual void FinishCommandList(GRAPHICSTHREAD thread); + virtual void ExecuteDeferredContexts(); + virtual void FinishCommandList(GRAPHICSTHREAD thread); - virtual bool GetMultithreadingSupport() { return DEFERREDCONTEXT_SUPPORT; } + virtual bool GetMultithreadingSupport() { return DEFERREDCONTEXT_SUPPORT; } - virtual void SetScreenWidth(int value); - virtual void SetScreenHeight(int value); + virtual void SetScreenWidth(int value); + virtual void SetScreenHeight(int value); - ///////////////Thread-sensitive//////////////////////// + ///////////////Thread-sensitive//////////////////////// - virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - D3D11_VIEWPORT* pd3dViewPorts = new D3D11_VIEWPORT[NumViewports]; - for (UINT i = 0; i < NumViewports; ++i) - { - pd3dViewPorts[i].TopLeftX = pViewports[i].TopLeftX; - pd3dViewPorts[i].TopLeftY = pViewports[i].TopLeftY; - pd3dViewPorts[i].Width = pViewports[i].Width; - pd3dViewPorts[i].Height = pViewports[i].Height; - pd3dViewPorts[i].MinDepth = pViewports[i].MinDepth; - pd3dViewPorts[i].MaxDepth = pViewports[i].MaxDepth; - } - deviceContexts[threadID]->RSSetViewports(NumViewports, pd3dViewPorts); - SAFE_DELETE_ARRAY(pd3dViewPorts); - } - } - virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - static thread_local RenderTargetView renderTargetViews[8]; - for (UINT i = 0; i < min(NumViews, 8); ++i) - { - renderTargetViews[i] = ppRenderTargetViews[i]->renderTargetView; - } - deviceContexts[threadID]->OMSetRenderTargets(NumViews, renderTargetViews, - (depthStencilTexture == nullptr ? nullptr : depthStencilTexture->depthStencilView)); - } - } - virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && pTexture != nullptr && pTexture->renderTargetView != nullptr) { - deviceContexts[threadID]->ClearRenderTargetView(pTexture->renderTargetView, ColorRGBA); - } - } - virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && pTexture != nullptr && pTexture->depthStencilView != nullptr) { - UINT _flags = 0; - if (ClearFlags & CLEAR_DEPTH) - _flags |= D3D11_CLEAR_DEPTH; - if (ClearFlags & CLEAR_STENCIL) - _flags |= D3D11_CLEAR_STENCIL; - deviceContexts[threadID]->ClearDepthStencilView(pTexture->depthStencilView, _flags, Depth, Stencil); - } - } - virtual void BindTexturePS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && texture != nullptr) { - deviceContexts[threadID]->PSSetShaderResources(slot, 1, &texture->shaderResourceView); - } - } - virtual void BindTextureVS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && texture != nullptr) { - deviceContexts[threadID]->VSSetShaderResources(slot, 1, &texture->shaderResourceView); - } - } - virtual void BindTextureGS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && texture != nullptr) { - deviceContexts[threadID]->GSSetShaderResources(slot, 1, &texture->shaderResourceView); - } - } - virtual void BindTextureDS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && texture != nullptr) { - deviceContexts[threadID]->DSSetShaderResources(slot, 1, &texture->shaderResourceView); - } - } - virtual void BindTextureHS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && texture != nullptr) { - deviceContexts[threadID]->HSSetShaderResources(slot, 1, &texture->shaderResourceView); - } - } - virtual void UnbindTextures(int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) - { - assert(num <= 32 && "UnbindTextures limit of 32 reached!"); - if (deviceContexts[threadID] != nullptr) - { - static ID3D11ShaderResourceView* empties[32] = { - nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, - nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, - nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, - nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, - }; - deviceContexts[threadID]->PSSetShaderResources(slot, num, empties); - deviceContexts[threadID]->VSSetShaderResources(slot, num, empties); - deviceContexts[threadID]->GSSetShaderResources(slot, num, empties); - deviceContexts[threadID]->HSSetShaderResources(slot, num, empties); - deviceContexts[threadID]->DSSetShaderResources(slot, num, empties); - } - } - virtual void BindSamplerPS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && sampler != nullptr) { - deviceContexts[threadID]->PSSetSamplers(slot, 1, &sampler); - } - } - virtual void BindSamplersPS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && samplers != nullptr) { - deviceContexts[threadID]->PSSetSamplers(slot, num, samplers); - } - } - virtual void BindSamplerVS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && sampler != nullptr) { - deviceContexts[threadID]->VSSetSamplers(slot, 1, &sampler); - } - } - virtual void BindSamplersVS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && samplers != nullptr) { - deviceContexts[threadID]->VSSetSamplers(slot, num, samplers); - } - } - virtual void BindSamplerGS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && sampler != nullptr) { - deviceContexts[threadID]->GSSetSamplers(slot, 1, &sampler); - } - } - virtual void BindSamplersGS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && samplers != nullptr) { - deviceContexts[threadID]->GSSetSamplers(slot, num, samplers); - } - } - virtual void BindSamplerHS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && sampler != nullptr) { - deviceContexts[threadID]->HSSetSamplers(slot, 1, &sampler); - } - } - virtual void BindSamplersHS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && samplers != nullptr) { - deviceContexts[threadID]->HSSetSamplers(slot, num, samplers); - } - } - virtual void BindSamplerDS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && sampler != nullptr) { - deviceContexts[threadID]->DSSetSamplers(slot, 1, &sampler); - } - } - virtual void BindSamplersDS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr && samplers != nullptr) { - deviceContexts[threadID]->DSSetSamplers(slot, num, samplers); - } - } - virtual void BindConstantBufferPS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->PSSetConstantBuffers(slot, 1, &buffer); - } - } - virtual void BindConstantBufferVS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->VSSetConstantBuffers(slot, 1, &buffer); - - } - } - virtual void BindConstantBufferGS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->GSSetConstantBuffers(slot, 1, &buffer); - } - } - virtual void BindConstantBufferDS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - - deviceContexts[threadID]->DSSetConstantBuffers(slot, 1, &buffer); - } - } - virtual void BindConstantBufferHS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->HSSetConstantBuffers(slot, 1, &buffer); - } - } - virtual void BindVertexBuffer(BufferResource vertexBuffer, int slot, UINT stride, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - UINT offset = 0; - deviceContexts[threadID]->IASetVertexBuffers(slot, 1, &vertexBuffer, &stride, &offset); - } - } - virtual void BindIndexBuffer(BufferResource indexBuffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0); - } - } - virtual void BindPrimitiveTopology(PRIMITIVETOPOLOGY type, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - D3D11_PRIMITIVE_TOPOLOGY d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - switch (type) - { - case TRIANGLELIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - break; - case TRIANGLESTRIP: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; - break; - case POINTLIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST; - break; - case LINELIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_LINELIST; - break; - case PATCHLIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST; - break; - default: - break; - }; - deviceContexts[threadID]->IASetPrimitiveTopology(d3dType); - } - } - virtual void BindVertexLayout(VertexLayout layout, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->IASetInputLayout(layout); - } - } - virtual void BindBlendState(BlendState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - static float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; - static UINT sampleMask = 0xffffffff; - deviceContexts[threadID]->OMSetBlendState(state, blendFactor, sampleMask); - } - } - virtual void BindBlendStateEx(BlendState state, const XMFLOAT4& blendFactor = XMFLOAT4(1, 1, 1, 1), UINT sampleMask = 0xffffffff, - GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - float fblendFactor[4] = { blendFactor.x, blendFactor.y, blendFactor.z, blendFactor.w }; - } - } - virtual void BindDepthStencilState(DepthStencilState state, UINT stencilRef, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->OMSetDepthStencilState(state, stencilRef); - } - } - virtual void BindRasterizerState(RasterizerState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->RSSetState(state); - } - } - virtual void BindStreamOutTarget(BufferResource buffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - UINT offsetSO[1] = { 0 }; - deviceContexts[threadID]->SOSetTargets(1, &buffer, offsetSO); - } - } - virtual void BindPS(PixelShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->PSSetShader(shader, nullptr, 0); - } - } - virtual void BindVS(VertexShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->VSSetShader(shader, nullptr, 0); - } - } - virtual void BindGS(GeometryShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->GSSetShader(shader, nullptr, 0); - } - } - virtual void BindHS(HullShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->HSSetShader(shader, nullptr, 0); - } - } - virtual void BindDS(DomainShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->DSSetShader(shader, nullptr, 0); - } - } - virtual void Draw(int vertexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->Draw(vertexCount, 0); - } - } - virtual void DrawIndexed(int indexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->DrawIndexed(indexCount, 0, 0); - } - } - virtual void DrawIndexedInstanced(int indexCount, int instanceCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->DrawIndexedInstanced(indexCount, instanceCount, 0, 0, 0); - } - } - virtual void GenerateMips(Texture* texture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) - { - deviceContexts[threadID]->GenerateMips(texture->shaderResourceView); - } - virtual void CopyResource(APIResource pDstResource, const APIResource pSrcResource, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - deviceContexts[threadID]->CopyResource(pDstResource, pSrcResource); - } - } - virtual void CopyTexture2D(Texture2D* pDst, const Texture2D* pSrc, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { - if (deviceContexts[threadID] != nullptr) { - SAFE_RELEASE(pDst->shaderResourceView); - deviceContexts[threadID]->CopyResource(pDst->texture2D, pSrc->texture2D); - CreateShaderResourceView(pDst); - } - } - virtual void UpdateBuffer(BufferResource& buffer, const void* data, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, int dataSize = -1) - { - if (buffer != nullptr && data != nullptr && deviceContexts[threadID] != nullptr) { - static thread_local D3D11_BUFFER_DESC d3dDesc; - buffer->GetDesc(&d3dDesc); - HRESULT hr; - if (dataSize>(int)d3dDesc.ByteWidth) { //recreate the buffer if new datasize exceeds buffer size - buffer->Release(); - d3dDesc.ByteWidth = dataSize * 2; - - BufferDesc desc; - desc.ByteWidth = d3dDesc.ByteWidth; - switch (d3dDesc.Usage) + virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + D3D11_VIEWPORT* pd3dViewPorts = new D3D11_VIEWPORT[NumViewports]; + for (UINT i = 0; i < NumViewports; ++i) { - case D3D11_USAGE_DEFAULT: - desc.Usage = USAGE_DEFAULT; + pd3dViewPorts[i].TopLeftX = pViewports[i].TopLeftX; + pd3dViewPorts[i].TopLeftY = pViewports[i].TopLeftY; + pd3dViewPorts[i].Width = pViewports[i].Width; + pd3dViewPorts[i].Height = pViewports[i].Height; + pd3dViewPorts[i].MinDepth = pViewports[i].MinDepth; + pd3dViewPorts[i].MaxDepth = pViewports[i].MaxDepth; + } + deviceContexts[threadID]->RSSetViewports(NumViewports, pd3dViewPorts); + SAFE_DELETE_ARRAY(pd3dViewPorts); + } + } + virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + static thread_local RenderTargetView renderTargetViews[8]; + for (UINT i = 0; i < min(NumViews, 8); ++i) + { + renderTargetViews[i] = ppRenderTargetViews[i]->renderTargetView; + } + deviceContexts[threadID]->OMSetRenderTargets(NumViews, renderTargetViews, + (depthStencilTexture == nullptr ? nullptr : depthStencilTexture->depthStencilView)); + } + } + virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && pTexture != nullptr && pTexture->renderTargetView != nullptr) { + deviceContexts[threadID]->ClearRenderTargetView(pTexture->renderTargetView, ColorRGBA); + } + } + virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && pTexture != nullptr && pTexture->depthStencilView != nullptr) { + UINT _flags = 0; + if (ClearFlags & CLEAR_DEPTH) + _flags |= D3D11_CLEAR_DEPTH; + if (ClearFlags & CLEAR_STENCIL) + _flags |= D3D11_CLEAR_STENCIL; + deviceContexts[threadID]->ClearDepthStencilView(pTexture->depthStencilView, _flags, Depth, Stencil); + } + } + virtual void BindTexturePS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && texture != nullptr) { + deviceContexts[threadID]->PSSetShaderResources(slot, 1, &texture->shaderResourceView); + } + } + virtual void BindTextureVS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && texture != nullptr) { + deviceContexts[threadID]->VSSetShaderResources(slot, 1, &texture->shaderResourceView); + } + } + virtual void BindTextureGS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && texture != nullptr) { + deviceContexts[threadID]->GSSetShaderResources(slot, 1, &texture->shaderResourceView); + } + } + virtual void BindTextureDS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && texture != nullptr) { + deviceContexts[threadID]->DSSetShaderResources(slot, 1, &texture->shaderResourceView); + } + } + virtual void BindTextureHS(const Texture* texture, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && texture != nullptr) { + deviceContexts[threadID]->HSSetShaderResources(slot, 1, &texture->shaderResourceView); + } + } + virtual void UnbindTextures(int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) + { + assert(num <= 32 && "UnbindTextures limit of 32 reached!"); + if (deviceContexts[threadID] != nullptr) + { + static ID3D11ShaderResourceView* empties[32] = { + nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, + nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, + nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, + nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, + }; + deviceContexts[threadID]->PSSetShaderResources(slot, num, empties); + deviceContexts[threadID]->VSSetShaderResources(slot, num, empties); + deviceContexts[threadID]->GSSetShaderResources(slot, num, empties); + deviceContexts[threadID]->HSSetShaderResources(slot, num, empties); + deviceContexts[threadID]->DSSetShaderResources(slot, num, empties); + } + } + virtual void BindSamplerPS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && sampler != nullptr) { + deviceContexts[threadID]->PSSetSamplers(slot, 1, &sampler); + } + } + virtual void BindSamplersPS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && samplers != nullptr) { + deviceContexts[threadID]->PSSetSamplers(slot, num, samplers); + } + } + virtual void BindSamplerVS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && sampler != nullptr) { + deviceContexts[threadID]->VSSetSamplers(slot, 1, &sampler); + } + } + virtual void BindSamplersVS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && samplers != nullptr) { + deviceContexts[threadID]->VSSetSamplers(slot, num, samplers); + } + } + virtual void BindSamplerGS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && sampler != nullptr) { + deviceContexts[threadID]->GSSetSamplers(slot, 1, &sampler); + } + } + virtual void BindSamplersGS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && samplers != nullptr) { + deviceContexts[threadID]->GSSetSamplers(slot, num, samplers); + } + } + virtual void BindSamplerHS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && sampler != nullptr) { + deviceContexts[threadID]->HSSetSamplers(slot, 1, &sampler); + } + } + virtual void BindSamplersHS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && samplers != nullptr) { + deviceContexts[threadID]->HSSetSamplers(slot, num, samplers); + } + } + virtual void BindSamplerDS(Sampler sampler, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && sampler != nullptr) { + deviceContexts[threadID]->DSSetSamplers(slot, 1, &sampler); + } + } + virtual void BindSamplersDS(Sampler samplers[], int slot, int num, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr && samplers != nullptr) { + deviceContexts[threadID]->DSSetSamplers(slot, num, samplers); + } + } + virtual void BindConstantBufferPS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->PSSetConstantBuffers(slot, 1, &buffer); + } + } + virtual void BindConstantBufferVS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->VSSetConstantBuffers(slot, 1, &buffer); + + } + } + virtual void BindConstantBufferGS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->GSSetConstantBuffers(slot, 1, &buffer); + } + } + virtual void BindConstantBufferDS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + + deviceContexts[threadID]->DSSetConstantBuffers(slot, 1, &buffer); + } + } + virtual void BindConstantBufferHS(BufferResource buffer, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->HSSetConstantBuffers(slot, 1, &buffer); + } + } + virtual void BindVertexBuffer(BufferResource vertexBuffer, int slot, UINT stride, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + UINT offset = 0; + deviceContexts[threadID]->IASetVertexBuffers(slot, 1, &vertexBuffer, &stride, &offset); + } + } + virtual void BindIndexBuffer(BufferResource indexBuffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0); + } + } + virtual void BindPrimitiveTopology(PRIMITIVETOPOLOGY type, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + D3D11_PRIMITIVE_TOPOLOGY d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + switch (type) + { + case TRIANGLELIST: + d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; break; - case D3D11_USAGE_IMMUTABLE: - desc.Usage = USAGE_IMMUTABLE; + case TRIANGLESTRIP: + d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; break; - case D3D11_USAGE_DYNAMIC: - desc.Usage = USAGE_DYNAMIC; + case POINTLIST: + d3dType = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST; break; - case D3D11_USAGE_STAGING: - desc.Usage = USAGE_STAGING; + case LINELIST: + d3dType = D3D11_PRIMITIVE_TOPOLOGY_LINELIST; + break; + case PATCHLIST: + d3dType = D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST; + break; + default: break; }; - desc.BindFlags = 0; - { - if (d3dDesc.BindFlags & D3D11_BIND_CONSTANT_BUFFER) - desc.BindFlags |= BIND_CONSTANT_BUFFER; - if (d3dDesc.BindFlags & D3D11_BIND_VERTEX_BUFFER) - desc.BindFlags |= BIND_VERTEX_BUFFER; - if (d3dDesc.BindFlags & D3D11_BIND_INDEX_BUFFER) - desc.BindFlags |= BIND_INDEX_BUFFER; - } - desc.CPUAccessFlags = 0; - { - if (d3dDesc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) - desc.CPUAccessFlags |= CPU_ACCESS_WRITE; - if (d3dDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) - desc.CPUAccessFlags |= CPU_ACCESS_READ; - } - desc.MiscFlags = 0; - desc.StructureByteStride = d3dDesc.StructureByteStride; - - hr = CreateBuffer(&desc, nullptr, &buffer); - } - if (d3dDesc.Usage == D3D11_USAGE_DYNAMIC) { - static thread_local D3D11_MAPPED_SUBRESOURCE mappedResource; - void* dataPtr; - deviceContexts[threadID]->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); - dataPtr = (void*)mappedResource.pData; - memcpy(dataPtr, data, (dataSize >= 0 ? dataSize : d3dDesc.ByteWidth)); - deviceContexts[threadID]->Unmap(buffer, 0); - } - else { - deviceContexts[threadID]->UpdateSubresource(buffer, 0, nullptr, data, 0, 0); + deviceContexts[threadID]->IASetPrimitiveTopology(d3dType); } } - } + virtual void BindVertexLayout(VertexLayout layout, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->IASetInputLayout(layout); + } + } + virtual void BindBlendState(BlendState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + static float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + static UINT sampleMask = 0xffffffff; + deviceContexts[threadID]->OMSetBlendState(state, blendFactor, sampleMask); + } + } + virtual void BindBlendStateEx(BlendState state, const XMFLOAT4& blendFactor = XMFLOAT4(1, 1, 1, 1), UINT sampleMask = 0xffffffff, + GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + float fblendFactor[4] = { blendFactor.x, blendFactor.y, blendFactor.z, blendFactor.w }; + } + } + virtual void BindDepthStencilState(DepthStencilState state, UINT stencilRef, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->OMSetDepthStencilState(state, stencilRef); + } + } + virtual void BindRasterizerState(RasterizerState state, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->RSSetState(state); + } + } + virtual void BindStreamOutTarget(BufferResource buffer, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + UINT offsetSO[1] = { 0 }; + deviceContexts[threadID]->SOSetTargets(1, &buffer, offsetSO); + } + } + virtual void BindPS(PixelShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->PSSetShader(shader, nullptr, 0); + } + } + virtual void BindVS(VertexShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->VSSetShader(shader, nullptr, 0); + } + } + virtual void BindGS(GeometryShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->GSSetShader(shader, nullptr, 0); + } + } + virtual void BindHS(HullShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->HSSetShader(shader, nullptr, 0); + } + } + virtual void BindDS(DomainShader shader, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->DSSetShader(shader, nullptr, 0); + } + } + virtual void Draw(int vertexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->Draw(vertexCount, 0); + } + } + virtual void DrawIndexed(int indexCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->DrawIndexed(indexCount, 0, 0); + } + } + virtual void DrawIndexedInstanced(int indexCount, int instanceCount, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->DrawIndexedInstanced(indexCount, instanceCount, 0, 0, 0); + } + } + virtual void GenerateMips(Texture* texture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) + { + deviceContexts[threadID]->GenerateMips(texture->shaderResourceView); + } + virtual void CopyResource(APIResource pDstResource, const APIResource pSrcResource, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + deviceContexts[threadID]->CopyResource(pDstResource, pSrcResource); + } + } + virtual void CopyTexture2D(Texture2D* pDst, const Texture2D* pSrc, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) { + if (deviceContexts[threadID] != nullptr) { + SAFE_RELEASE(pDst->shaderResourceView); + deviceContexts[threadID]->CopyResource(pDst->texture2D, pSrc->texture2D); + CreateShaderResourceView(pDst); + } + } + virtual void UpdateBuffer(BufferResource& buffer, const void* data, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, int dataSize = -1) + { + if (buffer != nullptr && data != nullptr && deviceContexts[threadID] != nullptr) { + static thread_local D3D11_BUFFER_DESC d3dDesc; + buffer->GetDesc(&d3dDesc); + HRESULT hr; + if (dataSize > (int)d3dDesc.ByteWidth) { //recreate the buffer if new datasize exceeds buffer size + buffer->Release(); + d3dDesc.ByteWidth = dataSize * 2; - virtual HRESULT CreateTextureFromFile(const wstring& fileName, Texture2D **ppTexture, bool mipMaps = true, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE); + BufferDesc desc; + desc.ByteWidth = d3dDesc.ByteWidth; + switch (d3dDesc.Usage) + { + case D3D11_USAGE_DEFAULT: + desc.Usage = USAGE_DEFAULT; + break; + case D3D11_USAGE_IMMUTABLE: + desc.Usage = USAGE_IMMUTABLE; + break; + case D3D11_USAGE_DYNAMIC: + desc.Usage = USAGE_DYNAMIC; + break; + case D3D11_USAGE_STAGING: + desc.Usage = USAGE_STAGING; + break; + }; + desc.BindFlags = 0; + { + if (d3dDesc.BindFlags & D3D11_BIND_CONSTANT_BUFFER) + desc.BindFlags |= BIND_CONSTANT_BUFFER; + if (d3dDesc.BindFlags & D3D11_BIND_VERTEX_BUFFER) + desc.BindFlags |= BIND_VERTEX_BUFFER; + if (d3dDesc.BindFlags & D3D11_BIND_INDEX_BUFFER) + desc.BindFlags |= BIND_INDEX_BUFFER; + } + desc.CPUAccessFlags = 0; + { + if (d3dDesc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) + desc.CPUAccessFlags |= CPU_ACCESS_WRITE; + if (d3dDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) + desc.CPUAccessFlags |= CPU_ACCESS_READ; + } + desc.MiscFlags = 0; + desc.StructureByteStride = d3dDesc.StructureByteStride; -}; + hr = CreateBuffer(&desc, nullptr, &buffer); + } + if (d3dDesc.Usage == D3D11_USAGE_DYNAMIC) { + static thread_local D3D11_MAPPED_SUBRESOURCE mappedResource; + void* dataPtr; + deviceContexts[threadID]->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + dataPtr = (void*)mappedResource.pData; + memcpy(dataPtr, data, (dataSize >= 0 ? dataSize : d3dDesc.ByteWidth)); + deviceContexts[threadID]->Unmap(buffer, 0); + } + else { + deviceContexts[threadID]->UpdateSubresource(buffer, 0, nullptr, data, 0, 0); + } + } + } + + virtual HRESULT CreateTextureFromFile(const wstring& fileName, Texture2D **ppTexture, bool mipMaps = true, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE); + + }; + +} diff --git a/WickedEngine/wiHairParticle.cpp b/WickedEngine/wiHairParticle.cpp index a8d2bbdbf..f11ceb6c1 100644 --- a/WickedEngine/wiHairParticle.cpp +++ b/WickedEngine/wiHairParticle.cpp @@ -7,6 +7,8 @@ #include "wiRandom.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + VertexLayout wiHairParticle::il; VertexShader wiHairParticle::vs; PixelShader wiHairParticle::ps,wiHairParticle::qps; @@ -71,9 +73,9 @@ void wiHairParticle::LoadShaders() VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "NORMAL", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TANGENT", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); VertexShaderInfo* vsinfo = static_cast(wiResourceManager::GetShaderManager()->add(wiRenderer::SHADERPATH + "grassVS.cso", wiResourceManager::VERTEXSHADER, layout, numElements)); diff --git a/WickedEngine/wiHairParticle.h b/WickedEngine/wiHairParticle.h index 092056e7c..e940c0e37 100644 --- a/WickedEngine/wiHairParticle.h +++ b/WickedEngine/wiHairParticle.h @@ -41,14 +41,14 @@ private: ALIGN_16 }; - static VertexLayout il; - static VertexShader vs; - static PixelShader ps, qps; - static GeometryShader gs[3],qgs[2]; - static BufferResource cbgs; - static DepthStencilState dss; - static RasterizerState rs,ncrs; - static BlendState bs; + static wiGraphicsTypes::VertexLayout il; + static wiGraphicsTypes::VertexShader vs; + static wiGraphicsTypes::PixelShader ps, qps; + static wiGraphicsTypes::GeometryShader gs[3],qgs[2]; + static wiGraphicsTypes::BufferResource cbgs; + static wiGraphicsTypes::DepthStencilState dss; + static wiGraphicsTypes::RasterizerState rs,ncrs; + static wiGraphicsTypes::BlendState bs; static int LOD[3]; public: static void LoadShaders(); @@ -71,6 +71,6 @@ public: Object* object; vector patches; wiSPTree* spTree; - BufferResource vb[3]; + wiGraphicsTypes::BufferResource vb[3]; }; diff --git a/WickedEngine/wiImage.cpp b/WickedEngine/wiImage.cpp index e7f8f8222..c240fff83 100644 --- a/WickedEngine/wiImage.cpp +++ b/WickedEngine/wiImage.cpp @@ -7,6 +7,8 @@ #include "SamplerMapping.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; + #pragma region STATICS BlendState wiImage::blendState, wiImage::blendStateAdd, wiImage::blendStateNoBlend, wiImage::blendStateAvg; BufferResource wiImage::constantBuffer,wiImage::processCb; diff --git a/WickedEngine/wiImage.h b/WickedEngine/wiImage.h index 389c493d8..3fb8ac4c1 100644 --- a/WickedEngine/wiImage.h +++ b/WickedEngine/wiImage.h @@ -43,17 +43,17 @@ protected: ALIGN_16 }; - static BlendState blendState, blendStateAdd, blendStateNoBlend, blendStateAvg; - static BufferResource constantBuffer,processCb; + static wiGraphicsTypes::BlendState blendState, blendStateAdd, blendStateNoBlend, blendStateAvg; + static wiGraphicsTypes::BufferResource constantBuffer,processCb; - static VertexShader vertexShader,screenVS; - static PixelShader pixelShader,blurHPS,blurVPS,shaftPS,outlinePS,dofPS,motionBlurPS,bloomSeparatePS + static wiGraphicsTypes::VertexShader vertexShader,screenVS; + static wiGraphicsTypes::PixelShader pixelShader,blurHPS,blurVPS,shaftPS,outlinePS,dofPS,motionBlurPS,bloomSeparatePS ,fxaaPS,ssaoPS,ssssPS,deferredPS,linDepthPS,colorGradePS,ssrPS, screenPS, stereogramPS; - static RasterizerState rasterizerState; - static DepthStencilState depthStencilStateGreater,depthStencilStateLess,depthNoStencilState; + static wiGraphicsTypes::RasterizerState rasterizerState; + static wiGraphicsTypes::DepthStencilState depthStencilStateGreater,depthStencilStateLess,depthNoStencilState; public: static void LoadShaders(); @@ -65,12 +65,12 @@ private: public: wiImage(); - static void Draw(Texture2D* texture, const wiImageEffects& effects); - static void Draw(Texture2D* texture, const wiImageEffects& effects,GRAPHICSTHREAD threadID); + static void Draw(wiGraphicsTypes::Texture2D* texture, const wiImageEffects& effects); + static void Draw(wiGraphicsTypes::Texture2D* texture, const wiImageEffects& effects,GRAPHICSTHREAD threadID); - static void DrawDeferred(Texture2D* texture - , Texture2D* depth, Texture2D* lightmap, Texture2D* normal - , Texture2D* ao, GRAPHICSTHREAD threadID, int stencilref = 0); + static void DrawDeferred(wiGraphicsTypes::Texture2D* texture + , wiGraphicsTypes::Texture2D* depth, wiGraphicsTypes::Texture2D* lightmap, wiGraphicsTypes::Texture2D* normal + , wiGraphicsTypes::Texture2D* ao, GRAPHICSTHREAD threadID, int stencilref = 0); static void Load(); static void CleanUp(); diff --git a/WickedEngine/wiImageEffects.h b/WickedEngine/wiImageEffects.h index 51649a2b1..b2c07c3bc 100644 --- a/WickedEngine/wiImageEffects.h +++ b/WickedEngine/wiImageEffects.h @@ -94,13 +94,13 @@ public: }; Processing process; bool deferred; - Texture2D* maskMap, *distortionMap, *refractionSource; + wiGraphicsTypes::Texture2D* maskMap, *distortionMap, *refractionSource; // Generic texture - void setMaskMap(Texture2D* view) { maskMap = view; } + void setMaskMap(wiGraphicsTypes::Texture2D* view) { maskMap = view; } // The normalmap texture which should distort the refraction source - void setDistortionMap(Texture2D* view) { distortionMap = view; } + void setDistortionMap(wiGraphicsTypes::Texture2D* view) { distortionMap = view; } // The texture which should be distorted - void setRefractionSource(Texture2D* view) { refractionSource = view; } + void setRefractionSource(wiGraphicsTypes::Texture2D* view) { refractionSource = view; } void init() { pos = XMFLOAT3(0, 0, 0); diff --git a/WickedEngine/wiLensFlare.cpp b/WickedEngine/wiLensFlare.cpp index 5cbb0dc7d..f12656c37 100644 --- a/WickedEngine/wiLensFlare.cpp +++ b/WickedEngine/wiLensFlare.cpp @@ -3,6 +3,7 @@ #include "wiResourceManager.h" #include "TextureMapping.h" +using namespace wiGraphicsTypes; BufferResource wiLensFlare::constantBuffer; PixelShader wiLensFlare::pixelShader; @@ -75,7 +76,7 @@ void wiLensFlare::LoadShaders(){ VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); VertexShaderInfo* vsinfo = static_cast(wiResourceManager::GetShaderManager()->add(wiRenderer::SHADERPATH + "lensFlareVS.cso", wiResourceManager::VERTEXSHADER, layout, numElements)); diff --git a/WickedEngine/wiLensFlare.h b/WickedEngine/wiLensFlare.h index 9d0c52d93..b173e7b0f 100644 --- a/WickedEngine/wiLensFlare.h +++ b/WickedEngine/wiLensFlare.h @@ -6,14 +6,14 @@ class wiLensFlare { private: - static BufferResource constantBuffer; - static PixelShader pixelShader; - static GeometryShader geometryShader; - static VertexShader vertexShader; - static VertexLayout inputLayout; - static RasterizerState rasterizerState; - static DepthStencilState depthStencilState; - static BlendState blendState; + static wiGraphicsTypes::BufferResource constantBuffer; + static wiGraphicsTypes::PixelShader pixelShader; + static wiGraphicsTypes::GeometryShader geometryShader; + static wiGraphicsTypes::VertexShader vertexShader; + static wiGraphicsTypes::VertexLayout inputLayout; + static wiGraphicsTypes::RasterizerState rasterizerState; + static wiGraphicsTypes::DepthStencilState depthStencilState; + static wiGraphicsTypes::BlendState blendState; GFX_STRUCT ConstantBuffer { @@ -33,7 +33,7 @@ private: public: static void Initialize(); static void CleanUp(); - static void Draw(GRAPHICSTHREAD threadID, const XMVECTOR& lightPos, vector& rims); + static void Draw(GRAPHICSTHREAD threadID, const XMVECTOR& lightPos, vector& rims); }; #endif diff --git a/WickedEngine/wiLines.cpp b/WickedEngine/wiLines.cpp index e2a8ee7ff..1361ac967 100644 --- a/WickedEngine/wiLines.cpp +++ b/WickedEngine/wiLines.cpp @@ -1,6 +1,8 @@ #include "wiLines.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; + Lines::Lines() { desc = Description(); diff --git a/WickedEngine/wiLines.h b/WickedEngine/wiLines.h index fa5aa6985..62d244559 100644 --- a/WickedEngine/wiLines.h +++ b/WickedEngine/wiLines.h @@ -41,7 +41,7 @@ public: Description desc; int parentArmature,parentBone; - BufferResource vertexBuffer; + wiGraphicsTypes::BufferResource vertexBuffer; ALIGN_16 }; diff --git a/WickedEngine/wiLoader.cpp b/WickedEngine/wiLoader.cpp index 594675277..c84fae31b 100644 --- a/WickedEngine/wiLoader.cpp +++ b/WickedEngine/wiLoader.cpp @@ -10,6 +10,7 @@ #include "wiTextureHelper.h" #include "wiPHYSICS.h" +using namespace wiGraphicsTypes; void LoadWiArmatures(const string& directory, const string& name, const string& identifier, vector& armatures) { diff --git a/WickedEngine/wiLoader.h b/WickedEngine/wiLoader.h index 3558aa8be..8d1c9e873 100644 --- a/WickedEngine/wiLoader.h +++ b/WickedEngine/wiLoader.h @@ -99,25 +99,25 @@ struct Material bool hasRefMap; string refMapName; - Texture2D* refMap; + wiGraphicsTypes::Texture2D* refMap; bool hasTexture; string textureName; - Texture2D* texture; + wiGraphicsTypes::Texture2D* texture; bool premultipliedTexture; BLENDMODE blendFlag; bool hasNormalMap; string normalMapName; - Texture2D* normalMap; + wiGraphicsTypes::Texture2D* normalMap; bool hasDisplacementMap; string displacementMapName; - Texture2D* displacementMap; + wiGraphicsTypes::Texture2D* displacementMap; bool hasSpecularMap; string specularMapName; - Texture2D* specularMap; + wiGraphicsTypes::Texture2D* specularMap; bool subsurface_scattering; bool toonshading; @@ -290,10 +290,10 @@ struct Mesh{ static thread_local vector instances; - BufferResource meshVertBuff; - static BufferResource meshInstanceBuffer; - BufferResource meshIndexBuff; - BufferResource sOutBuffer; + wiGraphicsTypes::BufferResource meshVertBuff; + static wiGraphicsTypes::BufferResource meshInstanceBuffer; + wiGraphicsTypes::BufferResource meshIndexBuff; + wiGraphicsTypes::BufferResource sOutBuffer; vector materialNames; vector materialIndices; @@ -502,9 +502,9 @@ struct Object : public Streamable, public Transform //RIBBON TRAIL deque trail; - BufferResource trailBuff; - Texture2D* trailDistortTex; - Texture2D* trailTex; + wiGraphicsTypes::BufferResource trailBuff; + wiGraphicsTypes::Texture2D* trailDistortTex; + wiGraphicsTypes::Texture2D* trailTex; int physicsObjectI; @@ -785,7 +785,7 @@ struct Light : public Cullable , public Transform XMFLOAT4 enerDis; bool noHalo; bool shadow; - vector lensFlareRimTextures; + vector lensFlareRimTextures; vector lensFlareNames; //vector shadowMap; @@ -826,7 +826,7 @@ struct Light : public Cullable , public Transform struct Decal : public Cullable, public Transform { string texName,norName; - Texture2D* texture,*normal; + wiGraphicsTypes::Texture2D* texture,*normal; XMFLOAT4X4 view,projection; XMFLOAT3 front; float life,fadeStart; @@ -979,7 +979,7 @@ struct Camera:public Transform{ }; struct HitSphere:public SPHERE, public Transform{ float radius_saved, radius; - static BufferResource vertexBuffer; + static wiGraphicsTypes::BufferResource vertexBuffer; enum HitSphereType{ HITTYPE, ATKTYPE, diff --git a/WickedEngine/wiRenderTarget.cpp b/WickedEngine/wiRenderTarget.cpp index 799de4fcd..d216ba609 100644 --- a/WickedEngine/wiRenderTarget.cpp +++ b/WickedEngine/wiRenderTarget.cpp @@ -2,6 +2,8 @@ #include "wiRenderer.h" #include "wiDepthTarget.h" +using namespace wiGraphicsTypes; + wiRenderTarget::wiRenderTarget() { @@ -10,7 +12,7 @@ wiRenderTarget::wiRenderTarget() isCube = false; } wiRenderTarget::wiRenderTarget(UINT width, UINT height, int numViews, bool hasDepth, UINT MSAAC, UINT MSAAQ - , DXGI_FORMAT format, UINT mipMapLevelCount) + , FORMAT format, UINT mipMapLevelCount) { numViews = 0; depth = nullptr; @@ -37,7 +39,7 @@ void wiRenderTarget::clear() { } void wiRenderTarget::Initialize(UINT width, UINT height, int numViews, bool hasDepth, UINT MSAAC, UINT MSAAQ - , DXGI_FORMAT format, UINT mipMapLevelCount) + , FORMAT format, UINT mipMapLevelCount) { clear(); @@ -103,7 +105,7 @@ void wiRenderTarget::Initialize(UINT width, UINT height, int numViews, bool hasD depth->Initialize(width,height,MSAAC,MSAAQ); } } -void wiRenderTarget::InitializeCube(UINT size, int numViews, bool hasDepth, DXGI_FORMAT format, UINT mipMapLevelCount) +void wiRenderTarget::InitializeCube(UINT size, int numViews, bool hasDepth, FORMAT format, UINT mipMapLevelCount) { clear(); @@ -175,7 +177,7 @@ void wiRenderTarget::InitializeCube(UINT size, int numViews, bool hasDepth, DXGI } void wiRenderTarget::InitializeCube(UINT size, int numViews, bool hasDepth) { - InitializeCube(size,numViews,hasDepth,DXGI_FORMAT_R8G8B8A8_UNORM); + InitializeCube(size,numViews,hasDepth,FORMAT_R8G8B8A8_UNORM); } void wiRenderTarget::Activate(GRAPHICSTHREAD threadID) diff --git a/WickedEngine/wiRenderTarget.h b/WickedEngine/wiRenderTarget.h index c66419e5d..9e0d7912c 100644 --- a/WickedEngine/wiRenderTarget.h +++ b/WickedEngine/wiRenderTarget.h @@ -2,6 +2,7 @@ #include "CommonInclude.h" #include "wiGraphicsAPI.h" + class wiDepthTarget; class wiRenderTarget @@ -12,22 +13,22 @@ private: //vector SAVEDshaderResource; void clear(); //Texture2DDesc textureDesc; - vector renderTargets; - vector renderTargets_Cube; + vector renderTargets; + vector renderTargets_Cube; bool isCube; public: //vector texture2D; //vector renderTarget; //vector shaderResource; - ViewPort viewPort; - wiDepthTarget* depth; + wiGraphicsTypes::ViewPort viewPort; + wiDepthTarget* depth; wiRenderTarget(); - wiRenderTarget(UINT width, UINT height, int numViews = 1, bool hasDepth = false, UINT MSAAC = 1, UINT MSAAQ = 0, DXGI_FORMAT format = DXGI_FORMAT_R8G8B8A8_UNORM, UINT mipMapLevelCount = 1); + wiRenderTarget(UINT width, UINT height, int numViews = 1, bool hasDepth = false, UINT MSAAC = 1, UINT MSAAQ = 0, wiGraphicsTypes::FORMAT format = wiGraphicsTypes::FORMAT_R8G8B8A8_UNORM, UINT mipMapLevelCount = 1); ~wiRenderTarget(); - void Initialize(UINT width, UINT height, int numViews = 1, bool hasDepth = false, UINT MSAAC = 1, UINT MSAAQ = 0, DXGI_FORMAT format = DXGI_FORMAT_R8G8B8A8_UNORM, UINT mipMapLevelCount = 1); - void InitializeCube(UINT size, int numViews, bool hasDepth, DXGI_FORMAT format, UINT mipMapLevelCount = 1); + void Initialize(UINT width, UINT height, int numViews = 1, bool hasDepth = false, UINT MSAAC = 1, UINT MSAAQ = 0, wiGraphicsTypes::FORMAT format = wiGraphicsTypes::FORMAT_R8G8B8A8_UNORM, UINT mipMapLevelCount = 1); + void InitializeCube(UINT size, int numViews, bool hasDepth, wiGraphicsTypes::FORMAT format, UINT mipMapLevelCount = 1); void InitializeCube(UINT size, int numViews, bool hasDepth); void Activate(GRAPHICSTHREAD threadID); void Activate(GRAPHICSTHREAD threadID, float r, float g, float b, float a); @@ -39,8 +40,8 @@ public: //void Retarget(Texture2D* resource); //void Restore(); - Texture2D* GetTexture(int viewID = 0) const{ return (isCube ? renderTargets_Cube[viewID] : renderTargets[viewID]); } - Texture2DDesc GetDesc(int viewID = 0) const { assert(viewID < numViews); return GetTexture(viewID)->desc; } + wiGraphicsTypes::Texture2D* GetTexture(int viewID = 0) const{ return (isCube ? renderTargets_Cube[viewID] : renderTargets[viewID]); } + wiGraphicsTypes::Texture2DDesc GetDesc(int viewID = 0) const { assert(viewID < numViews); return GetTexture(viewID)->desc; } UINT GetMipCount(); bool IsInitialized() { return (numViews > 0 || depth != nullptr); } }; diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp index 23d09c218..656609046 100644 --- a/WickedEngine/wiRenderer.cpp +++ b/WickedEngine/wiRenderer.cpp @@ -23,6 +23,8 @@ #include "TextureMapping.h" #include "wiGraphicsAPI_DX11.h" +using namespace wiGraphicsTypes; + #pragma region STATICS GraphicsDevice* wiRenderer::graphicsDevice = nullptr; Sampler wiRenderer::samplers[SSLOT_COUNT]; @@ -214,7 +216,7 @@ void wiRenderer::SetUpStaticComponents() normalMapRT.Initialize( GetDevice()->GetScreenWidth() ,GetDevice()->GetScreenHeight() - ,1,false,1,0,DXGI_FORMAT_R8G8B8A8_SNORM + ,1,false,1,0,FORMAT_R8G8B8A8_SNORM ); imagesRTAdd.Initialize( GetDevice()->GetScreenWidth() @@ -546,15 +548,15 @@ void wiRenderer::LoadBasicShaders() { VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "NORMAL", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 1, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "MATI", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, - { "MATI", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, - { "MATI", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, - { "COLOR_DITHER", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, + { "MATI", 0, FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, + { "MATI", 1, FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, + { "MATI", 2, FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, + { "COLOR_DITHER", 0, FORMAT_R32G32B32A32_FLOAT, 1, APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA, 1 }, }; UINT numElements = ARRAYSIZE(layout); VertexShaderInfo* vsinfo = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "objectVS10.cso", wiResourceManager::VERTEXSHADER, layout, numElements)); @@ -568,11 +570,11 @@ void wiRenderer::LoadBasicShaders() VertexLayoutDesc oslayout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "NORMAL", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 1, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 2, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(oslayout); @@ -632,7 +634,7 @@ void wiRenderer::LoadLineShaders() { VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); @@ -682,9 +684,9 @@ void wiRenderer::LoadWaterShaders() void wiRenderer::LoadTrailShaders(){ VertexLayoutDesc layout[] = { - { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, - { "TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "POSITION", 0, FORMAT_R32G32B32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, FORMAT_R32G32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 1, FORMAT_R32G32B32A32_FLOAT, 0, APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); @@ -3179,7 +3181,7 @@ void wiRenderer::PutEnvProbe(const XMFLOAT3& position, int resolution) { EnvironmentProbe* probe = new EnvironmentProbe; probe->transform(position); - probe->cubeMap.InitializeCube(resolution, 1, true, DXGI_FORMAT_R16G16B16A16_FLOAT, 0); + probe->cubeMap.InitializeCube(resolution, 1, true, FORMAT_R16G16B16A16_FLOAT, 0); GetDevice()->LOCK(); diff --git a/WickedEngine/wiRenderer.h b/WickedEngine/wiRenderer.h index 938f9e220..26bfa097b 100644 --- a/WickedEngine/wiRenderer.h +++ b/WickedEngine/wiRenderer.h @@ -48,8 +48,8 @@ typedef map MaterialCollection; class wiRenderer { public: - static GraphicsDevice* graphicsDevice; - static GraphicsDevice* GetDevice() { return graphicsDevice; } + static wiGraphicsTypes::GraphicsDevice* graphicsDevice; + static wiGraphicsTypes::GraphicsDevice* GetDevice() { return graphicsDevice; } #ifndef WINSTORE_SUPPORT static void InitDevice(HWND window, int screenW, int screenH, bool windowed); @@ -59,7 +59,7 @@ public: static void Present(function drawToScreen1=nullptr,function drawToScreen2=nullptr,function drawToScreen3=nullptr); - static Sampler samplers[SSLOT_COUNT]; + static wiGraphicsTypes::Sampler samplers[SSLOT_COUNT]; static int SHADOWMAPRES,SOFTSHADOW,POINTLIGHTSHADOW,POINTLIGHTSHADOWRES,SPOTLIGHTSHADOW,SPOTLIGHTSHADOWRES; @@ -248,16 +248,16 @@ protected: }; - static BufferResource constantBuffers[CBTYPE_LAST]; - static VertexShader vertexShaders[VSTYPE_LAST]; - static PixelShader pixelShaders[PSTYPE_LAST]; - static GeometryShader geometryShaders[GSTYPE_LAST]; - static HullShader hullShaders[HSTYPE_LAST]; - static DomainShader domainShaders[DSTYPE_LAST]; - static RasterizerState rasterizers[RSTYPE_LAST]; - static DepthStencilState depthStencils[DSSTYPE_LAST]; - static VertexLayout vertexLayouts[VLTYPE_LAST]; - static BlendState blendStates[BSTYPE_LAST]; + static wiGraphicsTypes::BufferResource constantBuffers[CBTYPE_LAST]; + static wiGraphicsTypes::VertexShader vertexShaders[VSTYPE_LAST]; + static wiGraphicsTypes::PixelShader pixelShaders[PSTYPE_LAST]; + static wiGraphicsTypes::GeometryShader geometryShaders[GSTYPE_LAST]; + static wiGraphicsTypes::HullShader hullShaders[HSTYPE_LAST]; + static wiGraphicsTypes::DomainShader domainShaders[DSTYPE_LAST]; + static wiGraphicsTypes::RasterizerState rasterizers[RSTYPE_LAST]; + static wiGraphicsTypes::DepthStencilState depthStencils[DSSTYPE_LAST]; + static wiGraphicsTypes::VertexLayout vertexLayouts[VLTYPE_LAST]; + static wiGraphicsTypes::BlendState blendStates[BSTYPE_LAST]; void UpdateSpheres(); @@ -271,7 +271,7 @@ protected: static bool wireRender, debugSpheres, debugBoneLines, debugBoxes; - static Texture2D* enviroMap,*colorGrading; + static wiGraphicsTypes::Texture2D* enviroMap,*colorGrading; static void LoadBuffers(); static void LoadBasicShaders(); static void LoadLineShaders(); @@ -322,10 +322,10 @@ public: static void SetToDrawDebugBoxes(bool param){debugBoxes=param;} static bool GetToDrawDebugSpheres(){return debugSpheres;}; static bool GetToDrawDebugBoxes(){return debugBoxes;}; - static Texture2D* GetColorGrading(){return colorGrading;}; - static void SetColorGrading(Texture2D* tex){colorGrading=tex;}; - static void SetEnviromentMap(Texture2D* tex){ enviroMap = tex; } - static Texture2D* GetEnviromentMap(){ return enviroMap; } + static wiGraphicsTypes::Texture2D* GetColorGrading(){return colorGrading;}; + static void SetColorGrading(wiGraphicsTypes::Texture2D* tex){colorGrading=tex;}; + static void SetEnviromentMap(wiGraphicsTypes::Texture2D* tex){ enviroMap = tex; } + static wiGraphicsTypes::Texture2D* GetEnviromentMap(){ return enviroMap; } static Transform* getTransformByName(const string& name); @@ -352,28 +352,28 @@ public: static void UpdateFrameCB(GRAPHICSTHREAD threadID); static void UpdateCameraCB(GRAPHICSTHREAD threadID); static void SetClipPlane(XMFLOAT4 clipPlane, GRAPHICSTHREAD threadID); - static void UpdateGBuffer(Texture2D* slot0, Texture2D* slot1, Texture2D* slot2, Texture2D* slot3, Texture2D* slot4, GRAPHICSTHREAD threadID); - static void UpdateDepthBuffer(Texture2D* depth, Texture2D* linearDepth, GRAPHICSTHREAD threadID); + static void UpdateGBuffer(wiGraphicsTypes::Texture2D* slot0, wiGraphicsTypes::Texture2D* slot1, wiGraphicsTypes::Texture2D* slot2, wiGraphicsTypes::Texture2D* slot3, wiGraphicsTypes::Texture2D* slot4, GRAPHICSTHREAD threadID); + static void UpdateDepthBuffer(wiGraphicsTypes::Texture2D* depth, wiGraphicsTypes::Texture2D* linearDepth, GRAPHICSTHREAD threadID); static void DrawSky(GRAPHICSTHREAD threadID, bool isReflection = false); static void DrawSun(GRAPHICSTHREAD threadID); static void DrawWorld(Camera* camera, bool DX11Eff, int tessF, GRAPHICSTHREAD threadID - , bool BlackOut, bool isReflection, SHADERTYPE shaded, Texture2D* refRes, bool grass, GRAPHICSTHREAD thread); + , bool BlackOut, bool isReflection, SHADERTYPE shaded, wiGraphicsTypes::Texture2D* refRes, bool grass, GRAPHICSTHREAD thread); static void ClearShadowMaps(GRAPHICSTHREAD threadID); static void DrawForShadowMap(GRAPHICSTHREAD threadID); - static void DrawWorldTransparent(Camera* camera, Texture2D* refracRes, Texture2D* refRes - , Texture2D* waterRippleNormals, GRAPHICSTHREAD threadID); + static void DrawWorldTransparent(Camera* camera, wiGraphicsTypes::Texture2D* refracRes, wiGraphicsTypes::Texture2D* refRes + , wiGraphicsTypes::Texture2D* waterRippleNormals, GRAPHICSTHREAD threadID); void DrawDebugSpheres(Camera* camera, GRAPHICSTHREAD threadID); static void DrawDebugBoneLines(Camera* camera, GRAPHICSTHREAD threadID); static void DrawDebugLines(Camera* camera, GRAPHICSTHREAD threadID); static void DrawDebugBoxes(Camera* camera, GRAPHICSTHREAD threadID); static void DrawSoftParticles(Camera* camera, GRAPHICSTHREAD threadID, bool dark = false); static void DrawSoftPremulParticles(Camera* camera, GRAPHICSTHREAD threadID, bool dark = false); - static void DrawTrails(GRAPHICSTHREAD threadID, Texture2D* refracRes); - static void DrawImagesAdd(GRAPHICSTHREAD threadID, Texture2D* refracRes); + static void DrawTrails(GRAPHICSTHREAD threadID, wiGraphicsTypes::Texture2D* refracRes); + static void DrawImagesAdd(GRAPHICSTHREAD threadID, wiGraphicsTypes::Texture2D* refracRes); //alpha-opaque - static void DrawImages(GRAPHICSTHREAD threadID, Texture2D* refracRes); - static void DrawImagesNormals(GRAPHICSTHREAD threadID, Texture2D* refracRes); + static void DrawImages(GRAPHICSTHREAD threadID, wiGraphicsTypes::Texture2D* refracRes); + static void DrawImagesNormals(GRAPHICSTHREAD threadID, wiGraphicsTypes::Texture2D* refracRes); static void DrawLights(Camera* camera, GRAPHICSTHREAD threadID, unsigned int stencilRef = 2); static void DrawVolumeLights(Camera* camera, GRAPHICSTHREAD threadID); static void DrawLensFlares(GRAPHICSTHREAD threadID); diff --git a/WickedEngine/wiRenderer_BindLua.cpp b/WickedEngine/wiRenderer_BindLua.cpp index e2c00b120..441095d1c 100644 --- a/WickedEngine/wiRenderer_BindLua.cpp +++ b/WickedEngine/wiRenderer_BindLua.cpp @@ -12,6 +12,8 @@ #include "wiHairParticle.h" #include "wiPHYSICS.h" +using namespace wiGraphicsTypes; + namespace wiRenderer_BindLua { diff --git a/WickedEngine/wiResourceManager.cpp b/WickedEngine/wiResourceManager.cpp index bcccad566..1d1731787 100644 --- a/WickedEngine/wiResourceManager.cpp +++ b/WickedEngine/wiResourceManager.cpp @@ -3,6 +3,8 @@ #include "wiSound.h" #include "wiHelper.h" +using namespace wiGraphicsTypes; + wiResourceManager::filetypes wiResourceManager::types; wiResourceManager* wiResourceManager::globalResources = nullptr; diff --git a/WickedEngine/wiResourceManager.h b/WickedEngine/wiResourceManager.h index 126ec45d9..9b1f9de1a 100644 --- a/WickedEngine/wiResourceManager.h +++ b/WickedEngine/wiResourceManager.h @@ -50,7 +50,7 @@ public: const Resource* get(const string& name, bool IncRefCount = false); //specify datatype for shaders void* add(const string& name, Data_Type newType = Data_Type::DYNAMIC - , VertexLayoutDesc* vertexLayoutDesc = nullptr, UINT elementCount = 0, StreamOutDeclaration* streamOutDecl = nullptr); + , wiGraphicsTypes::VertexLayoutDesc* vertexLayoutDesc = nullptr, UINT elementCount = 0, wiGraphicsTypes::StreamOutDeclaration* streamOutDecl = nullptr); bool del(const string& name, bool forceDelete = false); bool CleanUp(); }; diff --git a/WickedEngine/wiResourceManager_BindLua.cpp b/WickedEngine/wiResourceManager_BindLua.cpp index 01309b5ad..416f0c27f 100644 --- a/WickedEngine/wiResourceManager_BindLua.cpp +++ b/WickedEngine/wiResourceManager_BindLua.cpp @@ -4,6 +4,7 @@ #include "Texture_BindLua.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; const char wiResourceManager_BindLua::className[] = "Resource"; diff --git a/WickedEngine/wiSprite.cpp b/WickedEngine/wiSprite.cpp index 596303653..7da8bcd9a 100644 --- a/WickedEngine/wiSprite.cpp +++ b/WickedEngine/wiSprite.cpp @@ -4,6 +4,8 @@ #include "wiImage.h" #include "wiRenderer.h" +using namespace wiGraphicsTypes; + wiSprite::wiSprite(wiResourceManager* contentHolder) :ContentHolder(contentHolder) { diff --git a/WickedEngine/wiSprite.h b/WickedEngine/wiSprite.h index 0850b290a..6d2eebd8f 100644 --- a/WickedEngine/wiSprite.h +++ b/WickedEngine/wiSprite.h @@ -9,7 +9,7 @@ class wiSprite : public wiImage { private: string texture, mask, normal; - Texture2D* texturePointer,*normalPointer,*maskPointer; + wiGraphicsTypes::Texture2D* texturePointer,*normalPointer,*maskPointer; wiResourceManager* ContentHolder; public: wiSprite(wiResourceManager* contentHolder = nullptr); @@ -22,7 +22,7 @@ public: void Update(float); void Update(); - void Draw(Texture2D* refracRes, GRAPHICSTHREAD threadID); + void Draw(wiGraphicsTypes::Texture2D* refracRes, GRAPHICSTHREAD threadID); void Draw(); void DrawNormal(GRAPHICSTHREAD threadID); @@ -66,7 +66,7 @@ public: }; Anim anim; - Texture2D* getTexture(){return texturePointer;} - void setTexture(Texture2D* value){texturePointer=value;} + wiGraphicsTypes::Texture2D* getTexture(){return texturePointer;} + void setTexture(wiGraphicsTypes::Texture2D* value){texturePointer=value;} }; diff --git a/WickedEngine/wiTextureHelper.cpp b/WickedEngine/wiTextureHelper.cpp index fec853d87..6dab7c7ee 100644 --- a/WickedEngine/wiTextureHelper.cpp +++ b/WickedEngine/wiTextureHelper.cpp @@ -1,7 +1,7 @@ #include "wiTextureHelper.h" #include "wiRandom.h" -wiTextureHelper::wiTextureHelperInstance* wiTextureHelper::instance = nullptr; +using namespace wiGraphicsTypes; wiTextureHelper::wiTextureHelperInstance::wiTextureHelperInstance() { diff --git a/WickedEngine/wiTextureHelper.h b/WickedEngine/wiTextureHelper.h index 539f67a28..cec3d7004 100644 --- a/WickedEngine/wiTextureHelper.h +++ b/WickedEngine/wiTextureHelper.h @@ -17,41 +17,39 @@ private: HELPERTEXTURE_NORMALMAPDEFAULT, HELPERTEXTURE_COUNT }; - Texture2D* helperTextures[HELPERTEXTURE_COUNT]; + wiGraphicsTypes::Texture2D* helperTextures[HELPERTEXTURE_COUNT]; - unordered_map colorTextures; + unordered_map colorTextures; public: wiTextureHelperInstance(); ~wiTextureHelperInstance(); - Texture2D* getRandom64x64(); - Texture2D* getColorGradeDefault(); - Texture2D* getNormalMapDefault(); + wiGraphicsTypes::Texture2D* getRandom64x64(); + wiGraphicsTypes::Texture2D* getColorGradeDefault(); + wiGraphicsTypes::Texture2D* getNormalMapDefault(); - Texture2D* getWhite(); - Texture2D* getBlack(); - Texture2D* getTransparent(); - Texture2D* getColor(const wiColor& color); + wiGraphicsTypes::Texture2D* getWhite(); + wiGraphicsTypes::Texture2D* getBlack(); + wiGraphicsTypes::Texture2D* getTransparent(); + wiGraphicsTypes::Texture2D* getColor(const wiColor& color); }; - static wiTextureHelperInstance* instance; public: - inline static wiTextureHelperInstance* getInstance() + static wiTextureHelperInstance* getInstance() { - if (instance != nullptr) - return instance; - - return instance = new wiTextureHelperInstance(); + static wiTextureHelperInstance* instance = new wiTextureHelperInstance(); + return instance; } template - static HRESULT CreateTexture(Texture2D*& texture, T* data, UINT width, UINT height, UINT channelCount, DXGI_FORMAT format = DXGI_FORMAT_R8G8B8A8_UNORM) + static HRESULT CreateTexture(wiGraphicsTypes::Texture2D*& texture, T* data, UINT width, UINT height, UINT channelCount, wiGraphicsTypes::FORMAT format = wiGraphicsTypes::FORMAT_R8G8B8A8_UNORM) { if (data == nullptr) { return E_FAIL; } + using namespace wiGraphicsTypes; Texture2DDesc textureDesc; ZeroMemory(&textureDesc, sizeof(textureDesc)); @@ -67,27 +65,13 @@ public: textureDesc.CPUAccessFlags = 0; textureDesc.MiscFlags = 0; - //ShaderResourceViewDesc shaderResourceViewDesc; - //shaderResourceViewDesc.Format = format; - //shaderResourceViewDesc.ViewDimension = RESOURCE_DIMENSION_TEXTURE2D; - ////shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; - ////shaderResourceViewDesc.Texture2D.MipLevels = 1; - //shaderResourceViewDesc.mipLevels = 1; - SubresourceData InitData; ZeroMemory(&InitData, sizeof(InitData)); InitData.pSysMem = data; InitData.SysMemPitch = static_cast(width * channelCount); - //Texture2D* texture2D = nullptr; HRESULT hr; hr = wiRenderer::GetDevice()->CreateTexture2D(&textureDesc, &InitData, &texture); - //if (FAILED(hr)) - //{ - // return hr; - //} - //hr = wiRenderer::GetDevice()->CreateShaderResourceView(texture2D, &shaderResourceViewDesc, &texture); - //SAFE_RELEASE(texture2D); return hr; }