diff --git a/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.cpp b/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.cpp new file mode 100644 index 000000000..14c37c63a --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.cpp @@ -0,0 +1,72 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11CardProfiler.h" +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "platformWin32/videoInfo/wmiVideoInfo.h" +#include "console/console.h" +#include "gfx/primBuilder.h" + + +GFXD3D11CardProfiler::GFXD3D11CardProfiler() : GFXCardProfiler() +{ +} + +GFXD3D11CardProfiler::~GFXD3D11CardProfiler() +{ + +} + +void GFXD3D11CardProfiler::init() +{ + U32 adapterIndex = D3D11->getAdaterIndex(); + WMIVideoInfo wmiVidInfo; + if (wmiVidInfo.profileAdapters()) + { + const PlatformVideoInfo::PVIAdapter &adapter = wmiVidInfo.getAdapterInformation(adapterIndex); + + mCardDescription = adapter.description; + mChipSet = adapter.chipSet; + mVersionString = adapter.driverVersion; + mVideoMemory = adapter.vram; + } + Parent::init(); +} + +void GFXD3D11CardProfiler::setupCardCapabilities() +{ + setCapability("maxTextureWidth", D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION); + setCapability("maxTextureHeight", D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION); + setCapability("maxTextureSize", D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION); +} + +bool GFXD3D11CardProfiler::_queryCardCap(const String &query, U32 &foundResult) +{ + return false; +} + +bool GFXD3D11CardProfiler::_queryFormat( const GFXFormat fmt, const GFXTextureProfile *profile, bool &inOutAutogenMips ) +{ + // D3D11 feature level should guarantee that any format is valid! + return GFXD3D11TextureFormat[fmt] != DXGI_FORMAT_UNKNOWN; +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.h b/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.h new file mode 100644 index 000000000..c26432928 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11CardProfiler.h @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11CARDPROFILER_H_ +#define _GFXD3D11CARDPROFILER_H_ + +#include "gfx/gfxCardProfile.h" + +class GFXD3D11CardProfiler : public GFXCardProfiler +{ +private: + typedef GFXCardProfiler Parent; + +public: + GFXD3D11CardProfiler(); + ~GFXD3D11CardProfiler(); + void init(); + +protected: + const String &getRendererString() const { static String sRS("Direct3D11"); return sRS; } + + void setupCardCapabilities(); + bool _queryCardCap(const String &query, U32 &foundResult); + bool _queryFormat(const GFXFormat fmt, const GFXTextureProfile *profile, bool &inOutAutogenMips); +}; + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp new file mode 100644 index 000000000..281e7e786 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp @@ -0,0 +1,352 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Cubemap.h" +#include "gfx/gfxCardProfile.h" +#include "gfx/gfxTextureManager.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" + +GFXD3D11Cubemap::GFXD3D11Cubemap() : mTexture(NULL), mSRView(NULL), mDSView(NULL) +{ + mDynamic = false; + mAutoGenMips = false; + mFaceFormat = GFXFormatR8G8B8A8; + + for (U32 i = 0; i < CubeFaces; i++) + { + mRTView[i] = NULL; + } +} + +GFXD3D11Cubemap::~GFXD3D11Cubemap() +{ + releaseSurfaces(); +} + +void GFXD3D11Cubemap::releaseSurfaces() +{ + if (mDynamic) + GFXTextureManager::removeEventDelegate(this, &GFXD3D11Cubemap::_onTextureEvent); + + for (U32 i = 0; i < CubeFaces; i++) + { + SAFE_RELEASE(mRTView[i]); + } + + SAFE_RELEASE(mDSView); + SAFE_RELEASE(mSRView); + SAFE_RELEASE(mTexture); +} + +void GFXD3D11Cubemap::_onTextureEvent(GFXTexCallbackCode code) +{ + if (code == GFXZombify) + releaseSurfaces(); + else if (code == GFXResurrect) + initDynamic(mTexSize); +} + +bool GFXD3D11Cubemap::isCompressed(GFXFormat format) +{ + if (format >= GFXFormatDXT1 && format <= GFXFormatDXT5) + return true; + + return false; +} + +void GFXD3D11Cubemap::initStatic(GFXTexHandle *faces) +{ + AssertFatal( faces, "GFXD3D11Cubemap::initStatic - Got null GFXTexHandle!" ); + AssertFatal( *faces, "empty texture passed to CubeMap::create" ); + + // NOTE - check tex sizes on all faces - they MUST be all same size + mTexSize = faces->getWidth(); + mFaceFormat = faces->getFormat(); + bool compressed = isCompressed(mFaceFormat); + + UINT bindFlags = D3D11_BIND_SHADER_RESOURCE; + UINT miscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; + if (!compressed) + { + bindFlags |= D3D11_BIND_RENDER_TARGET; + miscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + } + + U32 mipLevels = faces->getPointer()->getMipLevels(); + if (mipLevels > 1) + mAutoGenMips = true; + + D3D11_TEXTURE2D_DESC desc; + ZeroMemory(&desc, sizeof(D3D11_TEXTURE2D_DESC)); + desc.Width = mTexSize; + desc.Height = mTexSize; + desc.MipLevels = mAutoGenMips ? 0 : mipLevels; + desc.ArraySize = 6; + desc.Format = GFXD3D11TextureFormat[mFaceFormat]; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = bindFlags; + desc.MiscFlags = miscFlags; + desc.CPUAccessFlags = 0; + + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &mTexture); + + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap:initStatic(GFXTexhandle *faces) - failed to create texcube texture"); + } + + for (U32 i = 0; i < CubeFaces; i++) + { + GFXD3D11TextureObject *texObj = static_cast((GFXTextureObject*)faces[i]); + U32 subResource = D3D11CalcSubresource(0, i, mipLevels); + D3D11DEVICECONTEXT->CopySubresourceRegion(mTexture, subResource, 0, 0, 0, texObj->get2DTex(), 0, NULL); + } + + D3D11_SHADER_RESOURCE_VIEW_DESC SMViewDesc; + SMViewDesc.Format = GFXD3D11TextureFormat[mFaceFormat]; + SMViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + SMViewDesc.TextureCube.MipLevels = mAutoGenMips ? -1 : mipLevels; + SMViewDesc.TextureCube.MostDetailedMip = 0; + + hr = D3D11DEVICE->CreateShaderResourceView(mTexture, &SMViewDesc, &mSRView); + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initStatic(GFXTexHandle *faces) - texcube shader resource view creation failure"); + } + + if (mAutoGenMips && !compressed) + D3D11DEVICECONTEXT->GenerateMips(mSRView); +} + +void GFXD3D11Cubemap::initStatic(DDSFile *dds) +{ + AssertFatal(dds, "GFXD3D11Cubemap::initStatic - Got null DDS file!"); + AssertFatal(dds->isCubemap(), "GFXD3D11Cubemap::initStatic - Got non-cubemap DDS file!"); + AssertFatal(dds->mSurfaces.size() == 6, "GFXD3D11Cubemap::initStatic - DDS has less than 6 surfaces!"); + + // NOTE - check tex sizes on all faces - they MUST be all same size + mTexSize = dds->getWidth(); + mFaceFormat = dds->getFormat(); + U32 levels = dds->getMipLevels(); + + D3D11_TEXTURE2D_DESC desc; + + desc.Width = mTexSize; + desc.Height = mTexSize; + desc.MipLevels = levels; + desc.ArraySize = 6; + desc.Format = GFXD3D11TextureFormat[mFaceFormat]; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_IMMUTABLE; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE | D3D11_RESOURCE_MISC_GENERATE_MIPS; + + D3D11_SUBRESOURCE_DATA* pData = new D3D11_SUBRESOURCE_DATA[6 + levels]; + + for (U32 i = 0; imSurfaces[i]) + continue; + + for(U32 j = 0; j < levels; j++) + { + pData[i + j].pSysMem = dds->mSurfaces[i]->mMips[j]; + pData[i + j].SysMemPitch = dds->getSurfacePitch(j); + pData[i + j].SysMemSlicePitch = dds->getSurfaceSize(j); + } + } + + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, pData, &mTexture); + + delete [] pData; + + D3D11_SHADER_RESOURCE_VIEW_DESC SMViewDesc; + SMViewDesc.Format = GFXD3D11TextureFormat[mFaceFormat]; + SMViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + SMViewDesc.TextureCube.MipLevels = levels; + SMViewDesc.TextureCube.MostDetailedMip = 0; + + hr = D3D11DEVICE->CreateShaderResourceView(mTexture, &SMViewDesc, &mSRView); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initStatic(DDSFile *dds) - CreateTexture2D call failure"); + } +} + +void GFXD3D11Cubemap::initDynamic(U32 texSize, GFXFormat faceFormat) +{ + if(!mDynamic) + GFXTextureManager::addEventDelegate(this, &GFXD3D11Cubemap::_onTextureEvent); + + mDynamic = true; + mAutoGenMips = true; + mTexSize = texSize; + mFaceFormat = faceFormat; + bool compressed = isCompressed(mFaceFormat); + + UINT bindFlags = D3D11_BIND_SHADER_RESOURCE; + UINT miscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; + if (!compressed) + { + bindFlags |= D3D11_BIND_RENDER_TARGET; + miscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + } + + D3D11_TEXTURE2D_DESC desc; + + desc.Width = mTexSize; + desc.Height = mTexSize; + desc.MipLevels = 0; + desc.ArraySize = 6; + desc.Format = GFXD3D11TextureFormat[mFaceFormat]; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = 0; + desc.MiscFlags = miscFlags; + + + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &mTexture); + + D3D11_SHADER_RESOURCE_VIEW_DESC SMViewDesc; + SMViewDesc.Format = GFXD3D11TextureFormat[mFaceFormat]; + SMViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + SMViewDesc.TextureCube.MipLevels = -1; + SMViewDesc.TextureCube.MostDetailedMip = 0; + + hr = D3D11DEVICE->CreateShaderResourceView(mTexture, &SMViewDesc, &mSRView); + + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initDynamic - CreateTexture2D call failure"); + } + + D3D11_RENDER_TARGET_VIEW_DESC viewDesc; + viewDesc.Format = desc.Format; + viewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + viewDesc.Texture2DArray.ArraySize = 1; + viewDesc.Texture2DArray.MipSlice = 0; + + for (U32 i = 0; i < CubeFaces; i++) + { + viewDesc.Texture2DArray.FirstArraySlice = i; + hr = D3D11DEVICE->CreateRenderTargetView(mTexture, &viewDesc, &mRTView[i]); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initDynamic - CreateRenderTargetView call failure"); + } + } + + D3D11_TEXTURE2D_DESC depthTexDesc; + depthTexDesc.Width = mTexSize; + depthTexDesc.Height = mTexSize; + depthTexDesc.MipLevels = 1; + depthTexDesc.ArraySize = 1; + depthTexDesc.SampleDesc.Count = 1; + depthTexDesc.SampleDesc.Quality = 0; + depthTexDesc.Format = DXGI_FORMAT_D32_FLOAT; + depthTexDesc.Usage = D3D11_USAGE_DEFAULT; + depthTexDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + depthTexDesc.CPUAccessFlags = 0; + depthTexDesc.MiscFlags = 0; + + ID3D11Texture2D* depthTex = 0; + hr = D3D11DEVICE->CreateTexture2D(&depthTexDesc, 0, &depthTex); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initDynamic - CreateTexture2D for depth stencil call failure"); + } + + // Create the depth stencil view for the entire cube + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = depthTexDesc.Format; //The format must match the depth texture we created above + dsvDesc.Flags = 0; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + dsvDesc.Texture2D.MipSlice = 0; + hr = D3D11DEVICE->CreateDepthStencilView(depthTex, &dsvDesc, &mDSView); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Cubemap::initDynamic - CreateDepthStencilView call failure"); + } + + SAFE_RELEASE(depthTex); + +} + +//----------------------------------------------------------------------------- +// Set the cubemap to the specified texture unit num +//----------------------------------------------------------------------------- +void GFXD3D11Cubemap::setToTexUnit(U32 tuNum) +{ + D3D11DEVICECONTEXT->PSSetShaderResources(tuNum, 1, &mSRView); +} + +void GFXD3D11Cubemap::zombify() +{ + // Static cubemaps are handled by D3D + if( mDynamic ) + releaseSurfaces(); +} + +void GFXD3D11Cubemap::resurrect() +{ + // Static cubemaps are handled by D3D + if( mDynamic ) + initDynamic( mTexSize, mFaceFormat ); +} + +ID3D11ShaderResourceView* GFXD3D11Cubemap::getSRView() +{ + return mSRView; +} + +ID3D11RenderTargetView* GFXD3D11Cubemap::getRTView(U32 faceIdx) +{ + AssertFatal(faceIdx < CubeFaces, "GFXD3D11Cubemap::getRTView - face index out of bounds"); + + return mRTView[faceIdx]; +} + +ID3D11RenderTargetView** GFXD3D11Cubemap::getRTViewArray() +{ + return mRTView; +} + +ID3D11DepthStencilView* GFXD3D11Cubemap::getDSView() +{ + return mDSView; +} + +ID3D11Texture2D* GFXD3D11Cubemap::get2DTex() +{ + return mTexture; +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11Cubemap.h b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.h new file mode 100644 index 000000000..f24933d08 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.h @@ -0,0 +1,80 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11CUBEMAP_H_ +#define _GFXD3D11CUBEMAP_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/gfxCubemap.h" +#include "gfx/gfxResource.h" +#include "gfx/gfxTarget.h" + +const U32 CubeFaces = 6; + +class GFXD3D11Cubemap : public GFXCubemap +{ +public: + virtual void initStatic( GFXTexHandle *faces ); + virtual void initStatic( DDSFile *dds ); + virtual void initDynamic( U32 texSize, GFXFormat faceFormat = GFXFormatR8G8B8A8 ); + virtual void setToTexUnit( U32 tuNum ); + virtual U32 getSize() const { return mTexSize; } + virtual GFXFormat getFormat() const { return mFaceFormat; } + + GFXD3D11Cubemap(); + virtual ~GFXD3D11Cubemap(); + + // GFXResource interface + virtual void zombify(); + virtual void resurrect(); + + // Get functions + ID3D11ShaderResourceView* getSRView(); + ID3D11RenderTargetView* getRTView(U32 faceIdx); + ID3D11RenderTargetView** getRTViewArray(); + ID3D11DepthStencilView* getDSView(); + ID3D11Texture2D* get2DTex(); + +private: + + friend class GFXD3D11TextureTarget; + friend class GFXD3D11Device; + + ID3D11Texture2D* mTexture; + ID3D11ShaderResourceView* mSRView; // for shader resource input + ID3D11RenderTargetView* mRTView[CubeFaces]; // for render targets, 6 faces of the cubemap + ID3D11DepthStencilView* mDSView; //render target view for depth stencil + + bool mAutoGenMips; + bool mDynamic; + U32 mTexSize; + GFXFormat mFaceFormat; + + void releaseSurfaces(); + + bool isCompressed(GFXFormat format); + /// The callback used to get texture events. + /// @see GFXTextureManager::addEventDelegate + void _onTextureEvent(GFXTexCallbackCode code); +}; + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11Device.cpp b/Engine/source/gfx/D3D11/gfxD3D11Device.cpp new file mode 100644 index 000000000..e38ff546c --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Device.cpp @@ -0,0 +1,1721 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "console/console.h" +#include "core/stream/fileStream.h" +#include "core/strings/unicode.h" +#include "core/util/journal/process.h" +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11CardProfiler.h" +#include "gfx/D3D11/gfxD3D11VertexBuffer.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "gfx/D3D11/gfxD3D11QueryFence.h" +#include "gfx/D3D11/gfxD3D11OcclusionQuery.h" +#include "gfx/D3D11/gfxD3D11Shader.h" +#include "gfx/D3D11/gfxD3D11Target.h" +#include "platformWin32/platformWin32.h" +#include "windowManager/win32/win32Window.h" +#include "windowManager/platformWindow.h" +#include "gfx/D3D11/screenshotD3D11.h" +#include "materials/shaderData.h" + +#ifdef TORQUE_DEBUG +#include "d3d11sdklayers.h" +#endif + +#pragma comment(lib, "dxgi.lib") +#pragma comment(lib, "d3d11.lib") + +GFXAdapter::CreateDeviceInstanceDelegate GFXD3D11Device::mCreateDeviceInstance(GFXD3D11Device::createInstance); + +GFXDevice *GFXD3D11Device::createInstance(U32 adapterIndex) +{ + GFXD3D11Device* dev = new GFXD3D11Device(adapterIndex); + return dev; +} + +GFXFormat GFXD3D11Device::selectSupportedFormat(GFXTextureProfile *profile, const Vector &formats, bool texture, bool mustblend, bool mustfilter) +{ + U32 features = 0; + if(texture) + features |= D3D11_FORMAT_SUPPORT_TEXTURE2D; + if(mustblend) + features |= D3D11_FORMAT_SUPPORT_BLENDABLE; + if(mustfilter) + features |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE; + + for(U32 i = 0; i < formats.size(); i++) + { + if(GFXD3D11TextureFormat[formats[i]] == DXGI_FORMAT_UNKNOWN) + continue; + + U32 supportFlag = 0; + mD3DDevice->CheckFormatSupport(GFXD3D11TextureFormat[formats[i]],&supportFlag); + if(supportFlag & features) + return formats[i]; + } + + return GFXFormatR8G8B8A8; +} + +DXGI_SWAP_CHAIN_DESC GFXD3D11Device::setupPresentParams(const GFXVideoMode &mode, const HWND &hwnd) +{ + DXGI_SWAP_CHAIN_DESC d3dpp; + ZeroMemory(&d3dpp, sizeof(d3dpp)); + + DXGI_SAMPLE_DESC sampleDesc; + sampleDesc.Count = 1; + sampleDesc.Quality = 0; + + mMultisampleDesc = sampleDesc; + + d3dpp.BufferCount = !smDisableVSync ? 2 : 1; // triple buffering when vsync is on. + d3dpp.BufferDesc.Width = mode.resolution.x; + d3dpp.BufferDesc.Height = mode.resolution.y; + d3dpp.BufferDesc.Format = GFXD3D11TextureFormat[GFXFormatR8G8B8A8]; + d3dpp.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + d3dpp.OutputWindow = hwnd; + d3dpp.SampleDesc = sampleDesc; + d3dpp.Windowed = !mode.fullScreen; + d3dpp.BufferDesc.RefreshRate.Numerator = mode.refreshRate; + d3dpp.BufferDesc.RefreshRate.Denominator = 1; + d3dpp.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + + if (mode.fullScreen) + { + d3dpp.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + d3dpp.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + d3dpp.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + } + + return d3dpp; +} + +void GFXD3D11Device::enumerateAdapters(Vector &adapterList) +{ + IDXGIAdapter1* EnumAdapter; + IDXGIFactory1* DXGIFactory; + + CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast(&DXGIFactory)); + + for(U32 adapterIndex = 0; DXGIFactory->EnumAdapters1(adapterIndex, &EnumAdapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) + { + GFXAdapter *toAdd = new GFXAdapter; + toAdd->mType = Direct3D11; + toAdd->mIndex = adapterIndex; + toAdd->mCreateDeviceInstanceDelegate = mCreateDeviceInstance; + + toAdd->mShaderModel = 5.0f; + DXGI_ADAPTER_DESC1 desc; + EnumAdapter->GetDesc1(&desc); + + size_t size=wcslen(desc.Description); + char *str = new char[size+1]; + + wcstombs(str, desc.Description,size); + str[size]='\0'; + String Description=str; + SAFE_DELETE_ARRAY(str); + + dStrncpy(toAdd->mName, Description.c_str(), GFXAdapter::MaxAdapterNameLen); + dStrncat(toAdd->mName, " (D3D11)", GFXAdapter::MaxAdapterNameLen); + + IDXGIOutput* pOutput = NULL; + HRESULT hr; + + hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); + + if(hr == DXGI_ERROR_NOT_FOUND) + { + SAFE_RELEASE(EnumAdapter); + break; + } + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> EnumOutputs call failure"); + + UINT numModes = 0; + DXGI_MODE_DESC* displayModes = NULL; + DXGI_FORMAT format = DXGI_FORMAT_B8G8R8A8_UNORM; + + // Get the number of elements + hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); + + displayModes = new DXGI_MODE_DESC[numModes]; + + // Get the list + hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); + + for(U32 numMode = 0; numMode < numModes; ++numMode) + { + GFXVideoMode vmAdd; + + vmAdd.fullScreen = true; + vmAdd.bitDepth = 32; + vmAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; + vmAdd.resolution.x = displayModes[numMode].Width; + vmAdd.resolution.y = displayModes[numMode].Height; + toAdd->mAvailableModes.push_back(vmAdd); + } + + delete[] displayModes; + SAFE_RELEASE(pOutput); + SAFE_RELEASE(EnumAdapter); + adapterList.push_back(toAdd); + } + + SAFE_RELEASE(DXGIFactory); +} + +void GFXD3D11Device::enumerateVideoModes() +{ + mVideoModes.clear(); + + IDXGIAdapter1* EnumAdapter; + IDXGIFactory1* DXGIFactory; + HRESULT hr; + + hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast(&DXGIFactory)); + + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> CreateDXGIFactory1 call failure"); + + for(U32 adapterIndex = 0; DXGIFactory->EnumAdapters1(adapterIndex, &EnumAdapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) + { + IDXGIOutput* pOutput = NULL; + + hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); + + if(hr == DXGI_ERROR_NOT_FOUND) + { + SAFE_RELEASE(EnumAdapter); + break; + } + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> EnumOutputs call failure"); + + UINT numModes = 0; + DXGI_MODE_DESC* displayModes = NULL; + DXGI_FORMAT format = GFXD3D11TextureFormat[GFXFormatR8G8B8A8]; + + // Get the number of elements + hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); + + displayModes = new DXGI_MODE_DESC[numModes]; + + // Get the list + hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); + + for(U32 numMode = 0; numMode < numModes; ++numMode) + { + GFXVideoMode toAdd; + + toAdd.fullScreen = false; + toAdd.bitDepth = 32; + toAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; + toAdd.resolution.x = displayModes[numMode].Width; + toAdd.resolution.y = displayModes[numMode].Height; + mVideoModes.push_back(toAdd); + } + + delete[] displayModes; + SAFE_RELEASE(pOutput); + SAFE_RELEASE(EnumAdapter); + } + + SAFE_RELEASE(DXGIFactory); +} + +IDXGISwapChain* GFXD3D11Device::getSwapChain() +{ + return mSwapChain; +} + +void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) +{ + AssertFatal(window, "GFXD3D11Device::init - must specify a window!"); + + HWND winHwnd = (HWND)window->getSystemWindow( PlatformWindow::WindowSystem_Windows ); + + UINT createDeviceFlags = D3D11_CREATE_DEVICE_SINGLETHREADED | D3D11_CREATE_DEVICE_BGRA_SUPPORT; +#ifdef TORQUE_DEBUG + createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; + mDebugLayers = true; +#endif + + DXGI_SWAP_CHAIN_DESC d3dpp = setupPresentParams(mode, winHwnd); + + D3D_FEATURE_LEVEL deviceFeature; + D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_HARDWARE;// use D3D_DRIVER_TYPE_REFERENCE for reference device + // create a device, device context and swap chain using the information in the d3dpp struct + HRESULT hres = D3D11CreateDeviceAndSwapChain(NULL, + driverType, + NULL, + createDeviceFlags, + NULL, + 0, + D3D11_SDK_VERSION, + &d3dpp, + &mSwapChain, + &mD3DDevice, + &deviceFeature, + &mD3DDeviceContext); + + if(FAILED(hres)) + { + #ifdef TORQUE_DEBUG + //try again without debug device layer enabled + createDeviceFlags &= ~D3D11_CREATE_DEVICE_DEBUG; + HRESULT hres = D3D11CreateDeviceAndSwapChain(NULL, driverType,NULL,createDeviceFlags,NULL, 0, + D3D11_SDK_VERSION, + &d3dpp, + &mSwapChain, + &mD3DDevice, + &deviceFeature, + &mD3DDeviceContext); + //if we failed again than we definitely have a problem + if (FAILED(hres)) + AssertFatal(false, "GFXD3D11Device::init - D3D11CreateDeviceAndSwapChain failed!"); + + Con::warnf("GFXD3D11Device::init - Debug layers not detected!"); + mDebugLayers = false; + #else + AssertFatal(false, "GFXD3D11Device::init - D3D11CreateDeviceAndSwapChain failed!"); + #endif + } + + //set the fullscreen state here if we need to + if(mode.fullScreen) + { + hres = mSwapChain->SetFullscreenState(TRUE, NULL); + if(FAILED(hres)) + { + AssertFatal(false, "GFXD3D11Device::init- Failed to set fullscreen state!"); + } + } + + mTextureManager = new GFXD3D11TextureManager(); + + // Now reacquire all the resources we trashed earlier + reacquireDefaultPoolResources(); + //TODO implement feature levels? + if (deviceFeature >= D3D_FEATURE_LEVEL_11_0) + mPixVersion = 5.0f; + else + AssertFatal(false, "GFXD3D11Device::init - We don't support anything below feature level 11."); + + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = D3D11_QUERY_OCCLUSION; + queryDesc.MiscFlags = 0; + + ID3D11Query *testQuery = NULL; + + // detect occlusion query support + if (SUCCEEDED(mD3DDevice->CreateQuery(&queryDesc, &testQuery))) mOcclusionQuerySupported = true; + + SAFE_RELEASE(testQuery); + + Con::printf("Hardware occlusion query detected: %s", mOcclusionQuerySupported ? "Yes" : "No"); + + mCardProfiler = new GFXD3D11CardProfiler(); + mCardProfiler->init(); + + D3D11_TEXTURE2D_DESC desc; + desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + desc.CPUAccessFlags = 0; + desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.Width = mode.resolution.x; + desc.Height = mode.resolution.y; + desc.SampleDesc.Count =1; + desc.SampleDesc.Quality =0; + desc.MiscFlags = 0; + + HRESULT hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::init - couldn't create device's depth-stencil surface."); + } + + D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; + depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + depthDesc.Flags =0 ; + depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + depthDesc.Texture2D.MipSlice = 0; + + hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::init - couldn't create depth stencil view"); + } + + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::init - coudln't retrieve backbuffer ref"); + + //create back buffer view + D3D11_RENDER_TARGET_VIEW_DESC RTDesc; + + RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + RTDesc.Texture2D.MipSlice = 0; + RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + + hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); + + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::init - couldn't create back buffer target view"); + +#ifdef TORQUE_DEBUG + String backBufferName = "MainBackBuffer"; + String depthSteniclName = "MainDepthStencil"; + String backBuffViewName = "MainBackBuffView"; + String depthStencViewName = "MainDepthView"; + mDeviceBackbuffer->SetPrivateData(WKPDID_D3DDebugObjectName, backBufferName.size(), backBufferName.c_str()); + mDeviceDepthStencil->SetPrivateData(WKPDID_D3DDebugObjectName, depthSteniclName.size(), depthSteniclName.c_str()); + mDeviceDepthStencilView->SetPrivateData(WKPDID_D3DDebugObjectName, depthStencViewName.size(), depthStencViewName.c_str()); + mDeviceBackBufferView->SetPrivateData(WKPDID_D3DDebugObjectName, backBuffViewName.size(), backBuffViewName.c_str()); + + _suppressDebugMessages(); + +#endif + + gScreenShot = new ScreenShotD3D11; + + mInitialized = true; + deviceInited(); +} + +// Supress any debug layer messages we don't want to see +void GFXD3D11Device::_suppressDebugMessages() +{ + if (mDebugLayers) + { + ID3D11Debug *pDebug = NULL; + if (SUCCEEDED(mD3DDevice->QueryInterface(__uuidof(ID3D11Debug), (void**)&pDebug))) + { + ID3D11InfoQueue *pInfoQueue = NULL; + if (SUCCEEDED(pDebug->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&pInfoQueue))) + { + //Disable breaking on error or corruption, this can be handy when using VS graphics debugging + pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, false); + pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, false); + + D3D11_MESSAGE_ID hide[] = + { + //this is harmless and no need to spam the console + D3D11_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS + }; + + D3D11_INFO_QUEUE_FILTER filter; + memset(&filter, 0, sizeof(filter)); + filter.DenyList.NumIDs = _countof(hide); + filter.DenyList.pIDList = hide; + pInfoQueue->AddStorageFilterEntries(&filter); + SAFE_RELEASE(pInfoQueue); + } + SAFE_RELEASE(pDebug); + } + } +} + +bool GFXD3D11Device::beginSceneInternal() +{ + mCanCurrentlyRender = true; + return mCanCurrentlyRender; +} + +GFXWindowTarget * GFXD3D11Device::allocWindowTarget(PlatformWindow *window) +{ + AssertFatal(window,"GFXD3D11Device::allocWindowTarget - no window provided!"); + + // Allocate the device. + init(window->getVideoMode(), window); + + // Set up a new window target... + GFXD3D11WindowTarget *gdwt = new GFXD3D11WindowTarget(); + gdwt->mWindow = window; + gdwt->mSize = window->getClientExtent(); + gdwt->initPresentationParams(); + gdwt->registerResourceWithDevice(this); + + return gdwt; +} + +GFXTextureTarget* GFXD3D11Device::allocRenderToTextureTarget() +{ + GFXD3D11TextureTarget *targ = new GFXD3D11TextureTarget(); + targ->registerResourceWithDevice(this); + + return targ; +} + +void GFXD3D11Device::reset(DXGI_SWAP_CHAIN_DESC &d3dpp) +{ + if (!mD3DDevice) + return; + + mInitialized = false; + + // Clean up some commonly dangling state. This helps prevents issues with + // items that are destroyed by the texture manager callbacks and recreated + // later, but still left bound. + setVertexBuffer(NULL); + setPrimitiveBuffer(NULL); + for (S32 i = 0; iClearState(); + + DXGI_MODE_DESC displayModes; + displayModes.Format = d3dpp.BufferDesc.Format; + displayModes.Height = d3dpp.BufferDesc.Height; + displayModes.Width = d3dpp.BufferDesc.Width; + displayModes.RefreshRate = d3dpp.BufferDesc.RefreshRate; + displayModes.Scaling = d3dpp.BufferDesc.Scaling; + displayModes.ScanlineOrdering = d3dpp.BufferDesc.ScanlineOrdering; + + HRESULT hr; + if (!d3dpp.Windowed) + { + hr = mSwapChain->ResizeTarget(&displayModes); + + if (FAILED(hr)) + { + AssertFatal(false, "D3D11Device::reset - failed to resize target!"); + } + } + + // First release all the stuff we allocated from D3DPOOL_DEFAULT + releaseDefaultPoolResources(); + + //release the backbuffer, depthstencil, and their views + SAFE_RELEASE(mDeviceBackBufferView); + SAFE_RELEASE(mDeviceBackbuffer); + SAFE_RELEASE(mDeviceDepthStencilView); + SAFE_RELEASE(mDeviceDepthStencil); + + hr = mSwapChain->ResizeBuffers(d3dpp.BufferCount, d3dpp.BufferDesc.Width, d3dpp.BufferDesc.Height, d3dpp.BufferDesc.Format, d3dpp.Windowed ? 0 : DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH); + + if (FAILED(hr)) + { + AssertFatal(false, "D3D11Device::reset - failed to resize back buffer!"); + } + + //recreate backbuffer view. depth stencil view and texture + D3D11_TEXTURE2D_DESC desc; + desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + desc.CPUAccessFlags = 0; + desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.Width = d3dpp.BufferDesc.Width; + desc.Height = d3dpp.BufferDesc.Height; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.MiscFlags = 0; + + hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::reset - couldn't create device's depth-stencil surface."); + } + + D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; + depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + depthDesc.Flags = 0; + depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + depthDesc.Texture2D.MipSlice = 0; + + hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); + + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::reset - couldn't create depth stencil view"); + } + + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::reset - coudln't retrieve backbuffer ref"); + + //create back buffer view + D3D11_RENDER_TARGET_VIEW_DESC RTDesc; + + RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + RTDesc.Texture2D.MipSlice = 0; + RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + + hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); + + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::reset - couldn't create back buffer target view"); + + mD3DDeviceContext->OMSetRenderTargets(1, &mDeviceBackBufferView, mDeviceDepthStencilView); + + hr = mSwapChain->SetFullscreenState(!d3dpp.Windowed, NULL); + + if (FAILED(hr)) + { + AssertFatal(false, "D3D11Device::reset - failed to change screen states!"); + } + + //Microsoft recommend this, see DXGI documentation + if (!d3dpp.Windowed) + { + displayModes.RefreshRate.Numerator = 0; + displayModes.RefreshRate.Denominator = 0; + hr = mSwapChain->ResizeTarget(&displayModes); + + if (FAILED(hr)) + { + AssertFatal(false, "D3D11Device::reset - failed to resize target!"); + } + } + + mInitialized = true; + + // Now re aquire all the resources we trashed earlier + reacquireDefaultPoolResources(); + + // Mark everything dirty and flush to card, for sanity. + updateStates(true); +} + +class GFXPCD3D11RegisterDevice +{ +public: + GFXPCD3D11RegisterDevice() + { + GFXInit::getRegisterDeviceSignal().notify(&GFXD3D11Device::enumerateAdapters); + } +}; + +static GFXPCD3D11RegisterDevice pPCD3D11RegisterDevice; + +//----------------------------------------------------------------------------- +/// Parse command line arguments for window creation +//----------------------------------------------------------------------------- +static void sgPCD3D11DeviceHandleCommandLine(S32 argc, const char **argv) +{ + // useful to pass parameters by command line for d3d (e.g. -dx9 -dx11) + for (U32 i = 1; i < argc; i++) + { + argv[i]; + } +} + +// Register the command line parsing hook +static ProcessRegisterCommandLine sgCommandLine( sgPCD3D11DeviceHandleCommandLine ); + +GFXD3D11Device::GFXD3D11Device(U32 index) +{ + mDeviceSwizzle32 = &Swizzles::bgra; + GFXVertexColor::setSwizzle( mDeviceSwizzle32 ); + + mDeviceSwizzle24 = &Swizzles::bgr; + + mAdapterIndex = index; + mD3DDevice = NULL; + mVolatileVB = NULL; + + mCurrentPB = NULL; + mDynamicPB = NULL; + + mLastVertShader = NULL; + mLastPixShader = NULL; + + mCanCurrentlyRender = false; + mTextureManager = NULL; + mCurrentStateBlock = NULL; + mResourceListHead = NULL; + + mPixVersion = 0.0; + + mDrawInstancesCount = 0; + + mCardProfiler = NULL; + + mDeviceDepthStencil = NULL; + mDeviceBackbuffer = NULL; + mDeviceBackBufferView = NULL; + mDeviceDepthStencilView = NULL; + + mCreateFenceType = -1; // Unknown, test on first allocate + + mCurrentConstBuffer = NULL; + + mOcclusionQuerySupported = false; + + mDebugLayers = false; + + for(U32 i = 0; i < GS_COUNT; ++i) + mModelViewProjSC[i] = NULL; + + // Set up the Enum translation tables + GFXD3D11EnumTranslate::init(); +} + +GFXD3D11Device::~GFXD3D11Device() +{ + // Release our refcount on the current stateblock object + mCurrentStateBlock = NULL; + + releaseDefaultPoolResources(); + + mD3DDeviceContext->ClearState(); + mD3DDeviceContext->Flush(); + + // Free the vertex declarations. + VertexDeclMap::Iterator iter = mVertexDecls.begin(); + for ( ; iter != mVertexDecls.end(); iter++ ) + delete iter->value; + + // Forcibly clean up the pools + mVolatileVBList.setSize(0); + mDynamicPB = NULL; + + // And release our D3D resources. + SAFE_RELEASE(mDeviceDepthStencilView); + SAFE_RELEASE(mDeviceBackBufferView); + SAFE_RELEASE(mDeviceDepthStencil); + SAFE_RELEASE(mDeviceBackbuffer); + SAFE_RELEASE(mD3DDeviceContext); + + SAFE_DELETE(mCardProfiler); + SAFE_DELETE(gScreenShot); + +#ifdef TORQUE_DEBUG + if (mDebugLayers) + { + ID3D11Debug *pDebug = NULL; + mD3DDevice->QueryInterface(IID_PPV_ARGS(&pDebug)); + AssertFatal(pDebug, "~GFXD3D11Device- Failed to get debug layer"); + pDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL); + SAFE_RELEASE(pDebug); + } +#endif + + SAFE_RELEASE(mSwapChain); + SAFE_RELEASE(mD3DDevice); +} + +void GFXD3D11Device::setupGenericShaders(GenericShaderType type) +{ + AssertFatal(type != GSTargetRestore, ""); //not used + + if(mGenericShader[GSColor] == NULL) + { + ShaderData *shaderData; + + shaderData = new ShaderData(); + shaderData->setField("DXVertexShaderFile", "shaders/common/fixedFunction/colorV.hlsl"); + shaderData->setField("DXPixelShaderFile", "shaders/common/fixedFunction/colorP.hlsl"); + shaderData->setField("pixVersion", "5.0"); + shaderData->registerObject(); + mGenericShader[GSColor] = shaderData->getShader(); + mGenericShaderBuffer[GSColor] = mGenericShader[GSColor]->allocConstBuffer(); + mModelViewProjSC[GSColor] = mGenericShader[GSColor]->getShaderConstHandle("$modelView"); + Sim::getRootGroup()->addObject(shaderData); + + shaderData = new ShaderData(); + shaderData->setField("DXVertexShaderFile", "shaders/common/fixedFunction/modColorTextureV.hlsl"); + shaderData->setField("DXPixelShaderFile", "shaders/common/fixedFunction/modColorTextureP.hlsl"); + shaderData->setField("pixVersion", "5.0"); + shaderData->registerObject(); + mGenericShader[GSModColorTexture] = shaderData->getShader(); + mGenericShaderBuffer[GSModColorTexture] = mGenericShader[GSModColorTexture]->allocConstBuffer(); + mModelViewProjSC[GSModColorTexture] = mGenericShader[GSModColorTexture]->getShaderConstHandle("$modelView"); + Sim::getRootGroup()->addObject(shaderData); + + shaderData = new ShaderData(); + shaderData->setField("DXVertexShaderFile", "shaders/common/fixedFunction/addColorTextureV.hlsl"); + shaderData->setField("DXPixelShaderFile", "shaders/common/fixedFunction/addColorTextureP.hlsl"); + shaderData->setField("pixVersion", "5.0"); + shaderData->registerObject(); + mGenericShader[GSAddColorTexture] = shaderData->getShader(); + mGenericShaderBuffer[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->allocConstBuffer(); + mModelViewProjSC[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->getShaderConstHandle("$modelView"); + Sim::getRootGroup()->addObject(shaderData); + + shaderData = new ShaderData(); + shaderData->setField("DXVertexShaderFile", "shaders/common/fixedFunction/textureV.hlsl"); + shaderData->setField("DXPixelShaderFile", "shaders/common/fixedFunction/textureP.hlsl"); + shaderData->setField("pixVersion", "5.0"); + shaderData->registerObject(); + mGenericShader[GSTexture] = shaderData->getShader(); + mGenericShaderBuffer[GSTexture] = mGenericShader[GSTexture]->allocConstBuffer(); + mModelViewProjSC[GSTexture] = mGenericShader[GSTexture]->getShaderConstHandle("$modelView"); + Sim::getRootGroup()->addObject(shaderData); + + //Force an update + mViewportDirty = true; + _updateRenderTargets(); + } + + MatrixF tempMatrix = mProjectionMatrix * mViewMatrix * mWorldMatrix[mWorldStackSize]; + mGenericShaderBuffer[type]->setSafe(mModelViewProjSC[type], tempMatrix); + + setShader(mGenericShader[type]); + setShaderConstBuffer(mGenericShaderBuffer[type]); +} + +//----------------------------------------------------------------------------- +/// Creates a state block object based on the desc passed in. This object +/// represents an immutable state. +GFXStateBlockRef GFXD3D11Device::createStateBlockInternal(const GFXStateBlockDesc& desc) +{ + return GFXStateBlockRef(new GFXD3D11StateBlock(desc)); +} + +/// Activates a stateblock +void GFXD3D11Device::setStateBlockInternal(GFXStateBlock* block, bool force) +{ + AssertFatal(static_cast(block), "Incorrect stateblock type for this device!"); + GFXD3D11StateBlock* d3dBlock = static_cast(block); + GFXD3D11StateBlock* d3dCurrent = static_cast(mCurrentStateBlock.getPointer()); + + if (force) + d3dCurrent = NULL; + + d3dBlock->activate(d3dCurrent); +} + +/// Called by base GFXDevice to actually set a const buffer +void GFXD3D11Device::setShaderConstBufferInternal(GFXShaderConstBuffer* buffer) +{ + if (buffer) + { + PROFILE_SCOPE(GFXD3D11Device_setShaderConstBufferInternal); + AssertFatal(static_cast(buffer), "Incorrect shader const buffer type for this device!"); + GFXD3D11ShaderConstBuffer* d3dBuffer = static_cast(buffer); + + d3dBuffer->activate(mCurrentConstBuffer); + mCurrentConstBuffer = d3dBuffer; + } + else + { + mCurrentConstBuffer = NULL; + } +} + +//----------------------------------------------------------------------------- + +void GFXD3D11Device::clear(U32 flags, ColorI color, F32 z, U32 stencil) +{ + // Make sure we have flushed our render target state. + _updateRenderTargets(); + + UINT depthstencilFlag = 0; + + ID3D11RenderTargetView* rtView = NULL; + ID3D11DepthStencilView* dsView = NULL; + + mD3DDeviceContext->OMGetRenderTargets(1, &rtView, &dsView); + + const FLOAT clearColor[4] = { + static_cast(color.red) * (1.0f / 255.0f), + static_cast(color.green) * (1.0f / 255.0f), + static_cast(color.blue) * (1.0f / 255.0f), + static_cast(color.alpha) * (1.0f / 255.0f) + }; + + if (flags & GFXClearTarget && rtView) + mD3DDeviceContext->ClearRenderTargetView(rtView, clearColor); + + if (flags & GFXClearZBuffer) + depthstencilFlag |= D3D11_CLEAR_DEPTH; + + if (flags & GFXClearStencil) + depthstencilFlag |= D3D11_CLEAR_STENCIL; + + if (depthstencilFlag && dsView) + mD3DDeviceContext->ClearDepthStencilView(dsView, depthstencilFlag, z, stencil); + + SAFE_RELEASE(rtView); + SAFE_RELEASE(dsView); +} + +void GFXD3D11Device::endSceneInternal() +{ + mCanCurrentlyRender = false; +} + +void GFXD3D11Device::_updateRenderTargets() +{ + if (mRTDirty || (mCurrentRT && mCurrentRT->isPendingState())) + { + if (mRTDeactivate) + { + mRTDeactivate->deactivate(); + mRTDeactivate = NULL; + } + + // NOTE: The render target changes are not really accurate + // as the GFXTextureTarget supports MRT internally. So when + // we activate a GFXTarget it could result in multiple calls + // to SetRenderTarget on the actual device. + mDeviceStatistics.mRenderTargetChanges++; + + mCurrentRT->activate(); + + mRTDirty = false; + } + + if (mViewportDirty) + { + D3D11_VIEWPORT viewport; + + viewport.TopLeftX = mViewport.point.x; + viewport.TopLeftY = mViewport.point.y; + viewport.Width = mViewport.extent.x; + viewport.Height = mViewport.extent.y; + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; + + mD3DDeviceContext->RSSetViewports(1, &viewport); + + mViewportDirty = false; + } +} + +void GFXD3D11Device::releaseDefaultPoolResources() +{ + // Release all the dynamic vertex buffer arrays + // Forcibly clean up the pools + for(U32 i=0; ivb); + mVolatileVBList[i] = NULL; + } + mVolatileVBList.setSize(0); + + // We gotta clear the current const buffer else the next + // activate may erroneously think the device is still holding + // this state and fail to set it. + mCurrentConstBuffer = NULL; + + // Set current VB to NULL and set state dirty + for (U32 i=0; i < VERTEX_STREAM_COUNT; i++) + { + mCurrentVertexBuffer[i] = NULL; + mVertexBufferDirty[i] = true; + mVertexBufferFrequency[i] = 0; + mVertexBufferFrequencyDirty[i] = true; + } + + // Release dynamic index buffer + if(mDynamicPB != NULL) + { + SAFE_RELEASE(mDynamicPB->ib); + } + + // Set current PB/IB to NULL and set state dirty + mCurrentPrimitiveBuffer = NULL; + mCurrentPB = NULL; + mPrimitiveBufferDirty = true; + + // Zombify texture manager (for D3D this only modifies default pool textures) + if( mTextureManager ) + mTextureManager->zombify(); + + // Set global dirty state so the IB/PB and VB get reset + mStateDirty = true; + + // Walk the resource list and zombify everything. + GFXResource *walk = mResourceListHead; + while(walk) + { + walk->zombify(); + walk = walk->getNextResource(); + } +} + +void GFXD3D11Device::reacquireDefaultPoolResources() +{ + // Now do the dynamic index buffers + if( mDynamicPB == NULL ) + mDynamicPB = new GFXD3D11PrimitiveBuffer(this, 0, 0, GFXBufferTypeDynamic); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = sizeof(U16) * MAX_DYNAMIC_INDICES; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &mDynamicPB->ib); + + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate dynamic IB"); + } + + // Walk the resource list and zombify everything. + GFXResource *walk = mResourceListHead; + while(walk) + { + walk->resurrect(); + walk = walk->getNextResource(); + } + + if(mTextureManager) + mTextureManager->resurrect(); +} + +GFXD3D11VertexBuffer* GFXD3D11Device::findVBPool( const GFXVertexFormat *vertexFormat, U32 vertsNeeded ) +{ + PROFILE_SCOPE( GFXD3D11Device_findVBPool ); + + for( U32 i=0; imVertexFormat.isEqual( *vertexFormat ) ) + return mVolatileVBList[i]; + + return NULL; +} + +GFXD3D11VertexBuffer * GFXD3D11Device::createVBPool( const GFXVertexFormat *vertexFormat, U32 vertSize ) +{ + PROFILE_SCOPE( GFXD3D11Device_createVBPool ); + + // this is a bit funky, but it will avoid problems with (lack of) copy constructors + // with a push_back() situation + mVolatileVBList.increment(); + StrongRefPtr newBuff; + mVolatileVBList.last() = new GFXD3D11VertexBuffer(); + newBuff = mVolatileVBList.last(); + + newBuff->mNumVerts = 0; + newBuff->mBufferType = GFXBufferTypeVolatile; + newBuff->mVertexFormat.copy( *vertexFormat ); + newBuff->mVertexSize = vertSize; + newBuff->mDevice = this; + + // Requesting it will allocate it. + vertexFormat->getDecl(); + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = vertSize * MAX_DYNAMIC_VERTS; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &newBuff->vb); + + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate dynamic VB"); + } + + return newBuff; +} + +//----------------------------------------------------------------------------- + +void GFXD3D11Device::setClipRect( const RectI &inRect ) +{ + // We transform the incoming rect by the view + // matrix first, so that it can be used to pan + // and scale the clip rect. + // + // This is currently used to take tiled screenshots. + Point3F pos( inRect.point.x, inRect.point.y, 0.0f ); + Point3F extent( inRect.extent.x, inRect.extent.y, 0.0f ); + getViewMatrix().mulP( pos ); + getViewMatrix().mulV( extent ); + RectI rect( pos.x, pos.y, extent.x, extent.y ); + + // Clip the rect against the renderable size. + Point2I size = mCurrentRT->getSize(); + + RectI maxRect(Point2I(0,0), size); + rect.intersect(maxRect); + + mClipRect = rect; + + F32 l = F32( mClipRect.point.x ); + F32 r = F32( mClipRect.point.x + mClipRect.extent.x ); + F32 b = F32( mClipRect.point.y + mClipRect.extent.y ); + F32 t = F32( mClipRect.point.y ); + + // Set up projection matrix, + static Point4F pt; + pt.set(2.0f / (r - l), 0.0f, 0.0f, 0.0f); + mTempMatrix.setColumn(0, pt); + + pt.set(0.0f, 2.0f/(t - b), 0.0f, 0.0f); + mTempMatrix.setColumn(1, pt); + + pt.set(0.0f, 0.0f, 1.0f, 0.0f); + mTempMatrix.setColumn(2, pt); + + pt.set((l+r)/(l-r), (t+b)/(b-t), 1.0f, 1.0f); + mTempMatrix.setColumn(3, pt); + + setProjectionMatrix( mTempMatrix ); + + // Set up world/view matrix + mTempMatrix.identity(); + setWorldMatrix( mTempMatrix ); + + setViewport( mClipRect ); +} + +void GFXD3D11Device::setVertexStream( U32 stream, GFXVertexBuffer *buffer ) +{ + GFXD3D11VertexBuffer *d3dBuffer = static_cast( buffer ); + + if ( stream == 0 ) + { + // Set the volatile buffer which is used to + // offset the start index when doing draw calls. + if ( d3dBuffer && d3dBuffer->mVolatileStart > 0 ) + mVolatileVB = d3dBuffer; + else + mVolatileVB = NULL; + } + + // NOTE: We do not use the stream offset here for stream 0 + // as that feature is *supposedly* not as well supported as + // using the start index in drawPrimitive. + // + // If we can verify that this is not the case then we should + // start using this method exclusively for all streams. + + U32 strides[1] = { d3dBuffer ? d3dBuffer->mVertexSize : 0 }; + U32 offset = d3dBuffer && stream != 0 ? d3dBuffer->mVolatileStart * d3dBuffer->mVertexSize : 0; + ID3D11Buffer* buff = d3dBuffer ? d3dBuffer->vb : NULL; + + getDeviceContext()->IASetVertexBuffers(stream, 1, &buff, strides, &offset); +} + +void GFXD3D11Device::setVertexStreamFrequency( U32 stream, U32 frequency ) +{ + if (stream == 0) + mDrawInstancesCount = frequency; // instances count +} + +void GFXD3D11Device::_setPrimitiveBuffer( GFXPrimitiveBuffer *buffer ) +{ + mCurrentPB = static_cast( buffer ); + + mD3DDeviceContext->IASetIndexBuffer(mCurrentPB->ib, DXGI_FORMAT_R16_UINT, 0); +} + +U32 GFXD3D11Device::primCountToIndexCount(GFXPrimitiveType primType, U32 primitiveCount) +{ + switch (primType) + { + case GFXPointList: + return primitiveCount; + break; + case GFXLineList: + return primitiveCount * 2; + break; + case GFXLineStrip: + return primitiveCount + 1; + break; + case GFXTriangleList: + return primitiveCount * 3; + break; + case GFXTriangleStrip: + return 2 + primitiveCount; + break; + default: + AssertFatal(false, "GFXGLDevice::primCountToIndexCount - unrecognized prim type"); + break; + + } + return 0; +} + + +void GFXD3D11Device::drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount ) +{ + // This is done to avoid the function call overhead if possible + if( mStateDirty ) + updateStates(); + if (mCurrentShaderConstBuffer) + setShaderConstBufferInternal(mCurrentShaderConstBuffer); + + if ( mVolatileVB ) + vertexStart += mVolatileVB->mVolatileStart; + + mD3DDeviceContext->IASetPrimitiveTopology(GFXD3D11PrimType[primType]); + + if ( mDrawInstancesCount ) + mD3DDeviceContext->DrawInstanced(primCountToIndexCount(primType, primitiveCount), mDrawInstancesCount, vertexStart, 0); + else + mD3DDeviceContext->Draw(primCountToIndexCount(primType, primitiveCount), vertexStart); + + mDeviceStatistics.mDrawCalls++; + if ( mVertexBufferFrequency[0] > 1 ) + mDeviceStatistics.mPolyCount += primitiveCount * mVertexBufferFrequency[0]; + else + mDeviceStatistics.mPolyCount += primitiveCount; +} + +void GFXD3D11Device::drawIndexedPrimitive( GFXPrimitiveType primType, + U32 startVertex, + U32 minIndex, + U32 numVerts, + U32 startIndex, + U32 primitiveCount ) +{ + // This is done to avoid the function call overhead if possible + if( mStateDirty ) + updateStates(); + if (mCurrentShaderConstBuffer) + setShaderConstBufferInternal(mCurrentShaderConstBuffer); + + AssertFatal( mCurrentPB != NULL, "Trying to call drawIndexedPrimitive with no current index buffer, call setIndexBuffer()" ); + + if ( mVolatileVB ) + startVertex += mVolatileVB->mVolatileStart; + + mD3DDeviceContext->IASetPrimitiveTopology(GFXD3D11PrimType[primType]); + + if ( mDrawInstancesCount ) + mD3DDeviceContext->DrawIndexedInstanced(primCountToIndexCount(primType, primitiveCount), mDrawInstancesCount, mCurrentPB->mVolatileStart + startIndex, startVertex, 0); + else + mD3DDeviceContext->DrawIndexed(primCountToIndexCount(primType,primitiveCount), mCurrentPB->mVolatileStart + startIndex, startVertex); + + mDeviceStatistics.mDrawCalls++; + if ( mVertexBufferFrequency[0] > 1 ) + mDeviceStatistics.mPolyCount += primitiveCount * mVertexBufferFrequency[0]; + else + mDeviceStatistics.mPolyCount += primitiveCount; +} + +GFXShader* GFXD3D11Device::createShader() +{ + GFXD3D11Shader* shader = new GFXD3D11Shader(); + shader->registerResourceWithDevice( this ); + return shader; +} + +//----------------------------------------------------------------------------- +// Set shader - this function exists to make sure this is done in one place, +// and to make sure redundant shader states are not being +// sent to the card. +//----------------------------------------------------------------------------- +void GFXD3D11Device::setShader(GFXShader *shader, bool force) +{ + if(shader) + { + GFXD3D11Shader *d3dShader = static_cast(shader); + + if (d3dShader->mPixShader != mLastPixShader || force) + { + mD3DDeviceContext->PSSetShader( d3dShader->mPixShader, NULL, 0); + mLastPixShader = d3dShader->mPixShader; + } + + if (d3dShader->mVertShader != mLastVertShader || force) + { + mD3DDeviceContext->VSSetShader( d3dShader->mVertShader, NULL, 0); + mLastVertShader = d3dShader->mVertShader; + } + } + else + { + setupGenericShaders(); + } +} + +GFXPrimitiveBuffer * GFXD3D11Device::allocPrimitiveBuffer(U32 numIndices, U32 numPrimitives, GFXBufferType bufferType, void *data ) +{ + // Allocate a buffer to return + GFXD3D11PrimitiveBuffer * res = new GFXD3D11PrimitiveBuffer(this, numIndices, numPrimitives, bufferType); + + // Determine usage flags + D3D11_USAGE usage = D3D11_USAGE_DEFAULT; + + // Assumptions: + // - static buffers are write once, use many + // - dynamic buffers are write many, use many + // - volatile buffers are write once, use once + // You may never read from a buffer. + //TODO: enable proper support for D3D11_USAGE_IMMUTABLE + switch(bufferType) + { + case GFXBufferTypeImmutable: + case GFXBufferTypeStatic: + usage = D3D11_USAGE_DEFAULT; //D3D11_USAGE_IMMUTABLE; + break; + + case GFXBufferTypeDynamic: + case GFXBufferTypeVolatile: + usage = D3D11_USAGE_DYNAMIC; + break; + } + + // Register resource + res->registerResourceWithDevice(this); + + // Create d3d index buffer + if(bufferType == GFXBufferTypeVolatile) + { + // Get it from the pool if it's a volatile... + AssertFatal(numIndices < MAX_DYNAMIC_INDICES, "Cannot allocate that many indices in a volatile buffer, increase MAX_DYNAMIC_INDICES."); + + res->ib = mDynamicPB->ib; + res->mVolatileBuffer = mDynamicPB; + } + else + { + // Otherwise, get it as a seperate buffer... + D3D11_BUFFER_DESC desc; + desc.ByteWidth = sizeof(U16) * numIndices; + desc.Usage = usage; + if(bufferType == GFXBufferTypeDynamic) + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a primitive buffer. + else + desc.CPUAccessFlags = 0; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->ib); + + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate an index buffer."); + } + } + + if (data) + { + void* dest; + res->lock(0, numIndices, &dest); + dMemcpy(dest, data, sizeof(U16) * numIndices); + res->unlock(); + } + + return res; +} + +GFXVertexBuffer * GFXD3D11Device::allocVertexBuffer(U32 numVerts, const GFXVertexFormat *vertexFormat, U32 vertSize, GFXBufferType bufferType, void *data) +{ + PROFILE_SCOPE( GFXD3D11Device_allocVertexBuffer ); + + GFXD3D11VertexBuffer *res = new GFXD3D11VertexBuffer( this, + numVerts, + vertexFormat, + vertSize, + bufferType ); + + // Determine usage flags + D3D11_USAGE usage = D3D11_USAGE_DEFAULT; + + res->mNumVerts = 0; + + // Assumptions: + // - static buffers are write once, use many + // - dynamic buffers are write many, use many + // - volatile buffers are write once, use once + // You may never read from a buffer. + //TODO: enable proper support for D3D11_USAGE_IMMUTABLE + switch(bufferType) + { + case GFXBufferTypeImmutable: + case GFXBufferTypeStatic: + usage = D3D11_USAGE_DEFAULT; + break; + + case GFXBufferTypeDynamic: + case GFXBufferTypeVolatile: + usage = D3D11_USAGE_DYNAMIC; + break; + } + + // Register resource + res->registerResourceWithDevice(this); + + // Create vertex buffer + if(bufferType == GFXBufferTypeVolatile) + { + // NOTE: Volatile VBs are pooled and will be allocated at lock time. + AssertFatal(numVerts <= MAX_DYNAMIC_VERTS, "GFXD3D11Device::allocVertexBuffer - Volatile vertex buffer is too big... see MAX_DYNAMIC_VERTS!"); + } + else + { + // Requesting it will allocate it. + vertexFormat->getDecl(); //-ALEX disabled to postpone until after shader is actually set... + + // Get a new buffer... + D3D11_BUFFER_DESC desc; + desc.ByteWidth = vertSize * numVerts; + desc.Usage = usage; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + if(bufferType == GFXBufferTypeDynamic) + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a vertex buffer. + else + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->vb); + + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate VB"); + } + } + + res->mNumVerts = numVerts; + + if (data) + { + void* dest; + res->lock(0, numVerts, &dest); + dMemcpy(dest, data, vertSize * numVerts); + res->unlock(); + } + + return res; +} + +String GFXD3D11Device::_createTempShaderInternal(const GFXVertexFormat *vertexFormat) +{ + U32 elemCount = vertexFormat->getElementCount(); + //Input data + StringBuilder inputData; + inputData.append("struct VertIn {"); + //Output data + StringBuilder outputData; + outputData.append("struct VertOut {"); + // Shader main body data + StringBuilder mainBodyData; + //make shader + mainBodyData.append("VertOut main(VertIn IN){VertOut OUT;"); + for (U32 i = 0; i < elemCount; i++) + { + const GFXVertexElement &element = vertexFormat->getElement(i); + String semantic = element.getSemantic(); + String semanticOut = semantic; + String type; + + if (element.isSemantic(GFXSemantic::POSITION)) + { + semantic = "POSITION"; + semanticOut = "SV_Position"; + } + else if (element.isSemantic(GFXSemantic::NORMAL)) + { + semantic = "NORMAL"; + semanticOut = semantic; + } + else if (element.isSemantic(GFXSemantic::COLOR)) + { + semantic = "COLOR"; + semanticOut = semantic; + } + else if (element.isSemantic(GFXSemantic::TANGENT)) + { + semantic = "TANGENT"; + semanticOut = semantic; + } + else if (element.isSemantic(GFXSemantic::BINORMAL)) + { + semantic = "BINORMAL"; + semanticOut = semantic; + } + else + { + //Anything that falls thru to here will be a texture coord. + semantic = String::ToString("TEXCOORD%d", element.getSemanticIndex()); + semanticOut = semantic; + } + + switch (GFXD3D11DeclType[element.getType()]) + { + case DXGI_FORMAT_R32_FLOAT: + type = "float"; + break; + case DXGI_FORMAT_R32G32_FLOAT: + type = "float2"; + break; + case DXGI_FORMAT_R32G32B32_FLOAT: + type = "float3"; + break; + case DXGI_FORMAT_R32G32B32A32_FLOAT: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM: + type = "float4"; + break; + } + + StringBuilder in; + in.format("%s %s%d : %s;", type.c_str(), "var", i, semantic.c_str()); + inputData.append(in.data()); + + //SV_Position must be float4 + if (semanticOut == String("SV_Position")) + { + StringBuilder out; + out.format("float4 %s%d : %s;", "var", i, semanticOut.c_str()); + outputData.append(out.data()); + StringBuilder body; + body.format("OUT.%s%d = float4(IN.%s%d.xyz,1);", "var", i, "var", i); + mainBodyData.append(body.data()); + } + else + { + StringBuilder out; + out.format("%s %s%d : %s;", type.c_str(), "var", i, semanticOut.c_str()); + outputData.append(out.data()); + StringBuilder body; + body.format("OUT.%s%d = IN.%s%d;", "var", i, "var", i); + mainBodyData.append(body.data()); + } + } + + inputData.append("};"); + outputData.append("};"); + mainBodyData.append("return OUT;}"); + + //final data + StringBuilder finalData; + finalData.append(inputData.data()); + finalData.append(outputData.data()); + finalData.append(mainBodyData.data()); + + return String(finalData.data()); +} + +GFXVertexDecl* GFXD3D11Device::allocVertexDecl( const GFXVertexFormat *vertexFormat ) +{ + PROFILE_SCOPE( GFXD3D11Device_allocVertexDecl ); + + // First check the map... you shouldn't allocate VBs very often + // if you want performance. The map lookup should never become + // a performance bottleneck. + D3D11VertexDecl *decl = mVertexDecls[vertexFormat->getDescription()]; + if ( decl ) + return decl; + + U32 elemCount = vertexFormat->getElementCount(); + + ID3DBlob* code = NULL; + + // We have to generate a temporary shader here for now since the input layout creation + // expects a shader to be already compiled to verify the vertex layout structure. The problem + // is that most of the time the regular shaders are compiled AFTER allocVertexDecl is called. + if(!decl) + { + //TODO: Perhaps save/cache the ID3DBlob for later use on identical vertex formats,save creating/compiling the temp shader everytime + String shaderData = _createTempShaderInternal(vertexFormat); + +#ifdef TORQUE_DEBUG + U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS; +#else + U32 flags = D3DCOMPILE_ENABLE_STRICTNESS; +#endif + + ID3DBlob *errorBlob = NULL; + HRESULT hr = D3DCompile(shaderData.c_str(), shaderData.length(), NULL, NULL, NULL, "main", "vs_5_0", flags, 0, &code, &errorBlob); + StringBuilder error; + + if(errorBlob) + { + error.append((char*)errorBlob->GetBufferPointer(), errorBlob->GetBufferSize()); + AssertFatal(hr, error.data()); + } + + SAFE_RELEASE(errorBlob); + } + + AssertFatal(code, "D3D11Device::allocVertexDecl - compiled vert shader code missing!"); + + // Setup the declaration struct. + + U32 stream; + D3D11_INPUT_ELEMENT_DESC *vd = new D3D11_INPUT_ELEMENT_DESC[ elemCount]; + + for ( U32 i=0; i < elemCount; i++ ) + { + + const GFXVertexElement &element = vertexFormat->getElement( i ); + + stream = element.getStreamIndex(); + + vd[i].InputSlot = stream; + + vd[i].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; + vd[i].Format = GFXD3D11DeclType[element.getType()]; + // If instancing is enabled, the per instance data is only used on stream 1. + if (vertexFormat->hasInstancing() && stream == 1) + { + vd[i].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA; + vd[i].InstanceDataStepRate = 1; + } + else + { + vd[i].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; + vd[i].InstanceDataStepRate = 0; + } + // We force the usage index of 0 for everything but + // texture coords for now... this may change later. + vd[i].SemanticIndex = 0; + + if ( element.isSemantic( GFXSemantic::POSITION ) ) + vd[i].SemanticName = "POSITION"; + else if ( element.isSemantic( GFXSemantic::NORMAL ) ) + vd[i].SemanticName = "NORMAL"; + else if ( element.isSemantic( GFXSemantic::COLOR ) ) + vd[i].SemanticName = "COLOR"; + else if ( element.isSemantic( GFXSemantic::TANGENT ) ) + vd[i].SemanticName = "TANGENT"; + else if ( element.isSemantic( GFXSemantic::BINORMAL ) ) + vd[i].SemanticName = "BINORMAL"; + else + { + //Anything that falls thru to here will be a texture coord. + vd[i].SemanticName = "TEXCOORD"; + vd[i].SemanticIndex = element.getSemanticIndex(); + } + + } + + decl = new D3D11VertexDecl(); + HRESULT hr = mD3DDevice->CreateInputLayout(vd, elemCount,code->GetBufferPointer(), code->GetBufferSize(), &decl->decl); + + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::allocVertexDecl - Failed to create vertex input layout!"); + } + + delete [] vd; + SAFE_RELEASE(code); + + // Store it in the cache. + mVertexDecls[vertexFormat->getDescription()] = decl; + + return decl; +} + +void GFXD3D11Device::setVertexDecl( const GFXVertexDecl *decl ) +{ + ID3D11InputLayout *dx11Decl = NULL; + if (decl) + dx11Decl = static_cast(decl)->decl; + + mD3DDeviceContext->IASetInputLayout(dx11Decl); +} + +//----------------------------------------------------------------------------- +// This function should ONLY be called from GFXDevice::updateStates() !!! +//----------------------------------------------------------------------------- +void GFXD3D11Device::setTextureInternal( U32 textureUnit, const GFXTextureObject *texture) +{ + if( texture == NULL ) + { + ID3D11ShaderResourceView *pView = NULL; + mD3DDeviceContext->PSSetShaderResources(textureUnit, 1, &pView); + return; + } + + GFXD3D11TextureObject *tex = (GFXD3D11TextureObject*)(texture); + mD3DDeviceContext->PSSetShaderResources(textureUnit, 1, tex->getSRViewPtr()); +} + +GFXFence *GFXD3D11Device::createFence() +{ + // Figure out what fence type we should be making if we don't know + if( mCreateFenceType == -1 ) + { + D3D11_QUERY_DESC desc; + desc.MiscFlags = 0; + desc.Query = D3D11_QUERY_EVENT; + + ID3D11Query *testQuery = NULL; + + HRESULT hRes = mD3DDevice->CreateQuery(&desc, &testQuery); + + if(FAILED(hRes)) + { + mCreateFenceType = true; + } + + else + { + mCreateFenceType = false; + } + + SAFE_RELEASE(testQuery); + } + + // Cool, use queries + if(!mCreateFenceType) + { + GFXFence* fence = new GFXD3D11QueryFence( this ); + fence->registerResourceWithDevice(this); + return fence; + } + + // CodeReview: At some point I would like a specialized implementation of + // the method used by the general fence, only without the overhead incurred + // by using the GFX constructs. Primarily the lock() method on texture handles + // will do a data copy, and this method doesn't require a copy, just a lock + // [5/10/2007 Pat] + GFXFence* fence = new GFXGeneralFence( this ); + fence->registerResourceWithDevice(this); + return fence; +} + +GFXOcclusionQuery* GFXD3D11Device::createOcclusionQuery() +{ + GFXOcclusionQuery *query; + if (mOcclusionQuerySupported) + query = new GFXD3D11OcclusionQuery( this ); + else + return NULL; + + query->registerResourceWithDevice(this); + return query; +} + +GFXCubemap * GFXD3D11Device::createCubemap() +{ + GFXD3D11Cubemap* cube = new GFXD3D11Cubemap(); + cube->registerResourceWithDevice(this); + return cube; +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11Device.h b/Engine/source/gfx/D3D11/gfxD3D11Device.h new file mode 100644 index 000000000..97418d373 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Device.h @@ -0,0 +1,295 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11DEVICE_H_ +#define _GFXD3D11DEVICE_H_ + +#include + +#include "platform/tmm_off.h" +#include "platformWin32/platformWin32.h" +#include "gfx/D3D11/gfxD3D11Shader.h" +#include "gfx/D3D11/gfxD3D11StateBlock.h" +#include "gfx/D3D11/gfxD3D11TextureManager.h" +#include "gfx/D3D11/gfxD3D11Cubemap.h" +#include "gfx/D3D11/gfxD3D11PrimitiveBuffer.h" +#include "gfx/gfxInit.h" +#include "gfx/gfxResource.h" +#include "platform/tmm_on.h" + +#define D3D11 static_cast(GFX) +#define D3D11DEVICE D3D11->getDevice() +#define D3D11DEVICECONTEXT D3D11->getDeviceContext() + +class PlatformWindow; +class GFXD3D11ShaderConstBuffer; + +//------------------------------------------------------------------------------ + +class GFXD3D11Device : public GFXDevice +{ + friend class GFXResource; + friend class GFXD3D11PrimitiveBuffer; + friend class GFXD3D11VertexBuffer; + friend class GFXD3D11TextureObject; + friend class GFXD3D11TextureTarget; + friend class GFXD3D11WindowTarget; + + virtual GFXFormat selectSupportedFormat(GFXTextureProfile *profile, + const Vector &formats, bool texture, bool mustblend, bool mustfilter); + + virtual void enumerateVideoModes(); + + virtual GFXWindowTarget *allocWindowTarget(PlatformWindow *window); + virtual GFXTextureTarget *allocRenderToTextureTarget(); + + virtual void enterDebugEvent(ColorI color, const char *name){}; + virtual void leaveDebugEvent(){}; + virtual void setDebugMarker(ColorI color, const char *name){}; + +protected: + + class D3D11VertexDecl : public GFXVertexDecl + { + public: + virtual ~D3D11VertexDecl() + { + SAFE_RELEASE( decl ); + } + + ID3D11InputLayout *decl; + }; + + virtual void initStates() { }; + + static GFXAdapter::CreateDeviceInstanceDelegate mCreateDeviceInstance; + + MatrixF mTempMatrix; ///< Temporary matrix, no assurances on value at all + RectI mClipRect; + + typedef StrongRefPtr RPGDVB; + Vector mVolatileVBList; + + /// Used to lookup a vertex declaration for the vertex format. + /// @see allocVertexDecl + typedef Map VertexDeclMap; + VertexDeclMap mVertexDecls; + + ID3D11RenderTargetView* mDeviceBackBufferView; + ID3D11DepthStencilView* mDeviceDepthStencilView; + + ID3D11Texture2D *mDeviceBackbuffer; + ID3D11Texture2D *mDeviceDepthStencil; + + /// The stream 0 vertex buffer used for volatile VB offseting. + GFXD3D11VertexBuffer *mVolatileVB; + + //----------------------------------------------------------------------- + StrongRefPtr mDynamicPB; + GFXD3D11PrimitiveBuffer *mCurrentPB; + + ID3D11VertexShader *mLastVertShader; + ID3D11PixelShader *mLastPixShader; + + S32 mCreateFenceType; + + IDXGISwapChain *mSwapChain; + ID3D11Device* mD3DDevice; + ID3D11DeviceContext* mD3DDeviceContext; + + GFXShader* mCurrentShader; + GFXShaderRef mGenericShader[GS_COUNT]; + GFXShaderConstBufferRef mGenericShaderBuffer[GS_COUNT]; + GFXShaderConstHandle *mModelViewProjSC[GS_COUNT]; + + U32 mAdapterIndex; + + F32 mPixVersion; + + bool mDebugLayers; + + DXGI_SAMPLE_DESC mMultisampleDesc; + + bool mOcclusionQuerySupported; + + U32 mDrawInstancesCount; + + /// To manage creating and re-creating of these when device is aquired + void reacquireDefaultPoolResources(); + + /// To release all resources we control from D3DPOOL_DEFAULT + void releaseDefaultPoolResources(); + + virtual GFXD3D11VertexBuffer* findVBPool( const GFXVertexFormat *vertexFormat, U32 numVertsNeeded ); + virtual GFXD3D11VertexBuffer* createVBPool( const GFXVertexFormat *vertexFormat, U32 vertSize ); + + IDXGISwapChain* getSwapChain(); + // State overrides + // { + + /// + virtual void setTextureInternal(U32 textureUnit, const GFXTextureObject* texture); + + /// Called by GFXDevice to create a device specific stateblock + virtual GFXStateBlockRef createStateBlockInternal(const GFXStateBlockDesc& desc); + /// Called by GFXDevice to actually set a stateblock. + virtual void setStateBlockInternal(GFXStateBlock* block, bool force); + + /// Track the last const buffer we've used. Used to notify new constant buffers that + /// they should send all of their constants up + StrongRefPtr mCurrentConstBuffer; + /// Called by base GFXDevice to actually set a const buffer + virtual void setShaderConstBufferInternal(GFXShaderConstBuffer* buffer); + + virtual void setMatrix( GFXMatrixType /*mtype*/, const MatrixF &/*mat*/ ) { }; + virtual void setLightInternal(U32 /*lightStage*/, const GFXLightInfo /*light*/, bool /*lightEnable*/) { }; + virtual void setLightMaterialInternal(const GFXLightMaterial /*mat*/) { }; + virtual void setGlobalAmbientInternal(ColorF /*color*/) { }; + + // } + + // Index buffer management + // { + virtual void _setPrimitiveBuffer( GFXPrimitiveBuffer *buffer ); + virtual void drawIndexedPrimitive( GFXPrimitiveType primType, + U32 startVertex, + U32 minIndex, + U32 numVerts, + U32 startIndex, + U32 primitiveCount ); + // } + + virtual GFXShader* createShader(); + + /// Device helper function + virtual DXGI_SWAP_CHAIN_DESC setupPresentParams( const GFXVideoMode &mode, const HWND &hwnd ); + + String _createTempShaderInternal(const GFXVertexFormat *vertexFormat); + // Supress any debug layer messages we don't want to see + void _suppressDebugMessages(); + +public: + + static GFXDevice *createInstance( U32 adapterIndex ); + + static void enumerateAdapters( Vector &adapterList ); + + GFXTextureObject* createRenderSurface( U32 width, U32 height, GFXFormat format, U32 mipLevel ); + + ID3D11DepthStencilView* getDepthStencilView() { return mDeviceDepthStencilView; } + ID3D11RenderTargetView* getRenderTargetView() { return mDeviceBackBufferView; } + ID3D11Texture2D* getBackBufferTexture() { return mDeviceBackbuffer; } + + /// Constructor + /// @param d3d Direct3D object to instantiate this device with + /// @param index Adapter index since D3D can use multiple graphics adapters + GFXD3D11Device( U32 index ); + virtual ~GFXD3D11Device(); + + // Activate/deactivate + // { + virtual void init( const GFXVideoMode &mode, PlatformWindow *window = NULL ); + + virtual void preDestroy() { GFXDevice::preDestroy(); if(mTextureManager) mTextureManager->kill(); } + + GFXAdapterType getAdapterType(){ return Direct3D11; } + + U32 getAdaterIndex() const { return mAdapterIndex; } + + virtual GFXCubemap *createCubemap(); + + virtual F32 getPixelShaderVersion() const { return mPixVersion; } + virtual void setPixelShaderVersion( F32 version ){ mPixVersion = version;} + + virtual void setShader(GFXShader *shader, bool force = false); + virtual U32 getNumSamplers() const { return 16; } + virtual U32 getNumRenderTargets() const { return 8; } + // } + + // Misc rendering control + // { + virtual void clear( U32 flags, ColorI color, F32 z, U32 stencil ); + virtual bool beginSceneInternal(); + virtual void endSceneInternal(); + + virtual void setClipRect( const RectI &rect ); + virtual const RectI& getClipRect() const { return mClipRect; } + + // } + + + + /// @name Render Targets + /// @{ + virtual void _updateRenderTargets(); + /// @} + + // Vertex/Index buffer management + // { + virtual GFXVertexBuffer* allocVertexBuffer( U32 numVerts, + const GFXVertexFormat *vertexFormat, + U32 vertSize, + GFXBufferType bufferType, + void* data = NULL); + + virtual GFXPrimitiveBuffer *allocPrimitiveBuffer( U32 numIndices, + U32 numPrimitives, + GFXBufferType bufferType, + void* data = NULL); + + virtual GFXVertexDecl* allocVertexDecl( const GFXVertexFormat *vertexFormat ); + virtual void setVertexDecl( const GFXVertexDecl *decl ); + + virtual void setVertexStream( U32 stream, GFXVertexBuffer *buffer ); + virtual void setVertexStreamFrequency( U32 stream, U32 frequency ); + // } + + virtual U32 getMaxDynamicVerts() { return MAX_DYNAMIC_VERTS; } + virtual U32 getMaxDynamicIndices() { return MAX_DYNAMIC_INDICES; } + + inline U32 primCountToIndexCount(GFXPrimitiveType primType, U32 primitiveCount); + + // Rendering + // { + virtual void drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount ); + // } + + ID3D11DeviceContext* getDeviceContext(){ return mD3DDeviceContext; } + ID3D11Device* getDevice(){ return mD3DDevice; } + + /// Reset + void reset( DXGI_SWAP_CHAIN_DESC &d3dpp ); + + virtual void setupGenericShaders( GenericShaderType type = GSColor ); + + inline virtual F32 getFillConventionOffset() const { return 0.0f; } + virtual void doParanoidStateCheck() {}; + + GFXFence *createFence(); + + GFXOcclusionQuery* createOcclusionQuery(); + + // Default multisample parameters + DXGI_SAMPLE_DESC getMultisampleType() const { return mMultisampleDesc; } +}; + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp new file mode 100644 index 000000000..24f195247 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp @@ -0,0 +1,155 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "console/console.h" + +//------------------------------------------------------------------------------ + +DXGI_FORMAT GFXD3D11TextureFormat[GFXFormat_COUNT]; +D3D11_FILTER GFXD3D11TextureFilter[GFXTextureFilter_COUNT]; +D3D11_BLEND GFXD3D11Blend[GFXBlend_COUNT]; +D3D11_BLEND_OP GFXD3D11BlendOp[GFXBlendOp_COUNT]; +D3D11_STENCIL_OP GFXD3D11StencilOp[GFXStencilOp_COUNT]; +D3D11_COMPARISON_FUNC GFXD3D11CmpFunc[GFXCmp_COUNT]; +D3D11_CULL_MODE GFXD3D11CullMode[GFXCull_COUNT]; +D3D11_FILL_MODE GFXD3D11FillMode[GFXFill_COUNT]; +D3D11_PRIMITIVE_TOPOLOGY GFXD3D11PrimType[GFXPT_COUNT]; +D3D11_TEXTURE_ADDRESS_MODE GFXD3D11TextureAddress[GFXAddress_COUNT]; +DXGI_FORMAT GFXD3D11DeclType[GFXDeclType_COUNT]; + +//------------------------------------------------------------------------------ + +void GFXD3D11EnumTranslate::init() +{ + GFXD3D11TextureFormat[GFXFormatR8G8B8] = DXGI_FORMAT_B8G8R8X8_UNORM; + GFXD3D11TextureFormat[GFXFormatR8G8B8A8] = DXGI_FORMAT_B8G8R8A8_UNORM; + GFXD3D11TextureFormat[GFXFormatR8G8B8X8] = DXGI_FORMAT_B8G8R8X8_UNORM; + GFXD3D11TextureFormat[GFXFormatB8G8R8A8] = DXGI_FORMAT_B8G8R8A8_UNORM; + GFXD3D11TextureFormat[GFXFormatR5G6B5] = DXGI_FORMAT_B5G6R5_UNORM; + GFXD3D11TextureFormat[GFXFormatR5G5B5A1] = DXGI_FORMAT_B5G5R5A1_UNORM; + GFXD3D11TextureFormat[GFXFormatR5G5B5X1] = DXGI_FORMAT_UNKNOWN; + GFXD3D11TextureFormat[GFXFormatR32F] = DXGI_FORMAT_R32_FLOAT; + GFXD3D11TextureFormat[GFXFormatA4L4] = DXGI_FORMAT_UNKNOWN; + GFXD3D11TextureFormat[GFXFormatA8L8] = DXGI_FORMAT_R8G8_UNORM; + GFXD3D11TextureFormat[GFXFormatA8] = DXGI_FORMAT_A8_UNORM; + GFXD3D11TextureFormat[GFXFormatL8] = DXGI_FORMAT_R8_UNORM; + GFXD3D11TextureFormat[GFXFormatDXT1] = DXGI_FORMAT_BC1_UNORM; + GFXD3D11TextureFormat[GFXFormatDXT2] = DXGI_FORMAT_BC1_UNORM; + GFXD3D11TextureFormat[GFXFormatDXT3] = DXGI_FORMAT_BC2_UNORM; + GFXD3D11TextureFormat[GFXFormatDXT4] = DXGI_FORMAT_BC2_UNORM; + GFXD3D11TextureFormat[GFXFormatDXT5] = DXGI_FORMAT_BC3_UNORM; + GFXD3D11TextureFormat[GFXFormatR32G32B32A32F] = DXGI_FORMAT_R32G32B32A32_FLOAT; + GFXD3D11TextureFormat[GFXFormatR16G16B16A16F] = DXGI_FORMAT_R16G16B16A16_FLOAT; + GFXD3D11TextureFormat[GFXFormatL16] = DXGI_FORMAT_R16_UNORM; + GFXD3D11TextureFormat[GFXFormatR16G16B16A16] = DXGI_FORMAT_R16G16B16A16_UNORM; + GFXD3D11TextureFormat[GFXFormatR16G16] = DXGI_FORMAT_R16G16_UNORM; + GFXD3D11TextureFormat[GFXFormatR16F] = DXGI_FORMAT_R16_FLOAT; + GFXD3D11TextureFormat[GFXFormatR16G16F] = DXGI_FORMAT_R16G16_FLOAT; + GFXD3D11TextureFormat[GFXFormatR10G10B10A2] = DXGI_FORMAT_R10G10B10A2_UNORM; + GFXD3D11TextureFormat[GFXFormatD32] = DXGI_FORMAT_UNKNOWN; + GFXD3D11TextureFormat[GFXFormatD24X8] = DXGI_FORMAT_UNKNOWN; + GFXD3D11TextureFormat[GFXFormatD24S8] = DXGI_FORMAT_D24_UNORM_S8_UINT; + GFXD3D11TextureFormat[GFXFormatD24FS8] = DXGI_FORMAT_UNKNOWN; + GFXD3D11TextureFormat[GFXFormatD16] = DXGI_FORMAT_D16_UNORM; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11TextureFilter[GFXTextureFilterNone] = D3D11_FILTER_MIN_MAG_MIP_POINT; + GFXD3D11TextureFilter[GFXTextureFilterPoint] = D3D11_FILTER_MIN_MAG_MIP_POINT; + GFXD3D11TextureFilter[GFXTextureFilterLinear] = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + GFXD3D11TextureFilter[GFXTextureFilterAnisotropic] = D3D11_FILTER_ANISOTROPIC; + GFXD3D11TextureFilter[GFXTextureFilterPyramidalQuad] = D3D11_FILTER_ANISOTROPIC; + GFXD3D11TextureFilter[GFXTextureFilterGaussianQuad] = D3D11_FILTER_ANISOTROPIC; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11Blend[GFXBlendZero] = D3D11_BLEND_ZERO; + GFXD3D11Blend[GFXBlendOne] = D3D11_BLEND_ONE; + GFXD3D11Blend[GFXBlendSrcColor] = D3D11_BLEND_SRC_COLOR; + GFXD3D11Blend[GFXBlendInvSrcColor] = D3D11_BLEND_INV_SRC_COLOR; + GFXD3D11Blend[GFXBlendSrcAlpha] = D3D11_BLEND_SRC_ALPHA; + GFXD3D11Blend[GFXBlendInvSrcAlpha] = D3D11_BLEND_INV_SRC_ALPHA; + GFXD3D11Blend[GFXBlendDestAlpha] = D3D11_BLEND_DEST_ALPHA; + GFXD3D11Blend[GFXBlendInvDestAlpha] = D3D11_BLEND_INV_DEST_ALPHA; + GFXD3D11Blend[GFXBlendDestColor] = D3D11_BLEND_DEST_COLOR; + GFXD3D11Blend[GFXBlendInvDestColor] = D3D11_BLEND_INV_DEST_COLOR; + GFXD3D11Blend[GFXBlendSrcAlphaSat] = D3D11_BLEND_SRC_ALPHA_SAT; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11BlendOp[GFXBlendOpAdd] = D3D11_BLEND_OP_ADD; + GFXD3D11BlendOp[GFXBlendOpSubtract] = D3D11_BLEND_OP_SUBTRACT; + GFXD3D11BlendOp[GFXBlendOpRevSubtract] = D3D11_BLEND_OP_REV_SUBTRACT; + GFXD3D11BlendOp[GFXBlendOpMin] = D3D11_BLEND_OP_MIN; + GFXD3D11BlendOp[GFXBlendOpMax] = D3D11_BLEND_OP_MAX; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11StencilOp[GFXStencilOpKeep] = D3D11_STENCIL_OP_KEEP; + GFXD3D11StencilOp[GFXStencilOpZero] = D3D11_STENCIL_OP_ZERO; + GFXD3D11StencilOp[GFXStencilOpReplace] = D3D11_STENCIL_OP_REPLACE; + GFXD3D11StencilOp[GFXStencilOpIncrSat] = D3D11_STENCIL_OP_INCR_SAT; + GFXD3D11StencilOp[GFXStencilOpDecrSat] = D3D11_STENCIL_OP_DECR_SAT; + GFXD3D11StencilOp[GFXStencilOpInvert] = D3D11_STENCIL_OP_INVERT; + GFXD3D11StencilOp[GFXStencilOpIncr] = D3D11_STENCIL_OP_INCR; + GFXD3D11StencilOp[GFXStencilOpDecr] = D3D11_STENCIL_OP_DECR; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11CmpFunc[GFXCmpNever] = D3D11_COMPARISON_NEVER; + GFXD3D11CmpFunc[GFXCmpLess] = D3D11_COMPARISON_LESS; + GFXD3D11CmpFunc[GFXCmpEqual] = D3D11_COMPARISON_EQUAL; + GFXD3D11CmpFunc[GFXCmpLessEqual] = D3D11_COMPARISON_LESS_EQUAL; + GFXD3D11CmpFunc[GFXCmpGreater] = D3D11_COMPARISON_GREATER; + GFXD3D11CmpFunc[GFXCmpNotEqual] = D3D11_COMPARISON_NOT_EQUAL; + GFXD3D11CmpFunc[GFXCmpGreaterEqual] = D3D11_COMPARISON_GREATER_EQUAL; + GFXD3D11CmpFunc[GFXCmpAlways] = D3D11_COMPARISON_ALWAYS; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11CullMode[GFXCullNone] = D3D11_CULL_NONE; + GFXD3D11CullMode[GFXCullCW] = D3D11_CULL_FRONT; + GFXD3D11CullMode[GFXCullCCW] = D3D11_CULL_BACK; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11FillMode[GFXFillPoint] = D3D11_FILL_SOLID; + GFXD3D11FillMode[GFXFillWireframe] = D3D11_FILL_WIREFRAME; + GFXD3D11FillMode[GFXFillSolid] = D3D11_FILL_SOLID; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11PrimType[GFXPointList] = D3D_PRIMITIVE_TOPOLOGY_POINTLIST; + GFXD3D11PrimType[GFXLineList] = D3D_PRIMITIVE_TOPOLOGY_LINELIST; + GFXD3D11PrimType[GFXLineStrip] = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP; + GFXD3D11PrimType[GFXTriangleList] = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + GFXD3D11PrimType[GFXTriangleStrip] = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11TextureAddress[GFXAddressWrap] = D3D11_TEXTURE_ADDRESS_WRAP; + GFXD3D11TextureAddress[GFXAddressMirror] = D3D11_TEXTURE_ADDRESS_MIRROR; + GFXD3D11TextureAddress[GFXAddressClamp] = D3D11_TEXTURE_ADDRESS_CLAMP; + GFXD3D11TextureAddress[GFXAddressBorder] = D3D11_TEXTURE_ADDRESS_BORDER; + GFXD3D11TextureAddress[GFXAddressMirrorOnce] = D3D11_TEXTURE_ADDRESS_MIRROR_ONCE; +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + GFXD3D11DeclType[GFXDeclType_Float] = DXGI_FORMAT_R32_FLOAT; + GFXD3D11DeclType[GFXDeclType_Float2] = DXGI_FORMAT_R32G32_FLOAT; + GFXD3D11DeclType[GFXDeclType_Float3] = DXGI_FORMAT_R32G32B32_FLOAT; + GFXD3D11DeclType[GFXDeclType_Float4] = DXGI_FORMAT_R32G32B32A32_FLOAT; + GFXD3D11DeclType[GFXDeclType_Color] = DXGI_FORMAT_B8G8R8A8_UNORM; // DXGI_FORMAT_R8G8B8A8_UNORM; +} + diff --git a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.h b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.h new file mode 100644 index 000000000..daede2a1c --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.h @@ -0,0 +1,51 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + + +#ifndef _GFXD3D11ENUMTRANSLATE_H_ +#define _GFXD3D11ENUMTRANSLATE_H_ + +#include "gfx/D3D11/gfxD3D11Shader.h" +#include "gfx/gfxEnums.h" + +//------------------------------------------------------------------------------ + +namespace GFXD3D11EnumTranslate +{ + void init(); +}; + +//------------------------------------------------------------------------------ + +extern DXGI_FORMAT GFXD3D11TextureFormat[GFXFormat_COUNT]; +extern D3D11_FILTER GFXD3D11TextureFilter[GFXTextureFilter_COUNT]; +extern D3D11_BLEND GFXD3D11Blend[GFXBlend_COUNT]; +extern D3D11_BLEND_OP GFXD3D11BlendOp[GFXBlendOp_COUNT]; +extern D3D11_STENCIL_OP GFXD3D11StencilOp[GFXStencilOp_COUNT]; +extern D3D11_COMPARISON_FUNC GFXD3D11CmpFunc[GFXCmp_COUNT]; +extern D3D11_CULL_MODE GFXD3D11CullMode[GFXCull_COUNT]; +extern D3D11_FILL_MODE GFXD3D11FillMode[GFXFill_COUNT]; +extern D3D11_PRIMITIVE_TOPOLOGY GFXD3D11PrimType[GFXPT_COUNT]; +extern D3D11_TEXTURE_ADDRESS_MODE GFXD3D11TextureAddress[GFXAddress_COUNT]; +extern DXGI_FORMAT GFXD3D11DeclType[GFXDeclType_COUNT]; + +#endif \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.cpp b/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.cpp new file mode 100644 index 000000000..6df92c68a --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.cpp @@ -0,0 +1,177 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11OcclusionQuery.h" + +#include "gui/3d/guiTSControl.h" + +#ifdef TORQUE_GATHER_METRICS +// For TickMs define +#include "T3D/gameBase/processList.h" +#endif + +GFXD3D11OcclusionQuery::GFXD3D11OcclusionQuery(GFXDevice *device) + : GFXOcclusionQuery(device), + mQuery(NULL) +{ +#ifdef TORQUE_GATHER_METRICS + mTimer = PlatformTimer::create(); + mTimer->getElapsedMs(); + + mTimeSinceEnd = 0; + mBeginFrame = 0; +#endif +} + +GFXD3D11OcclusionQuery::~GFXD3D11OcclusionQuery() +{ + SAFE_RELEASE(mQuery); + +#ifdef TORQUE_GATHER_METRICS + SAFE_DELETE(mTimer); +#endif +} + +bool GFXD3D11OcclusionQuery::begin() +{ + if(GFXDevice::getDisableOcclusionQuery()) + return true; + + if (mQuery == NULL) + { + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = D3D11_QUERY_OCCLUSION; + queryDesc.MiscFlags = 0; + + HRESULT hRes = D3D11DEVICE->CreateQuery(&queryDesc, &mQuery); + + if(FAILED(hRes)) + { + AssertFatal(false, "GFXD3D11OcclusionQuery::begin - Hardware does not support D3D11 Occlusion-Queries, this should be caught before this type is created"); + } + + AssertISV(hRes != E_OUTOFMEMORY, "GFXD3D11OcclusionQuery::begin - Out of memory"); + } + + // Add a begin marker to the command buffer queue. + D3D11DEVICECONTEXT->Begin(mQuery); + +#ifdef TORQUE_GATHER_METRICS + mBeginFrame = GuiTSCtrl::getFrameCount(); +#endif + + return true; +} + +void GFXD3D11OcclusionQuery::end() +{ + if (GFXDevice::getDisableOcclusionQuery()) + return; + + // Add an end marker to the command buffer queue. + D3D11DEVICECONTEXT->End(mQuery); + +#ifdef TORQUE_GATHER_METRICS + AssertFatal( mBeginFrame == GuiTSCtrl::getFrameCount(), "GFXD3D11OcclusionQuery::end - ended query on different frame than begin!" ); + mTimer->getElapsedMs(); + mTimer->reset(); +#endif +} + +GFXD3D11OcclusionQuery::OcclusionQueryStatus GFXD3D11OcclusionQuery::getStatus(bool block, U32 *data) +{ + // If this ever shows up near the top of a profile then your system is + // GPU bound or you are calling getStatus too soon after submitting it. + // + // To test if you are GPU bound resize your window very small and see if + // this profile no longer appears at the top. + // + // To test if you are calling getStatus to soon after submitting it, + // check the value of mTimeSinceEnd in a debug build. If it is < half the length + // of time to render an individual frame you could have problems. + PROFILE_SCOPE(GFXD3D11OcclusionQuery_getStatus); + + if ( GFXDevice::getDisableOcclusionQuery() ) + return NotOccluded; + + if ( mQuery == NULL ) + return Unset; + +#ifdef TORQUE_GATHER_METRICS + //AssertFatal( mBeginFrame < GuiTSCtrl::getFrameCount(), "GFXD3D11OcclusionQuery::getStatus - called on the same frame as begin!" ); + + //U32 mTimeSinceEnd = mTimer->getElapsedMs(); + //AssertFatal( mTimeSinceEnd >= 5, "GFXD3DOcculsionQuery::getStatus - less than TickMs since called ::end!" ); +#endif + + HRESULT hRes; + U64 dwOccluded = 0; + + if ( block ) + { + while ((hRes = D3D11DEVICECONTEXT->GetData(mQuery, &dwOccluded, sizeof(U64), 0)) == S_FALSE); + } + else + { + hRes = D3D11DEVICECONTEXT->GetData(mQuery, &dwOccluded, sizeof(U64), 0); + } + + if (hRes == S_OK) + { + if (data != NULL) + *data = (U32)dwOccluded; + + return dwOccluded > 0 ? NotOccluded : Occluded; + } + + if (hRes == S_FALSE) + return Waiting; + + return Error; +} + +void GFXD3D11OcclusionQuery::zombify() +{ + SAFE_RELEASE( mQuery ); +} + +void GFXD3D11OcclusionQuery::resurrect() +{ + // Recreate the query + if( mQuery == NULL ) + { + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = D3D11_QUERY_OCCLUSION; + queryDesc.MiscFlags = 0; + + HRESULT hRes = D3D11DEVICE->CreateQuery(&queryDesc, &mQuery); + + AssertISV( hRes != E_OUTOFMEMORY, "GFXD3D9QueryFence::resurrect - Out of memory" ); + } +} + +const String GFXD3D11OcclusionQuery::describeSelf() const +{ + // We've got nothing + return String(); +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.h b/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.h new file mode 100644 index 000000000..9ec3774b9 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.h @@ -0,0 +1,58 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFX_D3D11_OCCLUSIONQUERY_H_ +#define _GFX_D3D11_OCCLUSIONQUERY_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/gfxOcclusionQuery.h" + +#ifdef TORQUE_GATHER_METRICS + #include "platform/platformTimer.h" +#endif + +class GFXD3D11OcclusionQuery : public GFXOcclusionQuery +{ +private: + mutable ID3D11Query *mQuery; + +#ifdef TORQUE_GATHER_METRICS + U32 mBeginFrame; + U32 mTimeSinceEnd; + PlatformTimer *mTimer; +#endif + +public: + GFXD3D11OcclusionQuery(GFXDevice *device); + virtual ~GFXD3D11OcclusionQuery(); + + virtual bool begin(); + virtual void end(); + virtual OcclusionQueryStatus getStatus(bool block, U32 *data = NULL); + + // GFXResource + virtual void zombify(); + virtual void resurrect(); + virtual const String describeSelf() const; +}; + +#endif \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp b/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp new file mode 100644 index 000000000..74e5dbc4e --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp @@ -0,0 +1,222 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "gfx/D3D11/gfxD3D11PrimitiveBuffer.h" +#include "core/util/safeRelease.h" + +void GFXD3D11PrimitiveBuffer::prepare() +{ + D3D11->_setPrimitiveBuffer(this); +} + +void GFXD3D11PrimitiveBuffer::lock(U32 indexStart, U32 indexEnd, void **indexPtr) +{ + AssertFatal(!mLocked, "GFXD3D11PrimitiveBuffer::lock - Can't lock a primitive buffer more than once!"); + + mLocked = true; + D3D11_MAP flags = D3D11_MAP_WRITE_DISCARD; + + switch(mBufferType) + { + case GFXBufferTypeImmutable: + case GFXBufferTypeStatic: + case GFXBufferTypeDynamic: + flags = D3D11_MAP_WRITE_DISCARD; + break; + + case GFXBufferTypeVolatile: + // Get our range now... + AssertFatal(indexStart == 0, "Cannot get a subrange on a volatile buffer."); + AssertFatal(indexEnd < MAX_DYNAMIC_INDICES, "Cannot get more than MAX_DYNAMIC_INDICES in a volatile buffer. Up the constant!"); + + // Get the primtive buffer + mVolatileBuffer = D3D11->mDynamicPB; + + AssertFatal( mVolatileBuffer, "GFXD3D11PrimitiveBuffer::lock - No dynamic primitive buffer was available!"); + + // We created the pool when we requested this volatile buffer, so assume it exists... + if(mVolatileBuffer->mIndexCount + indexEnd > MAX_DYNAMIC_INDICES) + { + flags = D3D11_MAP_WRITE_DISCARD; + mVolatileStart = indexStart = 0; + indexEnd = indexEnd; + } + else + { + flags = D3D11_MAP_WRITE_NO_OVERWRITE; + mVolatileStart = indexStart = mVolatileBuffer->mIndexCount; + indexEnd += mVolatileBuffer->mIndexCount; + } + + mVolatileBuffer->mIndexCount = indexEnd + 1; + ib = mVolatileBuffer->ib; + + break; + } + + + mIndexStart = indexStart; + mIndexEnd = indexEnd; + + if (mBufferType == GFXBufferTypeStatic || mBufferType == GFXBufferTypeImmutable) + { + U32 sizeToLock = (indexEnd - indexStart) * sizeof(U16); + *indexPtr = new U8[sizeToLock]; + mLockedBuffer = *indexPtr; + } + else + { + D3D11_MAPPED_SUBRESOURCE pIndexData; + ZeroMemory(&pIndexData, sizeof(D3D11_MAPPED_SUBRESOURCE)); + + HRESULT hr = D3D11DEVICECONTEXT->Map(ib, 0, flags, 0, &pIndexData); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11PrimitiveBuffer::lock - Could not lock primitive buffer."); + } + + *indexPtr = (U8*)pIndexData.pData + (indexStart * sizeof(U16)) ; + } + + #ifdef TORQUE_DEBUG + + // Allocate a debug buffer large enough for the lock + // plus space for over and under run guard strings. + mLockedSize = (indexEnd - indexStart) * sizeof(U16); + const U32 guardSize = sizeof( _PBGuardString ); + mDebugGuardBuffer = new U8[mLockedSize+(guardSize*2)]; + + // Setup the guard strings. + dMemcpy( mDebugGuardBuffer, _PBGuardString, guardSize ); + dMemcpy( mDebugGuardBuffer + mLockedSize + guardSize, _PBGuardString, guardSize ); + + // Store the real lock pointer and return our debug pointer. + mLockedBuffer = *indexPtr; + *indexPtr = (U16*)( mDebugGuardBuffer + guardSize ); + + #endif // TORQUE_DEBUG +} + +void GFXD3D11PrimitiveBuffer::unlock() +{ + #ifdef TORQUE_DEBUG + + if ( mDebugGuardBuffer ) + { + const U32 guardSize = sizeof( _PBGuardString ); + + // First check the guard areas for overwrites. + AssertFatal( dMemcmp( mDebugGuardBuffer, _PBGuardString, guardSize ) == 0, + "GFXD3D11PrimitiveBuffer::unlock - Caught lock memory underrun!" ); + AssertFatal( dMemcmp( mDebugGuardBuffer + mLockedSize + guardSize, _PBGuardString, guardSize ) == 0, + "GFXD3D11PrimitiveBuffer::unlock - Caught lock memory overrun!" ); + + // Copy the debug content down to the real PB. + dMemcpy( mLockedBuffer, mDebugGuardBuffer + guardSize, mLockedSize ); + + // Cleanup. + delete [] mDebugGuardBuffer; + mDebugGuardBuffer = NULL; + //mLockedBuffer = NULL; + mLockedSize = 0; + } + + #endif // TORQUE_DEBUG + + const U32 totalSize = this->mIndexCount * sizeof(U16); + + if (mBufferType == GFXBufferTypeStatic || mBufferType == GFXBufferTypeImmutable) + { + //set up the update region of the buffer + D3D11_BOX box; + box.back = 1; + box.front = 0; + box.top = 0; + box.bottom =1; + box.left = mIndexStart *sizeof(U16); + box.right = mIndexEnd * sizeof(U16); + //update the real ib buffer + D3D11DEVICECONTEXT->UpdateSubresource(ib, 0, &box,mLockedBuffer,totalSize, 0); + //clean up the old buffer + delete[] mLockedBuffer; + mLockedBuffer = NULL; + } + else + { + D3D11DEVICECONTEXT->Unmap(ib,0); + } + + mLocked = false; + mIsFirstLock = false; + mVolatileBuffer = NULL; +} + +GFXD3D11PrimitiveBuffer::~GFXD3D11PrimitiveBuffer() +{ + if( mBufferType != GFXBufferTypeVolatile ) + { + SAFE_RELEASE(ib); + } +} + +void GFXD3D11PrimitiveBuffer::zombify() +{ + if (mBufferType == GFXBufferTypeStatic || mBufferType == GFXBufferTypeImmutable) + return; + + AssertFatal(!mLocked, "GFXD3D11PrimitiveBuffer::zombify - Cannot zombify a locked buffer!"); + + if (mBufferType == GFXBufferTypeVolatile) + { + // We must null the volatile buffer else we're holding + // a dead pointer which can be set on the device. + ib = NULL; + return; + } + + // Dynamic buffers get released. + SAFE_RELEASE(ib); +} + +void GFXD3D11PrimitiveBuffer::resurrect() +{ + if ( mBufferType != GFXBufferTypeDynamic ) + return; + + D3D11_BUFFER_DESC desc; + desc.ByteWidth = sizeof(U16) * mIndexCount; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &ib); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11PrimitiveBuffer::resurrect - Failed to allocate an index buffer."); + } +} diff --git a/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.h b/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.h new file mode 100644 index 000000000..1be1952d4 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.h @@ -0,0 +1,83 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11PRIMITIVEBUFFER_H_ +#define _GFXD3D11PRIMITIVEBUFFER_H_ + +#include "gfx/gfxPrimitiveBuffer.h" + +class GFXD3D11PrimitiveBuffer : public GFXPrimitiveBuffer +{ +public: + ID3D11Buffer *ib; + StrongRefPtr mVolatileBuffer; + U32 mVolatileStart; + U32 mIndexStart; + U32 mIndexEnd; + +#ifdef TORQUE_DEBUG + #define _PBGuardString "GFX_PRIMTIVE_BUFFER_GUARD_STRING" + U8 *mDebugGuardBuffer; + U32 mLockedSize; +#endif TORQUE_DEBUG + + void *mLockedBuffer; + bool mLocked; + bool mIsFirstLock; + + GFXD3D11PrimitiveBuffer( GFXDevice *device, + U32 indexCount, + U32 primitiveCount, + GFXBufferType bufferType ); + + virtual ~GFXD3D11PrimitiveBuffer(); + + virtual void lock(U32 indexStart, U32 indexEnd, void **indexPtr); + virtual void unlock(); + + virtual void prepare(); + + // GFXResource interface + virtual void zombify(); + virtual void resurrect(); +}; + +inline GFXD3D11PrimitiveBuffer::GFXD3D11PrimitiveBuffer( GFXDevice *device, + U32 indexCount, + U32 primitiveCount, + GFXBufferType bufferType ) + : GFXPrimitiveBuffer( device, indexCount, primitiveCount, bufferType ) +{ + mVolatileStart = 0; + ib = NULL; + mIsFirstLock = true; + mLocked = false; +#ifdef TORQUE_DEBUG + mDebugGuardBuffer = NULL; + mLockedBuffer = NULL; + mLockedSize = 0; + mIndexStart = 0; + mIndexEnd = 0; +#endif +} + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11QueryFence.cpp b/Engine/source/gfx/D3D11/gfxD3D11QueryFence.cpp new file mode 100644 index 000000000..f111ce432 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11QueryFence.cpp @@ -0,0 +1,110 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11QueryFence.h" + +GFXD3D11QueryFence::~GFXD3D11QueryFence() +{ + SAFE_RELEASE(mQuery); +} + +void GFXD3D11QueryFence::issue() +{ + PROFILE_START(GFXD3D11QueryFence_issue); + + // Create the query if we need to + if(mQuery == NULL) + { + D3D11_QUERY_DESC QueryDesc; + QueryDesc.Query = D3D11_QUERY_EVENT; + QueryDesc.MiscFlags = 0; + + HRESULT hRes = D3D11DEVICE->CreateQuery(&QueryDesc, &mQuery); + + if(FAILED(hRes)) + { + AssertFatal(false, "Hardware does not support D3D11 Queries, this should be caught before this fence type is created" ); + } + + AssertISV(hRes != E_OUTOFMEMORY, "Out of memory"); + } + + // Issue the query + D3D11DEVICECONTEXT->End(mQuery); + PROFILE_END(); +} + +GFXFence::FenceStatus GFXD3D11QueryFence::getStatus() const +{ + if(mQuery == NULL) + return GFXFence::Unset; + + HRESULT hRes = D3D11DEVICECONTEXT->GetData(mQuery, NULL, 0, 0); + + return (hRes == S_OK ? GFXFence::Processed : GFXFence::Pending); +} + +void GFXD3D11QueryFence::block() +{ + PROFILE_SCOPE(GFXD3D11QueryFence_block); + + // Calling block() before issue() is valid, catch this case + if( mQuery == NULL ) + return; + + HRESULT hRes; + while((hRes = D3D11DEVICECONTEXT->GetData(mQuery, NULL, 0, 0)) == S_FALSE); //D3DGETDATA_FLUSH + +} + +void GFXD3D11QueryFence::zombify() +{ + // Release our query + SAFE_RELEASE( mQuery ); +} + +void GFXD3D11QueryFence::resurrect() +{ + // Recreate the query + if(mQuery == NULL) + { + D3D11_QUERY_DESC QueryDesc; + QueryDesc.Query = D3D11_QUERY_EVENT; + QueryDesc.MiscFlags = 0; + + HRESULT hRes = D3D11DEVICE->CreateQuery(&QueryDesc, &mQuery); + + if(FAILED(hRes)) + { + AssertFatal(false, "GFXD3D11QueryFence::resurrect - Hardware does not support D3D11 Queries, this should be caught before this fence type is created"); + } + + AssertISV(hRes != E_OUTOFMEMORY, "GFXD3D11QueryFence::resurrect - Out of memory"); + } +} + +const String GFXD3D11QueryFence::describeSelf() const +{ + // We've got nothing + return String(); +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11QueryFence.h b/Engine/source/gfx/D3D11/gfxD3D11QueryFence.h new file mode 100644 index 000000000..5113651c9 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11QueryFence.h @@ -0,0 +1,49 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFX_D3D11_QUERYFENCE_H_ +#define _GFX_D3D11_QUERYFENCE_H_ + +#include "gfx/gfxFence.h" +#include "gfx/gfxResource.h" +#include "gfx/D3D11/gfxD3D11Device.h" + +class GFXD3D11QueryFence : public GFXFence +{ +private: + mutable ID3D11Query *mQuery; + +public: + GFXD3D11QueryFence( GFXDevice *device ) : GFXFence( device ), mQuery( NULL ) {}; + virtual ~GFXD3D11QueryFence(); + + virtual void issue(); + virtual FenceStatus getStatus() const; + virtual void block(); + + // GFXResource interface + virtual void zombify(); + virtual void resurrect(); + virtual const String describeSelf() const; +}; + +#endif \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11Shader.cpp b/Engine/source/gfx/D3D11/gfxD3D11Shader.cpp new file mode 100644 index 000000000..a5273a93e --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Shader.cpp @@ -0,0 +1,1542 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "platform/platform.h" +#include "gfx/D3D11/gfxD3D11Shader.h" +#include "core/frameAllocator.h" +#include "core/stream/fileStream.h" +#include "core/util/safeDelete.h" +#include "console/console.h" + +extern bool gDisassembleAllShaders; + +#pragma comment(lib, "d3dcompiler.lib") + +gfxD3DIncludeRef GFXD3D11Shader::smD3DInclude = NULL; + +class gfxD3D11Include : public ID3DInclude, public StrongRefBase +{ +private: + + Vector mLastPath; + +public: + + void setPath(const String &path) + { + mLastPath.clear(); + mLastPath.push_back(path); + } + + gfxD3D11Include() {} + virtual ~gfxD3D11Include() {} + + STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes); + STDMETHOD(Close)(THIS_ LPCVOID pData); +}; + +HRESULT gfxD3D11Include::Open(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) +{ + using namespace Torque; + // First try making the path relative to the parent. + Torque::Path path = Torque::Path::Join( mLastPath.last(), '/', pFileName ); + path = Torque::Path::CompressPath( path ); + + if ( !Torque::FS::ReadFile( path, (void *&)*ppData, *pBytes, true ) ) + { + // Ok... now try using the path as is. + path = String( pFileName ); + path = Torque::Path::CompressPath( path ); + + if ( !Torque::FS::ReadFile( path, (void *&)*ppData, *pBytes, true ) ) + { + AssertISV(false, avar( "Failed to open include '%s'.", pFileName)); + return E_FAIL; + } + } + + // If the data was of zero size then we cannot recurse + // into this file and DX won't call Close() below. + // + // So in this case don't push on the path. + if ( *pBytes > 0 ) + mLastPath.push_back( path.getRootAndPath() ); + + return S_OK; +} + +HRESULT gfxD3D11Include::Close( THIS_ LPCVOID pData ) +{ + // Free the data file and pop its path off the stack. + delete [] (U8*)pData; + mLastPath.pop_back(); + + return S_OK; +} + +GFXD3D11ShaderConstHandle::GFXD3D11ShaderConstHandle() +{ + clear(); +} + +const String& GFXD3D11ShaderConstHandle::getName() const +{ + if ( mVertexConstant ) + return mVertexHandle.name; + else + return mPixelHandle.name; +} + +GFXShaderConstType GFXD3D11ShaderConstHandle::getType() const +{ + if ( mVertexConstant ) + return mVertexHandle.constType; + else + return mPixelHandle.constType; +} + +U32 GFXD3D11ShaderConstHandle::getArraySize() const +{ + if ( mVertexConstant ) + return mVertexHandle.arraySize; + else + return mPixelHandle.arraySize; +} + +S32 GFXD3D11ShaderConstHandle::getSamplerRegister() const +{ + if ( !mValid || !isSampler() ) + return -1; + + // We always store sampler type and register index in the pixelHandle, + // sampler registers are shared between vertex and pixel shaders anyway. + + return mPixelHandle.offset; +} + +GFXD3D11ConstBufferLayout::GFXD3D11ConstBufferLayout() +{ + mSubBuffers.reserve(CBUFFER_MAX); +} + +bool GFXD3D11ConstBufferLayout::set(const ParamDesc& pd, const GFXShaderConstType constType, const U32 inSize, const void* data, U8* basePointer) +{ + PROFILE_SCOPE(GenericConstBufferLayout_set); + S32 size = inSize; + // Shader compilers like to optimize float4x4 uniforms into float3x3s. + // So long as the real paramater is a matrix of-some-type and the data + // passed in is a MatrixF ( which is will be ), we DO NOT have a + // mismatched const type. + AssertFatal(pd.constType == constType || + ( + (pd.constType == GFXSCT_Float2x2 || + pd.constType == GFXSCT_Float3x3 || + pd.constType == GFXSCT_Float4x4) && + (constType == GFXSCT_Float2x2 || + constType == GFXSCT_Float3x3 || + constType == GFXSCT_Float4x4) + ), "Mismatched const type!"); + + // This "cute" bit of code allows us to support 2x3 and 3x3 matrices in shader constants but use our MatrixF class. Yes, a hack. -BTR + switch (pd.constType) + { + case GFXSCT_Float2x2: + case GFXSCT_Float3x3: + case GFXSCT_Float4x4: + return setMatrix(pd, constType, size, data, basePointer); + break; + // TODO add other AlignedVector here + case GFXSCT_Float2: + if (size > sizeof(Point2F)) + size = pd.size; + default: + break; + } + + AssertFatal(pd.size >= size, "Not enough room in the buffer for this data!"); + + // Ok, we only set data if it's different than the data we already have, this maybe more expensive than just setting the data, but + // we'll have to do some timings to see. For example, the lighting shader constants rarely change, but we can't assume that at the + // renderInstMgr level, but we can check down here. -BTR + if (dMemcmp(basePointer + pd.offset, data, size) != 0) + { + dMemcpy(basePointer + pd.offset, data, size); + return true; + } + return false; +} + +bool GFXD3D11ConstBufferLayout::setMatrix(const ParamDesc& pd, const GFXShaderConstType constType, const U32 size, const void* data, U8* basePointer) +{ + PROFILE_SCOPE(GFXD3D11ConstBufferLayout_setMatrix); + + if (pd.constType == GFXSCT_Float4x4) + { + // Special case, we can just blast this guy. + AssertFatal(pd.size >= size, "Not enough room in the buffer for this data!"); + if (dMemcmp(basePointer+pd.offset, data, size) != 0) + { + dMemcpy(basePointer+pd.offset, data, size); + return true; + } + + return false; + } + else + { + PROFILE_SCOPE(GFXD3D11ConstBufferLayout_setMatrix_not4x4); + + // Figure out how big of a chunk we are copying. We're going to copy 4 columns by N rows of data + U32 csize; + switch (pd.constType) + { + case GFXSCT_Float2x2 : + csize = 24; //this takes up 16+8 + break; + case GFXSCT_Float3x3 : + csize = 44; //This takes up 16+16+12 + break; + default: + AssertFatal(false, "Unhandled case!"); + return false; + break; + } + + // Loop through and copy + bool ret = false; + U8* currDestPointer = basePointer+pd.offset; + const U8* currSourcePointer = static_cast(data); + const U8* endData = currSourcePointer + size; + while (currSourcePointer < endData) + { + if (dMemcmp(currDestPointer, currSourcePointer, csize) != 0) + { + dMemcpy(currDestPointer, currSourcePointer, csize); + ret = true; + } + + currDestPointer += csize; + currSourcePointer += sizeof(MatrixF); + } + + return ret; + } +} + +//------------------------------------------------------------------------------ +GFXD3D11ShaderConstBuffer::GFXD3D11ShaderConstBuffer( GFXD3D11Shader* shader, + GFXD3D11ConstBufferLayout* vertexLayout, + GFXD3D11ConstBufferLayout* pixelLayout) +{ + AssertFatal( shader, "GFXD3D11ShaderConstBuffer() - Got a null shader!" ); + + // We hold on to this so we don't have to call + // this virtual method during activation. + mShader = shader; + + for (U32 i = 0; i < CBUFFER_MAX; ++i) + { + mConstantBuffersV[i] = NULL; + mConstantBuffersP[i] = NULL; + } + + // TODO: Remove buffers and layouts that don't exist for performance? + //Mandatory + mVertexConstBufferLayout = vertexLayout; + mVertexConstBuffer = new GenericConstBuffer(vertexLayout); + + mPixelConstBufferLayout = pixelLayout; + mPixelConstBuffer = new GenericConstBuffer(pixelLayout); + + _createBuffers(); + +} + +GFXD3D11ShaderConstBuffer::~GFXD3D11ShaderConstBuffer() +{ + // release constant buffer + for (U32 i = 0; i < CBUFFER_MAX; ++i) + { + SAFE_RELEASE(mConstantBuffersP[i]); + SAFE_RELEASE(mConstantBuffersV[i]); + } + + SAFE_DELETE(mVertexConstBuffer); + SAFE_DELETE(mPixelConstBuffer); + + + if ( mShader ) + mShader->_unlinkBuffer( this ); +} + +void GFXD3D11ShaderConstBuffer::_createBuffers() +{ + HRESULT hr; + // Create a vertex constant buffer + if (mVertexConstBufferLayout->getBufferSize() > 0) + { + const Vector &subBuffers = mVertexConstBufferLayout->getSubBufferDesc(); + for (U32 i = 0; i < subBuffers.size(); ++i) + { + D3D11_BUFFER_DESC cbDesc; + cbDesc.ByteWidth = subBuffers[i].size; + cbDesc.Usage = D3D11_USAGE_DEFAULT; + cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + cbDesc.CPUAccessFlags = 0; + cbDesc.MiscFlags = 0; + cbDesc.StructureByteStride = 0; + + hr = D3D11DEVICE->CreateBuffer(&cbDesc, NULL, &mConstantBuffersV[i]); + + if (FAILED(hr)) + { + AssertFatal(false, "can't create constant mConstantBuffersV!"); + } + } + } + + // Create a pixel constant buffer + if (mPixelConstBufferLayout->getBufferSize()) + { + const Vector &subBuffers = mPixelConstBufferLayout->getSubBufferDesc(); + for (U32 i = 0; i < subBuffers.size(); ++i) + { + // Create a pixel float constant buffer + D3D11_BUFFER_DESC cbDesc; + cbDesc.ByteWidth = subBuffers[i].size; + cbDesc.Usage = D3D11_USAGE_DEFAULT; + cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + cbDesc.CPUAccessFlags = 0; + cbDesc.MiscFlags = 0; + cbDesc.StructureByteStride = 0; + + hr = D3D11DEVICE->CreateBuffer(&cbDesc, NULL, &mConstantBuffersP[i]); + + if (FAILED(hr)) + { + AssertFatal(false, "can't create constant mConstantBuffersP!"); + } + } + } +} + +GFXShader* GFXD3D11ShaderConstBuffer::getShader() +{ + return mShader; +} + +// This is kind of cheesy, but I don't think templates would work well here because +// these functions potentially need to be handled differently by other derived types +template +inline void GFXD3D11ShaderConstBuffer::SET_CONSTANT( GFXShaderConstHandle* handle, const T& fv, + GenericConstBuffer *vBuffer, GenericConstBuffer *pBuffer ) +{ + AssertFatal(static_cast(handle), "Incorrect const buffer type!"); + const GFXD3D11ShaderConstHandle* h = static_cast(handle); + AssertFatal(h, "Handle is NULL!" ); + AssertFatal(h->isValid(), "Handle is not valid!" ); + AssertFatal(!h->isSampler(), "Handle is sampler constant!" ); + AssertFatal(!mShader.isNull(), "Buffer's shader is null!" ); + AssertFatal(!h->mShader.isNull(), "Handle's shader is null!" ); + AssertFatal(h->mShader.getPointer() == mShader.getPointer(), "Mismatched shaders!"); + + if ( h->mInstancingConstant ) + { + dMemcpy( mInstPtr+h->mPixelHandle.offset, &fv, sizeof( fv ) ); + return; + } + if (h->mVertexConstant) + vBuffer->set(h->mVertexHandle, fv); + if (h->mPixelConstant) + pBuffer->set(h->mPixelHandle, fv); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const F32 fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2F& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3F& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4F& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const PlaneF& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const ColorF& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const S32 f) +{ + // This is the only type that is allowed to be used + // with a sampler shader constant type, but it is only + // allowed to be set from GLSL. + // + // So we ignore it here... all other cases will assert. + // + if ( ((GFXD3D11ShaderConstHandle*)handle)->isSampler() ) + return; + + SET_CONSTANT(handle, f, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2I& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3I& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4I& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray& fv) +{ + SET_CONSTANT(handle, fv, mVertexConstBuffer, mPixelConstBuffer); +} +#undef SET_CONSTANT + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matrixType) +{ + AssertFatal(handle, "Handle is NULL!" ); + AssertFatal(handle->isValid(), "Handle is not valid!" ); + + AssertFatal(static_cast(handle), "Incorrect const buffer type!"); + const GFXD3D11ShaderConstHandle* h = static_cast(handle); + AssertFatal(!h->isSampler(), "Handle is sampler constant!" ); + AssertFatal(h->mShader == mShader, "Mismatched shaders!"); + + MatrixF transposed; + mat.transposeTo(transposed); + + if (h->mInstancingConstant) + { + if ( matrixType == GFXSCT_Float4x4 ) + dMemcpy( mInstPtr+h->mPixelHandle.offset, mat, sizeof( mat ) ); + + // TODO: Support 3x3 and 2x2 matricies? + return; + } + + if (h->mVertexConstant) + mVertexConstBuffer->set(h->mVertexHandle, transposed, matrixType); + if (h->mPixelConstant) + mPixelConstBuffer->set(h->mPixelHandle, transposed, matrixType); +} + +void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType) +{ + AssertFatal(handle, "Handle is NULL!" ); + AssertFatal(handle->isValid(), "Handle is not valid!" ); + + AssertFatal(static_cast(handle), "Incorrect const buffer type!"); + const GFXD3D11ShaderConstHandle* h = static_cast(handle); + AssertFatal(!h->isSampler(), "Handle is sampler constant!" ); + AssertFatal(h->mShader == mShader, "Mismatched shaders!"); + + static Vector transposed; + if (arraySize > transposed.size()) + transposed.setSize(arraySize); + for (U32 i = 0; i < arraySize; i++) + mat[i].transposeTo(transposed[i]); + + // TODO: Maybe support this in the future? + if (h->mInstancingConstant) + return; + + if (h->mVertexConstant) + mVertexConstBuffer->set(h->mVertexHandle, transposed.begin(), arraySize, matrixType); + if (h->mPixelConstant) + mPixelConstBuffer->set(h->mPixelHandle, transposed.begin(), arraySize, matrixType); +} + +const String GFXD3D11ShaderConstBuffer::describeSelf() const +{ + String ret; + ret = String(" GFXD3D11ShaderConstBuffer\n"); + + for (U32 i = 0; i < mVertexConstBufferLayout->getParameterCount(); i++) + { + GenericConstBufferLayout::ParamDesc pd; + mVertexConstBufferLayout->getDesc(i, pd); + + ret += String::ToString(" Constant name: %s", pd.name); + } + + return ret; +} + +void GFXD3D11ShaderConstBuffer::zombify() +{ +} + +void GFXD3D11ShaderConstBuffer::resurrect() +{ +} + +bool GFXD3D11ShaderConstBuffer::isDirty() +{ + bool ret = mVertexConstBuffer->isDirty(); + ret |= mPixelConstBuffer->isDirty(); + + return ret; +} + +void GFXD3D11ShaderConstBuffer::activate( GFXD3D11ShaderConstBuffer *prevShaderBuffer ) +{ + PROFILE_SCOPE(GFXD3D11ShaderConstBuffer_activate); + + // NOTE: This is a really critical function as it gets + // called between every draw call to update the constants. + // + // Alot of the calls here are inlined... be careful + // what you change. + + // If the buffer has changed we need to compare it + // with the new buffer to see if we can skip copying + // equal buffer content. + // + // If the buffer hasn't changed then we only will + // be copying the changes that have occured since + // the last activate call. + if ( prevShaderBuffer != this ) + { + // If the previous buffer is dirty, than we can't compare + // against it, because it hasn't sent its contents to the + // card yet and must be copied. + if ( prevShaderBuffer && !prevShaderBuffer->isDirty() ) + { + PROFILE_SCOPE(GFXD3D11ShaderConstBuffer_activate_dirty_check_1); + // If the buffer content is equal then we set the dirty + // flag to false knowing the current state of the card matches + // the new buffer. + // + // If the content is not equal we set the dirty flag to + // true which causes the full content of the buffer to be + // copied to the card. + // + mVertexConstBuffer->setDirty( !prevShaderBuffer->mVertexConstBuffer->isEqual( mVertexConstBuffer ) ); + mPixelConstBuffer->setDirty( !prevShaderBuffer->mPixelConstBuffer->isEqual( mPixelConstBuffer ) ); + } + else + { + // This happens rarely... but it can happen. + // We copy the entire dirty state to the card. + PROFILE_SCOPE(GFXD3D11ShaderConstBuffer_activate_dirty_check_2); + + mVertexConstBuffer->setDirty( true ); + mPixelConstBuffer->setDirty( true ); + } + } + + ID3D11DeviceContext* devCtx = D3D11DEVICECONTEXT; + + D3D11_MAPPED_SUBRESOURCE pConstData; + ZeroMemory(&pConstData, sizeof(D3D11_MAPPED_SUBRESOURCE)); + + const U8* buf; + HRESULT hr; + U32 nbBuffers = 0; + if(mVertexConstBuffer->isDirty()) + { + const Vector &subBuffers = mVertexConstBufferLayout->getSubBufferDesc(); + // TODO: This is not very effecient updating the whole lot, re-implement the dirty system to work with multiple constant buffers. + // TODO: Implement DX 11.1 UpdateSubresource1 which supports updating ranges with constant buffers + buf = mVertexConstBuffer->getEntireBuffer(); + for (U32 i = 0; i < subBuffers.size(); ++i) + { + const ConstSubBufferDesc &desc = subBuffers[i]; + devCtx->UpdateSubresource(mConstantBuffersV[i], 0, NULL, buf + desc.start, desc.size, 0); + nbBuffers++; + } + + devCtx->VSSetConstantBuffers(0, nbBuffers, mConstantBuffersV); + } + + nbBuffers = 0; + + if(mPixelConstBuffer->isDirty()) + { + const Vector &subBuffers = mPixelConstBufferLayout->getSubBufferDesc(); + // TODO: This is not very effecient updating the whole lot, re-implement the dirty system to work with multiple constant buffers. + // TODO: Implement DX 11.1 UpdateSubresource1 which supports updating ranges with constant buffers + buf = mPixelConstBuffer->getEntireBuffer(); + for (U32 i = 0; i < subBuffers.size(); ++i) + { + const ConstSubBufferDesc &desc = subBuffers[i]; + devCtx->UpdateSubresource(mConstantBuffersP[i], 0, NULL, buf + desc.start, desc.size, 0); + nbBuffers++; + } + + devCtx->PSSetConstantBuffers(0, nbBuffers, mConstantBuffersP); + } + + #ifdef TORQUE_DEBUG + // Make sure all the constants for this buffer were assigned. + if(mWasLost) + { + mVertexConstBuffer->assertUnassignedConstants( mShader->getVertexShaderFile().c_str() ); + mPixelConstBuffer->assertUnassignedConstants( mShader->getPixelShaderFile().c_str() ); + } + #endif + + // Clear the lost state. + mWasLost = false; +} + +void GFXD3D11ShaderConstBuffer::onShaderReload( GFXD3D11Shader *shader ) +{ + AssertFatal( shader == mShader, "GFXD3D11ShaderConstBuffer::onShaderReload is hosed!" ); + + // release constant buffers + for (U32 i = 0; i < CBUFFER_MAX; ++i) + { + SAFE_RELEASE(mConstantBuffersP[i]); + SAFE_RELEASE(mConstantBuffersV[i]); + } + + SAFE_DELETE( mVertexConstBuffer ); + SAFE_DELETE( mPixelConstBuffer ); + + AssertFatal( mVertexConstBufferLayout == shader->mVertexConstBufferLayout, "GFXD3D11ShaderConstBuffer::onShaderReload is hosed!" ); + AssertFatal( mPixelConstBufferLayout == shader->mPixelConstBufferLayout, "GFXD3D11ShaderConstBuffer::onShaderReload is hosed!" ); + + mVertexConstBuffer = new GenericConstBuffer( mVertexConstBufferLayout ); + mPixelConstBuffer = new GenericConstBuffer( mPixelConstBufferLayout ); + + _createBuffers(); + + // Set the lost state. + mWasLost = true; +} + +//------------------------------------------------------------------------------ + +GFXD3D11Shader::GFXD3D11Shader() +{ + VECTOR_SET_ASSOCIATION( mShaderConsts ); + + AssertFatal(D3D11DEVICE, "Invalid device for shader."); + mVertShader = NULL; + mPixShader = NULL; + mVertexConstBufferLayout = NULL; + mPixelConstBufferLayout = NULL; + + if( smD3DInclude == NULL ) + smD3DInclude = new gfxD3D11Include; +} + +//------------------------------------------------------------------------------ + +GFXD3D11Shader::~GFXD3D11Shader() +{ + for (HandleMap::Iterator i = mHandles.begin(); i != mHandles.end(); i++) + delete i->value; + + // delete const buffer layouts + SAFE_DELETE(mVertexConstBufferLayout); + SAFE_DELETE(mPixelConstBufferLayout); + + // release shaders + SAFE_RELEASE(mVertShader); + SAFE_RELEASE(mPixShader); + //maybe add SAFE_RELEASE(mVertexCode) ? +} + +bool GFXD3D11Shader::_init() +{ + PROFILE_SCOPE( GFXD3D11Shader_Init ); + + SAFE_RELEASE(mVertShader); + SAFE_RELEASE(mPixShader); + + // Create the macro array including the system wide macros. + const U32 macroCount = smGlobalMacros.size() + mMacros.size() + 2; + FrameTemp d3dMacros( macroCount ); + + for ( U32 i=0; i < smGlobalMacros.size(); i++ ) + { + d3dMacros[i].Name = smGlobalMacros[i].name.c_str(); + d3dMacros[i].Definition = smGlobalMacros[i].value.c_str(); + } + + for ( U32 i=0; i < mMacros.size(); i++ ) + { + d3dMacros[i+smGlobalMacros.size()].Name = mMacros[i].name.c_str(); + d3dMacros[i+smGlobalMacros.size()].Definition = mMacros[i].value.c_str(); + } + + //TODO support D3D_FEATURE_LEVEL properly with shaders instead of hard coding at hlsl 5 + d3dMacros[macroCount - 2].Name = "TORQUE_SM"; + d3dMacros[macroCount - 2].Definition = "50"; + + memset(&d3dMacros[macroCount - 1], 0, sizeof(D3D_SHADER_MACRO)); + + if ( !mVertexConstBufferLayout ) + mVertexConstBufferLayout = new GFXD3D11ConstBufferLayout(); + else + mVertexConstBufferLayout->clear(); + + if ( !mPixelConstBufferLayout ) + mPixelConstBufferLayout = new GFXD3D11ConstBufferLayout(); + else + mPixelConstBufferLayout->clear(); + + + mSamplerDescriptions.clear(); + mShaderConsts.clear(); + + if ( !Con::getBoolVariable( "$shaders::forceLoadCSF", false ) ) + { + if (!mVertexFile.isEmpty() && !_compileShader( mVertexFile, "vs_5_0", d3dMacros, mVertexConstBufferLayout, mSamplerDescriptions ) ) + return false; + + if (!mPixelFile.isEmpty() && !_compileShader( mPixelFile, "ps_5_0", d3dMacros, mPixelConstBufferLayout, mSamplerDescriptions ) ) + return false; + + } + else + { + if ( !_loadCompiledOutput( mVertexFile, "vs_5_0", mVertexConstBufferLayout, mSamplerDescriptions ) ) + { + if ( smLogErrors ) + Con::errorf( "GFXD3D11Shader::init - Unable to load precompiled vertex shader for '%s'.", mVertexFile.getFullPath().c_str() ); + + return false; + } + + if ( !_loadCompiledOutput( mPixelFile, "ps_5_0", mPixelConstBufferLayout, mSamplerDescriptions ) ) + { + if ( smLogErrors ) + Con::errorf( "GFXD3D11Shader::init - Unable to load precompiled pixel shader for '%s'.", mPixelFile.getFullPath().c_str() ); + + return false; + } + } + + // Existing handles are resored to an uninitialized state. + // Those that are found when parsing the layout parameters + // will then be re-initialized. + HandleMap::Iterator iter = mHandles.begin(); + for ( ; iter != mHandles.end(); iter++ ) + (iter->value)->clear(); + + _buildShaderConstantHandles(mVertexConstBufferLayout, true); + _buildShaderConstantHandles(mPixelConstBufferLayout, false); + + _buildSamplerShaderConstantHandles( mSamplerDescriptions ); + _buildInstancingShaderConstantHandles(); + + // Notify any existing buffers that the buffer + // layouts have changed and they need to update. + Vector::iterator biter = mActiveBuffers.begin(); + for ( ; biter != mActiveBuffers.end(); biter++ ) + ((GFXD3D11ShaderConstBuffer*)(*biter))->onShaderReload( this ); + + return true; +} + +bool GFXD3D11Shader::_compileShader( const Torque::Path &filePath, + const String& target, + const D3D_SHADER_MACRO *defines, + GenericConstBufferLayout* bufferLayout, + Vector &samplerDescriptions ) +{ + PROFILE_SCOPE( GFXD3D11Shader_CompileShader ); + + using namespace Torque; + + HRESULT res = E_FAIL; + ID3DBlob* code = NULL; + ID3DBlob* errorBuff = NULL; + ID3D11ShaderReflection* reflectionTable = NULL; + +#ifdef TORQUE_DEBUG + U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS; +#else + U32 flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_OPTIMIZATION_LEVEL3; //TODO double check load times with D3DCOMPILE_OPTIMIZATION_LEVEL3 + //recommended flags for NSight, uncomment to use. NSight should be used in release mode only. *Still works with above flags however + //flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PREFER_FLOW_CONTROL | D3DCOMPILE_SKIP_OPTIMIZATION; +#endif + +#ifdef D3D11_DEBUG_SPEW + Con::printf( "Compiling Shader: '%s'", filePath.getFullPath().c_str() ); +#endif + + // Is it an HLSL shader? + if(filePath.getExtension().equal("hlsl", String::NoCase)) + { + // Set this so that the D3DInclude::Open will have this + // information for relative paths. + smD3DInclude->setPath(filePath.getRootAndPath()); + + FileStream s; + if (!s.open(filePath, Torque::FS::File::Read)) + { + AssertISV(false, avar("GFXD3D11Shader::initShader - failed to open shader '%s'.", filePath.getFullPath().c_str())); + + if ( smLogErrors ) + Con::errorf( "GFXD3D11Shader::_compileShader - Failed to open shader file '%s'.", filePath.getFullPath().c_str() ); + + return false; + } + + // Convert the path which might have virtualized + // mount paths to a real file system path. + Torque::Path realPath; + if (!FS::GetFSPath( filePath, realPath)) + realPath = filePath; + + U32 bufSize = s.getStreamSize(); + + FrameAllocatorMarker fam; + char *buffer = NULL; + + buffer = (char*)fam.alloc(bufSize + 1); + s.read(bufSize, buffer); + buffer[bufSize] = 0; + + res = D3DCompile(buffer, bufSize, realPath.getFullPath().c_str(), defines, smD3DInclude, "main", target, flags, 0, &code, &errorBuff); + + } + + // Is it a precompiled obj shader? + else if(filePath.getExtension().equal("obj", String::NoCase)) + { + FileStream s; + if(!s.open(filePath, Torque::FS::File::Read)) + { + AssertISV(false, avar("GFXD3D11Shader::initShader - failed to open shader '%s'.", filePath.getFullPath().c_str())); + + if ( smLogErrors ) + Con::errorf( "GFXD3D11Shader::_compileShader - Failed to open shader file '%s'.", filePath.getFullPath().c_str() ); + + return false; + } + + res = D3DCreateBlob(s.getStreamSize(), &code); + AssertISV(SUCCEEDED(res), "Unable to create buffer!"); + s.read(s.getStreamSize(), code->GetBufferPointer()); + } + else + { + if (smLogErrors) + Con::errorf("GFXD3D11Shader::_compileShader - Unsupported shader file type '%s'.", filePath.getFullPath().c_str()); + + return false; + } + + if(errorBuff) + { + // remove \n at end of buffer + U8 *buffPtr = (U8*) errorBuff->GetBufferPointer(); + U32 len = dStrlen( (const char*) buffPtr ); + buffPtr[len-1] = '\0'; + + if(FAILED(res)) + { + if(smLogErrors) + Con::errorf("failed to compile shader: %s", buffPtr); + } + else + { + if(smLogWarnings) + Con::errorf("shader compiled with warning(s): %s", buffPtr); + } + } + else if (code == NULL && smLogErrors) + Con::errorf( "GFXD3D11Shader::_compileShader - no compiled code produced; possibly missing file '%s'.", filePath.getFullPath().c_str() ); + + AssertISV(SUCCEEDED(res), "Unable to compile shader!"); + + if(code != NULL) + { +#ifndef TORQUE_SHIPPING + + if(gDisassembleAllShaders) + { + ID3DBlob* disassem = NULL; + D3DDisassemble(code->GetBufferPointer(), code->GetBufferSize(), 0, NULL, &disassem); + mDissasembly = (const char*)disassem->GetBufferPointer(); + + String filename = filePath.getFullPath(); + filename.replace( ".hlsl", "_dis.txt" ); + + FileStream *fstream = FileStream::createAndOpen( filename, Torque::FS::File::Write ); + if ( fstream ) + { + fstream->write( mDissasembly ); + fstream->close(); + delete fstream; + } + + SAFE_RELEASE(disassem); + } + +#endif + + if (target.compare("ps_", 3) == 0) + res = D3D11DEVICE->CreatePixelShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mPixShader); + else if (target.compare("vs_", 3) == 0) + res = D3D11DEVICE->CreateVertexShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mVertShader); + + if (FAILED(res)) + { + AssertFatal(false, "D3D11Shader::_compilershader- failed to create shader"); + } + + if(res == S_OK){ + HRESULT reflectionResult = D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&reflectionTable); + if(FAILED(reflectionResult)) + AssertFatal(false, "D3D11Shader::_compilershader - Failed to get shader reflection table interface"); + } + + if(res == S_OK) + _getShaderConstants(reflectionTable, bufferLayout, samplerDescriptions); + +#ifdef TORQUE_ENABLE_CSF_GENERATION + + // Ok, we've got a valid shader and constants, let's write them all out. + if (!_saveCompiledOutput(filePath, code, bufferLayout) && smLogErrors) + Con::errorf( "GFXD3D11Shader::_compileShader - Unable to save shader compile output for: %s", + filePath.getFullPath().c_str()); +#endif + + if(FAILED(res) && smLogErrors) + Con::errorf("GFXD3D11Shader::_compileShader - Unable to create shader for '%s'.", filePath.getFullPath().c_str()); + } + + //bool result = code && SUCCEEDED(res) && HasValidConstants; + bool result = code && SUCCEEDED(res); + +#ifdef TORQUE_DEBUG + if (target.compare("vs_", 3) == 0) + { + String vertShader = mVertexFile.getFileName(); + mVertShader->SetPrivateData(WKPDID_D3DDebugObjectName, vertShader.size(), vertShader.c_str()); + } + else if (target.compare("ps_", 3) == 0) + { + String pixelShader = mPixelFile.getFileName(); + mPixShader->SetPrivateData(WKPDID_D3DDebugObjectName, pixelShader.size(), pixelShader.c_str()); + } +#endif + + SAFE_RELEASE(code); + SAFE_RELEASE(reflectionTable); + SAFE_RELEASE(errorBuff); + + return result; +} +void GFXD3D11Shader::_getShaderConstants( ID3D11ShaderReflection *table, + GenericConstBufferLayout *bufferLayoutIn, + Vector &samplerDescriptions ) +{ + PROFILE_SCOPE( GFXD3D11Shader_GetShaderConstants ); + + AssertFatal(table, "NULL constant table not allowed, is this an assembly shader?"); + + GFXD3D11ConstBufferLayout *bufferLayout = (GFXD3D11ConstBufferLayout*)bufferLayoutIn; + Vector &subBuffers = bufferLayout->getSubBufferDesc(); + subBuffers.clear(); + + D3D11_SHADER_DESC tableDesc; + HRESULT hr = table->GetDesc(&tableDesc); + if (FAILED(hr)) + { + AssertFatal(false, "Shader Reflection table unable to be created"); + } + + //offset for sub constant buffers + U32 bufferOffset = 0; + for (U32 i = 0; i < tableDesc.ConstantBuffers; i++) + { + ID3D11ShaderReflectionConstantBuffer* constantBuffer = table->GetConstantBufferByIndex(i); + D3D11_SHADER_BUFFER_DESC constantBufferDesc; + + if (constantBuffer->GetDesc(&constantBufferDesc) == S_OK) + { + + #ifdef TORQUE_DEBUG + AssertFatal(constantBufferDesc.Type == D3D_CT_CBUFFER, "Only scalar cbuffers supported for now."); + + if (dStrcmp(constantBufferDesc.Name, "$Globals") != 0 && dStrcmp(constantBufferDesc.Name, "$Params") != 0) + AssertFatal(false, "Only $Global and $Params cbuffer supported for now."); + #endif + #ifdef D3D11_DEBUG_SPEW + Con::printf("Constant Buffer Name: %s", constantBufferDesc.Name); + #endif + + for(U32 j =0; j< constantBufferDesc.Variables; j++) + { + GFXShaderConstDesc desc; + ID3D11ShaderReflectionVariable* variable = constantBuffer->GetVariableByIndex(j); + D3D11_SHADER_VARIABLE_DESC variableDesc; + D3D11_SHADER_TYPE_DESC variableTypeDesc; + + variable->GetDesc(&variableDesc); + + ID3D11ShaderReflectionType* variableType =variable->GetType(); + + variableType->GetDesc(&variableTypeDesc); + desc.name = String(variableDesc.Name); + // Prepend a "$" if it doesn't exist. Just to make things consistent. + if (desc.name.find("$") != 0) + desc.name = String::ToString("$%s", desc.name.c_str()); + + bool unusedVar = variableDesc.uFlags & D3D_SVF_USED ? false : true; + + if (variableTypeDesc.Elements == 0) + desc.arraySize = 1; + else + desc.arraySize = variableTypeDesc.Elements; + + #ifdef D3D11_DEBUG_SPEW + Con::printf("Variable Name %s:, offset: %d, size: %d, constantDesc.Elements: %d", desc.name.c_str(), variableDesc.StartOffset, variableDesc.Size, desc.arraySize); + #endif + if (_convertShaderVariable(variableTypeDesc, desc)) + { + //The HLSL compiler for 4.0 and above doesn't strip out unused registered constants. We'll have to do it manually + if (!unusedVar) + { + mShaderConsts.push_back(desc); + U32 alignBytes = getAlignmentValue(desc.constType); + U32 paramSize = variableDesc.Size; + bufferLayout->addParameter( desc.name, + desc.constType, + variableDesc.StartOffset + bufferOffset, + paramSize, + desc.arraySize, + alignBytes); + + } //unusedVar + } //_convertShaderVariable + } //constantBufferDesc.Variables + + // fill out our const sub buffer sizes etc + ConstSubBufferDesc subBufferDesc; + subBufferDesc.size = constantBufferDesc.Size; + subBufferDesc.start = bufferOffset; + subBuffers.push_back(subBufferDesc); + // increase our bufferOffset by the constant buffer size + bufferOffset += constantBufferDesc.Size; + + } + else + AssertFatal(false, "Unable to get shader constant description! (may need more elements of constantDesc"); + } + + // Set buffer size to the aligned size + bufferLayout->setSize(bufferOffset); + + + //get the sampler descriptions from the resource binding description + U32 resourceCount = tableDesc.BoundResources; + for (U32 i = 0; i < resourceCount; i++) + { + GFXShaderConstDesc desc; + D3D11_SHADER_INPUT_BIND_DESC bindDesc; + table->GetResourceBindingDesc(i, &bindDesc); + + switch (bindDesc.Type) + { + case D3D_SIT_SAMPLER: + // Prepend a "$" if it doesn't exist. Just to make things consistent. + desc.name = String(bindDesc.Name); + if (desc.name.find("$") != 0) + desc.name = String::ToString("$%s", desc.name.c_str()); + desc.constType = GFXSCT_Sampler; + desc.arraySize = bindDesc.BindPoint; + samplerDescriptions.push_back(desc); + break; + + } + } + +} + +bool GFXD3D11Shader::_convertShaderVariable(const D3D11_SHADER_TYPE_DESC &typeDesc, GFXShaderConstDesc &desc) +{ + switch (typeDesc.Type) + { + case D3D_SVT_INT: + { + switch (typeDesc.Class) + { + case D3D_SVC_SCALAR: + desc.constType = GFXSCT_Int; + break; + case D3D_SVC_VECTOR: + { + switch (typeDesc.Columns) + { + case 1: + desc.constType = GFXSCT_Int; + break; + case 2: + desc.constType = GFXSCT_Int2; + break; + case 3: + desc.constType = GFXSCT_Int3; + break; + case 4: + desc.constType = GFXSCT_Int4; + break; + } + } + break; + } + break; + } + case D3D_SVT_FLOAT: + { + switch (typeDesc.Class) + { + case D3D_SVC_SCALAR: + desc.constType = GFXSCT_Float; + break; + case D3D_SVC_VECTOR: + { + switch (typeDesc.Columns) + { + case 1: + desc.constType = GFXSCT_Float; + break; + case 2: + desc.constType = GFXSCT_Float2; + break; + case 3: + desc.constType = GFXSCT_Float3; + break; + case 4: + desc.constType = GFXSCT_Float4; + break; + } + } + break; + case D3D_SVC_MATRIX_ROWS: + case D3D_SVC_MATRIX_COLUMNS: + { + switch (typeDesc.Columns) + { + case 3: + if (typeDesc.Rows == 3) + { + desc.constType = GFXSCT_Float3x3; + } + break; + case 4: + if (typeDesc.Rows == 4) + { + desc.constType = GFXSCT_Float4x4; + } + break; + } + } + break; + case D3D_SVC_OBJECT: + case D3D_SVC_STRUCT: + return false; + } + } + break; + + default: + AssertFatal(false, "Unknown shader constant class enum"); + break; + } + + return true; +} + +const U32 GFXD3D11Shader::smCompiledShaderTag = MakeFourCC('t','c','s','f'); + +bool GFXD3D11Shader::_saveCompiledOutput( const Torque::Path &filePath, + ID3DBlob *buffer, + GenericConstBufferLayout *bufferLayout, + Vector &samplerDescriptions ) +{ + Torque::Path outputPath(filePath); + outputPath.setExtension("csf"); // "C"ompiled "S"hader "F"ile (fancy!) + + FileStream f; + if (!f.open(outputPath, Torque::FS::File::Write)) + return false; + if (!f.write(smCompiledShaderTag)) + return false; + // We could reverse engineer the structure in the compiled output, but this + // is a bit easier because we can just read it into the struct that we want. + if (!bufferLayout->write(&f)) + return false; + + U32 bufferSize = buffer->GetBufferSize(); + if (!f.write(bufferSize)) + return false; + if (!f.write(bufferSize, buffer->GetBufferPointer())) + return false; + + // Write out sampler descriptions. + + f.write( samplerDescriptions.size() ); + + for ( U32 i = 0; i < samplerDescriptions.size(); i++ ) + { + f.write( samplerDescriptions[i].name ); + f.write( (U32)(samplerDescriptions[i].constType) ); + f.write( samplerDescriptions[i].arraySize ); + } + + f.close(); + + return true; +} + +bool GFXD3D11Shader::_loadCompiledOutput( const Torque::Path &filePath, + const String &target, + GenericConstBufferLayout *bufferLayout, + Vector &samplerDescriptions ) +{ + Torque::Path outputPath(filePath); + outputPath.setExtension("csf"); // "C"ompiled "S"hader "F"ile (fancy!) + + FileStream f; + if (!f.open(outputPath, Torque::FS::File::Read)) + return false; + U32 fileTag; + if (!f.read(&fileTag)) + return false; + if (fileTag != smCompiledShaderTag) + return false; + if (!bufferLayout->read(&f)) + return false; + U32 bufferSize; + if (!f.read(&bufferSize)) + return false; + U32 waterMark = FrameAllocator::getWaterMark(); + DWORD* buffer = static_cast(FrameAllocator::alloc(bufferSize)); + if (!f.read(bufferSize, buffer)) + return false; + + // Read sampler descriptions. + + U32 samplerCount; + f.read( &samplerCount ); + + for ( U32 i = 0; i < samplerCount; i++ ) + { + GFXShaderConstDesc samplerDesc; + f.read( &(samplerDesc.name) ); + f.read( (U32*)&(samplerDesc.constType) ); + f.read( &(samplerDesc.arraySize) ); + + samplerDescriptions.push_back( samplerDesc ); + } + + f.close(); + + HRESULT res; + if (target.compare("ps_", 3) == 0) + res = D3D11DEVICE->CreatePixelShader(buffer, bufferSize, NULL, &mPixShader); + else + res = D3D11DEVICE->CreateVertexShader(buffer, bufferSize, NULL, &mVertShader); + AssertFatal(SUCCEEDED(res), "Unable to load shader!"); + + FrameAllocator::setWaterMark(waterMark); + return SUCCEEDED(res); +} + +void GFXD3D11Shader::_buildShaderConstantHandles(GenericConstBufferLayout* layout, bool vertexConst) +{ + for (U32 i = 0; i < layout->getParameterCount(); i++) + { + GenericConstBufferLayout::ParamDesc pd; + layout->getDesc(i, pd); + + GFXD3D11ShaderConstHandle* handle; + HandleMap::Iterator j = mHandles.find(pd.name); + + if (j != mHandles.end()) + { + handle = j->value; + handle->mShader = this; + handle->setValid( true ); + } + else + { + handle = new GFXD3D11ShaderConstHandle(); + handle->mShader = this; + mHandles[pd.name] = handle; + handle->setValid( true ); + } + + if (vertexConst) + { + handle->mVertexConstant = true; + handle->mVertexHandle = pd; + } + else + { + handle->mPixelConstant = true; + handle->mPixelHandle = pd; + } + } +} + +void GFXD3D11Shader::_buildSamplerShaderConstantHandles( Vector &samplerDescriptions ) +{ + Vector::iterator iter = samplerDescriptions.begin(); + for ( ; iter != samplerDescriptions.end(); iter++ ) + { + const GFXShaderConstDesc &desc = *iter; + + AssertFatal( desc.constType == GFXSCT_Sampler || + desc.constType == GFXSCT_SamplerCube, + "GFXD3D11Shader::_buildSamplerShaderConstantHandles - Invalid samplerDescription type!" ); + + GFXD3D11ShaderConstHandle *handle; + HandleMap::Iterator j = mHandles.find(desc.name); + + if ( j != mHandles.end() ) + handle = j->value; + else + { + handle = new GFXD3D11ShaderConstHandle(); + mHandles[desc.name] = handle; + } + + handle->mShader = this; + handle->setValid( true ); + handle->mPixelConstant = true; + handle->mPixelHandle.name = desc.name; + handle->mPixelHandle.constType = desc.constType; + handle->mPixelHandle.offset = desc.arraySize; + } +} + +void GFXD3D11Shader::_buildInstancingShaderConstantHandles() +{ + // If we have no instancing than just return + if (!mInstancingFormat) + return; + + U32 offset = 0; + for ( U32 i=0; i < mInstancingFormat->getElementCount(); i++ ) + { + const GFXVertexElement &element = mInstancingFormat->getElement( i ); + + String constName = String::ToString( "$%s", element.getSemantic().c_str() ); + + GFXD3D11ShaderConstHandle *handle; + HandleMap::Iterator j = mHandles.find( constName ); + + if ( j != mHandles.end() ) + handle = j->value; + else + { + handle = new GFXD3D11ShaderConstHandle(); + mHandles[ constName ] = handle; + } + + handle->mShader = this; + handle->setValid( true ); + handle->mInstancingConstant = true; + + // We shouldn't have an instancing constant that is also + // a vertex or pixel constant! This means the shader features + // are confused as to what is instanced. + // + AssertFatal( !handle->mVertexConstant && + !handle->mPixelConstant, + "GFXD3D11Shader::_buildInstancingShaderConstantHandles - Bad instanced constant!" ); + + // HACK: The GFXD3D11ShaderConstHandle will check mVertexConstant then + // fall back to reading the mPixelHandle values. We depend on this here + // and store the data we need in the mPixelHandle constant although its + // not a pixel shader constant. + // + handle->mPixelHandle.name = constName; + handle->mPixelHandle.offset = offset; + + // If this is a matrix we will have 2 or 3 more of these + // semantics with the same name after it. + for ( ; i < mInstancingFormat->getElementCount(); i++ ) + { + const GFXVertexElement &nextElement = mInstancingFormat->getElement( i ); + if ( nextElement.getSemantic() != element.getSemantic() ) + { + i--; + break; + } + offset += nextElement.getSizeInBytes(); + } + } +} + +GFXShaderConstBufferRef GFXD3D11Shader::allocConstBuffer() +{ + if (mVertexConstBufferLayout && mPixelConstBufferLayout) + { + GFXD3D11ShaderConstBuffer* buffer = new GFXD3D11ShaderConstBuffer(this, mVertexConstBufferLayout, mPixelConstBufferLayout); + mActiveBuffers.push_back( buffer ); + buffer->registerResourceWithDevice(getOwningDevice()); + return buffer; + } + + return NULL; +} + +/// Returns a shader constant handle for name, if the variable doesn't exist NULL is returned. +GFXShaderConstHandle* GFXD3D11Shader::getShaderConstHandle(const String& name) +{ + HandleMap::Iterator i = mHandles.find(name); + if ( i != mHandles.end() ) + { + return i->value; + } + else + { + GFXD3D11ShaderConstHandle *handle = new GFXD3D11ShaderConstHandle(); + handle->setValid( false ); + handle->mShader = this; + mHandles[name] = handle; + + return handle; + } +} + +GFXShaderConstHandle* GFXD3D11Shader::findShaderConstHandle(const String& name) +{ + HandleMap::Iterator i = mHandles.find(name); + if(i != mHandles.end()) + return i->value; + else + { + return NULL; + } +} + +const Vector& GFXD3D11Shader::getShaderConstDesc() const +{ + return mShaderConsts; +} + +U32 GFXD3D11Shader::getAlignmentValue(const GFXShaderConstType constType) const +{ + const U32 mRowSizeF = 16; + const U32 mRowSizeI = 16; + + switch (constType) + { + case GFXSCT_Float : + case GFXSCT_Float2 : + case GFXSCT_Float3 : + case GFXSCT_Float4 : + return mRowSizeF; + break; + // Matrices + case GFXSCT_Float2x2 : + return mRowSizeF * 2; + break; + case GFXSCT_Float3x3 : + return mRowSizeF * 3; + break; + case GFXSCT_Float4x4 : + return mRowSizeF * 4; + break; + //// Scalar + case GFXSCT_Int : + case GFXSCT_Int2 : + case GFXSCT_Int3 : + case GFXSCT_Int4 : + return mRowSizeI; + break; + default: + AssertFatal(false, "Unsupported type!"); + return 0; + break; + } +} + +void GFXD3D11Shader::zombify() +{ + // Shaders don't need zombification +} + +void GFXD3D11Shader::resurrect() +{ + // Shaders are never zombies, and therefore don't have to be brought back. +} diff --git a/Engine/source/gfx/D3D11/gfxD3D11Shader.h b/Engine/source/gfx/D3D11/gfxD3D11Shader.h new file mode 100644 index 000000000..2e4074a8f --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Shader.h @@ -0,0 +1,471 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11SHADER_H_ +#define _GFXD3D11SHADER_H_ + +#include + +#include "core/util/path.h" +#include "core/util/tDictionary.h" +#include "gfx/gfxShader.h" +#include "gfx/gfxResource.h" +#include "gfx/genericConstBuffer.h" +#include "gfx/D3D11/gfxD3D11Device.h" + +class GFXD3D11Shader; + +enum CONST_CLASS +{ + D3DPC_SCALAR, + D3DPC_VECTOR, + D3DPC_MATRIX_ROWS, + D3DPC_MATRIX_COLUMNS, + D3DPC_OBJECT, + D3DPC_STRUCT +}; + +enum CONST_TYPE +{ + D3DPT_VOID, + D3DPT_BOOL, + D3DPT_INT, + D3DPT_FLOAT, + D3DPT_STRING, + D3DPT_TEXTURE, + D3DPT_TEXTURE1D, + D3DPT_TEXTURE2D, + D3DPT_TEXTURE3D, + D3DPT_TEXTURECUBE, + D3DPT_SAMPLER, + D3DPT_SAMPLER1D, + D3DPT_SAMPLER2D, + D3DPT_SAMPLER3D, + D3DPT_SAMPLERCUBE, + D3DPT_PIXELSHADER, + D3DPT_VERTEXSHADER, + D3DPT_PIXELFRAGMENT, + D3DPT_VERTEXFRAGMENT +}; + +enum REGISTER_TYPE +{ + D3DRS_BOOL, + D3DRS_INT4, + D3DRS_FLOAT4, + D3DRS_SAMPLER +}; + +struct ConstantDesc +{ + String Name; + S32 RegisterIndex; + S32 RegisterCount; + S32 Rows; + S32 Columns; + S32 Elements; + S32 StructMembers; + REGISTER_TYPE RegisterSet; + CONST_CLASS Class; + CONST_TYPE Type; + U32 Bytes; +}; + +class ConstantTable +{ +public: + bool Create(const void* data); + + U32 GetConstantCount() const { return m_constants.size(); } + const String& GetCreator() const { return m_creator; } + + const ConstantDesc* GetConstantByIndex(U32 i) const { return &m_constants[i]; } + const ConstantDesc* GetConstantByName(const String& name) const; + + void ClearConstants() { m_constants.clear(); } + +private: + Vector m_constants; + String m_creator; +}; + +// Structs +struct CTHeader +{ + U32 Size; + U32 Creator; + U32 Version; + U32 Constants; + U32 ConstantInfo; + U32 Flags; + U32 Target; +}; + +struct CTInfo +{ + U32 Name; + U16 RegisterSet; + U16 RegisterIndex; + U16 RegisterCount; + U16 Reserved; + U32 TypeInfo; + U32 DefaultValue; +}; + +struct CTType +{ + U16 Class; + U16 Type; + U16 Rows; + U16 Columns; + U16 Elements; + U16 StructMembers; + U32 StructMemberInfo; +}; + +// Shader instruction opcodes +const U32 SIO_COMMENT = 0x0000FFFE; +const U32 SIO_END = 0x0000FFFF; +const U32 SI_OPCODE_MASK = 0x0000FFFF; +const U32 SI_COMMENTSIZE_MASK = 0x7FFF0000; +const U32 CTAB_CONSTANT = 0x42415443; + +// Member functions +inline bool ConstantTable::Create(const void* data) +{ + const U32* ptr = static_cast(data); + while(*++ptr != SIO_END) + { + if((*ptr & SI_OPCODE_MASK) == SIO_COMMENT) + { + // Check for CTAB comment + U32 comment_size = (*ptr & SI_COMMENTSIZE_MASK) >> 16; + if(*(ptr+1) != CTAB_CONSTANT) + { + ptr += comment_size; + continue; + } + + // Read header + const char* ctab = reinterpret_cast(ptr+2); + size_t ctab_size = (comment_size-1)*4; + + const CTHeader* header = reinterpret_cast(ctab); + if(ctab_size < sizeof(*header) || header->Size != sizeof(*header)) + return false; + m_creator = ctab + header->Creator; + + // Read constants + m_constants.reserve(header->Constants); + const CTInfo* info = reinterpret_cast(ctab + header->ConstantInfo); + for(U32 i = 0; i < header->Constants; ++i) + { + const CTType* type = reinterpret_cast(ctab + info[i].TypeInfo); + + // Fill struct + ConstantDesc desc; + desc.Name = ctab + info[i].Name; + desc.RegisterSet = static_cast(info[i].RegisterSet); + desc.RegisterIndex = info[i].RegisterIndex; + desc.RegisterCount = info[i].RegisterCount; + desc.Rows = type->Rows; + desc.Class = static_cast(type->Class); + desc.Type = static_cast(type->Type); + desc.Columns = type->Columns; + desc.Elements = type->Elements; + desc.StructMembers = type->StructMembers; + desc.Bytes = 4 * desc.Elements * desc.Rows * desc.Columns; + m_constants.push_back(desc); + } + + return true; + } + } + return false; +} + +inline const ConstantDesc* ConstantTable::GetConstantByName(const String& name) const +{ + Vector::const_iterator it; + for(it = m_constants.begin(); it != m_constants.end(); ++it) + { + if(it->Name == name) + return &(*it); + } + return NULL; +} + +/////////////////// Constant Buffers ///////////////////////////// + +// Maximum number of CBuffers ($Globals & $Params) +const U32 CBUFFER_MAX = 2; + +struct ConstSubBufferDesc +{ + U32 start; + U32 size; + + ConstSubBufferDesc() : start(0), size(0){} +}; + +class GFXD3D11ConstBufferLayout : public GenericConstBufferLayout +{ +public: + GFXD3D11ConstBufferLayout(); + /// Get our constant sub buffer data + Vector &getSubBufferDesc(){ return mSubBuffers; } + + /// We need to manually set the size due to D3D11 alignment + void setSize(U32 size){ mBufferSize = size;} + + /// Set a parameter, given a base pointer + virtual bool set(const ParamDesc& pd, const GFXShaderConstType constType, const U32 size, const void* data, U8* basePointer); + +protected: + /// Set a matrix, given a base pointer + virtual bool setMatrix(const ParamDesc& pd, const GFXShaderConstType constType, const U32 size, const void* data, U8* basePointer); + + Vector mSubBuffers; +}; + +class GFXD3D11ShaderConstHandle : public GFXShaderConstHandle +{ +public: + + // GFXShaderConstHandle + const String& getName() const; + GFXShaderConstType getType() const; + U32 getArraySize() const; + + WeakRefPtr mShader; + + bool mVertexConstant; + GenericConstBufferLayout::ParamDesc mVertexHandle; + bool mPixelConstant; + GenericConstBufferLayout::ParamDesc mPixelHandle; + + /// Is true if this constant is for hardware mesh instancing. + /// + /// Note: We currently store its settings in mPixelHandle. + /// + bool mInstancingConstant; + + void setValid( bool valid ) { mValid = valid; } + S32 getSamplerRegister() const; + + // Returns true if this is a handle to a sampler register. + bool isSampler() const + { + return ( mPixelConstant && mPixelHandle.constType >= GFXSCT_Sampler ) || ( mVertexConstant && mVertexHandle.constType >= GFXSCT_Sampler ); + } + + /// Restore to uninitialized state. + void clear() + { + mShader = NULL; + mVertexConstant = false; + mPixelConstant = false; + mInstancingConstant = false; + mVertexHandle.clear(); + mPixelHandle.clear(); + mValid = false; + } + + GFXD3D11ShaderConstHandle(); +}; + +/// The D3D11 implementation of a shader constant buffer. +class GFXD3D11ShaderConstBuffer : public GFXShaderConstBuffer +{ + friend class GFXD3D11Shader; + +public: + + GFXD3D11ShaderConstBuffer(GFXD3D11Shader* shader, + GFXD3D11ConstBufferLayout* vertexLayout, + GFXD3D11ConstBufferLayout* pixelLayout); + + virtual ~GFXD3D11ShaderConstBuffer(); + + /// Called by GFXD3D11Device to activate this buffer. + /// @param mPrevShaderBuffer The previously active buffer + void activate(GFXD3D11ShaderConstBuffer *prevShaderBuffer); + + /// Used internally by GXD3D11ShaderConstBuffer to determine if it's dirty. + bool isDirty(); + + /// Called from GFXD3D11Shader when constants have changed and need + /// to be the shader this buffer references is reloaded. + void onShaderReload(GFXD3D11Shader *shader); + + // GFXShaderConstBuffer + virtual GFXShader* getShader(); + virtual void set(GFXShaderConstHandle* handle, const F32 fv); + virtual void set(GFXShaderConstHandle* handle, const Point2F& fv); + virtual void set(GFXShaderConstHandle* handle, const Point3F& fv); + virtual void set(GFXShaderConstHandle* handle, const Point4F& fv); + virtual void set(GFXShaderConstHandle* handle, const PlaneF& fv); + virtual void set(GFXShaderConstHandle* handle, const ColorF& fv); + virtual void set(GFXShaderConstHandle* handle, const S32 f); + virtual void set(GFXShaderConstHandle* handle, const Point2I& fv); + virtual void set(GFXShaderConstHandle* handle, const Point3I& fv); + virtual void set(GFXShaderConstHandle* handle, const Point4I& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const AlignedArray& fv); + virtual void set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matType = GFXSCT_Float4x4); + virtual void set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType = GFXSCT_Float4x4); + + // GFXResource + virtual const String describeSelf() const; + virtual void zombify(); + virtual void resurrect(); + +protected: + + void _createBuffers(); + + template + inline void SET_CONSTANT(GFXShaderConstHandle* handle, + const T& fv, + GenericConstBuffer *vBuffer, + GenericConstBuffer *pBuffer); + + // Constant buffers, VSSetConstantBuffers1 has issues on win 7. So unfortunately for now we have multiple constant buffers + ID3D11Buffer* mConstantBuffersV[CBUFFER_MAX]; + ID3D11Buffer* mConstantBuffersP[CBUFFER_MAX]; + + /// We keep a weak reference to the shader + /// because it will often be deleted. + WeakRefPtr mShader; + + //vertex + GFXD3D11ConstBufferLayout* mVertexConstBufferLayout; + GenericConstBuffer* mVertexConstBuffer; + //pixel + GFXD3D11ConstBufferLayout* mPixelConstBufferLayout; + GenericConstBuffer* mPixelConstBuffer; +}; + +class gfxD3D11Include; +typedef StrongRefPtr gfxD3DIncludeRef; + +/////////////////// GFXShader implementation ///////////////////////////// + +class GFXD3D11Shader : public GFXShader +{ + friend class GFXD3D11Device; + friend class GFXD3D11ShaderConstBuffer; + +public: + typedef Map HandleMap; + + GFXD3D11Shader(); + virtual ~GFXD3D11Shader(); + + // GFXShader + virtual GFXShaderConstBufferRef allocConstBuffer(); + virtual const Vector& getShaderConstDesc() const; + virtual GFXShaderConstHandle* getShaderConstHandle(const String& name); + virtual GFXShaderConstHandle* findShaderConstHandle(const String& name); + virtual U32 getAlignmentValue(const GFXShaderConstType constType) const; + virtual bool getDisassembly( String &outStr ) const; + + // GFXResource + virtual void zombify(); + virtual void resurrect(); + +protected: + + virtual bool _init(); + + static const U32 smCompiledShaderTag; + + ConstantTable table; + + ID3D11VertexShader *mVertShader; + ID3D11PixelShader *mPixShader; + + GFXD3D11ConstBufferLayout* mVertexConstBufferLayout; + GFXD3D11ConstBufferLayout* mPixelConstBufferLayout; + + static gfxD3DIncludeRef smD3DInclude; + + HandleMap mHandles; + + /// The shader disassembly from DX when this shader is compiled. + /// We only store this data in non-release builds. + String mDissasembly; + + /// Vector of sampler type descriptions consolidated from _compileShader. + Vector mSamplerDescriptions; + + /// Vector of descriptions (consolidated for the getShaderConstDesc call) + Vector mShaderConsts; + + // These two functions are used when compiling shaders from hlsl + virtual bool _compileShader( const Torque::Path &filePath, + const String &target, + const D3D_SHADER_MACRO *defines, + GenericConstBufferLayout *bufferLayout, + Vector &samplerDescriptions ); + + void _getShaderConstants( ID3D11ShaderReflection* table, + GenericConstBufferLayout *bufferLayout, + Vector &samplerDescriptions ); + + bool _convertShaderVariable(const D3D11_SHADER_TYPE_DESC &typeDesc, GFXShaderConstDesc &desc); + + + bool _saveCompiledOutput( const Torque::Path &filePath, + ID3DBlob *buffer, + GenericConstBufferLayout *bufferLayout, + Vector &samplerDescriptions ); + + // Loads precompiled shaders + bool _loadCompiledOutput( const Torque::Path &filePath, + const String &target, + GenericConstBufferLayout *bufferLayoutF, + Vector &samplerDescriptions ); + + // This is used in both cases + virtual void _buildShaderConstantHandles(GenericConstBufferLayout *layout, bool vertexConst); + + virtual void _buildSamplerShaderConstantHandles( Vector &samplerDescriptions ); + + /// Used to build the instancing shader constants from + /// the instancing vertex format. + void _buildInstancingShaderConstantHandles(); +}; + +inline bool GFXD3D11Shader::getDisassembly(String &outStr) const +{ + outStr = mDissasembly; + return (outStr.isNotEmpty()); +} + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11StateBlock.cpp b/Engine/source/gfx/D3D11/gfxD3D11StateBlock.cpp new file mode 100644 index 000000000..fb5f43936 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11StateBlock.cpp @@ -0,0 +1,285 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/gfxDevice.h" +#include "gfx/D3D11/gfxD3D11StateBlock.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" + +GFXD3D11StateBlock::GFXD3D11StateBlock(const GFXStateBlockDesc& desc) +{ + AssertFatal(D3D11DEVICE, "Invalid D3DDevice!"); + + mDesc = desc; + mCachedHashValue = desc.getHashValue(); + + // Color writes + mColorMask = 0; + mColorMask |= (mDesc.colorWriteRed ? D3D11_COLOR_WRITE_ENABLE_RED : 0); + mColorMask |= (mDesc.colorWriteGreen ? D3D11_COLOR_WRITE_ENABLE_GREEN : 0); + mColorMask |= (mDesc.colorWriteBlue ? D3D11_COLOR_WRITE_ENABLE_BLUE : 0); + mColorMask |= (mDesc.colorWriteAlpha ? D3D11_COLOR_WRITE_ENABLE_ALPHA : 0); + + mBlendState = NULL; + for (U32 i = 0; i < GFX->getNumSamplers(); i++) + { + mSamplerStates[i] = NULL; + } + + mDepthStencilState = NULL; + mRasterizerState = NULL; + + mBlendDesc.AlphaToCoverageEnable = false; + mBlendDesc.IndependentBlendEnable = false; + + mBlendDesc.RenderTarget[0].BlendEnable = mDesc.blendEnable; + mBlendDesc.RenderTarget[0].BlendOp = GFXD3D11BlendOp[mDesc.blendOp]; + mBlendDesc.RenderTarget[0].BlendOpAlpha = GFXD3D11BlendOp[mDesc.separateAlphaBlendOp]; + mBlendDesc.RenderTarget[0].DestBlend = GFXD3D11Blend[mDesc.blendDest]; + mBlendDesc.RenderTarget[0].DestBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendDest]; + mBlendDesc.RenderTarget[0].SrcBlend = GFXD3D11Blend[mDesc.blendSrc]; + mBlendDesc.RenderTarget[0].SrcBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendSrc]; + mBlendDesc.RenderTarget[0].RenderTargetWriteMask = mColorMask; + + HRESULT hr = D3D11DEVICE->CreateBlendState(&mBlendDesc, &mBlendState); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11StateBlock::GFXD3D11StateBlock - CreateBlendState call failure."); + } + + mDepthStencilDesc.DepthWriteMask = mDesc.zWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; + mDepthStencilDesc.DepthEnable = mDesc.zEnable; + mDepthStencilDesc.DepthFunc = GFXD3D11CmpFunc[mDesc.zFunc]; + mDepthStencilDesc.StencilWriteMask = mDesc.stencilWriteMask; + mDepthStencilDesc.StencilReadMask = mDesc.stencilMask; + mDepthStencilDesc.StencilEnable = mDesc.stencilEnable; + + mDepthStencilDesc.FrontFace.StencilFunc = GFXD3D11CmpFunc[mDesc.stencilFunc]; + mDepthStencilDesc.FrontFace.StencilFailOp = GFXD3D11StencilOp[mDesc.stencilFailOp]; + mDepthStencilDesc.FrontFace.StencilDepthFailOp = GFXD3D11StencilOp[mDesc.stencilZFailOp]; + mDepthStencilDesc.FrontFace.StencilPassOp = GFXD3D11StencilOp[mDesc.stencilPassOp]; + mDepthStencilDesc.BackFace = mDepthStencilDesc.FrontFace; + + hr = D3D11DEVICE->CreateDepthStencilState(&mDepthStencilDesc, &mDepthStencilState); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11StateBlock::GFXD3D11StateBlock - CreateDepthStencilState call failure."); + } + + mRasterizerDesc.CullMode = GFXD3D11CullMode[mDesc.cullMode]; + mRasterizerDesc.FillMode = GFXD3D11FillMode[mDesc.fillMode]; + mRasterizerDesc.DepthBias = mDesc.zBias; + mRasterizerDesc.SlopeScaledDepthBias = mDesc.zSlopeBias; + mRasterizerDesc.AntialiasedLineEnable = FALSE; + mRasterizerDesc.MultisampleEnable = FALSE; + mRasterizerDesc.ScissorEnable = FALSE; + mRasterizerDesc.DepthClipEnable = TRUE; + mRasterizerDesc.FrontCounterClockwise = FALSE; + mRasterizerDesc.DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP; + + hr = D3D11DEVICE->CreateRasterizerState(&mRasterizerDesc, &mRasterizerState); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11StateBlock::GFXD3D11StateBlock - CreateDepthStencilState call failure."); + } + + for ( U32 i = 0; i < GFX->getNumSamplers(); i++ ) + { + mSamplerDesc[i].AddressU = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeU]; + mSamplerDesc[i].AddressV = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeV]; + mSamplerDesc[i].AddressW = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeW]; + mSamplerDesc[i].MaxAnisotropy = mDesc.samplers[i].maxAnisotropy; + + mSamplerDesc[i].MipLODBias = mDesc.samplers[i].mipLODBias; + mSamplerDesc[i].MinLOD = 0; + mSamplerDesc[i].MaxLOD = FLT_MAX; + + if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + else + mSamplerDesc[i].Filter = D3D11_FILTER_ANISOTROPIC; + + mSamplerDesc[i].BorderColor[0] = 1.0f; + mSamplerDesc[i].BorderColor[1] = 1.0f; + mSamplerDesc[i].BorderColor[2] = 1.0f; + mSamplerDesc[i].BorderColor[3] = 1.0f; + mSamplerDesc[i].ComparisonFunc = D3D11_COMPARISON_NEVER; + + hr = D3D11DEVICE->CreateSamplerState(&mSamplerDesc[i], &mSamplerStates[i]); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11StateBlock::GFXD3D11StateBlock - CreateSamplerState call failure."); + } + } +} + +GFXD3D11StateBlock::~GFXD3D11StateBlock() +{ + SAFE_RELEASE(mBlendState); + SAFE_RELEASE(mRasterizerState); + SAFE_RELEASE(mDepthStencilState); + + //Use TEXTURE_STAGE_COUNT here, not safe to rely on GFX pointer + for (U32 i = 0; i < TEXTURE_STAGE_COUNT; ++i) + { + SAFE_RELEASE(mSamplerStates[i]); + } +} + +/// Returns the hash value of the desc that created this block +U32 GFXD3D11StateBlock::getHashValue() const +{ + return mCachedHashValue; +} + +/// Returns a GFXStateBlockDesc that this block represents +const GFXStateBlockDesc& GFXD3D11StateBlock::getDesc() const +{ + return mDesc; +} + +/// Called by D3D11 device to active this state block. +/// @param oldState The current state, used to make sure we don't set redundant states on the device. Pass NULL to reset all states. +void GFXD3D11StateBlock::activate(GFXD3D11StateBlock* oldState) +{ + PROFILE_SCOPE( GFXD3D11StateBlock_Activate ); + + ID3D11DeviceContext* pDevCxt = D3D11DEVICECONTEXT; + + mBlendDesc.AlphaToCoverageEnable = false; + mBlendDesc.IndependentBlendEnable = mDesc.separateAlphaBlendEnable; + + mBlendDesc.RenderTarget[0].BlendEnable = mDesc.blendEnable; + mBlendDesc.RenderTarget[0].BlendOp = GFXD3D11BlendOp[mDesc.blendOp]; + mBlendDesc.RenderTarget[0].BlendOpAlpha = GFXD3D11BlendOp[mDesc.separateAlphaBlendOp]; + mBlendDesc.RenderTarget[0].DestBlend = GFXD3D11Blend[mDesc.blendDest]; + mBlendDesc.RenderTarget[0].DestBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendDest]; + mBlendDesc.RenderTarget[0].SrcBlend = GFXD3D11Blend[mDesc.blendSrc]; + mBlendDesc.RenderTarget[0].SrcBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendSrc]; + mBlendDesc.RenderTarget[0].RenderTargetWriteMask = mColorMask; + + float blendFactor[] = { 1.0f, 1.0f, 1.0f, 1.0f }; + + pDevCxt->OMSetBlendState(mBlendState, blendFactor, 0xFFFFFFFF); + + mDepthStencilDesc.DepthWriteMask = mDesc.zWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; + mDepthStencilDesc.DepthEnable = mDesc.zEnable; + mDepthStencilDesc.DepthFunc = GFXD3D11CmpFunc[mDesc.zFunc]; + mDepthStencilDesc.StencilWriteMask = mDesc.stencilWriteMask; + mDepthStencilDesc.StencilReadMask = mDesc.stencilMask; + mDepthStencilDesc.StencilEnable = mDesc.stencilEnable; + + mDepthStencilDesc.FrontFace.StencilFunc = GFXD3D11CmpFunc[mDesc.stencilFunc]; + mDepthStencilDesc.FrontFace.StencilFailOp = GFXD3D11StencilOp[mDesc.stencilFailOp]; + mDepthStencilDesc.FrontFace.StencilDepthFailOp = GFXD3D11StencilOp[mDesc.stencilZFailOp]; + mDepthStencilDesc.FrontFace.StencilPassOp = GFXD3D11StencilOp[mDesc.stencilPassOp]; + + if (mDesc.stencilEnable) + mDepthStencilDesc.BackFace = mDepthStencilDesc.FrontFace; + else + { + mDepthStencilDesc.BackFace.StencilFunc = GFXD3D11CmpFunc[GFXCmpAlways]; + mDepthStencilDesc.BackFace.StencilFailOp = GFXD3D11StencilOp[GFXStencilOpKeep]; + mDepthStencilDesc.BackFace.StencilDepthFailOp = GFXD3D11StencilOp[GFXStencilOpKeep]; + mDepthStencilDesc.BackFace.StencilPassOp = GFXD3D11StencilOp[GFXStencilOpKeep]; + } + + pDevCxt->OMSetDepthStencilState(mDepthStencilState, mDesc.stencilRef); + + mRasterizerDesc.CullMode = GFXD3D11CullMode[mDesc.cullMode]; + mRasterizerDesc.FillMode = GFXD3D11FillMode[mDesc.fillMode]; + mRasterizerDesc.DepthBias = mDesc.zBias; + mRasterizerDesc.SlopeScaledDepthBias = mDesc.zSlopeBias; + mRasterizerDesc.AntialiasedLineEnable = FALSE; + mRasterizerDesc.MultisampleEnable = FALSE; + mRasterizerDesc.ScissorEnable = FALSE; + + if (mDesc.zEnable) + mRasterizerDesc.DepthClipEnable = true; + else + mRasterizerDesc.DepthClipEnable = false; + + mRasterizerDesc.FrontCounterClockwise = FALSE; + mRasterizerDesc.DepthBiasClamp = 0.0f; + + pDevCxt->RSSetState(mRasterizerState); + + U32 numSamplers = GFX->getNumSamplers(); + for (U32 i = 0; i < numSamplers; i++) + { + mSamplerDesc[i].AddressU = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeU]; + mSamplerDesc[i].AddressV = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeV]; + mSamplerDesc[i].AddressW = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeW]; + mSamplerDesc[i].MaxAnisotropy = mDesc.samplers[i].maxAnisotropy; + + mSamplerDesc[i].MipLODBias = mDesc.samplers[i].mipLODBias; + mSamplerDesc[i].MinLOD = 0; + mSamplerDesc[i].MaxLOD = FLT_MAX; + + if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; + else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear) + mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + else + mSamplerDesc[i].Filter = D3D11_FILTER_ANISOTROPIC; + + mSamplerDesc[i].BorderColor[0] = 0.0f; + mSamplerDesc[i].BorderColor[1] = 0.0f; + mSamplerDesc[i].BorderColor[2] = 0.0f; + mSamplerDesc[i].BorderColor[3] = 0.0f; + mSamplerDesc[i].ComparisonFunc = D3D11_COMPARISON_NEVER; + } + + //TODO samplers for vertex shader + // Set all the samplers with one call + //pDevCxt->VSSetSamplers(0, numSamplers, &mSamplerStates[0]); + pDevCxt->PSSetSamplers(0, numSamplers, &mSamplerStates[0]); +} diff --git a/Engine/source/gfx/D3D11/gfxD3D11StateBlock.h b/Engine/source/gfx/D3D11/gfxD3D11StateBlock.h new file mode 100644 index 000000000..6e55b962f --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11StateBlock.h @@ -0,0 +1,76 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11STATEBLOCK_H_ +#define _GFXD3D11STATEBLOCK_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/gfxStateBlock.h" + +class GFXD3D11StateBlock : public GFXStateBlock +{ +public: + + GFXD3D11StateBlock(const GFXStateBlockDesc& desc); + virtual ~GFXD3D11StateBlock(); + + /// Called by D3D11 device to active this state block. + /// @param oldState The current state, used to make sure we don't set redundant states on the device. Pass NULL to reset all states. + void activate(GFXD3D11StateBlock* oldState); + + // + // GFXStateBlock interface + // + + /// Returns the hash value of the desc that created this block + virtual U32 getHashValue() const; + + /// Returns a GFXStateBlockDesc that this block represents + virtual const GFXStateBlockDesc& getDesc() const; + + // + // GFXResource + // + virtual void zombify() { } + /// When called the resource should restore all device sensitive information destroyed by zombify() + virtual void resurrect() { } +private: + + D3D11_BLEND_DESC mBlendDesc; + D3D11_RASTERIZER_DESC mRasterizerDesc; + D3D11_DEPTH_STENCIL_DESC mDepthStencilDesc; + D3D11_SAMPLER_DESC mSamplerDesc[TEXTURE_STAGE_COUNT]; + + ID3D11BlendState* mBlendState; + ID3D11DepthStencilState* mDepthStencilState; + ID3D11RasterizerState* mRasterizerState; + ID3D11SamplerState* mSamplerStates[TEXTURE_STAGE_COUNT]; + + GFXStateBlockDesc mDesc; + U32 mCachedHashValue; + // Cached D3D specific things, these are "calculated" from GFXStateBlock + U32 mColorMask; +}; + +typedef StrongRefPtr GFXD3D11StateBlockRef; + +#endif \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11Target.cpp b/Engine/source/gfx/D3D11/gfxD3D11Target.cpp new file mode 100644 index 000000000..a74b3e54d --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Target.cpp @@ -0,0 +1,409 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "platform/platform.h" +#include "gfx/D3D11/gfxD3D11Target.h" +#include "gfx/D3D11/gfxD3D11Cubemap.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "gfx/gfxDebugEvent.h" +#include "gfx/gfxStringEnumTranslate.h" +#include "windowManager/win32/win32Window.h" + +GFXD3D11TextureTarget::GFXD3D11TextureTarget() + : mTargetSize( Point2I::Zero ), + mTargetFormat( GFXFormatR8G8B8A8 ) +{ + for(S32 i=0; imDeviceDepthStencil; + mTargetViews[slot] = D3D11->mDeviceDepthStencilView; + mTargets[slot]->AddRef(); + mTargetViews[slot]->AddRef(); + } + else + { + // Cast the texture object to D3D... + AssertFatal(static_cast(tex), "GFXD3D11TextureTarget::attachTexture - invalid texture object."); + + GFXD3D11TextureObject *d3dto = static_cast(tex); + + // Grab the surface level. + if( slot == DepthStencil ) + { + mTargets[slot] = d3dto->getSurface(); + if ( mTargets[slot] ) + mTargets[slot]->AddRef(); + + mTargetViews[slot] = d3dto->getDSView(); + if( mTargetViews[slot]) + mTargetViews[slot]->AddRef(); + + } + else + { + // getSurface will almost always return NULL. It will only return non-NULL + // if the surface that it needs to render to is different than the mip level + // in the actual texture. This will happen with MSAA. + if( d3dto->getSurface() == NULL ) + { + + mTargets[slot] = d3dto->get2DTex(); + mTargets[slot]->AddRef(); + mTargetViews[slot] = d3dto->getRTView(); + mTargetViews[slot]->AddRef(); + } + else + { + mTargets[slot] = d3dto->getSurface(); + mTargets[slot]->AddRef(); + mTargetViews[slot]->AddRef(); + // Only assign resolve target if d3dto has a surface to give us. + // + // That usually means there is an MSAA target involved, which is why + // the resolve is needed to get the data out of the target. + mResolveTargets[slot] = d3dto; + + if ( tex && slot == Color0 ) + { + mTargetSize.set( tex->getSize().x, tex->getSize().y ); + mTargetFormat = tex->getFormat(); + } + } + } + + // Update surface size + if(slot == Color0) + { + ID3D11Texture2D *surface = mTargets[Color0]; + if ( surface ) + { + D3D11_TEXTURE2D_DESC sd; + surface->GetDesc(&sd); + mTargetSize = Point2I(sd.Width, sd.Height); + + S32 format = sd.Format; + GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, format ); + mTargetFormat = (GFXFormat)format; + } + } + } + +} + + +void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXCubemap *tex, U32 face, U32 mipLevel/*=0*/ ) +{ + GFXDEBUGEVENT_SCOPE( GFXPCD3D11TextureTarget_attachTexture_Cubemap, ColorI::RED ); + + AssertFatal(slot < MaxRenderSlotId, "GFXD3D11TextureTarget::attachTexture - out of range slot."); + + // Mark state as dirty so device can know to update. + invalidateState(); + + // Release what we had, it's definitely going to change. + SAFE_RELEASE(mTargetViews[slot]); + SAFE_RELEASE(mTargets[slot]); + SAFE_RELEASE(mTargetSRViews[slot]); + + mResolveTargets[slot] = NULL; + + // Cast the texture object to D3D... + AssertFatal(!tex || static_cast(tex), "GFXD3DTextureTarget::attachTexture - invalid cubemap object."); + + if(slot == Color0) + { + mTargetSize = Point2I::Zero; + mTargetFormat = GFXFormatR8G8B8A8; + } + + // Are we clearing? + if(!tex) + { + // Yup - just exit, it'll stay NULL. + return; + } + + GFXD3D11Cubemap *cube = static_cast(tex); + + mTargets[slot] = cube->get2DTex(); + mTargets[slot]->AddRef(); + mTargetViews[slot] = cube->getRTView(face); + mTargetViews[slot]->AddRef(); + mTargetSRViews[slot] = cube->getSRView(); + mTargetSRViews[slot]->AddRef(); + + // Update surface size + if(slot == Color0) + { + ID3D11Texture2D *surface = mTargets[Color0]; + if ( surface ) + { + D3D11_TEXTURE2D_DESC sd; + surface->GetDesc(&sd); + mTargetSize = Point2I(sd.Width, sd.Height); + + S32 format = sd.Format; + GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, format ); + mTargetFormat = (GFXFormat)format; + } + } + +} + +void GFXD3D11TextureTarget::activate() +{ + GFXDEBUGEVENT_SCOPE( GFXPCD3D11TextureTarget_activate, ColorI::RED ); + + AssertFatal( mTargets[GFXTextureTarget::Color0], "GFXD3D11TextureTarget::activate() - You can never have a NULL primary render target!" ); + + // Clear the state indicator. + stateApplied(); + + // Now set all the new surfaces into the appropriate slots. + ID3D11RenderTargetView* rtViews[MaxRenderSlotId] = { NULL, NULL, NULL, NULL, NULL, NULL}; + + ID3D11DepthStencilView* dsView = (ID3D11DepthStencilView*)(mTargetViews[GFXTextureTarget::DepthStencil]); + for (U32 i = 0; i < 4; i++) + { + rtViews[i] = (ID3D11RenderTargetView*)mTargetViews[GFXTextureTarget::Color0 + i]; + } + + D3D11DEVICECONTEXT->OMSetRenderTargets(MaxRenderSlotId, rtViews, dsView); + +} + +void GFXD3D11TextureTarget::deactivate() +{ + //re-gen mip maps + for (U32 i = 0; i < 4; i++) + { + ID3D11ShaderResourceView* pSRView = mTargetSRViews[GFXTextureTarget::Color0 + i]; + if (pSRView) + D3D11DEVICECONTEXT->GenerateMips(pSRView); + } + +} + +void GFXD3D11TextureTarget::resolve() +{ + GFXDEBUGEVENT_SCOPE( GFXPCD3D11TextureTarget_resolve, ColorI::RED ); + + for (U32 i = 0; i < MaxRenderSlotId; i++) + { + // We use existance @ mResolveTargets as a flag that we need to copy + // data from the rendertarget into the texture. + if (mResolveTargets[i]) + { + D3D11_TEXTURE2D_DESC desc; + mTargets[i]->GetDesc(&desc); + D3D11DEVICECONTEXT->CopySubresourceRegion(mResolveTargets[i]->get2DTex(), 0, 0, 0, 0, mTargets[i], 0, NULL); + } + } +} + +void GFXD3D11TextureTarget::resolveTo( GFXTextureObject *tex ) +{ + GFXDEBUGEVENT_SCOPE( GFXPCD3D11TextureTarget_resolveTo, ColorI::RED ); + + if ( mTargets[Color0] == NULL ) + return; + + D3D11_TEXTURE2D_DESC desc; + mTargets[Color0]->GetDesc(&desc); + D3D11DEVICECONTEXT->CopySubresourceRegion(((GFXD3D11TextureObject*)(tex))->get2DTex(), 0, 0, 0, 0, mTargets[Color0], 0, NULL); + +} + +void GFXD3D11TextureTarget::zombify() +{ + for(U32 i = 0; i < MaxRenderSlotId; i++) + attachTexture(RenderSlot(i), NULL); +} + +void GFXD3D11TextureTarget::resurrect() +{ +} + +GFXD3D11WindowTarget::GFXD3D11WindowTarget() +{ + mWindow = NULL; + mBackbuffer = NULL; +} + +GFXD3D11WindowTarget::~GFXD3D11WindowTarget() +{ + SAFE_RELEASE(mBackbuffer); +} + +void GFXD3D11WindowTarget::initPresentationParams() +{ + // Get some video mode related info. + GFXVideoMode vm = mWindow->getVideoMode(); + Win32Window* win = static_cast(mWindow); + HWND hwnd = win->getHWND(); + + mPresentationParams = D3D11->setupPresentParams(vm, hwnd); +} + +const Point2I GFXD3D11WindowTarget::getSize() +{ + return mWindow->getVideoMode().resolution; +} + +GFXFormat GFXD3D11WindowTarget::getFormat() +{ + S32 format = mPresentationParams.BufferDesc.Format; + GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, format ); + return (GFXFormat)format; +} + +bool GFXD3D11WindowTarget::present() +{ + return (D3D11->getSwapChain()->Present(!D3D11->smDisableVSync, 0) == S_OK); +} + +void GFXD3D11WindowTarget::setImplicitSwapChain() +{ + if (!mBackbuffer) + D3D11->mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackbuffer); +} + +void GFXD3D11WindowTarget::resetMode() +{ + mWindow->setSuppressReset(true); + + // Setup our presentation params. + initPresentationParams(); + + // Otherwise, we have to reset the device, if we're the implicit swapchain. + D3D11->reset(mPresentationParams); + + // Update our size, too. + mSize = Point2I(mPresentationParams.BufferDesc.Width, mPresentationParams.BufferDesc.Height); + + mWindow->setSuppressReset(false); + GFX->beginReset(); +} + +void GFXD3D11WindowTarget::zombify() +{ + SAFE_RELEASE(mBackbuffer); +} + +void GFXD3D11WindowTarget::resurrect() +{ + setImplicitSwapChain(); +} + +void GFXD3D11WindowTarget::activate() +{ + GFXDEBUGEVENT_SCOPE(GFXPCD3D11WindowTarget_activate, ColorI::RED); + + //clear ther rendertargets first + ID3D11RenderTargetView* rtViews[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; + + D3D11DEVICECONTEXT->OMSetRenderTargets(8, rtViews, NULL); + D3D11DEVICECONTEXT->OMSetRenderTargets(1, &D3D11->mDeviceBackBufferView, D3D11->mDeviceDepthStencilView); + + DXGI_SWAP_CHAIN_DESC pp; + D3D11->mSwapChain->GetDesc(&pp); + + // Update our video mode here, too. + GFXVideoMode vm; + vm = mWindow->getVideoMode(); + vm.resolution.x = pp.BufferDesc.Width; + vm.resolution.y = pp.BufferDesc.Height; + vm.fullScreen = !pp.Windowed; + mSize = vm.resolution; +} + +void GFXD3D11WindowTarget::resolveTo(GFXTextureObject *tex) +{ + GFXDEBUGEVENT_SCOPE(GFXPCD3D11WindowTarget_resolveTo, ColorI::RED); + + D3D11_TEXTURE2D_DESC desc; + ID3D11Texture2D* surf = ((GFXD3D11TextureObject*)(tex))->get2DTex(); + surf->GetDesc(&desc); + D3D11DEVICECONTEXT->ResolveSubresource(surf, 0, D3D11->mDeviceBackbuffer, 0, desc.Format); +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11Target.h b/Engine/source/gfx/D3D11/gfxD3D11Target.h new file mode 100644 index 000000000..ff4b193d6 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11Target.h @@ -0,0 +1,110 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFX_D3D_GFXD3D11TARGET_H_ +#define _GFX_D3D_GFXD3D11TARGET_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11TextureObject.h" +#include "gfx/gfxTarget.h" +#include "math/mPoint3.h" +#include "math/mPoint2.h" + +class GFXD3D11TextureTarget : public GFXTextureTarget +{ + friend class GFXD3D11Device; + + // Array of target surfaces, this is given to us by attachTexture + ID3D11Texture2D* mTargets[MaxRenderSlotId]; + + // Array of shader resource views + ID3D11ShaderResourceView* mTargetSRViews[MaxRenderSlotId]; + + //ID3D11DepthStencilView* mDepthTargetView; + ID3D11View* mTargetViews[MaxRenderSlotId]; + // Array of texture objects which correspond to the target surfaces above, + // needed for copy from RenderTarget to texture situations. Current only valid in those situations + GFXD3D11TextureObject* mResolveTargets[MaxRenderSlotId]; + + Point2I mTargetSize; + + GFXFormat mTargetFormat; + +public: + + GFXD3D11TextureTarget(); + ~GFXD3D11TextureTarget(); + + // Public interface. + virtual const Point2I getSize() { return mTargetSize; } + virtual GFXFormat getFormat() { return mTargetFormat; } + virtual void attachTexture(RenderSlot slot, GFXTextureObject *tex, U32 mipLevel=0, U32 zOffset = 0); + virtual void attachTexture(RenderSlot slot, GFXCubemap *tex, U32 face, U32 mipLevel=0); + virtual void resolve(); + + /// Note we always copy the Color0 RenderSlot. + virtual void resolveTo( GFXTextureObject *tex ); + + virtual void activate(); + virtual void deactivate(); + + void zombify(); + void resurrect(); +}; + +class GFXD3D11WindowTarget : public GFXWindowTarget +{ + friend class GFXD3D11Device; + + /// Our backbuffer + ID3D11Texture2D *mBackbuffer; + + /// Maximum size we can render to. + Point2I mSize; + + /// D3D presentation info. + DXGI_SWAP_CHAIN_DESC mPresentationParams; + + /// Internal interface that notifies us we need to reset our video mode. + void resetMode(); + +public: + + GFXD3D11WindowTarget(); + ~GFXD3D11WindowTarget(); + + virtual const Point2I getSize(); + virtual GFXFormat getFormat(); + virtual bool present(); + + void initPresentationParams(); + void setImplicitSwapChain(); + + virtual void activate(); + + void zombify(); + void resurrect(); + + virtual void resolveTo( GFXTextureObject *tex ); +}; + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureManager.cpp b/Engine/source/gfx/D3D11/gfxD3D11TextureManager.cpp new file mode 100644 index 000000000..ba90c4064 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11TextureManager.cpp @@ -0,0 +1,587 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11EnumTranslate.h" +#include "gfx/bitmap/bitmapUtils.h" +#include "gfx/gfxCardProfile.h" +#include "gfx/gfxStringEnumTranslate.h" +#include "core/strings/unicode.h" +#include "core/util/swizzle.h" +#include "core/util/safeDelete.h" +#include "console/console.h" +#include "core/resourceManager.h" + +GFXD3D11TextureManager::GFXD3D11TextureManager() +{ + ZeroMemory(mCurTexSet, sizeof(mCurTexSet)); +} + +GFXD3D11TextureManager::~GFXD3D11TextureManager() +{ + // Destroy texture table now so just in case some texture objects + // are still left, we don't crash on a pure virtual method call. + SAFE_DELETE_ARRAY( mHashTable ); +} + +void GFXD3D11TextureManager::_innerCreateTexture( GFXD3D11TextureObject *retTex, + U32 height, + U32 width, + U32 depth, + GFXFormat format, + GFXTextureProfile *profile, + U32 numMipLevels, + bool forceMips, + S32 antialiasLevel) +{ + U32 usage = 0; + U32 bindFlags = 0; + U32 miscFlags = 0; + + if(!retTex->mProfile->isZTarget() && !retTex->mProfile->isSystemMemory()) + bindFlags = D3D11_BIND_SHADER_RESOURCE; + + U32 cpuFlags = 0; + + retTex->mProfile = profile; + retTex->isManaged = false; + DXGI_FORMAT d3dTextureFormat = GFXD3D11TextureFormat[format]; + + if( retTex->mProfile->isDynamic() ) + { + usage = D3D11_USAGE_DYNAMIC; + cpuFlags |= D3D11_CPU_ACCESS_WRITE; + retTex->isManaged = false; + } + else if ( retTex->mProfile->isSystemMemory() ) + { + usage |= D3D11_USAGE_STAGING; + cpuFlags |= D3D11_CPU_ACCESS_READ; + } + else + { + usage = D3D11_USAGE_DEFAULT; + retTex->isManaged = true; + } + + if( retTex->mProfile->isRenderTarget() ) + { + bindFlags |= D3D11_BIND_RENDER_TARGET; + //need to check to make sure this format supports render targets + U32 supportFlag = 0; + + D3D11DEVICE->CheckFormatSupport(d3dTextureFormat, &supportFlag); + //if it doesn't support render targets then default to R8G8B8A8 + if(!(supportFlag & D3D11_FORMAT_SUPPORT_RENDER_TARGET)) + d3dTextureFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + + retTex->isManaged =false; + } + + if( retTex->mProfile->isZTarget() ) + { + bindFlags |= D3D11_BIND_DEPTH_STENCIL; + retTex->isManaged = false; + } + + if( !forceMips && !retTex->mProfile->isSystemMemory() && + numMipLevels == 0 && + !(depth > 0) ) + { + miscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + bindFlags |= D3D11_BIND_RENDER_TARGET; // in order to automatically generate mips. Resource needs to be a rendertarget and shader resource + } + + if( depth > 0 ) + { + D3D11_TEXTURE3D_DESC desc; + ZeroMemory(&desc, sizeof(D3D11_TEXTURE3D_DESC)); + + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = cpuFlags; + desc.Depth = depth; + desc.Width = width; + desc.Height = height; + desc.Format = d3dTextureFormat; + desc.Usage = (D3D11_USAGE)usage; + desc.MipLevels = numMipLevels; + + HRESULT hr = D3D11DEVICE->CreateTexture3D(&desc, NULL, retTex->get3DTexPtr()); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11TextureManager::_createTexture - failed to create volume texture!"); + } + + retTex->mTextureSize.set(width, height, depth); + retTex->get3DTex()->GetDesc(&desc); + retTex->mMipLevels = numMipLevels; + retTex->mFormat = format; + } + else + { + UINT numQualityLevels = 0; + + switch (antialiasLevel) + { + case 0: + case AA_MATCH_BACKBUFFER: + antialiasLevel = 1; + break; + + default: + { + antialiasLevel = 0; + UINT numQualityLevels; + D3D11DEVICE->CheckMultisampleQualityLevels(d3dTextureFormat, antialiasLevel, &numQualityLevels); + AssertFatal(numQualityLevels, "Invalid AA level!"); + break; + } + } + + if(retTex->mProfile->isZTarget()) + { + D3D11_TEXTURE2D_DESC desc; + + ZeroMemory(&desc, sizeof(D3D11_TEXTURE2D_DESC)); + desc.ArraySize = 1; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = cpuFlags; + //depth stencil must be a typeless format if it is bound on render target and shader resource simultaneously + // we'll send the real format for the creation of the views + desc.Format = DXGI_FORMAT_R24G8_TYPELESS; + desc.MipLevels = numMipLevels; + desc.SampleDesc.Count = antialiasLevel; + desc.SampleDesc.Quality = numQualityLevels; + desc.Height = height; + desc.Width = width; + desc.Usage = (D3D11_USAGE)usage; + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, retTex->getSurfacePtr()); + + if(FAILED(hr)) + { + AssertFatal(false, "Failed to create Zbuffer texture"); + } + + retTex->mFormat = format; // Assigning format like this should be fine. + } + else + { + D3D11_TEXTURE2D_DESC desc; + + ZeroMemory(&desc, sizeof(D3D11_TEXTURE2D_DESC)); + desc.ArraySize = 1; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = cpuFlags; + desc.Format = d3dTextureFormat; + desc.MipLevels = numMipLevels; + desc.SampleDesc.Count = antialiasLevel; + desc.SampleDesc.Quality = numQualityLevels; + desc.Height = height; + desc.Width = width; + desc.Usage = (D3D11_USAGE)usage; + desc.MiscFlags = miscFlags; + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, retTex->get2DTexPtr()); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11TextureManager::_createTexture - failed to create texture!"); + } + + retTex->get2DTex()->GetDesc(&desc); + retTex->mMipLevels = desc.MipLevels; + } + + // start creating the resource views... + // don't bother creating views for system memory/staging textures + // they are just used for copying + + if (!retTex->mProfile->isSystemMemory()) + { + createResourceView(height, width, depth, d3dTextureFormat, numMipLevels, bindFlags, retTex); + } + + // Get the actual size of the texture... + D3D11_TEXTURE2D_DESC probeDesc; + ZeroMemory(&probeDesc, sizeof(D3D11_TEXTURE2D_DESC)); + + if( retTex->get2DTex() != NULL ) + { + retTex->get2DTex()->GetDesc(&probeDesc); + } + else if( retTex->getSurface() != NULL ) + { + retTex->getSurface()->GetDesc(&probeDesc); + } + + retTex->mTextureSize.set(probeDesc.Width, probeDesc.Height, 0); + S32 fmt = 0; + + if(!profile->isZTarget()) + fmt = probeDesc.Format; + else + fmt = DXGI_FORMAT_D24_UNORM_S8_UINT; // we need to assign this manually. + + GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, fmt ); + retTex->mFormat = (GFXFormat)fmt; + } +} + +//----------------------------------------------------------------------------- +// createTexture +//----------------------------------------------------------------------------- +GFXTextureObject *GFXD3D11TextureManager::_createTextureObject( U32 height, + U32 width, + U32 depth, + GFXFormat format, + GFXTextureProfile *profile, + U32 numMipLevels, + bool forceMips, + S32 antialiasLevel, + GFXTextureObject *inTex ) +{ + GFXD3D11TextureObject *retTex; + if ( inTex ) + { + AssertFatal(static_cast( inTex ), "GFXD3D11TextureManager::_createTexture() - Bad inTex type!"); + retTex = static_cast( inTex ); + retTex->release(); + } + else + { + retTex = new GFXD3D11TextureObject(GFX, profile); + retTex->registerResourceWithDevice(GFX); + } + + _innerCreateTexture(retTex, height, width, depth, format, profile, numMipLevels, forceMips, antialiasLevel); + + return retTex; +} + +bool GFXD3D11TextureManager::_loadTexture(GFXTextureObject *aTexture, GBitmap *pDL) +{ + PROFILE_SCOPE(GFXD3D11TextureManager_loadTexture); + + GFXD3D11TextureObject *texture = static_cast(aTexture); + + // Check with profiler to see if we can do automatic mipmap generation. + const bool supportsAutoMips = GFX->getCardProfiler()->queryProfile("autoMipMapLevel", true); + + // Helper bool + const bool isCompressedTexFmt = aTexture->mFormat >= GFXFormatDXT1 && aTexture->mFormat <= GFXFormatDXT5; + + // Settings for mipmap generation + U32 maxDownloadMip = pDL->getNumMipLevels(); + U32 nbMipMapLevel = pDL->getNumMipLevels(); + + if( supportsAutoMips && !isCompressedTexFmt ) + { + maxDownloadMip = 1; + nbMipMapLevel = aTexture->mMipLevels; + } + GFXD3D11Device* dev = D3D11; + + bool isDynamic = texture->mProfile->isDynamic(); + // Fill the texture... + for( U32 i = 0; i < maxDownloadMip; i++ ) + { + U32 subResource = D3D11CalcSubresource(i, 0, aTexture->mMipLevels); + + if(!isDynamic) + { + U8* copyBuffer = NULL; + + switch(texture->mFormat) + { + case GFXFormatR8G8B8: + { + PROFILE_SCOPE(Swizzle24_Upload); + AssertFatal(pDL->getFormat() == GFXFormatR8G8B8, "Assumption failed"); + + U8* Bits = new U8[pDL->getWidth(i) * pDL->getHeight(i) * 4]; + dMemcpy(Bits, pDL->getBits(i), pDL->getWidth(i) * pDL->getHeight(i) * 3); + bitmapConvertRGB_to_RGBX(&Bits, pDL->getWidth(i) * pDL->getHeight(i)); + copyBuffer = new U8[pDL->getWidth(i) * pDL->getHeight(i) * 4]; + + dev->getDeviceSwizzle32()->ToBuffer(copyBuffer, Bits, pDL->getWidth(i) * pDL->getHeight(i) * 4); + dev->getDeviceContext()->UpdateSubresource(texture->get2DTex(), subResource, NULL, copyBuffer, pDL->getWidth() * 4, pDL->getHeight() *4); + SAFE_DELETE_ARRAY(Bits); + break; + } + + case GFXFormatR8G8B8A8: + case GFXFormatR8G8B8X8: + { + PROFILE_SCOPE(Swizzle32_Upload); + copyBuffer = new U8[pDL->getWidth(i) * pDL->getHeight(i) * pDL->getBytesPerPixel()]; + dev->getDeviceSwizzle32()->ToBuffer(copyBuffer, pDL->getBits(i), pDL->getWidth(i) * pDL->getHeight(i) * pDL->getBytesPerPixel()); + dev->getDeviceContext()->UpdateSubresource(texture->get2DTex(), subResource, NULL, copyBuffer, pDL->getWidth() * pDL->getBytesPerPixel(), pDL->getHeight() *pDL->getBytesPerPixel()); + break; + } + + default: + { + // Just copy the bits in no swizzle or padding + PROFILE_SCOPE(SwizzleNull_Upload); + AssertFatal( pDL->getFormat() == texture->mFormat, "Format mismatch"); + dev->getDeviceContext()->UpdateSubresource(texture->get2DTex(), subResource, NULL, pDL->getBits(i), pDL->getWidth() *pDL->getBytesPerPixel(), pDL->getHeight() *pDL->getBytesPerPixel()); + } + } + + SAFE_DELETE_ARRAY(copyBuffer); + } + + else + { + D3D11_MAPPED_SUBRESOURCE mapping; + HRESULT res = dev->getDeviceContext()->Map(texture->get2DTex(), subResource, D3D11_MAP_WRITE, 0, &mapping); + + AssertFatal(res, "tex2d map call failure"); + + switch( texture->mFormat ) + { + case GFXFormatR8G8B8: + { + PROFILE_SCOPE(Swizzle24_Upload); + AssertFatal(pDL->getFormat() == GFXFormatR8G8B8, "Assumption failed"); + + U8* Bits = new U8[pDL->getWidth(i) * pDL->getHeight(i) * 4]; + dMemcpy(Bits, pDL->getBits(i), pDL->getWidth(i) * pDL->getHeight(i) * 3); + bitmapConvertRGB_to_RGBX(&Bits, pDL->getWidth(i) * pDL->getHeight(i)); + + dev->getDeviceSwizzle32()->ToBuffer(mapping.pData, Bits, pDL->getWidth(i) * pDL->getHeight(i) * 4); + SAFE_DELETE_ARRAY(Bits); + } + break; + + case GFXFormatR8G8B8A8: + case GFXFormatR8G8B8X8: + { + PROFILE_SCOPE(Swizzle32_Upload); + dev->getDeviceSwizzle32()->ToBuffer(mapping.pData, pDL->getBits(i), pDL->getWidth(i) * pDL->getHeight(i) * pDL->getBytesPerPixel()); + } + break; + + default: + { + // Just copy the bits in no swizzle or padding + PROFILE_SCOPE(SwizzleNull_Upload); + AssertFatal( pDL->getFormat() == texture->mFormat, "Format mismatch"); + dMemcpy(mapping.pData, pDL->getBits(i), pDL->getWidth(i) * pDL->getHeight(i) * pDL->getBytesPerPixel()); + } + } + + dev->getDeviceContext()->Unmap(texture->get2DTex(), subResource); + } + } + + D3D11_TEXTURE2D_DESC desc; + // if the texture asked for mip generation. lets generate it. + texture->get2DTex()->GetDesc(&desc); + if (desc.MiscFlags &D3D11_RESOURCE_MISC_GENERATE_MIPS) + { + dev->getDeviceContext()->GenerateMips(texture->getSRView()); + //texture->mMipLevels = desc.MipLevels; + } + + return true; +} + +bool GFXD3D11TextureManager::_loadTexture(GFXTextureObject *inTex, void *raw) +{ + PROFILE_SCOPE(GFXD3D11TextureManager_loadTextureRaw); + + GFXD3D11TextureObject *texture = (GFXD3D11TextureObject *) inTex; + GFXD3D11Device* dev = static_cast(GFX); + // currently only for volume textures... + if(texture->getDepth() < 1) return false; + + U8* Bits = NULL; + + if(texture->mFormat == GFXFormatR8G8B8) + { + // convert 24 bit to 32 bit + Bits = new U8[texture->getWidth() * texture->getHeight() * texture->getDepth() * 4]; + dMemcpy(Bits, raw, texture->getWidth() * texture->getHeight() * texture->getDepth() * 3); + bitmapConvertRGB_to_RGBX(&Bits, texture->getWidth() * texture->getHeight() * texture->getDepth()); + } + + U32 bytesPerPix = 1; + + switch(texture->mFormat) + { + case GFXFormatR8G8B8: + case GFXFormatR8G8B8A8: + case GFXFormatR8G8B8X8: + bytesPerPix = 4; + break; + } + + D3D11_BOX box; + box.left = 0; + box.right = texture->getWidth(); + box.front = 0; + box.back = texture->getDepth(); + box.top = 0; + box.bottom = texture->getHeight(); + + if(texture->mFormat == GFXFormatR8G8B8) // converted format also for volume textures + dev->getDeviceContext()->UpdateSubresource(texture->get3DTex(), 0, &box, Bits, texture->getWidth() * bytesPerPix, texture->getHeight() * bytesPerPix); + else + dev->getDeviceContext()->UpdateSubresource(texture->get3DTex(), 0, &box, raw, texture->getWidth() * bytesPerPix, texture->getHeight() * bytesPerPix); + + SAFE_DELETE_ARRAY(Bits); + + return true; +} + +bool GFXD3D11TextureManager::_refreshTexture(GFXTextureObject *texture) +{ + U32 usedStrategies = 0; + GFXD3D11TextureObject *realTex = static_cast(texture); + + if(texture->mProfile->doStoreBitmap()) + { + if(texture->mBitmap) + _loadTexture(texture, texture->mBitmap); + + if(texture->mDDS) + _loadTexture(texture, texture->mDDS); + + usedStrategies++; + } + + if(texture->mProfile->isRenderTarget() || texture->mProfile->isDynamic() || texture->mProfile->isZTarget()) + { + realTex->release(); + _innerCreateTexture(realTex, texture->getHeight(), texture->getWidth(), texture->getDepth(), texture->mFormat, texture->mProfile, texture->mMipLevels, false, texture->mAntialiasLevel); + usedStrategies++; + } + + AssertFatal(usedStrategies < 2, "GFXD3D11TextureManager::_refreshTexture - Inconsistent profile flags!"); + + return true; +} + +bool GFXD3D11TextureManager::_freeTexture(GFXTextureObject *texture, bool zombify) +{ + AssertFatal(dynamic_cast(texture),"Not an actual d3d texture object!"); + GFXD3D11TextureObject *tex = static_cast( texture ); + + // If it's a managed texture and we're zombifying, don't blast it, D3D allows + // us to keep it. + if(zombify && tex->isManaged) + return true; + + tex->release(); + + return true; +} + +/// Load a texture from a proper DDSFile instance. +bool GFXD3D11TextureManager::_loadTexture(GFXTextureObject *aTexture, DDSFile *dds) +{ + PROFILE_SCOPE(GFXD3D11TextureManager_loadTextureDDS); + + GFXD3D11TextureObject *texture = static_cast(aTexture); + GFXD3D11Device* dev = static_cast(GFX); + // Fill the texture... + for( U32 i = 0; i < aTexture->mMipLevels; i++ ) + { + PROFILE_SCOPE(GFXD3DTexMan_loadSurface); + + AssertFatal( dds->mSurfaces.size() > 0, "Assumption failed. DDSFile has no surfaces." ); + + U32 subresource = D3D11CalcSubresource(i, 0, aTexture->mMipLevels); + dev->getDeviceContext()->UpdateSubresource(texture->get2DTex(), subresource, 0, dds->mSurfaces[0]->mMips[i], dds->getSurfacePitch(i), 0); + } + + D3D11_TEXTURE2D_DESC desc; + // if the texture asked for mip generation. lets generate it. + texture->get2DTex()->GetDesc(&desc); + if (desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS) + dev->getDeviceContext()->GenerateMips(texture->getSRView()); + + return true; +} + +void GFXD3D11TextureManager::createResourceView(U32 height, U32 width, U32 depth, DXGI_FORMAT format, U32 numMipLevels,U32 usageFlags, GFXTextureObject *inTex) +{ + GFXD3D11TextureObject *tex = static_cast(inTex); + ID3D11Resource* resource = NULL; + + if(tex->get2DTex()) + resource = tex->get2DTex(); + else if(tex->getSurface()) + resource = tex->getSurface(); + else + resource = tex->get3DTex(); + + HRESULT hr; + //TODO: add MSAA support later. + if(usageFlags & D3D11_BIND_SHADER_RESOURCE) + { + D3D11_SHADER_RESOURCE_VIEW_DESC desc; + + if(usageFlags & D3D11_BIND_DEPTH_STENCIL) + desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; // reads the depth + else + desc.Format = format; + + if(depth > 0) + { + desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; + desc.Texture3D.MipLevels = -1; + desc.Texture3D.MostDetailedMip = 0; + } + else + { + desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + desc.Texture2D.MipLevels = -1; + desc.Texture2D.MostDetailedMip = 0; + } + + hr = D3D11DEVICE->CreateShaderResourceView(resource,&desc, tex->getSRViewPtr()); + AssertFatal(SUCCEEDED(hr), "CreateShaderResourceView:: failed to create view!"); + } + + if(usageFlags & D3D11_BIND_RENDER_TARGET) + { + D3D11_RENDER_TARGET_VIEW_DESC desc; + desc.Format = format; + desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + desc.Texture2D.MipSlice = 0; + hr = D3D11DEVICE->CreateRenderTargetView(resource, &desc, tex->getRTViewPtr()); + AssertFatal(SUCCEEDED(hr), "CreateRenderTargetView:: failed to create view!"); + } + + if(usageFlags & D3D11_BIND_DEPTH_STENCIL) + { + D3D11_DEPTH_STENCIL_VIEW_DESC desc; + desc.Format = format; + desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + desc.Texture2D.MipSlice = 0; + desc.Flags = 0; + hr = D3D11DEVICE->CreateDepthStencilView(resource,&desc, tex->getDSViewPtr()); + AssertFatal(SUCCEEDED(hr), "CreateDepthStencilView:: failed to create view!"); + } +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureManager.h b/Engine/source/gfx/D3D11/gfxD3D11TextureManager.h new file mode 100644 index 000000000..fa32941d8 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11TextureManager.h @@ -0,0 +1,62 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3DTEXTUREMANAGER_H_ +#define _GFXD3DTEXTUREMANAGER_H_ + +#include "gfx/D3D11/gfxD3D11TextureObject.h" +#include "core/util/safeRelease.h" + +class GFXD3D11TextureManager : public GFXTextureManager +{ + friend class GFXD3D11TextureObject; + +public: + GFXD3D11TextureManager(); + virtual ~GFXD3D11TextureManager(); + void createResourceView(U32 height, U32 width, U32 depth, DXGI_FORMAT format, U32 numMipLevels,U32 usageFlags, GFXTextureObject *inTex); +protected: + + // GFXTextureManager + GFXTextureObject *_createTextureObject( U32 height, + U32 width, + U32 depth, + GFXFormat format, + GFXTextureProfile *profile, + U32 numMipLevels, + bool forceMips = false, + S32 antialiasLevel = 0, + GFXTextureObject *inTex = NULL ); + + bool _loadTexture(GFXTextureObject *texture, DDSFile *dds); + bool _loadTexture(GFXTextureObject *texture, GBitmap *bmp); + bool _loadTexture(GFXTextureObject *texture, void *raw); + bool _refreshTexture(GFXTextureObject *texture); + bool _freeTexture(GFXTextureObject *texture, bool zombify = false); + +private: + U32 mCurTexSet[TEXTURE_STAGE_COUNT]; + + void _innerCreateTexture(GFXD3D11TextureObject *obj, U32 height, U32 width, U32 depth, GFXFormat format, GFXTextureProfile *profile, U32 numMipLevels, bool forceMips = false, S32 antialiasLevel = 0); +}; + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp new file mode 100644 index 000000000..8f15cf550 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp @@ -0,0 +1,280 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/D3D11/gfxD3D11TextureObject.h" +#include "platform/profiler.h" +#include "console/console.h" + +#ifdef TORQUE_DEBUG +U32 GFXD3D11TextureObject::mTexCount = 0; +#endif + + +// GFXFormatR8G8B8 has now the same behaviour as GFXFormatR8G8B8X8. +// This is because 24 bit format are now deprecated by microsoft, for data alignment reason there's no changes beetween 24 and 32 bit formats. +// DirectX 10-11 both have 24 bit format no longer. + + +GFXD3D11TextureObject::GFXD3D11TextureObject( GFXDevice * d, GFXTextureProfile *profile) : GFXTextureObject( d, profile ) +{ +#ifdef D3D11_DEBUG_SPEW + mTexCount++; + Con::printf("+ texMake %d %x", mTexCount, this); +#endif + + mD3DTexture = NULL; + mLocked = false; + + mD3DSurface = NULL; + mLockedSubresource = 0; + mDSView = NULL; + mRTView = NULL; + mSRView = NULL; +} + +GFXD3D11TextureObject::~GFXD3D11TextureObject() +{ + kill(); +#ifdef D3D11_DEBUG_SPEW + mTexCount--; + Con::printf("+ texkill %d %x", mTexCount, this); +#endif +} + +GFXLockedRect *GFXD3D11TextureObject::lock(U32 mipLevel /*= 0*/, RectI *inRect /*= NULL*/) +{ + AssertFatal( !mLocked, "GFXD3D11TextureObject::lock - The texture is already locked!" ); + + D3D11_MAPPED_SUBRESOURCE mapInfo; + + if( mProfile->isRenderTarget() ) + { + //AssertFatal( 0, "GFXD3D11TextureObject::lock - Need to handle mapping render targets" ); + if( !mLockTex || + mLockTex->getWidth() != getWidth() || + mLockTex->getHeight() != getHeight() ) + { + mLockTex.set( getWidth(), getHeight(), mFormat, &GFXSystemMemProfile, avar("%s() - mLockTex (line %d)", __FUNCTION__, __LINE__) ); + } + + PROFILE_START(GFXD3D11TextureObject_lockRT); + + GFXD3D11Device* dev = D3D11; + + GFXD3D11TextureObject* to = (GFXD3D11TextureObject*) &(*mLockTex); + dev->getDeviceContext()->CopyResource(to->get2DTex(), mD3DTexture); + + mLockedSubresource = D3D11CalcSubresource(0, 0, 1); + HRESULT hr = dev->getDeviceContext()->Map(to->get2DTex(), mLockedSubresource, D3D11_MAP_READ, 0, &mapInfo); + + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11TextureObject:lock- failed to map render target resource!"); + + mLocked = true; + + + PROFILE_END(); + } + else + { + RECT r; + + if(inRect) + { + r.top = inRect->point.y; + r.left = inRect->point.x; + r.bottom = inRect->point.y + inRect->extent.y; + r.right = inRect->point.x + inRect->extent.x; + } + + mLockedSubresource = D3D11CalcSubresource(mipLevel, 0, getMipLevels()); + HRESULT hr = D3D11DEVICECONTEXT->Map(mD3DTexture, mLockedSubresource, D3D11_MAP_WRITE_DISCARD, 0, &mapInfo); + + if ( FAILED(hr) ) + AssertFatal(false, "GFXD3D11TextureObject::lock - Failed to map subresource."); + + mLocked = true; + + } + + mLockRect.pBits = static_cast(mapInfo.pData); + mLockRect.Pitch = mapInfo.RowPitch; + + return (GFXLockedRect*)&mLockRect; +} + +void GFXD3D11TextureObject::unlock(U32 mipLevel) +{ + AssertFatal( mLocked, "GFXD3D11TextureObject::unlock - Attempting to unlock a surface that has not been locked" ); + + if( mProfile->isRenderTarget() ) + { + //AssertFatal( 0, "GFXD3D11TextureObject::unlock - Need to handle mapping render targets" ); + GFXD3D11TextureObject* to = (GFXD3D11TextureObject*)&(*mLockTex); + + D3D11->getDeviceContext()->Unmap(to->get2DTex(), mLockedSubresource); + + mLockedSubresource = 0; + mLocked = false; + } + else + { + D3D11DEVICECONTEXT->Unmap(get2DTex(), mLockedSubresource); + mLockedSubresource = 0; + mLocked = false; + } +} + +void GFXD3D11TextureObject::release() +{ + SAFE_RELEASE(mSRView); + SAFE_RELEASE(mRTView); + SAFE_RELEASE(mDSView); + SAFE_RELEASE(mD3DTexture); + SAFE_RELEASE(mD3DSurface); +} + +void GFXD3D11TextureObject::zombify() +{ + // Managed textures are managed by D3D + AssertFatal(!mLocked, "GFXD3D11TextureObject::zombify - Cannot zombify a locked texture!"); + if(isManaged) + return; + release(); +} + +void GFXD3D11TextureObject::resurrect() +{ + // Managed textures are managed by D3D + if(isManaged) + return; + + static_cast(TEXMGR)->refreshTexture(this); +} + +bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp) +{ + if (!bmp) + return false; + + // check format limitations + // at the moment we only support RGBA for the source (other 4 byte formats should + // be easy to add though) + AssertFatal(mFormat == GFXFormatR8G8B8A8, "copyToBmp: invalid format"); + if (mFormat != GFXFormatR8G8B8A8) + return false; + + PROFILE_START(GFXD3D11TextureObject_copyToBmp); + + AssertFatal(bmp->getWidth() == getWidth(), "doh"); + AssertFatal(bmp->getHeight() == getHeight(), "doh"); + U32 width = getWidth(); + U32 height = getHeight(); + + bmp->setHasTransparency(mHasTransparency); + + // set some constants + const U32 sourceBytesPerPixel = 4; + U32 destBytesPerPixel = 0; + + if(bmp->getFormat() == GFXFormatR8G8B8A8) + destBytesPerPixel = 4; + else if(bmp->getFormat() == GFXFormatR8G8B8) + destBytesPerPixel = 3; + else + // unsupported + AssertFatal(false, "unsupported bitmap format"); + + + // lock the texture + DXGI_MAPPED_RECT* lockRect = (DXGI_MAPPED_RECT*) lock(); + + // set pointers + U8* srcPtr = (U8*)lockRect->pBits; + U8* destPtr = bmp->getWritableBits(); + + // we will want to skip over any D3D cache data in the source texture + const S32 sourceCacheSize = lockRect->Pitch - width * sourceBytesPerPixel; + AssertFatal(sourceCacheSize >= 0, "copyToBmp: cache size is less than zero?"); + + PROFILE_START(GFXD3D11TextureObject_copyToBmp_pixCopy); + // copy data into bitmap + for (U32 row = 0; row < height; ++row) + { + for (U32 col = 0; col < width; ++col) + { + destPtr[0] = srcPtr[2]; // red + destPtr[1] = srcPtr[1]; // green + destPtr[2] = srcPtr[0]; // blue + if (destBytesPerPixel == 4) + destPtr[3] = srcPtr[3]; // alpha + + // go to next pixel in src + srcPtr += sourceBytesPerPixel; + + // go to next pixel in dest + destPtr += destBytesPerPixel; + } + // skip past the cache data for this row (if any) + srcPtr += sourceCacheSize; + } + PROFILE_END(); + + // assert if we stomped or underran memory + AssertFatal(U32(destPtr - bmp->getWritableBits()) == width * height * destBytesPerPixel, "copyToBmp: doh, memory error"); + AssertFatal(U32(srcPtr - (U8*)lockRect->pBits) == height * lockRect->Pitch, "copyToBmp: doh, memory error"); + + // unlock + unlock(); + + PROFILE_END(); + + return true; +} + +ID3D11ShaderResourceView* GFXD3D11TextureObject::getSRView() +{ + return mSRView; +} +ID3D11RenderTargetView* GFXD3D11TextureObject::getRTView() +{ + return mRTView; +} +ID3D11DepthStencilView* GFXD3D11TextureObject::getDSView() +{ + return mDSView; +} + +ID3D11ShaderResourceView** GFXD3D11TextureObject::getSRViewPtr() +{ + return &mSRView; +} +ID3D11RenderTargetView** GFXD3D11TextureObject::getRTViewPtr() +{ + return &mRTView; +} + +ID3D11DepthStencilView** GFXD3D11TextureObject::getDSViewPtr() +{ + return &mDSView; +} \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.h b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.h new file mode 100644 index 000000000..b50cc2465 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.h @@ -0,0 +1,89 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D11TEXTUREOBJECT_H_ +#define _GFXD3D11TEXTUREOBJECT_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "gfx/gfxTextureHandle.h" +#include "gfx/gfxTextureManager.h" + +class GFXD3D11TextureObject : public GFXTextureObject +{ +protected: + static U32 mTexCount; + GFXTexHandle mLockTex; + DXGI_MAPPED_RECT mLockRect; + bool mLocked; + + U32 mLockedSubresource; + ID3D11Resource *mD3DTexture; + + // used for z buffers... + ID3D11Texture2D *mD3DSurface; + + ID3D11ShaderResourceView* mSRView; // for shader resource input + ID3D11RenderTargetView* mRTView; // for render targets + ID3D11DepthStencilView* mDSView; //render target view for depth stencil + +public: + + GFXD3D11TextureObject( GFXDevice * d, GFXTextureProfile *profile); + ~GFXD3D11TextureObject(); + + ID3D11Resource* getResource(){ return mD3DTexture; } + ID3D11Texture2D* get2DTex(){ return (ID3D11Texture2D*) mD3DTexture; } + ID3D11Texture2D** get2DTexPtr(){ return (ID3D11Texture2D**) &mD3DTexture; } + ID3D11Texture3D* get3DTex(){ return (ID3D11Texture3D*) mD3DTexture; } + ID3D11Texture3D** get3DTexPtr(){ return (ID3D11Texture3D**) &mD3DTexture; } + + ID3D11ShaderResourceView* getSRView(); + ID3D11RenderTargetView* getRTView(); + ID3D11DepthStencilView* getDSView(); + + ID3D11ShaderResourceView** getSRViewPtr(); + ID3D11RenderTargetView** getRTViewPtr(); + ID3D11DepthStencilView** getDSViewPtr(); + + + void release(); + + bool isManaged; //setting to true tells this texture not to be released from being zombify + + virtual GFXLockedRect * lock(U32 mipLevel = 0, RectI *inRect = NULL); + virtual void unlock(U32 mipLevel = 0 ); + + virtual bool copyToBmp(GBitmap* bmp); + ID3D11Texture2D* getSurface() {return mD3DSurface;} + ID3D11Texture2D** getSurfacePtr() {return &mD3DSurface;} + + // GFXResource + void zombify(); + void resurrect(); + +#ifdef TORQUE_DEBUG + virtual void pureVirtualCrash() {}; +#endif +}; + + +#endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.cpp b/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.cpp new file mode 100644 index 000000000..1a8729e76 --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.cpp @@ -0,0 +1,233 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "platform/platform.h" +#include "gfx/D3D11/gfxD3D11VertexBuffer.h" +#include "console/console.h" + +GFXD3D11VertexBuffer::~GFXD3D11VertexBuffer() +{ + if(getOwningDevice() != NULL) + { + if(mBufferType != GFXBufferTypeVolatile) + { + SAFE_RELEASE(vb); + } + } +} + +void GFXD3D11VertexBuffer::lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr) +{ + PROFILE_SCOPE(GFXD3D11VertexBuffer_lock); + + AssertFatal(lockedVertexStart == 0 && lockedVertexEnd == 0, "Cannot lock a buffer more than once!"); + + D3D11_MAP flags = D3D11_MAP_WRITE_DISCARD; + + switch(mBufferType) + { + case GFXBufferTypeStatic: + case GFXBufferTypeDynamic: + flags = D3D11_MAP_WRITE_DISCARD; + break; + + case GFXBufferTypeVolatile: + + // Get or create the volatile buffer... + mVolatileBuffer = D3D11->findVBPool( &mVertexFormat, vertexEnd ); + + if( !mVolatileBuffer ) + mVolatileBuffer = D3D11->createVBPool( &mVertexFormat, mVertexSize ); + + vb = mVolatileBuffer->vb; + + // Get our range now... + AssertFatal(vertexStart == 0, "Cannot get a subrange on a volatile buffer."); + AssertFatal(vertexEnd <= MAX_DYNAMIC_VERTS, "Cannot get more than MAX_DYNAMIC_VERTS in a volatile buffer. Up the constant!"); + AssertFatal(mVolatileBuffer->lockedVertexStart == 0 && mVolatileBuffer->lockedVertexEnd == 0, "Got more than one lock on the volatile pool."); + + // We created the pool when we requested this volatile buffer, so assume it exists... + if( mVolatileBuffer->mNumVerts + vertexEnd > MAX_DYNAMIC_VERTS ) + { + flags = D3D11_MAP_WRITE_DISCARD; + mVolatileStart = vertexStart = 0; + vertexEnd = vertexEnd; + } + else + { + flags = D3D11_MAP_WRITE_NO_OVERWRITE; + mVolatileStart = vertexStart = mVolatileBuffer->mNumVerts; + vertexEnd += mVolatileBuffer->mNumVerts; + } + + mVolatileBuffer->mNumVerts = vertexEnd+1; + + mVolatileBuffer->lockedVertexStart = vertexStart; + mVolatileBuffer->lockedVertexEnd = vertexEnd; + break; + } + + lockedVertexStart = vertexStart; + lockedVertexEnd = vertexEnd; + + // uncomment it for debugging purpose. called many times per frame... spammy! + //Con::printf("%x: Locking %s range (%d, %d)", this, (mBufferType == GFXBufferTypeVolatile ? "volatile" : "static"), lockedVertexStart, lockedVertexEnd); + + U32 sizeToLock = (vertexEnd - vertexStart) * mVertexSize; + if(mBufferType == GFXBufferTypeStatic) + { + *vertexPtr = new U8[sizeToLock]; + mLockedBuffer = *vertexPtr; + } + else + { + D3D11_MAPPED_SUBRESOURCE pVertexData; + ZeroMemory(&pVertexData, sizeof(D3D11_MAPPED_SUBRESOURCE)); + + HRESULT hr = D3D11DEVICECONTEXT->Map(vb, 0, flags, 0, &pVertexData); + + if(FAILED(hr)) + { + AssertFatal(false, "Unable to lock vertex buffer."); + } + + *vertexPtr = (U8*)pVertexData.pData + (vertexStart * mVertexSize); + } + + + + #ifdef TORQUE_DEBUG + + // Allocate a debug buffer large enough for the lock + // plus space for over and under run guard strings. + const U32 guardSize = sizeof( _VBGuardString ); + mDebugGuardBuffer = new U8[sizeToLock+(guardSize*2)]; + + // Setup the guard strings. + dMemcpy( mDebugGuardBuffer, _VBGuardString, guardSize ); + dMemcpy( mDebugGuardBuffer + sizeToLock + guardSize, _VBGuardString, guardSize ); + + // Store the real lock pointer and return our debug pointer. + mLockedBuffer = *vertexPtr; + *vertexPtr = mDebugGuardBuffer + guardSize; + + #endif // TORQUE_DEBUG +} + +void GFXD3D11VertexBuffer::unlock() +{ + PROFILE_SCOPE(GFXD3D11VertexBuffer_unlock); + + #ifdef TORQUE_DEBUG + + if ( mDebugGuardBuffer ) + { + const U32 guardSize = sizeof( _VBGuardString ); + const U32 sizeLocked = (lockedVertexEnd - lockedVertexStart) * mVertexSize; + + // First check the guard areas for overwrites. + AssertFatal(dMemcmp( mDebugGuardBuffer, _VBGuardString, guardSize) == 0, + "GFXD3D11VertexBuffer::unlock - Caught lock memory underrun!" ); + AssertFatal(dMemcmp( mDebugGuardBuffer + sizeLocked + guardSize, _VBGuardString, guardSize) == 0, + "GFXD3D11VertexBuffer::unlock - Caught lock memory overrun!" ); + + // Copy the debug content down to the real VB. + dMemcpy(mLockedBuffer, mDebugGuardBuffer + guardSize, sizeLocked); + + // Cleanup. + delete [] mDebugGuardBuffer; + mDebugGuardBuffer = NULL; + //mLockedBuffer = NULL; + } + + #endif // TORQUE_DEBUG + + if(mBufferType == GFXBufferTypeStatic) + { + const U32 sizeLocked = (lockedVertexEnd - lockedVertexStart) * mVertexSize; + //set up the update region of the buffer + D3D11_BOX box; + box.back = 1; + box.front = 0; + box.top = 0; + box.bottom = 1; + box.left = lockedVertexStart * mVertexSize; + box.right = lockedVertexEnd * mVertexSize; + //update the real vb buffer + D3D11DEVICECONTEXT->UpdateSubresource(vb, 0, &box,mLockedBuffer,sizeLocked, 0); + //clean up the old buffer + delete[] mLockedBuffer; + mLockedBuffer = NULL; + } + else + { + D3D11DEVICECONTEXT->Unmap(vb,0); + } + + + mIsFirstLock = false; + + //uncomment it for debugging purpose. called many times per frame... spammy! + //Con::printf("%x: Unlocking %s range (%d, %d)", this, (mBufferType == GFXBufferTypeVolatile ? "volatile" : "static"), lockedVertexStart, lockedVertexEnd); + + lockedVertexEnd = lockedVertexStart = 0; + + if(mVolatileBuffer.isValid()) + { + mVolatileBuffer->lockedVertexStart = 0; + mVolatileBuffer->lockedVertexEnd = 0; + mVolatileBuffer = NULL; + } +} + +void GFXD3D11VertexBuffer::zombify() +{ + AssertFatal(lockedVertexStart == 0 && lockedVertexEnd == 0, "GFXD3D11VertexBuffer::zombify - Cannot zombify a locked buffer!"); + // Static buffers are managed by D3D11 so we don't deal with them. + if(mBufferType == GFXBufferTypeDynamic) + { + SAFE_RELEASE(vb); + } +} + +void GFXD3D11VertexBuffer::resurrect() +{ + // Static buffers are managed by D3D11 so we don't deal with them. + if(mBufferType == GFXBufferTypeDynamic) + { + D3D11_BUFFER_DESC desc; + desc.ByteWidth = mVertexSize * mNumVerts; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; + + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &vb); + + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11VertexBuffer::resurrect - Failed to allocate VB"); + } + } +} + diff --git a/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.h b/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.h new file mode 100644 index 000000000..380a0f93b --- /dev/null +++ b/Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.h @@ -0,0 +1,95 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2015 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifndef _GFXD3D_VERTEXBUFFER_H_ +#define _GFXD3D_VERTEXBUFFER_H_ + +#include "gfx/D3D11/gfxD3D11Device.h" +#include "core/util/safeDelete.h" + +class GFXD3D11VertexBuffer : public GFXVertexBuffer +{ +public: + ID3D11Buffer *vb; + StrongRefPtr mVolatileBuffer; + void *mLockedBuffer; +#ifdef TORQUE_DEBUG + #define _VBGuardString "GFX_VERTEX_BUFFER_GUARD_STRING" + U8 *mDebugGuardBuffer; + +#endif TORQUE_DEBUG + + bool mIsFirstLock; + bool mClearAtFrameEnd; + + GFXD3D11VertexBuffer(); + GFXD3D11VertexBuffer( GFXDevice *device, + U32 numVerts, + const GFXVertexFormat *vertexFormat, + U32 vertexSize, + GFXBufferType bufferType ); + virtual ~GFXD3D11VertexBuffer(); + + void lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr); + void unlock(); + void prepare() {} + + // GFXResource interface + virtual void zombify(); + virtual void resurrect(); +}; + +//----------------------------------------------------------------------------- +// This is for debugging vertex buffers and trying to track down which vbs +// aren't getting free'd + +inline GFXD3D11VertexBuffer::GFXD3D11VertexBuffer() : GFXVertexBuffer(0,0,0,0,(GFXBufferType)0) +{ + vb = NULL; + mIsFirstLock = true; + lockedVertexEnd = lockedVertexStart = 0; + mClearAtFrameEnd = false; + +#ifdef TORQUE_DEBUG + mDebugGuardBuffer = NULL; + mLockedBuffer = NULL; +#endif +} + +inline GFXD3D11VertexBuffer::GFXD3D11VertexBuffer( GFXDevice *device, + U32 numVerts, + const GFXVertexFormat *vertexFormat, + U32 vertexSize, + GFXBufferType bufferType ) + : GFXVertexBuffer( device, numVerts, vertexFormat, vertexSize, bufferType ) +{ + vb = NULL; + mIsFirstLock = true; + mClearAtFrameEnd = false; + lockedVertexEnd = lockedVertexStart = 0; + mLockedBuffer = NULL; +#ifdef TORQUE_DEBUG + mDebugGuardBuffer = NULL; +#endif +} + +#endif // _GFXD3D_VERTEXBUFFER_H_ \ No newline at end of file diff --git a/Engine/source/gfx/D3D11/screenshotD3D11.cpp b/Engine/source/gfx/D3D11/screenshotD3D11.cpp new file mode 100644 index 000000000..89fa5f90c --- /dev/null +++ b/Engine/source/gfx/D3D11/screenshotD3D11.cpp @@ -0,0 +1,98 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2016 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#include "platform/platform.h" +#include "gfx/D3D11/screenshotD3D11.h" +#include "gfx/D3D11/gfxD3D11Device.h" + +//Note if MSAA is ever enabled this will need fixing +GBitmap* ScreenShotD3D11::_captureBackBuffer() +{ + ID3D11Texture2D* backBuf = D3D11->getBackBufferTexture(); + D3D11_TEXTURE2D_DESC desc; + backBuf->GetDesc(&desc); + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + desc.Usage = D3D11_USAGE_STAGING; + + //create temp texure + ID3D11Texture2D* pNewTexture = NULL; + HRESULT hr = D3D11DEVICE->CreateTexture2D(&desc, NULL, &pNewTexture); + if (FAILED(hr)) + return NULL; + + U32 width = desc.Width; + U32 height = desc.Height; + // pixel data + U8 *pData = new U8[width * height * 4]; + + D3D11DEVICECONTEXT->CopyResource(pNewTexture, backBuf); + D3D11_MAPPED_SUBRESOURCE Resource; + + hr = D3D11DEVICECONTEXT->Map(pNewTexture, 0, D3D11_MAP_READ, 0, &Resource); + if (FAILED(hr)) + { + //cleanup + SAFE_DELETE(pData); + SAFE_RELEASE(pNewTexture); + return NULL; + } + + const U32 pitch = width << 2; + const U8* pSource = (U8*)Resource.pData; + U32 totalPitch = 0; + for (U32 i = 0; i < height; ++i) + { + dMemcpy(pData, pSource, width * 4); + pSource += Resource.RowPitch; + pData += pitch; + totalPitch += pitch; + } + + D3D11DEVICECONTEXT->Unmap(pNewTexture, 0); + pData -= totalPitch; + GBitmap *gb = new GBitmap(width, height); + + //Set GBitmap data and convert from bgr to rgb + ColorI c; + for (S32 i = 0; isetColor(j, i, c); + } + } + + //cleanup + SAFE_DELETE(pData); + SAFE_RELEASE(pNewTexture); + + + return gb; + +} + diff --git a/Engine/source/gfx/D3D11/screenshotD3D11.h b/Engine/source/gfx/D3D11/screenshotD3D11.h new file mode 100644 index 000000000..1a3de23b7 --- /dev/null +++ b/Engine/source/gfx/D3D11/screenshotD3D11.h @@ -0,0 +1,39 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2016 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- +#ifndef _SCREENSHOTD3D11_H_ +#define _SCREENSHOTD3D11_H_ + +#include "gfx/screenshot.h" + +//************************************************************************** +// D3D implementation of screenshot +//************************************************************************** +class ScreenShotD3D11 : public ScreenShot +{ +protected: + + GBitmap* _captureBackBuffer(); + +}; + + +#endif // _SCREENSHOTD3D11_H_