From 1ff6f221fb2a1963fadb48e786ec87d1a9c02fcd Mon Sep 17 00:00:00 2001 From: rextimmy Date: Sun, 20 Mar 2016 21:48:52 +1000 Subject: [PATCH 01/13] Direct3D11 GFX device. --- .../source/gfx/D3D11/gfxD3D11CardProfiler.cpp | 72 + .../source/gfx/D3D11/gfxD3D11CardProfiler.h | 46 + Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp | 352 ++++ Engine/source/gfx/D3D11/gfxD3D11Cubemap.h | 80 + Engine/source/gfx/D3D11/gfxD3D11Device.cpp | 1721 +++++++++++++++++ Engine/source/gfx/D3D11/gfxD3D11Device.h | 295 +++ .../gfx/D3D11/gfxD3D11EnumTranslate.cpp | 155 ++ .../source/gfx/D3D11/gfxD3D11EnumTranslate.h | 51 + .../gfx/D3D11/gfxD3D11OcclusionQuery.cpp | 177 ++ .../source/gfx/D3D11/gfxD3D11OcclusionQuery.h | 58 + .../gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp | 222 +++ .../gfx/D3D11/gfxD3D11PrimitiveBuffer.h | 83 + .../source/gfx/D3D11/gfxD3D11QueryFence.cpp | 110 ++ Engine/source/gfx/D3D11/gfxD3D11QueryFence.h | 49 + Engine/source/gfx/D3D11/gfxD3D11Shader.cpp | 1542 +++++++++++++++ Engine/source/gfx/D3D11/gfxD3D11Shader.h | 471 +++++ .../source/gfx/D3D11/gfxD3D11StateBlock.cpp | 285 +++ Engine/source/gfx/D3D11/gfxD3D11StateBlock.h | 76 + Engine/source/gfx/D3D11/gfxD3D11Target.cpp | 409 ++++ Engine/source/gfx/D3D11/gfxD3D11Target.h | 110 ++ .../gfx/D3D11/gfxD3D11TextureManager.cpp | 587 ++++++ .../source/gfx/D3D11/gfxD3D11TextureManager.h | 62 + .../gfx/D3D11/gfxD3D11TextureObject.cpp | 280 +++ .../source/gfx/D3D11/gfxD3D11TextureObject.h | 89 + .../source/gfx/D3D11/gfxD3D11VertexBuffer.cpp | 233 +++ .../source/gfx/D3D11/gfxD3D11VertexBuffer.h | 95 + Engine/source/gfx/D3D11/screenshotD3D11.cpp | 98 + Engine/source/gfx/D3D11/screenshotD3D11.h | 39 + 28 files changed, 7847 insertions(+) create mode 100644 Engine/source/gfx/D3D11/gfxD3D11CardProfiler.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11CardProfiler.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Cubemap.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Device.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Device.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11QueryFence.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11QueryFence.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Shader.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Shader.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11StateBlock.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11StateBlock.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Target.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11Target.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11TextureManager.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11TextureManager.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11TextureObject.h create mode 100644 Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.cpp create mode 100644 Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.h create mode 100644 Engine/source/gfx/D3D11/screenshotD3D11.cpp create mode 100644 Engine/source/gfx/D3D11/screenshotD3D11.h 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_ From 3a9b50f702563d99317c8bd45f28146f67df362c Mon Sep 17 00:00:00 2001 From: rextimmy Date: Sun, 20 Mar 2016 21:50:21 +1000 Subject: [PATCH 02/13] Direct3D11 common shader changes. --- .../shaders/common/VolumetricFog/VFogP.hlsl | 34 ++--- .../common/VolumetricFog/VFogPreP.hlsl | 5 +- .../common/VolumetricFog/VFogPreV.hlsl | 14 +- .../common/VolumetricFog/VFogRefl.hlsl | 6 +- .../shaders/common/VolumetricFog/VFogV.hlsl | 13 +- .../game/shaders/common/basicCloudsP.hlsl | 8 +- .../game/shaders/common/basicCloudsV.hlsl | 27 ++-- .../game/shaders/common/cloudLayerP.hlsl | 15 ++- .../game/shaders/common/cloudLayerV.hlsl | 11 +- .../fixedFunction/addColorTextureP.hlsl | 17 ++- .../fixedFunction/addColorTextureV.hlsl | 14 +- .../shaders/common/fixedFunction/colorP.hlsl | 12 +- .../shaders/common/fixedFunction/colorV.hlsl | 14 +- .../fixedFunction/modColorTextureP.hlsl | 17 ++- .../fixedFunction/modColorTextureV.hlsl | 14 +- .../common/fixedFunction/textureP.hlsl | 36 ++++++ .../common/fixedFunction/textureV.hlsl | 46 +++++++ .../Empty/game/shaders/common/foliage.hlsl | 4 +- .../shaders/common/fxFoliageReplicatorP.hlsl | 25 ++-- .../shaders/common/fxFoliageReplicatorV.hlsl | 39 +++--- .../game/shaders/common/gl/basicCloudsV.glsl | 1 + .../game/shaders/common/gl/cloudLayerV.glsl | 1 + .../game/shaders/common/gl/lighting.glsl | 43 ++++++- .../game/shaders/common/gl/scatterSkyP.glsl | 3 + .../Empty/game/shaders/common/gl/torque.glsl | 33 +++++ .../game/shaders/common/guiMaterialV.hlsl | 12 +- .../game/shaders/common/hlslStructs.hlsl | 114 +++++++++++++++++ .../Empty/game/shaders/common/lighting.hlsl | 43 ++++++- .../lighting/advanced/convexGeometryV.hlsl | 19 ++- .../lighting/advanced/dbgColorBufferP.hlsl | 30 +++++ .../lighting/advanced/dbgDepthVisualizeP.hlsl | 12 +- .../lighting/advanced/dbgGlowVisualizeP.hlsl | 7 +- .../advanced/dbgLightColorVisualizeP.hlsl | 12 +- .../advanced/dbgLightSpecularVisualizeP.hlsl | 11 +- .../advanced/dbgNormalVisualizeP.hlsl | 8 +- .../advanced/dbgShadowVisualizeP.hlsl | 14 +- .../advanced/dbgSpecMapVisualizeP.hlsl | 31 +++++ .../advanced/deferredClearGBufferP.hlsl | 54 ++++++++ .../advanced/deferredClearGBufferV.hlsl | 43 +++++++ .../advanced/deferredColorShaderP.hlsl | 46 +++++++ .../lighting/advanced/deferredShadingP.hlsl | 54 ++++++++ .../lighting/advanced/farFrustumQuad.hlsl | 4 +- .../lighting/advanced/farFrustumQuadV.hlsl | 6 +- .../lighting/advanced/gl/dbgColorBufferP.glsl | 34 +++++ .../advanced/gl/dbgDepthVisualizeP.glsl | 4 +- .../advanced/gl/dbgLightColorVisualizeP.glsl | 8 +- .../gl/dbgLightSpecularVisualizeP.glsl | 6 +- .../advanced/gl/dbgNormalVisualizeP.glsl | 4 +- .../advanced/gl/dbgSpecMapVisualizeP.glsl | 34 +++++ .../advanced/gl/deferredClearGBufferP.glsl | 40 ++++++ .../advanced/gl/deferredColorShaderP.glsl | 37 ++++++ .../advanced/gl/deferredShadingP.glsl | 59 +++++++++ .../lighting/advanced/gl/pointLightP.glsl | 17 ++- .../lighting/advanced/gl/spotLightP.glsl | 18 ++- .../lighting/advanced/gl/vectorLightP.glsl | 29 +++-- .../advanced/particlePointLightP.hlsl | 25 ++-- .../advanced/particlePointLightV.hlsl | 20 +-- .../common/lighting/advanced/pointLightP.hlsl | 76 ++++++----- .../common/lighting/advanced/softShadow.hlsl | 19 ++- .../common/lighting/advanced/spotLightP.hlsl | 66 ++++++---- .../lighting/advanced/vectorLightP.hlsl | 120 ++++++++++-------- .../common/lighting/basic/shadowFilterP.hlsl | 12 +- .../common/lighting/basic/shadowFilterV.hlsl | 4 +- .../common/lighting/shadowMap/boxFilterP.hlsl | 22 ++-- .../common/lighting/shadowMap/boxFilterV.hlsl | 11 +- .../shaders/common/particleCompositeP.hlsl | 20 ++- .../shaders/common/particleCompositeV.hlsl | 18 ++- .../Empty/game/shaders/common/particlesP.hlsl | 22 ++-- .../Empty/game/shaders/common/particlesV.hlsl | 10 +- .../shaders/common/planarReflectBumpP.hlsl | 26 ++-- .../shaders/common/planarReflectBumpV.hlsl | 15 ++- .../game/shaders/common/planarReflectP.hlsl | 21 +-- .../game/shaders/common/planarReflectV.hlsl | 13 +- .../shaders/common/postFx/VolFogGlowP.hlsl | 22 ++-- .../common/postFx/caustics/causticsP.hlsl | 21 +-- .../shaders/common/postFx/chromaticLens.hlsl | 7 +- .../common/postFx/dof/DOF_CalcCoC_P.hlsl | 11 +- .../common/postFx/dof/DOF_CalcCoC_V.hlsl | 2 +- .../common/postFx/dof/DOF_DownSample_P.hlsl | 80 ++++++------ .../common/postFx/dof/DOF_DownSample_V.hlsl | 6 +- .../common/postFx/dof/DOF_Final_P.hlsl | 41 +++--- .../common/postFx/dof/DOF_Final_V.hlsl | 2 +- .../common/postFx/dof/DOF_Gausian_P.hlsl | 22 ++-- .../common/postFx/dof/DOF_Gausian_V.hlsl | 6 +- .../common/postFx/dof/DOF_Passthrough_V.hlsl | 2 +- .../common/postFx/dof/DOF_SmallBlur_P.hlsl | 15 ++- .../common/postFx/dof/DOF_SmallBlur_V.hlsl | 6 +- .../common/postFx/dof/gl/DOF_CalcCoC_P.glsl | 2 +- .../common/postFx/edgeaa/dbgEdgeDisplayP.hlsl | 8 +- .../shaders/common/postFx/edgeaa/edgeAAP.hlsl | 14 +- .../common/postFx/edgeaa/edgeDetectP.hlsl | 17 ++- .../game/shaders/common/postFx/flashP.hlsl | 6 +- .../game/shaders/common/postFx/fogP.hlsl | 9 +- .../shaders/common/postFx/fxaa/fxaaP.hlsl | 29 ++++- .../shaders/common/postFx/fxaa/fxaaV.hlsl | 4 +- .../game/shaders/common/postFx/gammaP.hlsl | 23 ++-- .../game/shaders/common/postFx/gl/gammaP.glsl | 8 ++ .../shaders/common/postFx/gl/glowBlurP.glsl | 4 +- .../game/shaders/common/postFx/glowBlurP.hlsl | 22 ++-- .../game/shaders/common/postFx/glowBlurV.hlsl | 4 +- .../common/postFx/hdr/bloomGaussBlurHP.hlsl | 7 +- .../common/postFx/hdr/bloomGaussBlurVP.hlsl | 7 +- .../common/postFx/hdr/brightPassFilterP.hlsl | 11 +- .../postFx/hdr/calculateAdaptedLumP.hlsl | 11 +- .../common/postFx/hdr/downScale4x4P.hlsl | 11 +- .../common/postFx/hdr/downScale4x4V.hlsl | 9 +- .../common/postFx/hdr/finalPassCombineP.hlsl | 41 +++--- .../postFx/hdr/gl/finalPassCombineP.glsl | 11 +- .../common/postFx/hdr/luminanceVisP.hlsl | 7 +- .../common/postFx/hdr/sampleLumInitialP.hlsl | 6 +- .../postFx/hdr/sampleLumIterativeP.hlsl | 6 +- .../postFx/lightRay/lightRayOccludeP.hlsl | 12 +- .../common/postFx/lightRay/lightRayP.hlsl | 17 +-- .../shaders/common/postFx/motionBlurP.hlsl | 15 +-- .../oculusvr/barrelDistortionChromaP.hlsl | 10 +- .../postFx/oculusvr/barrelDistortionP.hlsl | 7 +- .../common/postFx/oculusvr/monoToStereoP.hlsl | 7 +- .../game/shaders/common/postFx/passthruP.hlsl | 6 +- .../game/shaders/common/postFx/postFx.hlsl | 5 +- .../game/shaders/common/postFx/postFxV.hlsl | 2 +- .../common/postFx/ssao/SSAO_Blur_P.hlsl | 24 ++-- .../common/postFx/ssao/SSAO_Blur_V.hlsl | 6 +- .../shaders/common/postFx/ssao/SSAO_P.hlsl | 20 +-- .../common/postFx/ssao/SSAO_PowerTable_P.hlsl | 2 +- .../common/postFx/ssao/SSAO_PowerTable_V.hlsl | 2 +- .../shaders/common/postFx/turbulenceP.hlsl | 6 +- .../shaders/common/postFx/underwaterFogP.hlsl | 20 +-- .../common/postFx/vignette/VignetteP.hlsl | 7 +- .../Empty/game/shaders/common/precipP.hlsl | 16 ++- .../Empty/game/shaders/common/precipV.hlsl | 21 +-- .../game/shaders/common/projectedShadowP.hlsl | 11 +- .../game/shaders/common/projectedShadowV.hlsl | 18 +-- .../common/ribbons/basicRibbonShaderP.hlsl | 7 +- .../common/ribbons/basicRibbonShaderV.hlsl | 23 ++-- .../common/ribbons/texRibbonShaderP.hlsl | 13 +- .../common/ribbons/texRibbonShaderV.hlsl | 23 ++-- .../game/shaders/common/scatterSkyP.hlsl | 10 +- .../game/shaders/common/scatterSkyV.hlsl | 33 +++-- .../game/shaders/common/shaderModel.hlsl | 97 ++++++++++++++ .../shaders/common/shaderModelAutoGen.hlsl | 35 +++++ .../game/shaders/common/terrain/blendP.hlsl | 19 +-- .../game/shaders/common/terrain/blendV.hlsl | 11 +- .../game/shaders/common/terrain/terrain.glsl | 1 + .../game/shaders/common/terrain/terrain.hlsl | 1 + .../Empty/game/shaders/common/torque.hlsl | 51 ++++++-- .../shaders/common/water/gl/waterBasicP.glsl | 1 + .../game/shaders/common/water/gl/waterP.glsl | 3 +- .../shaders/common/water/waterBasicP.hlsl | 29 +++-- .../shaders/common/water/waterBasicV.hlsl | 23 ++-- .../game/shaders/common/water/waterP.hlsl | 49 +++---- .../game/shaders/common/water/waterV.hlsl | 18 +-- .../Empty/game/shaders/common/wavesP.hlsl | 29 +++-- .../Empty/game/shaders/common/wavesV.hlsl | 17 ++- .../lighting/advanced/deferredShading.cs | 2 +- .../shaders/common/VolumetricFog/VFogP.hlsl | 34 ++--- .../common/VolumetricFog/VFogPreP.hlsl | 5 +- .../common/VolumetricFog/VFogPreV.hlsl | 14 +- .../common/VolumetricFog/VFogRefl.hlsl | 5 +- .../shaders/common/VolumetricFog/VFogV.hlsl | 13 +- .../game/shaders/common/basicCloudsP.hlsl | 8 +- .../game/shaders/common/basicCloudsV.hlsl | 26 ++-- .../Full/game/shaders/common/cloudLayerP.hlsl | 15 ++- .../Full/game/shaders/common/cloudLayerV.hlsl | 11 +- .../fixedFunction/addColorTextureP.hlsl | 17 ++- .../fixedFunction/addColorTextureV.hlsl | 14 +- .../shaders/common/fixedFunction/colorP.hlsl | 12 +- .../shaders/common/fixedFunction/colorV.hlsl | 14 +- .../fixedFunction/modColorTextureP.hlsl | 17 ++- .../fixedFunction/modColorTextureV.hlsl | 14 +- .../common/fixedFunction/textureP.hlsl | 36 ++++++ .../common/fixedFunction/textureV.hlsl | 46 +++++++ .../Full/game/shaders/common/foliage.hlsl | 4 +- .../shaders/common/fxFoliageReplicatorP.hlsl | 25 ++-- .../shaders/common/fxFoliageReplicatorV.hlsl | 39 +++--- .../game/shaders/common/guiMaterialV.hlsl | 12 +- .../Full/game/shaders/common/hlslStructs.hlsl | 114 +++++++++++++++++ .../Full/game/shaders/common/lighting.hlsl | 2 +- .../lighting/advanced/convexGeometryV.hlsl | 19 ++- .../lighting/advanced/dbgColorBufferP.hlsl | 7 +- .../lighting/advanced/dbgDepthVisualizeP.hlsl | 12 +- .../lighting/advanced/dbgGlowVisualizeP.hlsl | 7 +- .../advanced/dbgLightColorVisualizeP.hlsl | 8 +- .../advanced/dbgLightSpecularVisualizeP.hlsl | 9 +- .../advanced/dbgNormalVisualizeP.hlsl | 8 +- .../advanced/dbgShadowVisualizeP.hlsl | 14 +- .../advanced/dbgSpecMapVisualizeP.hlsl | 7 +- .../advanced/deferredClearGBufferP.hlsl | 15 ++- .../advanced/deferredClearGBufferV.hlsl | 43 +++++++ .../advanced/deferredColorShaderP.hlsl | 8 +- .../lighting/advanced/deferredShadingP.hlsl | 20 +-- .../lighting/advanced/farFrustumQuad.hlsl | 4 +- .../lighting/advanced/farFrustumQuadV.hlsl | 6 +- .../advanced/particlePointLightP.hlsl | 25 ++-- .../advanced/particlePointLightV.hlsl | 20 +-- .../common/lighting/advanced/pointLightP.hlsl | 70 +++++----- .../common/lighting/advanced/softShadow.hlsl | 19 ++- .../common/lighting/advanced/spotLightP.hlsl | 62 ++++----- .../lighting/advanced/vectorLightP.hlsl | 111 ++++++++-------- .../common/lighting/basic/shadowFilterP.hlsl | 12 +- .../common/lighting/basic/shadowFilterV.hlsl | 4 +- .../common/lighting/shadowMap/boxFilterP.hlsl | 22 ++-- .../common/lighting/shadowMap/boxFilterV.hlsl | 11 +- .../shaders/common/particleCompositeP.hlsl | 20 ++- .../shaders/common/particleCompositeV.hlsl | 18 ++- .../Full/game/shaders/common/particlesP.hlsl | 22 ++-- .../Full/game/shaders/common/particlesV.hlsl | 10 +- .../shaders/common/planarReflectBumpP.hlsl | 26 ++-- .../shaders/common/planarReflectBumpV.hlsl | 15 ++- .../game/shaders/common/planarReflectP.hlsl | 21 +-- .../game/shaders/common/planarReflectV.hlsl | 13 +- .../shaders/common/postFx/VolFogGlowP.hlsl | 22 ++-- .../common/postFx/caustics/causticsP.hlsl | 21 +-- .../shaders/common/postFx/chromaticLens.hlsl | 7 +- .../common/postFx/dof/DOF_CalcCoC_P.hlsl | 11 +- .../common/postFx/dof/DOF_CalcCoC_V.hlsl | 2 +- .../common/postFx/dof/DOF_DownSample_P.hlsl | 80 ++++++------ .../common/postFx/dof/DOF_DownSample_V.hlsl | 6 +- .../common/postFx/dof/DOF_Final_P.hlsl | 41 +++--- .../common/postFx/dof/DOF_Final_V.hlsl | 2 +- .../common/postFx/dof/DOF_Gausian_P.hlsl | 22 ++-- .../common/postFx/dof/DOF_Gausian_V.hlsl | 6 +- .../common/postFx/dof/DOF_Passthrough_V.hlsl | 2 +- .../common/postFx/dof/DOF_SmallBlur_P.hlsl | 15 ++- .../common/postFx/dof/DOF_SmallBlur_V.hlsl | 6 +- .../common/postFx/edgeaa/dbgEdgeDisplayP.hlsl | 8 +- .../shaders/common/postFx/edgeaa/edgeAAP.hlsl | 14 +- .../common/postFx/edgeaa/edgeDetectP.hlsl | 17 ++- .../game/shaders/common/postFx/flashP.hlsl | 6 +- .../Full/game/shaders/common/postFx/fogP.hlsl | 9 +- .../shaders/common/postFx/fxaa/fxaaP.hlsl | 29 ++++- .../shaders/common/postFx/fxaa/fxaaV.hlsl | 4 +- .../game/shaders/common/postFx/gammaP.hlsl | 14 +- .../game/shaders/common/postFx/glowBlurP.hlsl | 22 ++-- .../game/shaders/common/postFx/glowBlurV.hlsl | 4 +- .../common/postFx/hdr/bloomGaussBlurHP.hlsl | 7 +- .../common/postFx/hdr/bloomGaussBlurVP.hlsl | 7 +- .../common/postFx/hdr/brightPassFilterP.hlsl | 11 +- .../postFx/hdr/calculateAdaptedLumP.hlsl | 11 +- .../common/postFx/hdr/downScale4x4P.hlsl | 11 +- .../common/postFx/hdr/downScale4x4V.hlsl | 9 +- .../common/postFx/hdr/finalPassCombineP.hlsl | 32 +++-- .../common/postFx/hdr/luminanceVisP.hlsl | 7 +- .../common/postFx/hdr/sampleLumInitialP.hlsl | 6 +- .../postFx/hdr/sampleLumIterativeP.hlsl | 6 +- .../postFx/lightRay/lightRayOccludeP.hlsl | 12 +- .../common/postFx/lightRay/lightRayP.hlsl | 17 +-- .../shaders/common/postFx/motionBlurP.hlsl | 15 +-- .../oculusvr/barrelDistortionChromaP.hlsl | 10 +- .../postFx/oculusvr/barrelDistortionP.hlsl | 7 +- .../common/postFx/oculusvr/monoToStereoP.hlsl | 7 +- .../game/shaders/common/postFx/passthruP.hlsl | 6 +- .../game/shaders/common/postFx/postFx.hlsl | 5 +- .../game/shaders/common/postFx/postFxV.hlsl | 2 +- .../common/postFx/ssao/SSAO_Blur_P.hlsl | 24 ++-- .../common/postFx/ssao/SSAO_Blur_V.hlsl | 6 +- .../shaders/common/postFx/ssao/SSAO_P.hlsl | 20 +-- .../common/postFx/ssao/SSAO_PowerTable_P.hlsl | 2 +- .../common/postFx/ssao/SSAO_PowerTable_V.hlsl | 2 +- .../shaders/common/postFx/turbulenceP.hlsl | 6 +- .../shaders/common/postFx/underwaterFogP.hlsl | 20 +-- .../common/postFx/vignette/VignetteP.hlsl | 7 +- .../Full/game/shaders/common/precipP.hlsl | 16 ++- .../Full/game/shaders/common/precipV.hlsl | 21 +-- .../game/shaders/common/projectedShadowP.hlsl | 11 +- .../game/shaders/common/projectedShadowV.hlsl | 18 +-- .../common/ribbons/basicRibbonShaderP.hlsl | 7 +- .../common/ribbons/basicRibbonShaderV.hlsl | 23 ++-- .../common/ribbons/texRibbonShaderP.hlsl | 13 +- .../common/ribbons/texRibbonShaderV.hlsl | 23 ++-- .../Full/game/shaders/common/scatterSkyP.hlsl | 10 +- .../Full/game/shaders/common/scatterSkyV.hlsl | 33 +++-- .../Full/game/shaders/common/shaderModel.hlsl | 97 ++++++++++++++ .../shaders/common/shaderModelAutoGen.hlsl | 35 +++++ .../game/shaders/common/terrain/blendP.hlsl | 19 +-- .../game/shaders/common/terrain/blendV.hlsl | 11 +- .../game/shaders/common/terrain/terrain.hlsl | 1 + .../Full/game/shaders/common/torque.hlsl | 19 +-- .../shaders/common/water/waterBasicP.hlsl | 28 ++-- .../shaders/common/water/waterBasicV.hlsl | 23 ++-- .../game/shaders/common/water/waterP.hlsl | 48 +++---- .../game/shaders/common/water/waterV.hlsl | 18 +-- .../Full/game/shaders/common/wavesP.hlsl | 29 +++-- .../Full/game/shaders/common/wavesV.hlsl | 17 ++- 283 files changed, 3547 insertions(+), 1834 deletions(-) create mode 100644 Templates/Empty/game/shaders/common/fixedFunction/textureP.hlsl create mode 100644 Templates/Empty/game/shaders/common/fixedFunction/textureV.hlsl create mode 100644 Templates/Empty/game/shaders/common/hlslStructs.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/deferredShadingP.hlsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgColorBufferP.glsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgSpecMapVisualizeP.glsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredClearGBufferP.glsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredColorShaderP.glsl create mode 100644 Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl create mode 100644 Templates/Empty/game/shaders/common/shaderModel.hlsl create mode 100644 Templates/Empty/game/shaders/common/shaderModelAutoGen.hlsl create mode 100644 Templates/Full/game/shaders/common/fixedFunction/textureP.hlsl create mode 100644 Templates/Full/game/shaders/common/fixedFunction/textureV.hlsl create mode 100644 Templates/Full/game/shaders/common/hlslStructs.hlsl create mode 100644 Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl create mode 100644 Templates/Full/game/shaders/common/shaderModel.hlsl create mode 100644 Templates/Full/game/shaders/common/shaderModelAutoGen.hlsl diff --git a/Templates/Empty/game/shaders/common/VolumetricFog/VFogP.hlsl b/Templates/Empty/game/shaders/common/VolumetricFog/VFogP.hlsl index aaadbf479..e900f7548 100644 --- a/Templates/Empty/game/shaders/common/VolumetricFog/VFogP.hlsl +++ b/Templates/Empty/game/shaders/common/VolumetricFog/VFogP.hlsl @@ -21,44 +21,44 @@ //----------------------------------------------------------------------------- // Volumetric Fog final pixel shader V2.00 - -#include "shadergen:/autogenConditioners.h" +#include "../shaderModel.hlsl" +#include "../shaderModelAutoGen.hlsl" #include "../torque.hlsl" -uniform sampler2D prepassTex : register(S0); -uniform sampler2D depthBuffer : register(S1); -uniform sampler2D frontBuffer : register(S2); -uniform sampler2D density : register(S3); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER2D(depthBuffer, 1); +TORQUE_UNIFORM_SAMPLER2D(frontBuffer, 2); +TORQUE_UNIFORM_SAMPLER2D(density, 3); +uniform float3 ambientColor; uniform float accumTime; uniform float4 fogColor; +uniform float4 modspeed;//xy speed layer 1, zw speed layer 2 +uniform float2 viewpoint; +uniform float2 texscale; uniform float fogDensity; uniform float preBias; uniform float textured; uniform float modstrength; -uniform float4 modspeed;//xy speed layer 1, zw speed layer 2 -uniform float2 viewpoint; -uniform float2 texscale; -uniform float3 ambientColor; uniform float numtiles; uniform float fadesize; uniform float2 PixelSize; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 htpos : TEXCOORD0; float2 uv0 : TEXCOORD1; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { float2 uvscreen=((IN.htpos.xy/IN.htpos.w) + 1.0 ) / 2.0; uvscreen.y = 1.0 - uvscreen.y; - float obj_test = prepassUncondition( prepassTex, uvscreen).w * preBias; - float depth = tex2D(depthBuffer,uvscreen).r; - float front = tex2D(frontBuffer,uvscreen).r; + float obj_test = TORQUE_PREPASS_UNCONDITION(prepassTex, uvscreen).w * preBias; + float depth = TORQUE_TEX2D(depthBuffer, uvscreen).r; + float front = TORQUE_TEX2D(frontBuffer, uvscreen).r; if (depth <= front) return float4(0,0,0,0); @@ -73,8 +73,8 @@ float4 main( ConnectData IN ) : COLOR0 { float2 offset = viewpoint + ((-0.5 + (texscale * uvscreen)) * numtiles); - float2 mod1 = tex2D(density,(offset + (modspeed.xy*accumTime))).rg; - float2 mod2= tex2D(density,(offset + (modspeed.zw*accumTime))).rg; + float2 mod1 = TORQUE_TEX2D(density, (offset + (modspeed.xy*accumTime))).rg; + float2 mod2 = TORQUE_TEX2D(density, (offset + (modspeed.zw*accumTime))).rg; diff = (mod2.r + mod1.r) * modstrength; col *= (2.0 - ((mod1.g + mod2.g) * fadesize))/2.0; } diff --git a/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreP.hlsl b/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreP.hlsl index bb06f5f7c..fdc839507 100644 --- a/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreP.hlsl +++ b/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreP.hlsl @@ -21,14 +21,15 @@ //----------------------------------------------------------------------------- // Volumetric Fog prepass pixel shader V1.00 +#include "../shaderModel.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { float OUT; diff --git a/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreV.hlsl b/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreV.hlsl index 2d13cdf01..aba7a745d 100644 --- a/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreV.hlsl +++ b/Templates/Empty/game/shaders/common/VolumetricFog/VFogPreV.hlsl @@ -22,11 +22,12 @@ // Volumetric Fog prepass vertex shader V1.00 -#include "shaders/common/hlslstructs.h" +#include "../shaderModel.hlsl" +#include "../hlslStructs.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; @@ -35,12 +36,9 @@ uniform float4x4 modelView; ConnectData main( VertexIn_P IN) { ConnectData OUT; - - float4 inPos = IN.pos; - inPos.w = 1.0; - OUT.hpos = mul( modelView, inPos ); - OUT.pos = OUT.hpos; + OUT.hpos = mul(modelView, float4(IN.pos, 1.0)); + OUT.pos = OUT.hpos; - return OUT; + return OUT; } diff --git a/Templates/Empty/game/shaders/common/VolumetricFog/VFogRefl.hlsl b/Templates/Empty/game/shaders/common/VolumetricFog/VFogRefl.hlsl index 87226a1ac..380233b5f 100644 --- a/Templates/Empty/game/shaders/common/VolumetricFog/VFogRefl.hlsl +++ b/Templates/Empty/game/shaders/common/VolumetricFog/VFogRefl.hlsl @@ -20,17 +20,19 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +// Volumetric Fog Reflection pixel shader V1.00 +#include "../shaderModel.hlsl" uniform float4 fogColor; uniform float fogDensity; uniform float reflStrength; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { return float4(fogColor.rgb,saturate(fogDensity*reflStrength)); } diff --git a/Templates/Empty/game/shaders/common/VolumetricFog/VFogV.hlsl b/Templates/Empty/game/shaders/common/VolumetricFog/VFogV.hlsl index 7f86802b5..167f83946 100644 --- a/Templates/Empty/game/shaders/common/VolumetricFog/VFogV.hlsl +++ b/Templates/Empty/game/shaders/common/VolumetricFog/VFogV.hlsl @@ -22,24 +22,25 @@ // Volumetric Fog final vertex shader V1.00 -#include "shaders/common/hlslstructs.h" +#include "../shaderModel.hlsl" +#include "../hlslStructs.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 htpos : TEXCOORD0; float2 uv0 : TEXCOORD1; }; uniform float4x4 modelView; -ConnectData main( VertexIn_PNT IN) +ConnectData main( VertexIn_PNTT IN) { - ConnectData OUT; + ConnectData OUT; - OUT.hpos = mul(modelView, IN.pos); + OUT.hpos = mul(modelView, float4(IN.pos,1.0)); OUT.htpos = OUT.hpos; OUT.uv0 = IN.uv0; - return OUT; + return OUT; } diff --git a/Templates/Empty/game/shaders/common/basicCloudsP.hlsl b/Templates/Empty/game/shaders/common/basicCloudsP.hlsl index 53b88d8b7..4b40e5e8c 100644 --- a/Templates/Empty/game/shaders/common/basicCloudsP.hlsl +++ b/Templates/Empty/game/shaders/common/basicCloudsP.hlsl @@ -24,14 +24,14 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; }; -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { - float4 col = tex2D( diffuseMap, IN.texCoord ); + float4 col = TORQUE_TEX2D(diffuseMap, IN.texCoord); return hdrEncode( col ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/basicCloudsV.hlsl b/Templates/Empty/game/shaders/common/basicCloudsV.hlsl index 49842fd37..477f17d50 100644 --- a/Templates/Empty/game/shaders/common/basicCloudsV.hlsl +++ b/Templates/Empty/game/shaders/common/basicCloudsV.hlsl @@ -20,39 +20,40 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" + struct CloudVert { - float4 pos : POSITION; - float3 normal : NORMAL; - float3 binormal : BINORMAL; - float3 tangent : TANGENT; + float3 pos : POSITION; float2 uv0 : TEXCOORD0; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; }; uniform float4x4 modelview; -uniform float accumTime; -uniform float texScale; uniform float2 texDirection; uniform float2 texOffset; +uniform float accumTime; +uniform float texScale; + ConnectData main( CloudVert IN ) -{ +{ ConnectData OUT; - - OUT.hpos = mul(modelview, IN.pos); - + + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); + OUT.hpos.w = OUT.hpos.z; + float2 uv = IN.uv0; uv += texOffset; uv *= texScale; uv += accumTime * texDirection; - OUT.texCoord = uv; - + OUT.texCoord = uv; + return OUT; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/cloudLayerP.hlsl b/Templates/Empty/game/shaders/common/cloudLayerP.hlsl index a3c2d06e8..efa8fe0b4 100644 --- a/Templates/Empty/game/shaders/common/cloudLayerP.hlsl +++ b/Templates/Empty/game/shaders/common/cloudLayerP.hlsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" #include "torque.hlsl" //----------------------------------------------------------------------------- @@ -27,7 +28,7 @@ //----------------------------------------------------------------------------- struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord12 : TEXCOORD0; float4 texCoord34 : TEXCOORD1; float3 vLightTS : TEXCOORD2; // light vector in tangent space, denormalized @@ -38,7 +39,7 @@ struct ConnectData //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler2D normalHeightMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(normalHeightMap, 0); uniform float3 ambientColor; uniform float3 sunColor; uniform float cloudCoverage; @@ -99,7 +100,7 @@ float3 ComputeIllumination( float2 texCoord, return finalColor; } -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Normalize the interpolated vectors: float3 vViewTS = normalize( IN.vViewTS ); @@ -109,11 +110,11 @@ float4 main( ConnectData IN ) : COLOR float2 texSample = IN.texCoord12.xy; - float4 noise1 = tex2D( normalHeightMap, IN.texCoord12.zw ); + float4 noise1 = TORQUE_TEX2D( normalHeightMap, IN.texCoord12.zw ); noise1 = normalize( ( noise1 - 0.5 ) * 2.0 ); //return noise1; - float4 noise2 = tex2D( normalHeightMap, IN.texCoord34.xy ); + float4 noise2 = TORQUE_TEX2D(normalHeightMap, IN.texCoord34.xy); noise2 = normalize( ( noise2 - 0.5 ) * 2.0 ); //return noise2; @@ -122,7 +123,7 @@ float4 main( ConnectData IN ) : COLOR float noiseHeight = noise1.a * noise2.a * ( cloudCoverage / 2.0 + 0.5 ); - float3 vNormalTS = normalize( tex2D( normalHeightMap, texSample ).xyz * 2.0 - 1.0 ); + float3 vNormalTS = normalize( TORQUE_TEX2D(normalHeightMap, texSample).xyz * 2.0 - 1.0); vNormalTS += noiseNormal; vNormalTS = normalize( vNormalTS ); @@ -130,7 +131,7 @@ float4 main( ConnectData IN ) : COLOR cResultColor.rgb = ComputeIllumination( texSample, vLightTS, vViewTS, vNormalTS ); float coverage = ( cloudCoverage - 0.5 ) * 2.0; - cResultColor.a = tex2D( normalHeightMap, texSample ).a + coverage + noiseHeight; + cResultColor.a = TORQUE_TEX2D(normalHeightMap, texSample).a + coverage + noiseHeight; if ( cloudCoverage > -1.0 ) cResultColor.a /= 1.0 + coverage; diff --git a/Templates/Empty/game/shaders/common/cloudLayerV.hlsl b/Templates/Empty/game/shaders/common/cloudLayerV.hlsl index 8c1cc555f..94f8b62cb 100644 --- a/Templates/Empty/game/shaders/common/cloudLayerV.hlsl +++ b/Templates/Empty/game/shaders/common/cloudLayerV.hlsl @@ -23,10 +23,11 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" struct CloudVert { - float4 pos : POSITION; + float3 pos : POSITION; float3 normal : NORMAL; float3 binormal : BINORMAL; float3 tangent : TANGENT; @@ -35,7 +36,7 @@ struct CloudVert struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord12 : TEXCOORD0; float4 texCoord34 : TEXCOORD1; float3 vLightTS : TEXCOORD2; // light vector in tangent space, denormalized @@ -61,8 +62,8 @@ ConnectData main( CloudVert IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.pos); - + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); + OUT.hpos.w = OUT.hpos.z; // Offset the uv so we don't have a seam directly over our head. float2 uv = IN.uv0 + float2( 0.5, 0.5 ); @@ -85,7 +86,7 @@ ConnectData main( CloudVert IN ) float3 vBinormalWS = -IN.binormal; // Compute position in world space: - float4 vPositionWS = IN.pos + float4( eyePosWorld, 1 ); //mul( IN.pos, objTrans ); + float4 vPositionWS = float4(IN.pos, 1.0) + float4(eyePosWorld, 1); //mul( IN.pos, objTrans ); // Compute and output the world view vector (unnormalized): float3 vViewWS = eyePosWorld - vPositionWS.xyz; diff --git a/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureP.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureP.hlsl index 52ae4e955..d0577428f 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureP.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureP.hlsl @@ -20,9 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, - float2 texCoord_in : TEXCOORD0, - uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return float4(color_in.rgb, color_in.a * tex2D(diffuseMap, texCoord_in).a); + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +float4 main( Conn IN ) : TORQUE_TARGET0 +{ + return float4(IN.color.rgb, IN.color.a * TORQUE_TEX2D(diffuseMap, IN.texCoord).a); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureV.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureV.hlsl index 43a82dca6..8bf4e88d8 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureV.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/addColorTextureV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; Out.texCoord = In.texCoord; return Out; diff --git a/Templates/Empty/game/shaders/common/fixedFunction/colorP.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/colorP.hlsl index 90bb08112..dd9990e07 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/colorP.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/colorP.hlsl @@ -20,7 +20,15 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return color_in; + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; +}; + +float4 main(Conn IN) : TORQUE_TARGET0 +{ + return IN.color; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/fixedFunction/colorV.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/colorV.hlsl index f0efe1493..d16dfb863 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/colorV.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/colorV.hlsl @@ -20,20 +20,26 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; return Out; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureP.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureP.hlsl index ccf22845c..63afec2a4 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureP.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureP.hlsl @@ -20,9 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, - float2 texCoord_in : TEXCOORD0, - uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return tex2D(diffuseMap, texCoord_in) * color_in; + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +float4 main( Conn IN ) : TORQUE_TARGET0 +{ + return TORQUE_TEX2D(diffuseMap, IN.texCoord) * IN.color; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureV.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureV.hlsl index 43a82dca6..8bf4e88d8 100644 --- a/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureV.hlsl +++ b/Templates/Empty/game/shaders/common/fixedFunction/modColorTextureV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; Out.texCoord = In.texCoord; return Out; diff --git a/Templates/Empty/game/shaders/common/fixedFunction/textureP.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/textureP.hlsl new file mode 100644 index 000000000..82dbd4ce9 --- /dev/null +++ b/Templates/Empty/game/shaders/common/fixedFunction/textureP.hlsl @@ -0,0 +1,36 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../shaderModel.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; +}; + +float4 main(Conn IN) : TORQUE_TARGET0 +{ + return TORQUE_TEX2D(diffuseMap, IN.texCoord); +} \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/fixedFunction/textureV.hlsl b/Templates/Empty/game/shaders/common/fixedFunction/textureV.hlsl new file mode 100644 index 000000000..204cf9514 --- /dev/null +++ b/Templates/Empty/game/shaders/common/fixedFunction/textureV.hlsl @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../shaderModel.hlsl" + +struct Appdata +{ + float3 position : POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; +}; + +uniform float4x4 modelview; + +Conn main( Appdata In ) +{ + Conn Out; + Out.hpos = mul(modelview, float4(In.position, 1.0)); + Out.texCoord = In.texCoord; + return Out; +} \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/foliage.hlsl b/Templates/Empty/game/shaders/common/foliage.hlsl index e875bb23f..9952c29d6 100644 --- a/Templates/Empty/game/shaders/common/foliage.hlsl +++ b/Templates/Empty/game/shaders/common/foliage.hlsl @@ -30,11 +30,11 @@ #define MAX_COVERTYPES 8 +uniform float2 gc_fadeParams; +uniform float2 gc_windDir; uniform float3 gc_camRight; uniform float3 gc_camUp; uniform float4 gc_typeRects[MAX_COVERTYPES]; -uniform float2 gc_fadeParams; -uniform float2 gc_windDir; // .x = gust length // .y = premultiplied simulation time and gust frequency diff --git a/Templates/Empty/game/shaders/common/fxFoliageReplicatorP.hlsl b/Templates/Empty/game/shaders/common/fxFoliageReplicatorP.hlsl index dfa2e4de0..a8bb68e28 100644 --- a/Templates/Empty/game/shaders/common/fxFoliageReplicatorP.hlsl +++ b/Templates/Empty/game/shaders/common/fxFoliageReplicatorP.hlsl @@ -21,36 +21,39 @@ //----------------------------------------------------------------------------- #include "shdrConsts.h" - +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct ConnectData { - float2 texCoord : TEXCOORD0; - float4 lum : COLOR0; + float4 hpos : TORQUE_POSITION; + float2 outTexCoord : TEXCOORD0; + float4 color : COLOR0; float4 groundAlphaCoeff : COLOR1; float2 alphaLookup : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); +TORQUE_UNIFORM_SAMPLER2D(alphaMap, 1); + +uniform float4 groundAlpha; +uniform float4 ambient; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D diffuseMap : register(S0), - uniform sampler2D alphaMap : register(S1), - uniform float4 groundAlpha, - uniform float4 ambient ) +Fragout main( ConnectData IN ) { Fragout OUT; - float4 alpha = tex2D(alphaMap, IN.alphaLookup); - OUT.col = float4( ambient.rgb * IN.lum.rgb, 1.0 ) * tex2D(diffuseMap, IN.texCoord); + float4 alpha = TORQUE_TEX2D(alphaMap, IN.alphaLookup); + OUT.col = float4( ambient.rgb * IN.lum.rgb, 1.0 ) * TORQUE_TEX2D(diffuseMap, IN.texCoord); OUT.col.a = OUT.col.a * min(alpha, groundAlpha + IN.groundAlphaCoeff.x).x; return OUT; diff --git a/Templates/Empty/game/shaders/common/fxFoliageReplicatorV.hlsl b/Templates/Empty/game/shaders/common/fxFoliageReplicatorV.hlsl index 06a9cf5e5..70ec9ff4c 100644 --- a/Templates/Empty/game/shaders/common/fxFoliageReplicatorV.hlsl +++ b/Templates/Empty/game/shaders/common/fxFoliageReplicatorV.hlsl @@ -23,39 +23,42 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct VertData { - float2 texCoord : TEXCOORD0; - float2 waveScale : TEXCOORD1; + float3 position : POSITION; float3 normal : NORMAL; - float4 position : POSITION; + float2 texCoord : TEXCOORD0; + float2 waveScale : TEXCOORD1; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 outTexCoord : TEXCOORD0; float4 color : COLOR0; float4 groundAlphaCoeff : COLOR1; float2 alphaLookup : TEXCOORD1; }; +uniform float4x4 projection : register(C0); +uniform float4x4 world : register(C4); +uniform float GlobalSwayPhase : register(C8); +uniform float SwayMagnitudeSide : register(C9); +uniform float SwayMagnitudeFront : register(C10); +uniform float GlobalLightPhase : register(C11); +uniform float LuminanceMagnitude : register(C12); +uniform float LuminanceMidpoint : register(C13); +uniform float DistanceRange : register(C14); +uniform float3 CameraPos : register(C15); +uniform float TrueBillboard : register(C16); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertData IN, - uniform float4x4 projection : register(C0), - uniform float4x4 world : register(C4), - uniform float GlobalSwayPhase : register(C8), - uniform float SwayMagnitudeSide : register(C9), - uniform float SwayMagnitudeFront : register(C10), - uniform float GlobalLightPhase : register(C11), - uniform float LuminanceMagnitude : register(C12), - uniform float LuminanceMidpoint : register(C13), - uniform float DistanceRange : register(C14), - uniform float3 CameraPos : register(C15), - uniform float TrueBillboard : register(C16) -) +ConnectData main( VertData IN ) { ConnectData OUT; @@ -113,7 +116,7 @@ ConnectData main( VertData IN, float Luminance = LuminanceMidpoint + LuminanceMagnitude * cos(GlobalLightPhase + IN.normal.y); // Alpha - float3 worldPos = float3(IN.position.x, IN.position.y, IN.position.z); + float3 worldPos = IN.position; float alpha = abs(distance(worldPos, CameraPos)) / DistanceRange; alpha = clamp(alpha, 0.0f, 1.0f); //pass it through diff --git a/Templates/Empty/game/shaders/common/gl/basicCloudsV.glsl b/Templates/Empty/game/shaders/common/gl/basicCloudsV.glsl index cccbafa8c..40c597120 100644 --- a/Templates/Empty/game/shaders/common/gl/basicCloudsV.glsl +++ b/Templates/Empty/game/shaders/common/gl/basicCloudsV.glsl @@ -41,6 +41,7 @@ out vec2 texCoord; void main() { gl_Position = tMul(modelview, IN_pos); + gl_Position.w = gl_Position.z; vec2 uv = IN_uv0; uv += texOffset; diff --git a/Templates/Empty/game/shaders/common/gl/cloudLayerV.glsl b/Templates/Empty/game/shaders/common/gl/cloudLayerV.glsl index 395c6f286..cba5c009a 100644 --- a/Templates/Empty/game/shaders/common/gl/cloudLayerV.glsl +++ b/Templates/Empty/game/shaders/common/gl/cloudLayerV.glsl @@ -62,6 +62,7 @@ void main() vec2 IN_uv0 = vTexCoord0.st; gl_Position = modelview * IN_pos; + gl_Position.w = gl_Position.z; // Offset the uv so we don't have a seam directly over our head. vec2 uv = IN_uv0 + vec2( 0.5, 0.5 ); diff --git a/Templates/Empty/game/shaders/common/gl/lighting.glsl b/Templates/Empty/game/shaders/common/gl/lighting.glsl index eb1c9b355..804ab1e3b 100644 --- a/Templates/Empty/game/shaders/common/gl/lighting.glsl +++ b/Templates/Empty/game/shaders/common/gl/lighting.glsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "./torque.glsl" #ifndef TORQUE_SHADERGEN @@ -207,14 +208,42 @@ void compute4Lights( vec3 wsView, /// float AL_CalcSpecular( vec3 toLight, vec3 normal, vec3 toEye ) { - #ifdef PHONG_SPECULAR - // (R.V)^c - float specVal = dot( normalize( -reflect( toLight, normal ) ), toEye ); - #else - // (N.H)^c [Blinn-Phong, TGEA style, default] - float specVal = dot( normal, normalize( toLight + toEye ) ); - #endif + // (R.V)^c + float specVal = dot( normalize( -reflect( toLight, normal ) ), toEye ); // Return the specular factor. return pow( max( specVal, 0.00001f ), AL_ConstantSpecularPower ); } + +/// The output for Deferred Lighting +/// +/// @param toLight Normalized vector representing direction from the pixel +/// being lit, to the light source, in world space. +/// +/// @param normal Normalized surface normal. +/// +/// @param toEye The normalized vector representing direction from the pixel +/// being lit to the camera. +/// +vec4 AL_DeferredOutput( + vec3 lightColor, + vec3 diffuseColor, + vec4 matInfo, + vec4 ambient, + float specular, + float shadowAttenuation) +{ + vec3 specularColor = vec3(specular); + bool metalness = getFlag(matInfo.r, 3); + if ( metalness ) + { + specularColor = 0.04 * (1 - specular) + diffuseColor * specular; + } + + //specular = color * map * spec^gloss + float specularOut = (specularColor * matInfo.b * min(pow(max(specular,1.0f), max((matInfo.a / AL_ConstantSpecularPower),1.0f)),matInfo.a)).r; + + lightColor *= vec3(shadowAttenuation); + lightColor += ambient.rgb; + return vec4(lightColor.rgb, specularOut); +} diff --git a/Templates/Empty/game/shaders/common/gl/scatterSkyP.glsl b/Templates/Empty/game/shaders/common/gl/scatterSkyP.glsl index d9fa80bcf..b4e70f902 100644 --- a/Templates/Empty/game/shaders/common/gl/scatterSkyP.glsl +++ b/Templates/Empty/game/shaders/common/gl/scatterSkyP.glsl @@ -73,5 +73,8 @@ void main() discard; OUT_col.a = 1; + + OUT_col = clamp(OUT_col, 0.0, 1.0); + OUT_col = hdrEncode( OUT_col ); } diff --git a/Templates/Empty/game/shaders/common/gl/torque.glsl b/Templates/Empty/game/shaders/common/gl/torque.glsl index 9032a57f7..d4a7c4538 100644 --- a/Templates/Empty/game/shaders/common/gl/torque.glsl +++ b/Templates/Empty/game/shaders/common/gl/torque.glsl @@ -284,4 +284,37 @@ void fizzle(vec2 vpos, float visibility) /// @note This macro will only work in the void main() method of a pixel shader. #define assert(condition, color) { if(!any(condition)) { OUT_col = color; return; } } +// Deferred Shading: Material Info Flag Check +bool getFlag(float flags, float num) +{ + float process = round(flags * 255); + float squareNum = pow(2.0, num); + return (mod(process, pow(2.0, squareNum)) >= squareNum); +} + +// #define TORQUE_STOCK_GAMMA +#ifdef TORQUE_STOCK_GAMMA +// Sample in linear space. Decodes gamma. +vec4 toLinear(vec4 tex) +{ + return tex; +} +// Encodes gamma. +vec4 toGamma(vec4 tex) +{ + return tex; +} +#else +// Sample in linear space. Decodes gamma. +vec4 toLinear(vec4 tex) +{ + return vec4(pow(abs(tex.rgb), vec3(2.2)), tex.a); +} +// Encodes gamma. +vec4 toGamma(vec4 tex) +{ + return vec4(pow(abs(tex.rgb), vec3(1.0/2.2)), tex.a); +} +#endif // + #endif // _TORQUE_GLSL_ diff --git a/Templates/Empty/game/shaders/common/guiMaterialV.hlsl b/Templates/Empty/game/shaders/common/guiMaterialV.hlsl index 425da5da4..5d725338f 100644 --- a/Templates/Empty/game/shaders/common/guiMaterialV.hlsl +++ b/Templates/Empty/game/shaders/common/guiMaterialV.hlsl @@ -20,23 +20,25 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "hlslStructs.h" +#include "hlslStructs.hlsl" +#include "shaderModel.hlsl" struct MaterialDecoratorConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; +uniform float4x4 modelview : register(C0); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -MaterialDecoratorConnectV main( VertexIn_PCT IN, - uniform float4x4 modelview : register(C0) ) +MaterialDecoratorConnectV main( VertexIn_PCT IN ) { MaterialDecoratorConnectV OUT; - OUT.hpos = mul(modelview, IN.pos); + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); OUT.uv0 = IN.uv0; return OUT; diff --git a/Templates/Empty/game/shaders/common/hlslStructs.hlsl b/Templates/Empty/game/shaders/common/hlslStructs.hlsl new file mode 100644 index 000000000..ce0ca305c --- /dev/null +++ b/Templates/Empty/game/shaders/common/hlslStructs.hlsl @@ -0,0 +1,114 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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. +//----------------------------------------------------------------------------- + +// The purpose of this file is to get all of our HLSL structures into one place. +// Please use the structures here instead of redefining input and output structures +// in each shader file. If structures are added, please adhere to the naming convention. + +//------------------------------------------------------------------------------ +// Vertex Input Structures +// +// These structures map to FVFs/Vertex Declarations in Torque. See gfxStructs.h +//------------------------------------------------------------------------------ + +// Notes +// +// Position should be specified as a float3 as our vertex structures in +// the engine output float3s for position. + +struct VertexIn_P +{ + float3 pos : POSITION; +}; + +struct VertexIn_PT +{ + float3 pos : POSITION; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PTTT +{ + float3 pos : POSITION; + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float2 uv2 : TEXCOORD2; +}; + +struct VertexIn_PC +{ + float3 pos : POSITION; + float4 color : DIFFUSE; +}; + +struct VertexIn_PNC +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float4 color : DIFFUSE; +}; + +struct VertexIn_PCT +{ + float3 pos : POSITION; + float4 color : DIFFUSE; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PN +{ + float3 pos : POSITION; + float3 normal : NORMAL; +}; + +struct VertexIn_PNT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNTT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float3 tangent : TANGENT; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNCT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float4 color : DIFFUSE; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNTTTB +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float3 T : TEXCOORD2; + float3 B : TEXCOORD3; +}; \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting.hlsl b/Templates/Empty/game/shaders/common/lighting.hlsl index ec8129e94..a41b8a873 100644 --- a/Templates/Empty/game/shaders/common/lighting.hlsl +++ b/Templates/Empty/game/shaders/common/lighting.hlsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "./torque.hlsl" #ifndef TORQUE_SHADERGEN @@ -207,14 +208,42 @@ void compute4Lights( float3 wsView, /// float AL_CalcSpecular( float3 toLight, float3 normal, float3 toEye ) { - #ifdef PHONG_SPECULAR - // (R.V)^c - float specVal = dot( normalize( -reflect( toLight, normal ) ), toEye ); - #else - // (N.H)^c [Blinn-Phong, TGEA style, default] - float specVal = dot( normal, normalize( toLight + toEye ) ); - #endif + // (R.V)^c + float specVal = dot( normalize( -reflect( toLight, normal ) ), toEye ); // Return the specular factor. return pow( max( specVal, 0.00001f ), AL_ConstantSpecularPower ); } + +/// The output for Deferred Lighting +/// +/// @param toLight Normalized vector representing direction from the pixel +/// being lit, to the light source, in world space. +/// +/// @param normal Normalized surface normal. +/// +/// @param toEye The normalized vector representing direction from the pixel +/// being lit to the camera. +/// +float4 AL_DeferredOutput( + float3 lightColor, + float3 diffuseColor, + float4 matInfo, + float4 ambient, + float specular, + float shadowAttenuation) +{ + float3 specularColor = float3(specular, specular, specular); + bool metalness = getFlag(matInfo.r, 3); + if ( metalness ) + { + specularColor = 0.04 * (1 - specular) + diffuseColor * specular; + } + + //specular = color * map * spec^gloss + float specularOut = (specularColor * matInfo.b * min(pow(abs(specular), max(( matInfo.a/ AL_ConstantSpecularPower),1.0f)),matInfo.a)).r; + + lightColor *= shadowAttenuation; + lightColor += ambient.rgb; + return float4(lightColor.rgb, specularOut); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/convexGeometryV.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/convexGeometryV.hlsl index c86cd4e89..064fcffa6 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/convexGeometryV.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/convexGeometryV.hlsl @@ -20,17 +20,24 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" +#include "../../shaderModel.hlsl" + +struct VertData +{ + float3 pos : POSITION; + float4 color : COLOR; +}; struct ConvexConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; }; -ConvexConnectV main( VertexIn_P IN, +ConvexConnectV main( VertData IN, uniform float4x4 modelview, uniform float4x4 objTrans, uniform float4x4 worldViewOnly, @@ -38,9 +45,9 @@ ConvexConnectV main( VertexIn_P IN, { ConvexConnectV OUT; - OUT.hpos = mul( modelview, IN.pos ); - OUT.wsEyeDir = mul( objTrans, IN.pos ) - float4( eyePosWorld, 0.0 ); - OUT.vsEyeDir = mul( worldViewOnly, IN.pos ); + OUT.hpos = mul( modelview, float4(IN.pos,1.0) ); + OUT.wsEyeDir = mul(objTrans, float4(IN.pos, 1.0)) - float4(eyePosWorld, 0.0); + OUT.vsEyeDir = mul(worldViewOnly, float4(IN.pos, 1.0)); OUT.ssPos = OUT.hpos; return OUT; diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl new file mode 100644 index 000000000..ad3debbaf --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl @@ -0,0 +1,30 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../postfx/postFx.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(colorBufferTex,0); + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 +{ + return float4(TORQUE_TEX2D( colorBufferTex, IN.uv0 ).rgb, 1.0); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl index a2b2b5d7d..68df09a78 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl @@ -20,14 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER1D(depthViz, 1); -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex : register(S0), - uniform sampler1D depthViz : register(S1) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; - return float4( tex1D( depthViz, depth ).rgb, 1.0 ); + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; + return float4( TORQUE_TEX1D( depthViz, depth ).rgb, 1.0 ); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl index 3c31c897e..257383659 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl @@ -20,12 +20,11 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(glowBuffer, 0); -float4 main( PFXVertToPix IN, - uniform sampler2D glowBuffer : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return tex2D(glowBuffer, IN.uv0); + return TORQUE_TEX2D(glowBuffer, IN.uv0); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl index 487b4c740..ca6d8d677 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl @@ -20,15 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,0); -float4 main( PFXVertToPix IN, - uniform sampler2D lightPrePassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float3 lightcolor; - float nl_Att, specular; - lightinfoUncondition( tex2D( lightPrePassTex, IN.uv0 ), lightcolor, nl_Att, specular ); - return float4( lightcolor, 1.0 ); + float4 lightColor = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ); + return float4( lightColor.rgb, 1.0 ); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl index edc25ed03..072f07e00 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl @@ -20,15 +20,12 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,0); - -float4 main( PFXVertToPix IN, - uniform sampler2D lightPrePassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float3 lightcolor; - float nl_Att, specular; - lightinfoUncondition( tex2D( lightPrePassTex, IN.uv0 ), lightcolor, nl_Att, specular ); + float specular = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ).a; return float4( specular, specular, specular, 1.0 ); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl index c160045b4..4f31d2c53 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl @@ -20,13 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float3 normal = prepassUncondition( prepassTex, IN.uv0 ).xyz; + float3 normal = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).xyz; return float4( ( normal + 1.0 ) * 0.5, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl index b1f2bca29..b54833499 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl @@ -20,15 +20,19 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + struct MaterialDecoratorConnectV { + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; -float4 main( MaterialDecoratorConnectV IN, - uniform sampler2D shadowMap : register(S0), - uniform sampler1D depthViz : register(S1) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 0); +TORQUE_UNIFORM_SAMPLER1D(depthViz, 1); + +float4 main( MaterialDecoratorConnectV IN ) : TORQUE_TARGET0 { - float depth = saturate( tex2D( shadowMap, IN.uv0 ).r ); - return float4( tex1D( depthViz, depth ).rgb, 1 ); + float depth = saturate( TORQUE_TEX2D( shadowMap, IN.uv0 ).r ); + return float4( TORQUE_TEX1D( depthViz, depth ).rgb, 1 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl new file mode 100644 index 000000000..eba38a879 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl @@ -0,0 +1,31 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../postfx/postFx.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(matinfoTex,0); + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 +{ + float specular = TORQUE_TEX2D( matinfoTex, IN.uv0 ).b; + return float4( specular, specular, specular, 1.0 ); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl new file mode 100644 index 000000000..cefebe8c7 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl @@ -0,0 +1,54 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../shaderModel.hlsl" + +struct Conn +{ + float4 hpos : TORQUE_POSITION; +}; + +struct Fragout +{ + float4 col : TORQUE_TARGET0; + float4 col1 : TORQUE_TARGET1; + float4 col2 : TORQUE_TARGET2; +}; + +//----------------------------------------------------------------------------- +// Main +//----------------------------------------------------------------------------- +Fragout main( Conn IN ) +{ + Fragout OUT; + + // Clear Prepass Buffer ( Normals/Depth ); + OUT.col = float4(1.0, 1.0, 1.0, 1.0); + + // Clear Color Buffer. + OUT.col1 = float4(0.0, 0.0, 0.0, 1.0); + + // Clear Material Info Buffer. + OUT.col2 = float4(0.0, 0.0, 0.0, 1.0); + + return OUT; +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl new file mode 100644 index 000000000..20ba4d509 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl @@ -0,0 +1,43 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../shaderModel.hlsl" + +struct Appdata +{ + float3 pos : POSITION; + float4 color : COLOR; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; +}; + +uniform float4x4 modelview; + +Conn main( Appdata In ) +{ + Conn Out; + Out.hpos = float4(In.pos,1.0); + return Out; +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl new file mode 100644 index 000000000..d91d2eb38 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../shaderModel.hlsl" + +struct Fragout +{ + float4 col : TORQUE_TARGET0; + float4 col1 : TORQUE_TARGET1; + float4 col2 : TORQUE_TARGET2; +}; + +//----------------------------------------------------------------------------- +// Main +//----------------------------------------------------------------------------- +Fragout main( ) +{ + Fragout OUT; + + OUT.col = float4(0.0, 0.0, 0.0, 0.0); + OUT.col1 = float4(1.0, 1.0, 1.0, 1.0); + + // Draw on color buffer. + OUT.col2 = float4(1.0, 0.0, 0.0, 1.0); + + return OUT; +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/deferredShadingP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/deferredShadingP.hlsl new file mode 100644 index 000000000..c710656f8 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/deferredShadingP.hlsl @@ -0,0 +1,54 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../shaderModelAutoGen.hlsl" +#include "../../postfx/postFx.hlsl" +#include "shaders/common/torque.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(colorBufferTex,0); +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,1); +TORQUE_UNIFORM_SAMPLER2D(matInfoTex,2); +TORQUE_UNIFORM_SAMPLER2D(prepassTex,3); + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 +{ + float4 lightBuffer = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ); + float4 colorBuffer = TORQUE_TEX2D( colorBufferTex, IN.uv0 ); + float4 matInfo = TORQUE_TEX2D( matInfoTex, IN.uv0 ); + float specular = saturate(lightBuffer.a); + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; + + if (depth>0.9999) + return float4(0,0,0,0); + + // Diffuse Color Altered by Metalness + bool metalness = getFlag(matInfo.r, 3); + if ( metalness ) + { + colorBuffer *= (1.0 - colorBuffer.a); + } + + colorBuffer *= float4(lightBuffer.rgb, 1.0); + colorBuffer += float4(specular, specular, specular, 1.0); + + return hdrEncode( float4(colorBuffer.rgb, 1.0) ); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl index 567dd11ce..543e21677 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl @@ -19,10 +19,11 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" struct FarFrustumQuadConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; float3 vsEyeRay : TEXCOORD2; @@ -30,6 +31,7 @@ struct FarFrustumQuadConnectV struct FarFrustumQuadConnectP { + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; float3 vsEyeRay : TEXCOORD2; diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl index 08cf61285..0167d901a 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" #include "farFrustumQuad.hlsl" @@ -36,8 +36,8 @@ FarFrustumQuadConnectV main( VertexIn_PNTT IN, // Interpolators will generate eye rays the // from far-frustum corners. - OUT.wsEyeRay = IN.tangent.xyz; - OUT.vsEyeRay = IN.normal.xyz; + OUT.wsEyeRay = IN.tangent; + OUT.vsEyeRay = IN.normal; return OUT; } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgColorBufferP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgColorBufferP.glsl new file mode 100644 index 000000000..48a96d47d --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgColorBufferP.glsl @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../../gl/hlslCompat.glsl" +#include "shadergen:/autogenConditioners.h" +#include "../../../postfx/gl/postFx.glsl" + +uniform sampler2D colorBufferTex; + +out vec4 OUT_FragColor0; + +void main() +{ + OUT_FragColor0 = vec4(texture( colorBufferTex, uv0 ).rgb, 1.0); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgDepthVisualizeP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgDepthVisualizeP.glsl index 7c1754097..eb3d6f761 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgDepthVisualizeP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgDepthVisualizeP.glsl @@ -24,13 +24,13 @@ #include "shadergen:/autogenConditioners.h" in vec2 uv0; -uniform sampler2D prepassBuffer; +uniform sampler2D prepassTex; uniform sampler1D depthViz; out vec4 OUT_col; void main() { - float depth = prepassUncondition( prepassBuffer, uv0 ).w; + float depth = prepassUncondition( prepassTex, uv0 ).w; OUT_col = vec4( texture( depthViz, depth ).rgb, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightColorVisualizeP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightColorVisualizeP.glsl index 05645e193..501e261ca 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightColorVisualizeP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightColorVisualizeP.glsl @@ -24,14 +24,12 @@ #include "shadergen:/autogenConditioners.h" in vec2 uv0; -uniform sampler2D lightInfoBuffer; +uniform sampler2D lightPrePassTex; out vec4 OUT_col; void main() { - vec3 lightcolor; - float nl_Att, specular; - lightinfoUncondition( texture( lightInfoBuffer, uv0 ), lightcolor, nl_Att, specular ); - OUT_col = vec4( lightcolor, 1.0 ); + vec4 lightColor = texture( lightPrePassTex, uv0 ); + OUT_col = vec4( lightColor.rgb, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightSpecularVisualizeP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightSpecularVisualizeP.glsl index 7e3e41ee9..c21c9b60f 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightSpecularVisualizeP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgLightSpecularVisualizeP.glsl @@ -24,14 +24,12 @@ #include "shadergen:/autogenConditioners.h" in vec2 uv0; -uniform sampler2D lightInfoBuffer; +uniform sampler2D lightPrePassTex; out vec4 OUT_col; void main() { - vec3 lightcolor; - float nl_Att, specular; - lightinfoUncondition( texture( lightInfoBuffer, uv0 ), lightcolor, nl_Att, specular ); + float specular = texture( lightPrePassTex, uv0 ).a; OUT_col = vec4( specular, specular, specular, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgNormalVisualizeP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgNormalVisualizeP.glsl index dfc611e88..84ea4d3fb 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgNormalVisualizeP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgNormalVisualizeP.glsl @@ -24,12 +24,12 @@ #include "shadergen:/autogenConditioners.h" in vec2 uv0; -uniform sampler2D prepassBuffer; +uniform sampler2D prepassTex; out vec4 OUT_col; void main() { - vec3 normal = prepassUncondition( prepassBuffer, uv0 ).xyz; + vec3 normal = prepassUncondition( prepassTex, uv0 ).xyz; OUT_col = vec4( ( normal + 1.0 ) * 0.5, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgSpecMapVisualizeP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgSpecMapVisualizeP.glsl new file mode 100644 index 000000000..4ba9f6734 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/dbgSpecMapVisualizeP.glsl @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../../gl/hlslCompat.glsl" +#include "shadergen:/autogenConditioners.h" +#include "../../../postfx/gl/postFx.glsl" + +uniform sampler2D matinfoTex; + +out vec4 OUT_FragColor0; + +void main() +{ + float specular = texture( matinfoTex, uv0 ).a; + OUT_FragColor0 = vec4( specular, specular, specular, 1.0 ); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredClearGBufferP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredClearGBufferP.glsl new file mode 100644 index 000000000..39dc0dc9f --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredClearGBufferP.glsl @@ -0,0 +1,40 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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. +//----------------------------------------------------------------------------- + +out vec4 OUT_col; +out vec4 OUT_col1; +out vec4 OUT_col2; + +//----------------------------------------------------------------------------- +// Main +//----------------------------------------------------------------------------- +void main() +{ + // Clear Prepass Buffer ( Normals/Depth ); + OUT_col = vec4(1.0, 1.0, 1.0, 1.0); + + // Clear Color Buffer. + OUT_col1 = vec4(0.0, 0.0, 0.0, 1.0); + + // Clear Material Info Buffer. + OUT_col2 = vec4(0.0, 0.0, 0.0, 1.0); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredColorShaderP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredColorShaderP.glsl new file mode 100644 index 000000000..85c553089 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredColorShaderP.glsl @@ -0,0 +1,37 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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. +//----------------------------------------------------------------------------- + +layout (location = 0) out vec4 col; +layout (location = 1) out vec4 col1; +layout (location = 2) out vec4 col2; + +//----------------------------------------------------------------------------- +// Main +//----------------------------------------------------------------------------- +void main() +{ + col = vec4(0.0, 0.0, 0.0, 0.0); + col1 = vec4(1.0, 1.0, 1.0, 1.0); + + // Draw on color buffer. + col2 = vec4(1.0, 0.0, 0.0, 1.0); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl new file mode 100644 index 000000000..4ee4b1d81 --- /dev/null +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl @@ -0,0 +1,59 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../../gl/hlslCompat.glsl" +#include "shadergen:/autogenConditioners.h" +#include "../../../postfx/gl/postFx.glsl" +#include "../../../gl/torque.glsl" + +uniform sampler2D colorBufferTex; +uniform sampler2D lightPrePassTex; +uniform sampler2D matInfoTex; +uniform sampler2D prepassTex; + +out vec4 OUT_col; + +void main() +{ + float depth = prepassUncondition( prepassTex, uv0 ).w; + if (depth>0.9999) + { + OUT_col = vec4(0.0); + return; + } + vec4 lightBuffer = texture( lightPrePassTex, uv0 ); + vec4 colorBuffer = texture( colorBufferTex, uv0 ); + vec4 matInfo = texture( matInfoTex, uv0 ); + float specular = clamp(lightBuffer.a,0.0,1.0); + + // Diffuse Color Altered by Metalness + bool metalness = getFlag(matInfo.r, 3); + if ( metalness ) + { + colorBuffer *= (1.0 - colorBuffer.a); + } + + colorBuffer *= vec4(lightBuffer.rgb, 1.0); + colorBuffer += vec4(specular, specular, specular, 1.0); + + OUT_col = hdrEncode( vec4(colorBuffer.rgb, 1.0) ); +} diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/pointLightP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/pointLightP.glsl index 92c9369a7..8a1aae3ca 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/pointLightP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/pointLightP.glsl @@ -33,6 +33,7 @@ in vec4 wsEyeDir; in vec4 ssPos; in vec4 vsEyeDir; +in vec4 color; #ifdef USE_COOKIE_TEX @@ -111,6 +112,10 @@ uniform sampler2D prePassBuffer; uniform sampler2D dynamicShadowMap; #endif +uniform sampler2D lightBuffer; +uniform sampler2D colorBuffer; +uniform sampler2D matInfoBuffer; + uniform vec4 rtParams0; uniform vec3 lightPosition; @@ -133,6 +138,15 @@ void main() vec3 ssPos = ssPos.xyz / ssPos.w; vec2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); + // Emissive. + vec4 matInfo = texture( matInfoBuffer, uvScene ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + OUT_col = vec4(0.0, 0.0, 0.0, 0.0); + return; + } + // Sample/unpack the normal/z data vec4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); vec3 normal = prepassSample.rgb; @@ -244,5 +258,6 @@ void main() addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - OUT_col = lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); + vec4 colorSample = texture( colorBuffer, uvScene ); + OUT_col = AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/spotLightP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/spotLightP.glsl index 29c278508..e7f3e88a7 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/spotLightP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/spotLightP.glsl @@ -32,10 +32,12 @@ in vec4 wsEyeDir; in vec4 ssPos; in vec4 vsEyeDir; +in vec4 color; #define IN_wsEyeDir wsEyeDir #define IN_ssPos ssPos #define IN_vsEyeDir vsEyeDir +#define IN_color color #ifdef USE_COOKIE_TEX @@ -48,6 +50,10 @@ uniform sampler2D prePassBuffer; uniform sampler2D shadowMap; uniform sampler2D dynamicShadowMap; +uniform sampler2D lightBuffer; +uniform sampler2D colorBuffer; +uniform sampler2D matInfoBuffer; + uniform vec4 rtParams0; uniform vec3 lightPosition; @@ -74,6 +80,15 @@ void main() vec3 ssPos = IN_ssPos.xyz / IN_ssPos.w; vec2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); + // Emissive. + vec4 matInfo = texture( matInfoBuffer, uvScene ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + OUT_col = vec4(0.0, 0.0, 0.0, 0.0); + return; + } + // Sample/unpack the normal/z data vec4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); vec3 normal = prepassSample.rgb; @@ -180,5 +195,6 @@ void main() addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - OUT_col = lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); + vec4 colorSample = texture( colorBuffer, uvScene ); + OUT_col = AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/gl/vectorLightP.glsl b/Templates/Empty/game/shaders/common/lighting/advanced/gl/vectorLightP.glsl index 4eb4973a3..608524a5a 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/gl/vectorLightP.glsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/gl/vectorLightP.glsl @@ -39,10 +39,13 @@ uniform sampler2D dynamicShadowMap; #ifdef USE_SSAO_MASK uniform sampler2D ssaoMask ; -uniform vec4 rtParams2; +uniform vec4 rtParams3; #endif -uniform sampler2D prePassBuffer; +uniform sampler2D prePassBuffer; +uniform sampler2D lightBuffer; +uniform sampler2D colorBuffer; +uniform sampler2D matInfoBuffer; uniform vec3 lightDirection; uniform vec4 lightColor; uniform float lightBrightness; @@ -189,7 +192,16 @@ vec4 AL_VectorLightShadowCast( sampler2D _sourceshadowMap, out vec4 OUT_col; void main() -{ +{ + // Emissive. + float4 matInfo = texture( matInfoBuffer, uv0 ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + OUT_col = vec4(1.0, 1.0, 1.0, 0.0); + return; + } + // Sample/unpack the normal/z data vec4 prepassSample = prepassUncondition( prePassBuffer, uv0 ); vec3 normal = prepassSample.rgb; @@ -228,8 +240,6 @@ void main() shadowSoftness, dotNL, overDarkPSSM); - - vec4 dynamic_shadowed_colors = AL_VectorLightShadowCast( dynamicShadowMap, uv0.xy, dynamicWorldToLightProj, @@ -242,14 +252,13 @@ void main() shadowSoftness, dotNL, overDarkPSSM); - float static_shadowed = static_shadowed_colors.a; float dynamic_shadowed = dynamic_shadowed_colors.a; #ifdef PSSM_DEBUG_RENDER debugColor = static_shadowed_colors.rgb*0.5+dynamic_shadowed_colors.rgb*0.5; #endif - + // Fade out the shadow at the end of the range. vec4 zDist = vec4(zNearFarInvNearFar.x + zNearFarInvNearFar.y * depth); float fadeOutAmt = ( zDist.x - fadeStartLength.x ) * fadeStartLength.y; @@ -295,7 +304,7 @@ void main() // Sample the AO texture. #ifdef USE_SSAO_MASK - float ao = 1.0 - texture( ssaoMask, viewportCoordToRenderTarget( uv0.xy, rtParams2 ) ).r; + float ao = 1.0 - texture( ssaoMask, viewportCoordToRenderTarget( uv0.xy, rtParams3 ) ).r; addToResult *= ao; #endif @@ -303,6 +312,6 @@ void main() lightColorOut = debugColor; #endif - OUT_col = lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); - + vec4 colorSample = texture( colorBuffer, uv0 ); + OUT_col = AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightP.hlsl index bc4784980..7ff5d50d2 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightP.hlsl @@ -20,35 +20,36 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" - #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" #include "../../lighting.hlsl" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 ssPos : TEXCOORD0; float3 vsEyeDir : TEXCOORD1; }; -float4 main( ConvexConnectP IN, - uniform sampler2D prePassBuffer : register(S0), - - uniform float4 lightPosition, - uniform float4 lightColor, - uniform float lightRange, - - uniform float4 vsFarPlane, - uniform float4 rtParams0 ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); + +uniform float4 lightPosition; +uniform float4 lightColor; +uniform float lightRange; +uniform float4 vsFarPlane; +uniform float4 rtParams0; + +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos(ssPos, rtParams0); // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition(prePassBuffer, uvScene); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION(prePassBuffer, uvScene); float3 normal = prepassSample.rgb; float depth = prepassSample.a; diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightV.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightV.hlsl index f5dc9e444..faa2ec115 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightV.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/particlePointLightV.hlsl @@ -20,24 +20,26 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" +#include "../../shaderModel.hlsl" struct ConvexConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 ssPos : TEXCOORD0; float3 vsEyeDir : TEXCOORD1; }; -ConvexConnectV main( VertexIn_P IN, - uniform float4x4 viewProj, - uniform float4x4 view, - uniform float3 particlePosWorld, - uniform float lightRange ) +uniform float4x4 viewProj; +uniform float4x4 view; +uniform float3 particlePosWorld; +uniform float lightRange; + +ConvexConnectV main( VertexIn_P IN ) { ConvexConnectV OUT; - - float4 vPosWorld = IN.pos + float4(particlePosWorld, 0.0) + float4(IN.pos.xyz, 0.0) * lightRange; + float4 pos = float4(IN.pos, 0.0); + float4 vPosWorld = pos + float4(particlePosWorld, 0.0) + pos * lightRange; OUT.hpos = mul(viewProj, vPosWorld); OUT.vsEyeDir = mul(view, vPosWorld); OUT.ssPos = OUT.hpos; diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/pointLightP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/pointLightP.hlsl index 48c0d76e3..540fd65c7 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/pointLightP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/pointLightP.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" @@ -31,6 +31,7 @@ struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; @@ -40,7 +41,7 @@ struct ConvexConnectP #ifdef USE_COOKIE_TEX /// The texture for cookie rendering. -uniform samplerCUBE cookieMap : register(S3); +TORQUE_UNIFORM_SAMPLERCUBE(cookieMap, 3); #endif @@ -52,9 +53,9 @@ uniform samplerCUBE cookieMap : register(S3); return shadowCoord; } - float4 shadowSample( samplerCUBE shadowMap, float3 shadowCoord ) + float4 shadowSample( TORQUE_SAMPLERCUBE(shadowMap), float3 shadowCoord ) { - return texCUBE( shadowMap, shadowCoord ); + return TORQUE_TEXCUBE( shadowMap, shadowCoord ); } #else @@ -105,40 +106,52 @@ uniform samplerCUBE cookieMap : register(S3); #endif +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); -float4 main( ConvexConnectP IN, +#ifdef SHADOW_CUBE +TORQUE_UNIFORM_SAMPLERCUBE(shadowMap, 1); +#else +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap, 2); +#endif - uniform sampler2D prePassBuffer : register(S0), +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); - #ifdef SHADOW_CUBE - uniform samplerCUBE shadowMap : register(S1), - #else - uniform sampler2D shadowMap : register(S1), - uniform sampler2D dynamicShadowMap : register(S2), - #endif +uniform float4 rtParams0; +uniform float4 lightColor; - uniform float4 rtParams0, +uniform float lightBrightness; +uniform float3 lightPosition; - uniform float3 lightPosition, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float lightRange, - uniform float2 lightAttenuation, - uniform float4 lightMapParams, +uniform float4 lightMapParams; +uniform float4 vsFarPlane; +uniform float4 lightParams; - uniform float4 vsFarPlane, - uniform float3x3 viewToLightProj, - uniform float3x3 dynamicViewToLightProj, +uniform float lightRange; +uniform float shadowSoftness; +uniform float2 lightAttenuation; - uniform float4 lightParams, - uniform float shadowSoftness ) : COLOR0 +uniform float3x3 viewToLightProj; +uniform float3x3 dynamicViewToLightProj; + +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); - + + // Emissive. + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, uvScene ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + return float4(0.0, 0.0, 0.0, 0.0); + } + // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, uvScene ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -175,14 +188,14 @@ float4 main( ConvexConnectP IN, #ifdef SHADOW_CUBE // TODO: We need to fix shadow cube to handle soft shadows! - float occ = texCUBE( shadowMap, mul( viewToLightProj, -lightVec ) ).r; + float occ = TORQUE_TEXCUBE( shadowMap, mul( viewToLightProj, -lightVec ) ).r; float shadowed = saturate( exp( lightParams.y * ( occ - distToLight ) ) ); #else // Static float2 shadowCoord = decodeShadowCoord( mul( viewToLightProj, -lightVec ) ).xy; - float static_shadowed = softShadow_filter( shadowMap, + float static_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(shadowMap), ssPos.xy, shadowCoord, shadowSoftness, @@ -192,7 +205,7 @@ float4 main( ConvexConnectP IN, // Dynamic float2 dynamicShadowCoord = decodeShadowCoord( mul( dynamicViewToLightProj, -lightVec ) ).xy; - float dynamic_shadowed = softShadow_filter( dynamicShadowMap, + float dynamic_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), ssPos.xy, dynamicShadowCoord, shadowSoftness, @@ -210,7 +223,7 @@ float4 main( ConvexConnectP IN, #ifdef USE_COOKIE_TEX // Lookup the cookie sample. - float4 cookie = texCUBE( cookieMap, mul( viewToLightProj, -lightVec ) ); + float4 cookie = TORQUE_TEXCUBE( cookieMap, mul( viewToLightProj, -lightVec ) ); // Multiply the light with the cookie tex. lightcol *= cookie.rgb; @@ -250,5 +263,6 @@ float4 main( ConvexConnectP IN, addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - return lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, uvScene ); + return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/softShadow.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/softShadow.hlsl index 36bffbfd9..0faf3e1fb 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/softShadow.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/softShadow.hlsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" #if defined( SOFTSHADOW ) && defined( SOFTSHADOW_HIGH_QUALITY ) @@ -69,10 +70,9 @@ static float2 sNonUniformTaps[NUM_PRE_TAPS] = /// The texture used to do per-pixel pseudorandom /// rotations of the filter taps. -uniform sampler2D gTapRotationTex : register(S4); +TORQUE_UNIFORM_SAMPLER2D(gTapRotationTex, 4); - -float softShadow_sampleTaps( sampler2D shadowMap, +float softShadow_sampleTaps( TORQUE_SAMPLER2D(shadowMap1), float2 sinCos, float2 shadowPos, float filterRadius, @@ -88,7 +88,7 @@ float softShadow_sampleTaps( sampler2D shadowMap, { tap.x = ( sNonUniformTaps[t].x * sinCos.y - sNonUniformTaps[t].y * sinCos.x ) * filterRadius; tap.y = ( sNonUniformTaps[t].y * sinCos.y + sNonUniformTaps[t].x * sinCos.x ) * filterRadius; - float occluder = tex2Dlod( shadowMap, float4( shadowPos + tap, 0, 0 ) ).r; + float occluder = TORQUE_TEX2DLOD( shadowMap1, float4( shadowPos + tap, 0, 0 ) ).r; float esm = saturate( exp( esmFactor * ( occluder - distToLight ) ) ); shadow += esm / float( endTap - startTap ); @@ -98,7 +98,7 @@ float softShadow_sampleTaps( sampler2D shadowMap, } -float softShadow_filter( sampler2D shadowMap, +float softShadow_filter( TORQUE_SAMPLER2D(shadowMap), float2 vpos, float2 shadowPos, float filterRadius, @@ -111,16 +111,15 @@ float softShadow_filter( sampler2D shadowMap, // If softshadow is undefined then we skip any complex // filtering... just do a single sample ESM. - float occluder = tex2Dlod( shadowMap, float4( shadowPos, 0, 0 ) ).r; + float occluder = TORQUE_TEX2DLOD(shadowMap, float4(shadowPos, 0, 0)).r; float shadow = saturate( exp( esmFactor * ( occluder - distToLight ) ) ); #else - // Lookup the random rotation for this screen pixel. - float2 sinCos = ( tex2Dlod( gTapRotationTex, float4( vpos * 16, 0, 0 ) ).rg - 0.5 ) * 2; + float2 sinCos = ( TORQUE_TEX2DLOD(gTapRotationTex, float4(vpos * 16, 0, 0)).rg - 0.5) * 2; // Do the prediction taps first. - float shadow = softShadow_sampleTaps( shadowMap, + float shadow = softShadow_sampleTaps( TORQUE_SAMPLER2D_MAKEARG(shadowMap), sinCos, shadowPos, filterRadius, @@ -137,7 +136,7 @@ float softShadow_filter( sampler2D shadowMap, // in a partially shadowed area. if ( shadow * ( 1.0 - shadow ) * max( dotNL, 0 ) > 0.06 ) { - shadow += softShadow_sampleTaps( shadowMap, + shadow += softShadow_sampleTaps( TORQUE_SAMPLER2D_MAKEARG(shadowMap), sinCos, shadowPos, filterRadius, diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/spotLightP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/spotLightP.hlsl index 33c7f333e..e1f3baf93 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/spotLightP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/spotLightP.hlsl @@ -20,7 +20,8 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" @@ -31,49 +32,63 @@ struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; }; +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap,2); + #ifdef USE_COOKIE_TEX /// The texture for cookie rendering. -uniform sampler2D cookieMap : register(S3); +TORQUE_UNIFORM_SAMPLER2D(cookieMap, 3); #endif +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); -float4 main( ConvexConnectP IN, +uniform float4 rtParams0; - uniform sampler2D prePassBuffer : register(S0), - uniform sampler2D shadowMap : register(S1), - uniform sampler2D dynamicShadowMap : register(S2), +uniform float lightBrightness; +uniform float3 lightPosition; - uniform float4 rtParams0, +uniform float4 lightColor; - uniform float3 lightPosition, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float lightRange, - uniform float2 lightAttenuation, - uniform float3 lightDirection, - uniform float4 lightSpotParams, - uniform float4 lightMapParams, +uniform float lightRange; +uniform float3 lightDirection; - uniform float4 vsFarPlane, - uniform float4x4 viewToLightProj, - uniform float4x4 dynamicViewToLightProj, +uniform float4 lightSpotParams; +uniform float4 lightMapParams; +uniform float4 vsFarPlane; +uniform float4x4 viewToLightProj; +uniform float4 lightParams; +uniform float4x4 dynamicViewToLightProj; - uniform float4 lightParams, - uniform float shadowSoftness ) : COLOR0 +uniform float2 lightAttenuation; +uniform float shadowSoftness; + +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); + // Emissive. + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, uvScene ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + return float4(0.0, 0.0, 0.0, 0.0); + } + // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, uvScene ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -117,7 +132,7 @@ float4 main( ConvexConnectP IN, // Get a linear depth from the light source. float distToLight = pxlPosLightProj.z / lightRange; - float static_shadowed = softShadow_filter( shadowMap, + float static_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(shadowMap), ssPos.xy, shadowCoord, shadowSoftness, @@ -125,7 +140,7 @@ float4 main( ConvexConnectP IN, nDotL, lightParams.y ); - float dynamic_shadowed = softShadow_filter( dynamicShadowMap, + float dynamic_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), ssPos.xy, dynshadowCoord, shadowSoftness, @@ -139,7 +154,7 @@ float4 main( ConvexConnectP IN, #ifdef USE_COOKIE_TEX // Lookup the cookie sample. - float4 cookie = tex2D( cookieMap, shadowCoord ); + float4 cookie = TORQUE_TEX2D( cookieMap, shadowCoord ); // Multiply the light with the cookie tex. lightcol *= cookie.rgb; @@ -179,5 +194,6 @@ float4 main( ConvexConnectP IN, addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - return lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, uvScene ); + return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/advanced/vectorLightP.hlsl b/Templates/Empty/game/shaders/common/lighting/advanced/vectorLightP.hlsl index 1b4548575..1a9726171 100644 --- a/Templates/Empty/game/shaders/common/lighting/advanced/vectorLightP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/advanced/vectorLightP.hlsl @@ -20,7 +20,8 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "../../torque.hlsl" @@ -29,16 +30,55 @@ #include "../shadowMap/shadowMapIO_HLSL.h" #include "softShadow.hlsl" - -uniform sampler2D shadowMap : register(S1); -uniform sampler2D dynamicShadowMap : register(S2); +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap, 2); #ifdef USE_SSAO_MASK -uniform sampler2D ssaoMask : register(S3); -uniform float4 rtParams2; +TORQUE_UNIFORM_SAMPLER2D(ssaoMask, 3); +uniform float4 rtParams3; #endif +//register 4? +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); -float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, +uniform float lightBrightness; +uniform float3 lightDirection; + +uniform float4 lightColor; +uniform float4 lightAmbient; + +uniform float shadowSoftness; +uniform float3 eyePosWorld; + +uniform float4 atlasXOffset; +uniform float4 atlasYOffset; +uniform float4 zNearFarInvNearFar; +uniform float4 lightMapParams; +uniform float4 farPlaneScalePSSM; +uniform float4 overDarkPSSM; + +uniform float2 fadeStartLength; +uniform float2 atlasScale; + +uniform float4x4 eyeMat; + +// Static Shadows +uniform float4x4 worldToLightProj; +uniform float4 scaleX; +uniform float4 scaleY; +uniform float4 offsetX; +uniform float4 offsetY; +// Dynamic Shadows +uniform float4x4 dynamicWorldToLightProj; +uniform float4 dynamicScaleX; +uniform float4 dynamicScaleY; +uniform float4 dynamicOffsetX; +uniform float4 dynamicOffsetY; +uniform float4 dynamicFarPlaneScalePSSM; + +float4 AL_VectorLightShadowCast( TORQUE_SAMPLER2D(sourceShadowMap), float2 texCoord, float4x4 worldToLightProj, float4 worldPos, @@ -52,8 +92,7 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, float2 atlasScale, float shadowSoftness, float dotNL , - float4 overDarkPSSM -) + float4 overDarkPSSM) { // Compute shadow map coordinate float4 pxlPosLightProj = mul(worldToLightProj, worldPos); @@ -144,7 +183,7 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, distToLight *= farPlaneScale; return float4(debugColor, - softShadow_filter( sourceShadowMap, + softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(sourceShadowMap), texCoord, shadowCoord, farPlaneScale * shadowSoftness, @@ -153,46 +192,18 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, dot( finalMask, overDarkPSSM ) ) ); }; -float4 main( FarFrustumQuadConnectP IN, - - uniform sampler2D prePassBuffer : register(S0), - - uniform float3 lightDirection, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float4 lightAmbient, - uniform float4x4 eyeMat, - - uniform float3 eyePosWorld, - uniform float4 atlasXOffset, - uniform float4 atlasYOffset, - uniform float2 atlasScale, - uniform float4 zNearFarInvNearFar, - uniform float4 lightMapParams, - uniform float2 fadeStartLength, - uniform float4 overDarkPSSM, - uniform float shadowSoftness, - - // Static Shadows - uniform float4x4 worldToLightProj, - uniform float4 scaleX, - uniform float4 scaleY, - uniform float4 offsetX, - uniform float4 offsetY, - uniform float4 farPlaneScalePSSM, - - // Dynamic Shadows - uniform float4x4 dynamicWorldToLightProj, - uniform float4 dynamicScaleX, - uniform float4 dynamicScaleY, - uniform float4 dynamicOffsetX, - uniform float4 dynamicOffsetY, - uniform float4 dynamicFarPlaneScalePSSM - - ) : COLOR0 -{ +float4 main( FarFrustumQuadConnectP IN ) : TORQUE_TARGET0 +{ + // Emissive. + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, IN.uv0 ); + bool emissive = getFlag( matInfo.r, 0 ); + if ( emissive ) + { + return float4(1.0, 1.0, 1.0, 0.0); + } + // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, IN.uv0 ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, IN.uv0 ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -217,7 +228,7 @@ float4 main( FarFrustumQuadConnectP IN, #else - float4 static_shadowed_colors = AL_VectorLightShadowCast( shadowMap, + float4 static_shadowed_colors = AL_VectorLightShadowCast( TORQUE_SAMPLER2D_MAKEARG(shadowMap), IN.uv0.xy, worldToLightProj, worldPos, @@ -229,8 +240,7 @@ float4 main( FarFrustumQuadConnectP IN, shadowSoftness, dotNL, overDarkPSSM); - - float4 dynamic_shadowed_colors = AL_VectorLightShadowCast( dynamicShadowMap, + float4 dynamic_shadowed_colors = AL_VectorLightShadowCast( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), IN.uv0.xy, dynamicWorldToLightProj, worldPos, @@ -276,6 +286,7 @@ float4 main( FarFrustumQuadConnectP IN, float Sat_NL_Att = saturate( dotNL * shadowed ) * lightBrightness; float3 lightColorOut = lightMapParams.rgb * lightColor.rgb; + float4 addToResult = (lightAmbient * (1 - ambientCameraFactor)) + ( lightAmbient * ambientCameraFactor * saturate(dot(normalize(-IN.vsEyeRay), normal)) ); // TODO: This needs to be removed when lightmapping is disabled @@ -295,7 +306,7 @@ float4 main( FarFrustumQuadConnectP IN, // Sample the AO texture. #ifdef USE_SSAO_MASK - float ao = 1.0 - tex2D( ssaoMask, viewportCoordToRenderTarget( IN.uv0.xy, rtParams2 ) ).r; + float ao = 1.0 - TORQUE_TEX2D( ssaoMask, viewportCoordToRenderTarget( IN.uv0.xy, rtParams3 ) ).r; addToResult *= ao; #endif @@ -303,5 +314,6 @@ float4 main( FarFrustumQuadConnectP IN, lightColorOut = debugColor; #endif - return lightinfoCondition( lightColorOut, Sat_NL_Att, specular, addToResult ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, IN.uv0 ); + return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterP.hlsl b/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterP.hlsl index f161fb5d3..b56aade8d 100644 --- a/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterP.hlsl @@ -22,11 +22,11 @@ #include "shaders/common/postFx/postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv : TEXCOORD0; }; @@ -35,15 +35,15 @@ static float weight[3] = { 0.2270270270, 0.3162162162, 0.0702702703 }; uniform float2 oneOverTargetSize; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { - float4 OUT = tex2D( diffuseMap, IN.uv ) * weight[0]; + float4 OUT = TORQUE_TEX2D( diffuseMap, IN.uv ) * weight[0]; for ( int i=1; i < 3; i++ ) { float2 sample = (BLUR_DIR * offset[i]) * oneOverTargetSize; - OUT += tex2D( diffuseMap, IN.uv + sample ) * weight[i]; - OUT += tex2D( diffuseMap, IN.uv - sample ) * weight[i]; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv + sample ) * weight[i]; + OUT += TORQUE_TEX2D(diffuseMap, IN.uv - sample) * weight[i]; } return OUT; diff --git a/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterV.hlsl b/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterV.hlsl index bf6a36249..c89af7357 100644 --- a/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterV.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/basic/shadowFilterV.hlsl @@ -27,7 +27,7 @@ float4 rtParams0; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv : TEXCOORD0; }; @@ -35,7 +35,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv = viewportCoordToRenderTarget( IN.uv, rtParams0 ); return OUT; diff --git a/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl b/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl index dd691de23..a187c3c63 100644 --- a/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl @@ -23,10 +23,12 @@ //***************************************************************************** // Box Filter //***************************************************************************** +#include "../ShaderModel.hlsl" struct ConnectData { - float2 tex0 : TEXCOORD0; + float4 hpos : TORQUE_POSITION; + float2 tex0 : TEXCOORD0; }; // If not defined from ShaderData then define @@ -40,12 +42,12 @@ float log_conv ( float x0, float X, float y0, float Y ) return (X + log(x0 + (y0 * exp(Y - X)))); } -float4 main( ConnectData IN, - uniform sampler2D diffuseMap0 : register(S0), - uniform float texSize : register(C0), - uniform float2 blurDimension : register(C2), - uniform float2 blurBoundaries : register(C3) - ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(diffuseMap0, 0); +uniform float texSize : register(C0); +uniform float2 blurDimension : register(C2); +uniform float2 blurBoundaries : register(C3); + +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // 5x5 if (IN.tex0.x <= blurBoundaries.x) @@ -56,8 +58,8 @@ float4 main( ConnectData IN, float2 texCoord = IN.tex0; - float accum = log_conv(0.3125, tex2D(diffuseMap0, texCoord - sampleOffset), 0.375, tex2D(diffuseMap0, texCoord)); - accum = log_conv(1, accum, 0.3125, tex2D(diffuseMap0, texCoord + sampleOffset)); + float accum = log_conv(0.3125, TORQUE_TEX2D(diffuseMap0, texCoord - sampleOffset), 0.375, tex2D(diffuseMap0, texCoord)); + accum = log_conv(1, accum, 0.3125, TORQUE_TEX2D(diffuseMap0, texCoord + sampleOffset)); return accum; } else { @@ -73,7 +75,7 @@ float4 main( ConnectData IN, return accum; } else { - return tex2D(diffuseMap0, IN.tex0); + return TORQUE_TEX2D(diffuseMap0, IN.tex0); } } } diff --git a/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl b/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl index 75d9af000..3679e41bb 100644 --- a/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl +++ b/Templates/Empty/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl @@ -26,15 +26,18 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "../ShaderModel.hlsl" + struct VertData { - float2 texCoord : TEXCOORD0; - float4 position : POSITION; + float3 position : POSITION; + float2 texCoord : TEXCOORD0; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 tex0 : TEXCOORD0; }; @@ -47,7 +50,7 @@ ConnectData main( VertData IN, { ConnectData OUT; - OUT.hpos = mul(modelview, IN.position); + OUT.hpos = mul(modelview, float4(IN.position,1.0)); OUT.tex0 = IN.texCoord; return OUT; diff --git a/Templates/Empty/game/shaders/common/particleCompositeP.hlsl b/Templates/Empty/game/shaders/common/particleCompositeP.hlsl index 35c2cb4c5..6e26ddbdb 100644 --- a/Templates/Empty/game/shaders/common/particleCompositeP.hlsl +++ b/Templates/Empty/game/shaders/common/particleCompositeP.hlsl @@ -20,22 +20,30 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- #include "torque.hlsl" +#include "shaderModel.hlsl" -uniform sampler2D colorSource : register(S0); +TORQUE_UNIFORM_SAMPLER2D(colorSource, 0); uniform float4 offscreenTargetParams; #ifdef TORQUE_LINEAR_DEPTH #define REJECT_EDGES -uniform sampler2D edgeSource : register(S1); +TORQUE_UNIFORM_SAMPLER2D(edgeSource, 1); uniform float4 edgeTargetParams; #endif +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float4 offscreenPos : TEXCOORD0; + float4 backbufferPos : TEXCOORD1; +}; -float4 main( float4 offscreenPos : TEXCOORD0, float4 backbufferPos : TEXCOORD1 ) : COLOR + +float4 main(Conn IN) : TORQUE_TARGET0 { // Off-screen particle source screenspace position in XY // Back-buffer screenspace position in ZW - float4 ssPos = float4(offscreenPos.xy / offscreenPos.w, backbufferPos.xy / backbufferPos.w); + float4 ssPos = float4(IN.offscreenPos.xy / IN.offscreenPos.w, IN.backbufferPos.xy / IN.backbufferPos.w); float4 uvScene = ( ssPos + 1.0 ) / 2.0; uvScene.yw = 1.0 - uvScene.yw; @@ -44,10 +52,10 @@ float4 main( float4 offscreenPos : TEXCOORD0, float4 backbufferPos : TEXCOORD1 ) #ifdef REJECT_EDGES // Cut out particles along the edges, this will create the stencil mask uvScene.zw = viewportCoordToRenderTarget(uvScene.zw, edgeTargetParams); - float edge = tex2D( edgeSource, uvScene.zw ).r; + float edge = TORQUE_TEX2D( edgeSource, uvScene.zw ).r; clip( -edge ); #endif // Sample offscreen target and return - return tex2D( colorSource, uvScene.xy ); + return TORQUE_TEX2D( colorSource, uvScene.xy ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/particleCompositeV.hlsl b/Templates/Empty/game/shaders/common/particleCompositeV.hlsl index 87fac0d94..c4c51204a 100644 --- a/Templates/Empty/game/shaders/common/particleCompositeV.hlsl +++ b/Templates/Empty/game/shaders/common/particleCompositeV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "hlslStructs.h" +#include "shaderModel.hlsl" -struct VertOut +struct Vertex { - float4 hpos : POSITION; + float3 pos : POSITION; + float4 uvCoord : COLOR0; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; float4 offscreenPos : TEXCOORD0; float4 backbufferPos : TEXCOORD1; }; uniform float4 screenRect; // point, extent -VertOut main( float4 uvCoord : COLOR ) +Conn main(Vertex IN) { - VertOut OUT; + Conn OUT; - OUT.hpos = float4(uvCoord.xy, 1.0, 1.0); + OUT.hpos = float4(IN.uvCoord.xy, 1.0, 1.0); OUT.hpos.xy *= screenRect.zw; OUT.hpos.xy += screenRect.xy; diff --git a/Templates/Empty/game/shaders/common/particlesP.hlsl b/Templates/Empty/game/shaders/common/particlesP.hlsl index 80e3c7105..37439c59a 100644 --- a/Templates/Empty/game/shaders/common/particlesP.hlsl +++ b/Templates/Empty/game/shaders/common/particlesP.hlsl @@ -21,7 +21,7 @@ //----------------------------------------------------------------------------- #include "torque.hlsl" - +#include "shaderModel.hlsl" // With advanced lighting we get soft particles. #ifdef TORQUE_LINEAR_DEPTH #define SOFTPARTICLES @@ -29,11 +29,11 @@ #ifdef SOFTPARTICLES - #include "shadergen:/autogenConditioners.h" + #include "shaderModelAutoGen.hlsl" uniform float oneOverSoftness; uniform float oneOverFar; - uniform sampler2D prepassTex : register(S1); + TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); //uniform float3 vEye; uniform float4 prePassTargetParams; #endif @@ -42,14 +42,14 @@ struct Conn { + float4 hpos : TORQUE_POSITION; float4 color : TEXCOORD0; float2 uv0 : TEXCOORD1; - float4 pos : TEXCOORD2; + float4 pos : TEXCOORD2; }; -uniform sampler2D diffuseMap : register(S0); - -uniform sampler2D paraboloidLightMap : register(S2); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); +TORQUE_UNIFORM_SAMPLER2D(paraboloidLightMap, 2); float4 lmSample( float3 nrm ) { @@ -69,14 +69,14 @@ float4 lmSample( float3 nrm ) // Atlasing front and back maps, so scale lmCoord.x *= 0.5; - return tex2D(paraboloidLightMap, lmCoord); + return TORQUE_TEX2D(paraboloidLightMap, lmCoord); } uniform float alphaFactor; uniform float alphaScale; -float4 main( Conn IN ) : COLOR +float4 main( Conn IN ) : TORQUE_TARGET0 { float softBlend = 1; @@ -84,7 +84,7 @@ float4 main( Conn IN ) : COLOR float2 tc = IN.pos.xy * float2(1.0, -1.0) / IN.pos.w; tc = viewportCoordToRenderTarget(saturate( ( tc + 1.0 ) * 0.5 ), prePassTargetParams); - float sceneDepth = prepassUncondition( prepassTex, tc ).w; + float sceneDepth = TORQUE_PREPASS_UNCONDITION(prepassTex, tc).w; float depth = IN.pos.w * oneOverFar; float diff = sceneDepth - depth; #ifdef CLIP_Z @@ -96,7 +96,7 @@ float4 main( Conn IN ) : COLOR softBlend = saturate( diff * oneOverSoftness ); #endif - float4 diffuse = tex2D( diffuseMap, IN.uv0 ); + float4 diffuse = TORQUE_TEX2D( diffuseMap, IN.uv0 ); //return float4( lmSample(float3(0, 0, -1)).rgb, IN.color.a * diffuse.a * softBlend * alphaScale); diff --git a/Templates/Empty/game/shaders/common/particlesV.hlsl b/Templates/Empty/game/shaders/common/particlesV.hlsl index f09604237..dbeff0cc2 100644 --- a/Templates/Empty/game/shaders/common/particlesV.hlsl +++ b/Templates/Empty/game/shaders/common/particlesV.hlsl @@ -20,16 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" + struct Vertex { - float4 pos : POSITION; + float3 pos : POSITION; float4 color : COLOR0; float2 uv0 : TEXCOORD0; }; struct Conn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 color : TEXCOORD0; float2 uv0 : TEXCOORD1; float4 pos : TEXCOORD2; @@ -43,8 +45,8 @@ Conn main( Vertex In ) { Conn Out; - Out.hpos = mul( modelViewProj, In.pos ); - Out.pos = mul( fsModelViewProj, In.pos ); + Out.hpos = mul( modelViewProj, float4(In.pos,1.0) ); + Out.pos = mul(fsModelViewProj, float4(In.pos, 1.0) ); Out.color = In.color; Out.uv0 = In.uv0; diff --git a/Templates/Empty/game/shaders/common/planarReflectBumpP.hlsl b/Templates/Empty/game/shaders/common/planarReflectBumpP.hlsl index a5057db50..d18331fb6 100644 --- a/Templates/Empty/game/shaders/common/planarReflectBumpP.hlsl +++ b/Templates/Empty/game/shaders/common/planarReflectBumpP.hlsl @@ -23,18 +23,26 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct ConnectData { - float4 texCoord : TEXCOORD0; - float2 tex2 : TEXCOORD1; + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; + float4 tex2 : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(texMap, 0); +TORQUE_UNIFORM_SAMPLER2D(refractMap, 1); +TORQUE_UNIFORM_SAMPLER2D(bumpMap, 2); + //----------------------------------------------------------------------------- // Fade edges of axis for texcoord passed in @@ -54,15 +62,11 @@ float fadeAxis( float val ) //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D refractMap : register(S1), - uniform sampler2D texMap : register(S0), - uniform sampler2D bumpMap : register(S2) -) +Fragout main( ConnectData IN ) { Fragout OUT; - float3 bumpNorm = tex2D( bumpMap, IN.tex2 ) * 2.0 - 1.0; + float3 bumpNorm = TORQUE_TEX2D( bumpMap, IN.tex2 ) * 2.0 - 1.0; float2 offset = float2( bumpNorm.x, bumpNorm.y ); float4 texIndex = IN.texCoord; @@ -74,8 +78,8 @@ Fragout main( ConnectData IN, const float distortion = 0.2; texIndex.xy += offset * distortion * fadeVal; - float4 reflectColor = tex2Dproj( refractMap, texIndex ); - float4 diffuseColor = tex2D( texMap, IN.tex2 ); + float4 reflectColor = TORQUE_TEX2DPROJ( refractMap, texIndex ); + float4 diffuseColor = TORQUE_TEX2D( texMap, IN.tex2 ); OUT.col = diffuseColor + reflectColor * diffuseColor.a; diff --git a/Templates/Empty/game/shaders/common/planarReflectBumpV.hlsl b/Templates/Empty/game/shaders/common/planarReflectBumpV.hlsl index 108f918ce..d45adb574 100644 --- a/Templates/Empty/game/shaders/common/planarReflectBumpV.hlsl +++ b/Templates/Empty/game/shaders/common/planarReflectBumpV.hlsl @@ -22,36 +22,37 @@ #define IN_HLSL #include "shdrConsts.h" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { + float3 position : POSITION; + float3 normal : NORMAL; float2 texCoord : TEXCOORD0; float2 lmCoord : TEXCOORD1; float3 T : TEXCOORD2; - float3 B : TEXCOORD3; - float3 normal : NORMAL; - float4 position : POSITION; + float3 B : TEXCOORD3; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord : TEXCOORD0; float2 tex2 : TEXCOORD1; }; +uniform float4x4 modelview; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertData IN, - uniform float4x4 modelview ) +ConnectData main( VertData IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.position); + OUT.hpos = mul(modelview, float4(IN.position,1.0)); float4x4 texGenTest = { 0.5, 0.0, 0.0, 0.5, 0.0, -0.5, 0.0, 0.5, diff --git a/Templates/Empty/game/shaders/common/planarReflectP.hlsl b/Templates/Empty/game/shaders/common/planarReflectP.hlsl index 981cc316d..43b420544 100644 --- a/Templates/Empty/game/shaders/common/planarReflectP.hlsl +++ b/Templates/Empty/game/shaders/common/planarReflectP.hlsl @@ -23,31 +23,34 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct ConnectData { - float2 texCoord : TEXCOORD0; - float4 tex2 : TEXCOORD1; + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; + float4 tex2 : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(texMap, 0); +TORQUE_UNIFORM_SAMPLER2D(refractMap, 1); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D texMap : register(S0), - uniform sampler2D refractMap : register(S1) -) +Fragout main( ConnectData IN ) { Fragout OUT; - float4 diffuseColor = tex2D( texMap, IN.texCoord ); - float4 reflectColor = tex2Dproj( refractMap, IN.tex2 ); + float4 diffuseColor = TORQUE_TEX2D( texMap, IN.texCoord ); + float4 reflectColor = TORQUE_TEX2DPROJ(refractMap, IN.tex2); OUT.col = diffuseColor + reflectColor * diffuseColor.a; diff --git a/Templates/Empty/game/shaders/common/planarReflectV.hlsl b/Templates/Empty/game/shaders/common/planarReflectV.hlsl index cd8cb2d96..1f2ca9d4f 100644 --- a/Templates/Empty/game/shaders/common/planarReflectV.hlsl +++ b/Templates/Empty/game/shaders/common/planarReflectV.hlsl @@ -21,7 +21,8 @@ //----------------------------------------------------------------------------- #define IN_HLSL -#include "hlslStructs.h" +#include "hlslStructs.hlsl" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures @@ -29,20 +30,20 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; float4 tex2 : TEXCOORD1; }; +uniform float4x4 modelview; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertexIn_PNTTTB IN, - uniform float4x4 modelview : register(C0) -) +ConnectData main( VertexIn_PNTTTB IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.pos); + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); float4x4 texGenTest = { 0.5, 0.0, 0.0, 0.5, 0.0, -0.5, 0.0, 0.5, diff --git a/Templates/Empty/game/shaders/common/postFx/VolFogGlowP.hlsl b/Templates/Empty/game/shaders/common/postFx/VolFogGlowP.hlsl index 8a61b5928..c3adb3b55 100644 --- a/Templates/Empty/game/shaders/common/postFx/VolFogGlowP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/VolFogGlowP.hlsl @@ -32,12 +32,12 @@ #include "./postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); uniform float strength; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -50,20 +50,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * strength; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Empty/game/shaders/common/postFx/caustics/causticsP.hlsl b/Templates/Empty/game/shaders/common/postFx/caustics/causticsP.hlsl index c7635027d..d2f4a058a 100644 --- a/Templates/Empty/game/shaders/common/postFx/caustics/causticsP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/caustics/causticsP.hlsl @@ -21,25 +21,26 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" +uniform float accumTime; uniform float3 eyePosWorld; uniform float4 rtParams0; uniform float4 waterFogPlane; -uniform float accumTime; + +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER2D(causticsTex0, 1); +TORQUE_UNIFORM_SAMPLER2D(causticsTex1, 2); float distanceToPlane(float4 plane, float3 pos) { return (plane.x * pos.x + plane.y * pos.y + plane.z * pos.z) + plane.w; } -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex :register(S0), - uniform sampler2D causticsTex0 :register(S1), - uniform sampler2D causticsTex1 :register(S2) ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //Sample the pre-pass - float4 prePass = prepassUncondition( prepassTex, IN.uv0 ); + float4 prePass = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ); //Get depth float depth = prePass.w; @@ -65,12 +66,12 @@ float4 main( PFXVertToPix IN, causticsUV1.xy -= float2(accumTime*0.15, timeSin*0.15); //Sample caustics texture - float4 caustics = tex2D(causticsTex0, causticsUV0); - caustics *= tex2D(causticsTex1, causticsUV1); + float4 caustics = TORQUE_TEX2D(causticsTex0, causticsUV0); + caustics *= TORQUE_TEX2D(causticsTex1, causticsUV1); //Use normal Z to modulate caustics //float waterDepth = 1 - saturate(pos.z + waterFogPlane.w + 1); - caustics *= saturate(prePass.z) * pow(1-depth, 64) * waterDepth; + caustics *= saturate(prePass.z) * pow(abs(1-depth), 64) * waterDepth; return caustics; } diff --git a/Templates/Empty/game/shaders/common/postFx/chromaticLens.hlsl b/Templates/Empty/game/shaders/common/postFx/chromaticLens.hlsl index 5916e985a..8fdca72b7 100644 --- a/Templates/Empty/game/shaders/common/postFx/chromaticLens.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/chromaticLens.hlsl @@ -26,14 +26,13 @@ #include "./postFx.hlsl" #include "./../torque.hlsl" - -uniform sampler2D backBuffer : register( s0 ); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); uniform float distCoeff; uniform float cubeDistort; uniform float3 colorDistort; -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 tex = IN.uv0; @@ -54,7 +53,7 @@ float4 main( PFXVertToPix IN ) : COLOR0 { float x = distort[i] * ( tex.x - 0.5 ) + 0.5; float y = distort[i] * ( tex.y - 0.5 ) + 0.5; - outColor[i] = tex2Dlod( backBuffer, float4(x,y,0,0) )[i]; + outColor[i] = TORQUE_TEX2DLOD( backBuffer, float4(x,y,0,0) )[i]; } return float4( outColor.rgb, 1 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl index bc17a2c04..2f5835fc2 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl @@ -23,21 +23,22 @@ #include "./../postFx.hlsl" // These are set by the game engine. -uniform sampler2D shrunkSampler : register(S0); // Output of DofDownsample() -uniform sampler2D blurredSampler : register(S1); // Blurred version of the shrunk sampler +TORQUE_UNIFORM_SAMPLER2D(shrunkSampler, 0); // Output of DofDownsample() +TORQUE_UNIFORM_SAMPLER2D(blurredSampler, 1); // Blurred version of the shrunk sampler + // This is the pixel shader function that calculates the actual // value used for the near circle of confusion. // "texCoords" are 0 at the bottom left pixel and 1 at the top right. -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float3 color; float coc; half4 blurred; half4 shrunk; - shrunk = tex2D( shrunkSampler, IN.uv0 ); - blurred = tex2D( blurredSampler, IN.uv1 ); + shrunk = half4(TORQUE_TEX2D( shrunkSampler, IN.uv0 )); + blurred = half4(TORQUE_TEX2D( blurredSampler, IN.uv1 )); color = shrunk.rgb; //coc = shrunk.a; //coc = blurred.a; diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl index 40cec49de..8131e45cd 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl @@ -57,7 +57,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl index 37e591f25..8c9028654 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl @@ -20,22 +20,23 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" // These are set by the game engine. // The render target size is one-quarter the scene rendering size. -uniform sampler2D colorSampler : register(S0); -uniform sampler2D depthSampler : register(S1); -uniform float2 dofEqWorld; -uniform float depthOffset; +TORQUE_UNIFORM_SAMPLER2D(colorSampler, 0); +TORQUE_UNIFORM_SAMPLER2D(depthSampler, 1); +uniform float2 dofEqWorld; uniform float2 targetSize; +uniform float depthOffset; uniform float maxWorldCoC; //uniform float2 dofEqWeapon; //uniform float2 dofRowDelta; // float2( 0, 0.25 / renderTargetHeight ) struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float2 tcColor0 : TEXCOORD0; float2 tcColor1 : TEXCOORD1; float2 tcDepth0 : TEXCOORD2; @@ -44,7 +45,7 @@ struct Pixel float2 tcDepth3 : TEXCOORD5; }; -half4 main( Pixel IN ) : COLOR +half4 main( Pixel IN ) : TORQUE_TARGET0 { //return float4( 1.0, 0.0, 1.0, 1.0 ); @@ -69,57 +70,64 @@ half4 main( Pixel IN ) : COLOR // Use bilinear filtering to average 4 color samples for free. color = 0; - color += tex2D( colorSampler, IN.tcColor0.xy + rowOfs[0] ).rgb; - color += tex2D( colorSampler, IN.tcColor1.xy + rowOfs[0] ).rgb; - color += tex2D( colorSampler, IN.tcColor0.xy + rowOfs[2] ).rgb; - color += tex2D( colorSampler, IN.tcColor1.xy + rowOfs[2] ).rgb; + color += half3(TORQUE_TEX2D( colorSampler, IN.tcColor0.xy + rowOfs[0] ).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor1.xy + rowOfs[0]).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor0.xy + rowOfs[2]).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor1.xy + rowOfs[2]).rgb); color /= 4; + //declare thse here to save doing it in each loop below + half4 zero4 = half4(0, 0, 0, 0); + coc = zero4; + half4 dofEqWorld4X = half4(dofEqWorld.xxxx); + half4 dofEqWorld4Y = half4(dofEqWorld.yyyy); + half4 maxWorldCoC4 = half4(maxWorldCoC, maxWorldCoC, maxWorldCoC, maxWorldCoC); // Process 4 samples at a time to use vector hardware efficiently. // The CoC will be 1 if the depth is negative, so use "min" to pick - // between "sceneCoc" and "viewCoc". - - for ( int i = 0; i < 4; i++ ) + // between "sceneCoc" and "viewCoc". + [unroll] // coc[i] causes this anyway + for (int i = 0; i < 4; i++) { - depth[0] = prepassUncondition( depthSampler, float4( IN.tcDepth0.xy + rowOfs[i], 0, 0 ) ).w; - depth[1] = prepassUncondition( depthSampler, float4( IN.tcDepth1.xy + rowOfs[i], 0, 0 ) ).w; - depth[2] = prepassUncondition( depthSampler, float4( IN.tcDepth2.xy + rowOfs[i], 0, 0 ) ).w; - depth[3] = prepassUncondition( depthSampler, float4( IN.tcDepth3.xy + rowOfs[i], 0, 0 ) ).w; - coc[i] = clamp( dofEqWorld.x * depth + dofEqWorld.y, 0.0, maxWorldCoC ); - } + depth[0] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth0.xy + rowOfs[i])).w; + depth[1] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth1.xy + rowOfs[i])).w; + depth[2] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth2.xy + rowOfs[i])).w; + depth[3] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth3.xy + rowOfs[i])).w; + + coc = max(coc, clamp(dofEqWorld4X * half4(depth)+dofEqWorld4Y, zero4, maxWorldCoC4)); + } /* - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[0] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[0] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[0] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[0] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[0] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[0] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[0] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[0] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = curCoc; - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[1] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[1] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[1] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[1] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[1] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[1] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[1] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[1] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = max( coc, curCoc ); - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[2] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[2] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[2] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[2] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[2] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[2] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[2] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[2] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = max( coc, curCoc ); - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[3] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[3] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[3] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[3] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[3] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[3] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[3] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[3] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl index da2a79fb4..0b3ec01e2 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl @@ -25,14 +25,14 @@ struct Vert { - float4 pos : POSITION; + float3 pos : POSITION; float2 tc : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; }; struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float2 tcColor0 : TEXCOORD0; float2 tcColor1 : TEXCOORD1; float2 tcDepth0 : TEXCOORD2; @@ -47,7 +47,7 @@ uniform float2 oneOverTargetSize; Pixel main( Vert IN ) { Pixel OUT; - OUT.position = IN.pos; + OUT.position = float4(IN.pos,1.0); float2 uv = viewportCoordToRenderTarget( IN.tc, rtParams0 ); //OUT.position = mul( IN.pos, modelView ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_P.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_P.hlsl index 36622495c..cb7342d40 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_P.hlsl @@ -20,13 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "./../postFx.hlsl" -uniform sampler2D colorSampler : register(S0); // Original source image -uniform sampler2D smallBlurSampler : register(S1); // Output of SmallBlurPS() -uniform sampler2D largeBlurSampler : register(S2); // Blurred output of DofDownsample() -uniform sampler2D depthSampler : register(S3); // +TORQUE_UNIFORM_SAMPLER2D(colorSampler,0); // Original source image +TORQUE_UNIFORM_SAMPLER2D(smallBlurSampler,1); // Output of SmallBlurPS() +TORQUE_UNIFORM_SAMPLER2D(largeBlurSampler,2); // Blurred output of DofDownsample() +TORQUE_UNIFORM_SAMPLER2D(depthSampler,3); + uniform float2 oneOverTargetSize; uniform float4 dofLerpScale; uniform float4 dofLerpBias; @@ -40,9 +41,9 @@ uniform float maxFarCoC; //static float4 dofLerpBias = float4( 1.0, (1.0 - d2) / d1, 1.0 / d2, (d2 - 1.0) / d2 ); //static float3 dofEqFar = float3( 2.0, 0.0, 1.0 ); -float4 tex2Doffset( sampler2D s, float2 tc, float2 offset ) +float4 tex2Doffset(TORQUE_SAMPLER2D(s), float2 tc, float2 offset) { - return tex2D( s, tc + offset * oneOverTargetSize ); + return TORQUE_TEX2D( s, tc + offset * oneOverTargetSize ); } half3 GetSmallBlurSample( float2 tc ) @@ -51,10 +52,10 @@ half3 GetSmallBlurSample( float2 tc ) const half weight = 4.0 / 17; sum = 0; // Unblurred sample done by alpha blending //sum += weight * tex2Doffset( colorSampler, tc, float2( 0, 0 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( +0.5, -1.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( -1.5, -0.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( -0.5, +1.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( +1.5, +0.5 ) ).rgb; + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(+0.5, -1.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(-1.5, -0.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(-0.5, +1.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(+1.5, +0.5)).rgb); return sum; } @@ -72,7 +73,7 @@ half4 InterpolateDof( half3 small, half3 med, half3 large, half t ) //float4 dofLerpScale = float4( -1 / d0, -1 / d1, -1 / d2, 1 / d2 ); //float4 dofLerpBias = float4( 1, (1 d2) / d1, 1 / d2, (d2 1) / d2 ); - weights = saturate( t * dofLerpScale + dofLerpBias ); + weights = half4(saturate( t * dofLerpScale + dofLerpBias )); weights.yz = min( weights.yz, 1 - weights.xy ); // Unblurred sample with weight "weights.x" done by alpha blending @@ -84,11 +85,11 @@ half4 InterpolateDof( half3 small, half3 med, half3 large, half t ) return half4( color, alpha ); } -half4 main( PFXVertToPix IN ) : COLOR +half4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //return half4( 1,0,1,1 ); - //return half4( tex2D( colorSampler, IN.uv0 ).rgb, 1.0 ); - //return half4( tex2D( colorSampler, texCoords ).rgb, 0 ); + //return half4( TORQUE_TEX2D( colorSampler, IN.uv0 ).rgb, 1.0 ); + //return half4( TORQUE_TEX2D( colorSampler, texCoords ).rgb, 0 ); half3 small; half4 med; half3 large; @@ -100,10 +101,10 @@ half4 main( PFXVertToPix IN ) : COLOR small = GetSmallBlurSample( IN.uv0 ); //small = half3( 1,0,0 ); //return half4( small, 1.0 ); - med = tex2D( smallBlurSampler, IN.uv1 ); + med = half4(TORQUE_TEX2D( smallBlurSampler, IN.uv1 )); //med.rgb = half3( 0,1,0 ); //return half4(med.rgb, 0.0); - large = tex2D( largeBlurSampler, IN.uv2 ).rgb; + large = half3(TORQUE_TEX2D(largeBlurSampler, IN.uv2).rgb); //large = half3( 0,0,1 ); //return large; //return half4(large.rgb,1.0); @@ -114,7 +115,7 @@ half4 main( PFXVertToPix IN ) : COLOR //med.rgb = large; //nearCoc = 0; - depth = prepassUncondition( depthSampler, float4( IN.uv3, 0, 0 ) ).w; + depth = half(TORQUE_PREPASS_UNCONDITION( depthSampler, IN.uv3 ).w); //return half4(depth.rrr,1); //return half4(nearCoc.rrr,1.0); @@ -128,8 +129,8 @@ half4 main( PFXVertToPix IN ) : COLOR // dofEqFar.x and dofEqFar.y specify the linear ramp to convert // to depth for the distant out-of-focus region. // dofEqFar.z is the ratio of the far to the near blur radius. - farCoc = clamp( dofEqFar.x * depth + dofEqFar.y, 0.0, maxFarCoC ); - coc = max( nearCoc, farCoc * dofEqFar.z ); + farCoc = half(clamp( dofEqFar.x * depth + dofEqFar.y, 0.0, maxFarCoC )); + coc = half(max( nearCoc, farCoc * dofEqFar.z )); //coc = nearCoc; } diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_V.hlsl index 91dfba0a2..86c93701a 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Final_V.hlsl @@ -59,7 +59,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); // + float2( -5, 1 ) * oneOverTargetSize; OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl index 084a2c014..f4d29f3e1 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl @@ -22,11 +22,11 @@ #include "./../postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -39,20 +39,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * 0.5 / 1.3; //25f; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl index e29746e96..b2d4582e0 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl @@ -24,13 +24,13 @@ #include "./../../torque.hlsl" -uniform float2 texSize0; uniform float4 rtParams0; +uniform float2 texSize0; uniform float2 oneOverTargetSize; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -47,7 +47,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); IN.uv = viewportCoordToRenderTarget( IN.uv, rtParams0 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl index 40cec49de..8131e45cd 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl @@ -57,7 +57,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl index 6d4144576..175525a91 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl @@ -24,22 +24,23 @@ // colorMapSampler, which is the same size as the render target. // The sample weights are 1/16 in the corners, 2/16 on the edges, // and 4/16 in the center. +#include "../../shaderModel.hlsl" -uniform sampler2D colorSampler; // Output of DofNearCoc() +TORQUE_UNIFORM_SAMPLER2D(colorSampler, 0); // Output of DofNearCoc() struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float4 texCoords : TEXCOORD0; }; -float4 main( Pixel IN ) : COLOR +float4 main( Pixel IN ) : TORQUE_TARGET0 { float4 color; color = 0.0; - color += tex2D( colorSampler, IN.texCoords.xz ); - color += tex2D( colorSampler, IN.texCoords.yz ); - color += tex2D( colorSampler, IN.texCoords.xw ); - color += tex2D( colorSampler, IN.texCoords.yw ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.xz ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.yz ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.xw ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.yw ); return color / 4.0; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl b/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl index 204f4639d..3edb1ec2a 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl @@ -30,13 +30,13 @@ struct Vert { - float4 position : POSITION; + float3 position : POSITION; float2 texCoords : TEXCOORD0; }; struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float4 texCoords : TEXCOORD0; }; @@ -47,7 +47,7 @@ Pixel main( Vert IN ) { Pixel OUT; const float4 halfPixel = { -0.5, 0.5, -0.5, 0.5 }; - OUT.position = IN.position; //Transform_ObjectToClip( IN.position ); + OUT.position = float4(IN.position,1.0); //Transform_ObjectToClip( IN.position ); //float2 uv = IN.texCoords + rtParams0.xy; float2 uv = viewportCoordToRenderTarget( IN.texCoords, rtParams0 ); diff --git a/Templates/Empty/game/shaders/common/postFx/dof/gl/DOF_CalcCoC_P.glsl b/Templates/Empty/game/shaders/common/postFx/dof/gl/DOF_CalcCoC_P.glsl index 9bfad955c..38cb099c4 100644 --- a/Templates/Empty/game/shaders/common/postFx/dof/gl/DOF_CalcCoC_P.glsl +++ b/Templates/Empty/game/shaders/common/postFx/dof/gl/DOF_CalcCoC_P.glsl @@ -25,7 +25,7 @@ // These are set by the game engine. uniform sampler2D shrunkSampler; // Output of DofDownsample() -uniform sampler2D blurredSampler; // Blurred version of the shrunk sampler +uniform sampler2D blurredSampler; // Blurred version of the shrunk sampler out vec4 OUT_col; diff --git a/Templates/Empty/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl b/Templates/Empty/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl index 90cf391dc..fbd529031 100644 --- a/Templates/Empty/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl @@ -21,10 +21,10 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -float4 main( PFXVertToPix IN, - uniform sampler2D edgeBuffer :register(S0) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(edgeBuffer); + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return float4( tex2D( edgeBuffer, IN.uv0 ).rrr, 1.0 ); + return float4( TORQUE_TEX2D( edgeBuffer, IN.uv0 ).rrr, 1.0 ); } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl b/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl index e45684199..f5a71687d 100644 --- a/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl @@ -21,17 +21,17 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -float4 main( PFXVertToPix IN, - uniform sampler2D edgeBuffer : register(S0), - uniform sampler2D backBuffer : register(S1), - uniform float2 targetSize : register(C0) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(edgeBuffer,0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 1); +uniform float2 targetSize; + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 pixelSize = 1.0 / targetSize; // Sample edge buffer, bail if not on an edge - float edgeSample = tex2D(edgeBuffer, IN.uv0).r; + float edgeSample = TORQUE_TEX2D(edgeBuffer, IN.uv0).r; clip(edgeSample - 1e-6); // Ok we're on an edge, so multi-tap sample, average, and return @@ -58,7 +58,7 @@ float4 main( PFXVertToPix IN, float2 offsetUV = IN.uv1 + edgeSample * ( offsets[i] * 0.5 ) * pixelSize;//rtWidthHeightInvWidthNegHeight.zw; //offsetUV *= 0.999; - accumColor+= tex2D(backBuffer, offsetUV); + accumColor += TORQUE_TEX2D(backBuffer, offsetUV); } accumColor /= 9.0; diff --git a/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl b/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl index bc79516ee..2277126a8 100644 --- a/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl @@ -21,10 +21,12 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(prepassBuffer,0); // GPU Gems 3, pg 443-444 -float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize) +float GetEdgeWeight(float2 uv0, in float2 targetSize) { float2 offsets[9] = { float2( 0.0, 0.0), @@ -44,10 +46,11 @@ float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize float Depth[9]; float3 Normal[9]; + [unroll] //no getting around this, may as well save the annoying warning message for(int i = 0; i < 9; i++) { float2 uv = uv0 + offsets[i] * PixelSize; - float4 gbSample = prepassUncondition( prepassBuffer, uv ); + float4 gbSample = TORQUE_PREPASS_UNCONDITION( prepassBuffer, uv ); Depth[i] = gbSample.a; Normal[i] = gbSample.rgb; } @@ -82,9 +85,9 @@ float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize return dot(normalResults, float4(1.0, 1.0, 1.0, 1.0)) * 0.25; } -float4 main( PFXVertToPix IN, - uniform sampler2D prepassBuffer :register(S0), - uniform float2 targetSize : register(C0) ) : COLOR0 +uniform float2 targetSize; + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return GetEdgeWeight(IN.uv0, prepassBuffer, targetSize );//rtWidthHeightInvWidthNegHeight.zw); + return GetEdgeWeight(IN.uv0, targetSize);//rtWidthHeightInvWidthNegHeight.zw); } diff --git a/Templates/Empty/game/shaders/common/postFx/flashP.hlsl b/Templates/Empty/game/shaders/common/postFx/flashP.hlsl index 3d9c6c744..93daf3c26 100644 --- a/Templates/Empty/game/shaders/common/postFx/flashP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/flashP.hlsl @@ -25,11 +25,11 @@ uniform float damageFlash; uniform float whiteOut; -uniform sampler2D backBuffer : register(S0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); -float4 main(PFXVertToPix IN) : COLOR0 +float4 main(PFXVertToPix IN) : TORQUE_TARGET0 { - float4 color1 = tex2D(backBuffer, IN.uv0); + float4 color1 = TORQUE_TEX2D(backBuffer, IN.uv0); float4 color2 = color1 * MUL_COLOR; float4 damage = lerp(color1,color2,damageFlash); return lerp(damage,WHITE_COLOR,whiteOut); diff --git a/Templates/Empty/game/shaders/common/postFx/fogP.hlsl b/Templates/Empty/game/shaders/common/postFx/fogP.hlsl index 0eba9a7b7..b54eea97a 100644 --- a/Templates/Empty/game/shaders/common/postFx/fogP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/fogP.hlsl @@ -20,20 +20,21 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" + #include "./postFx.hlsl" #include "./../torque.hlsl" +#include "./../shaderModelAutoGen.hlsl" -uniform sampler2D prepassTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); uniform float3 eyePosWorld; uniform float4 fogColor; uniform float3 fogData; uniform float4 rtParams0; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //float2 prepassCoord = ( IN.uv0.xy * rtParams0.zw ) + rtParams0.xy; - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; //return float4( depth, 0, 0, 0.7 ); float factor = computeSceneFog( eyePosWorld, diff --git a/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaP.hlsl b/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaP.hlsl index 357b794e4..269bfea67 100644 --- a/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaP.hlsl @@ -20,38 +20,53 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + #define FXAA_PC 1 +#if (TORQUE_SM <= 30) #define FXAA_HLSL_3 1 +#elif TORQUE_SM < 49 +#define FXAA_HLSL_4 1 +#elif TORQUE_SM >=50 +#define FXAA_HLSL_5 1 +#endif #define FXAA_QUALITY__PRESET 12 #define FXAA_GREEN_AS_LUMA 1 #include "Fxaa3_11.h" -#include "../postFx.hlsl" struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; -uniform sampler2D colorTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(colorTex, 0); uniform float2 oneOverTargetSize; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { +#if (TORQUE_SM >= 10 && TORQUE_SM <=30) + FxaaTex tex = colorTex; +#elif TORQUE_SM >=40 + FxaaTex tex; + tex.smpl = colorTex; + tex.tex = texture_colorTex; +#endif + return FxaaPixelShader( IN.uv0, // vertex position 0, // Unused... console stuff - colorTex, // The color back buffer + tex, // The color back buffer - colorTex, // Used for 360 optimization + tex, // Used for 360 optimization - colorTex, // Used for 360 optimization + tex, // Used for 360 optimization oneOverTargetSize, diff --git a/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaV.hlsl b/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaV.hlsl index ea2c3d106..3bef0a4d3 100644 --- a/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaV.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/fxaa/fxaaV.hlsl @@ -25,7 +25,7 @@ struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; @@ -35,7 +35,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); return OUT; diff --git a/Templates/Empty/game/shaders/common/postFx/gammaP.hlsl b/Templates/Empty/game/shaders/common/postFx/gammaP.hlsl index dedfe8eb5..6e284eb88 100644 --- a/Templates/Empty/game/shaders/common/postFx/gammaP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/gammaP.hlsl @@ -24,23 +24,30 @@ #include "./postFx.hlsl" #include "../torque.hlsl" -uniform sampler2D backBuffer : register(S0); -uniform sampler1D colorCorrectionTex : register( s1 ); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 1); uniform float OneOverGamma; +uniform float Brightness; +uniform float Contrast; - -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 color = tex2D(backBuffer, IN.uv0.xy); + float4 color = TORQUE_TEX2D(backBuffer, IN.uv0.xy); // Apply the color correction. - color.r = tex1D( colorCorrectionTex, color.r ).r; - color.g = tex1D( colorCorrectionTex, color.g ).g; - color.b = tex1D( colorCorrectionTex, color.b ).b; + color.r = TORQUE_TEX1D( colorCorrectionTex, color.r ).r; + color.g = TORQUE_TEX1D( colorCorrectionTex, color.g ).g; + color.b = TORQUE_TEX1D( colorCorrectionTex, color.b ).b; // Apply gamma correction color.rgb = pow( abs(color.rgb), OneOverGamma ); + // Apply contrast + color.rgb = ((color.rgb - 0.5f) * Contrast) + 0.5f; + + // Apply brightness + color.rgb += Brightness; + return color; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/postFx/gl/gammaP.glsl b/Templates/Empty/game/shaders/common/postFx/gl/gammaP.glsl index 414a277d3..1bf5d1b8f 100644 --- a/Templates/Empty/game/shaders/common/postFx/gl/gammaP.glsl +++ b/Templates/Empty/game/shaders/common/postFx/gl/gammaP.glsl @@ -28,6 +28,8 @@ uniform sampler2D backBuffer; uniform sampler1D colorCorrectionTex; uniform float OneOverGamma; +uniform float Brightness; +uniform float Contrast; in vec2 uv0; @@ -45,5 +47,11 @@ void main() // Apply gamma correction color.rgb = pow( abs(color.rgb), vec3(OneOverGamma) ); + // Apply contrast + color.rgb = ((color.rgb - 0.5f) * Contrast) + 0.5f; + + // Apply brightness + color.rgb += Brightness; + OUT_col = color; } \ No newline at end of file diff --git a/Templates/Empty/game/shaders/common/postFx/gl/glowBlurP.glsl b/Templates/Empty/game/shaders/common/postFx/gl/glowBlurP.glsl index d00bee26f..9ebca32fa 100644 --- a/Templates/Empty/game/shaders/common/postFx/gl/glowBlurP.glsl +++ b/Templates/Empty/game/shaders/common/postFx/gl/glowBlurP.glsl @@ -39,7 +39,7 @@ out vec4 OUT_col; void main() { vec4 kernel = vec4( 0.175, 0.275, 0.375, 0.475 ) * 0.5f; - + OUT_col = vec4(0); OUT_col += texture( diffuseMap, uv0 ) * kernel.x; OUT_col += texture( diffuseMap, uv1 ) * kernel.y; @@ -55,5 +55,5 @@ void main() // can use alpha test to save fillrate. vec3 rgb2lum = vec3( 0.30, 0.59, 0.11 ); OUT_col.a = dot( OUT_col.rgb, rgb2lum ); - + } diff --git a/Templates/Empty/game/shaders/common/postFx/glowBlurP.hlsl b/Templates/Empty/game/shaders/common/postFx/glowBlurP.hlsl index 65ae96c6f..80f8ed02d 100644 --- a/Templates/Empty/game/shaders/common/postFx/glowBlurP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/glowBlurP.hlsl @@ -22,11 +22,11 @@ #include "./postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -39,20 +39,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * 0.5f; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Empty/game/shaders/common/postFx/glowBlurV.hlsl b/Templates/Empty/game/shaders/common/postFx/glowBlurV.hlsl index c9c9052ec..b8f5cf9c2 100644 --- a/Templates/Empty/game/shaders/common/postFx/glowBlurV.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/glowBlurV.hlsl @@ -28,7 +28,7 @@ uniform float2 texSize0; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -45,7 +45,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); float2 uv = IN.uv + (0.5f / texSize0); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl index c28f9eb83..77f4b9915 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl @@ -21,9 +21,8 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; uniform float gaussMultiplier; uniform float gaussMean; @@ -48,7 +47,7 @@ float computeGaussianValue( float x, float mean, float std_deviation ) return tmp * tmp2; } -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 color = { 0.0f, 0.0f, 0.0f, 0.0f }; float offset = 0; @@ -62,7 +61,7 @@ float4 main( PFXVertToPix IN ) : COLOR offset = (i - 4.0) * oneOverTargetSize.x; x = (i - 4.0) / 4.0; weight = gaussMultiplier * computeGaussianValue( x, gaussMean, gaussStdDev ); - color += (tex2D( inputTex, IN.uv0 + float2( offset, 0.0f ) ) * weight ); + color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( offset, 0.0f ) ) * weight ); } return float4( color.rgb, 1.0f ); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl index 93e6b8382..8381f6a5d 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl @@ -21,9 +21,8 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; uniform float gaussMultiplier; uniform float gaussMean; @@ -47,7 +46,7 @@ float computeGaussianValue( float x, float mean, float std_deviation ) return tmp * tmp2; } -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 color = { 0.0f, 0.0f, 0.0f, 0.0f }; float offset = 0; @@ -61,7 +60,7 @@ float4 main( PFXVertToPix IN ) : COLOR offset = (fI - 4.0) * oneOverTargetSize.y; x = (fI - 4.0) / 4.0; weight = gaussMultiplier * computeGaussianValue( x, gaussMean, gaussStdDev ); - color += (tex2D( inputTex, IN.uv0 + float2( 0.0f, offset ) ) * weight ); + color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( 0.0f, offset ) ) * weight ); } return float4( color.rgb, 1.0f ); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl index c438a5153..9a8a93e97 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl @@ -21,12 +21,11 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" #include "../../torque.hlsl" -uniform sampler2D inputTex : register(S0); -uniform sampler2D luminanceTex : register(S1); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); +TORQUE_UNIFORM_SAMPLER2D(luminanceTex, 1); uniform float2 oneOverTargetSize; uniform float brightPassThreshold; uniform float g_fMiddleGray; @@ -40,17 +39,17 @@ static float2 gTapOffsets[4] = { -0.5, -0.5 }, { 0.5, 0.5 } }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 average = { 0.0f, 0.0f, 0.0f, 0.0f }; // Combine and average 4 samples from the source HDR texture. for( int i = 0; i < 4; i++ ) - average += hdrDecode( tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * oneOverTargetSize ) ) ); + average += hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * oneOverTargetSize ) ) ); average *= 0.25f; // Determine the brightness of this particular pixel. - float adaptedLum = tex2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; + float adaptedLum = TORQUE_TEX2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; float lum = (g_fMiddleGray / (adaptedLum + 0.0001)) * hdrLuminance( average.rgb ); //float lum = hdrLuminance( average.rgb ); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl index 3f443611c..0f895070a 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl @@ -21,18 +21,17 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D currLum : register( S0 ); -uniform sampler2D lastAdaptedLum : register( S1 ); +TORQUE_UNIFORM_SAMPLER2D(currLum, 0); +TORQUE_UNIFORM_SAMPLER2D(lastAdaptedLum, 1); uniform float adaptRate; uniform float deltaTime; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float fAdaptedLum = tex2D( lastAdaptedLum, float2(0.5f, 0.5f) ).r; - float fCurrentLum = tex2D( currLum, float2(0.5f, 0.5f) ).r; + float fAdaptedLum = TORQUE_TEX2D( lastAdaptedLum, float2(0.5f, 0.5f) ).r; + float fCurrentLum = TORQUE_TEX2D( currLum, float2(0.5f, 0.5f) ).r; // The user's adapted luminance level is simulated by closing the gap between // adapted luminance and current luminance by 2% every frame, based on a diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4P.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4P.hlsl index 3ce68452c..01998af0b 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4P.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4P.hlsl @@ -29,23 +29,24 @@ //----------------------------------------------------------------------------- struct VertIn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoords[8] : TEXCOORD0; }; + +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( VertIn IN, - uniform sampler2D inputTex : register(S0) ) : COLOR +float4 main( VertIn IN) : TORQUE_TARGET0 { // We calculate the texture coords // in the vertex shader as an optimization. float4 sample = 0.0f; for ( int i = 0; i < 8; i++ ) { - sample += tex2D( inputTex, IN.texCoords[i].xy ); - sample += tex2D( inputTex, IN.texCoords[i].zw ); + sample += TORQUE_TEX2D( inputTex, IN.texCoords[i].xy ); + sample += TORQUE_TEX2D( inputTex, IN.texCoords[i].zw ); } return sample / 16; diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4V.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4V.hlsl index 88794204e..c9a34b7f4 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4V.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/downScale4x4V.hlsl @@ -29,19 +29,20 @@ struct Conn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoords[8] : TEXCOORD0; }; +uniform float2 targetSize; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Conn main( PFXVert In, - uniform float2 targetSize : register(C0) ) +Conn main( PFXVert In ) { Conn Out; - Out.hpos = In.pos; + Out.hpos = float4(In.pos,1.0); // Sample from the 16 surrounding points. Since the center point will be in // the exact center of 16 texels, a 0.5f offset is needed to specify a texel diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl index 7ac71bebd..b786b3f6a 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl @@ -22,11 +22,13 @@ #include "../../torque.hlsl" #include "../postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" -uniform sampler2D sceneTex : register( s0 ); -uniform sampler2D luminanceTex : register( s1 ); -uniform sampler2D bloomTex : register( s2 ); -uniform sampler1D colorCorrectionTex : register( s3 ); +TORQUE_UNIFORM_SAMPLER2D(sceneTex, 0); +TORQUE_UNIFORM_SAMPLER2D(luminanceTex, 1); +TORQUE_UNIFORM_SAMPLER2D(bloomTex, 2); +TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 3); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 4); uniform float2 texSize0; uniform float2 texSize2; @@ -34,20 +36,20 @@ uniform float2 texSize2; uniform float g_fEnableToneMapping; uniform float g_fMiddleGray; uniform float g_fWhiteCutoff; - uniform float g_fEnableBlueShift; -uniform float3 g_fBlueShiftColor; +uniform float3 g_fBlueShiftColor; uniform float g_fBloomScale; uniform float g_fOneOverGamma; +uniform float Brightness; +uniform float Contrast; - -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 sample = hdrDecode( tex2D( sceneTex, IN.uv0 ) ); - float adaptedLum = tex2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; - float4 bloom = tex2D( bloomTex, IN.uv0 ); + float4 sample = hdrDecode( TORQUE_TEX2D( sceneTex, IN.uv0 ) ); + float adaptedLum = TORQUE_TEX2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; + float4 bloom = TORQUE_TEX2D( bloomTex, IN.uv0 ); // For very low light conditions, the rods will dominate the perception // of light, and therefore color will be desaturated and shifted @@ -81,15 +83,24 @@ float4 main( PFXVertToPix IN ) : COLOR0 } // Add the bloom effect. - sample += g_fBloomScale * bloom; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; + if (depth>0.9999) + sample += g_fBloomScale * bloom; // Apply the color correction. - sample.r = tex1D( colorCorrectionTex, sample.r ).r; - sample.g = tex1D( colorCorrectionTex, sample.g ).g; - sample.b = tex1D( colorCorrectionTex, sample.b ).b; + sample.r = TORQUE_TEX1D( colorCorrectionTex, sample.r ).r; + sample.g = TORQUE_TEX1D( colorCorrectionTex, sample.g ).g; + sample.b = TORQUE_TEX1D( colorCorrectionTex, sample.b ).b; + // Apply gamma correction sample.rgb = pow( abs(sample.rgb), g_fOneOverGamma ); + + // Apply contrast + sample.rgb = ((sample.rgb - 0.5f) * Contrast) + 0.5f; + + // Apply brightness + sample.rgb += Brightness; return sample; } diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/gl/finalPassCombineP.glsl b/Templates/Empty/game/shaders/common/postFx/hdr/gl/finalPassCombineP.glsl index f34cff1ef..24a516e79 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/gl/finalPassCombineP.glsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/gl/finalPassCombineP.glsl @@ -23,11 +23,13 @@ #include "../../../gl/torque.glsl" #include "../../../gl/hlslCompat.glsl" #include "../../gl/postFX.glsl" +#include "shadergen:/autogenConditioners.h" uniform sampler2D sceneTex; uniform sampler2D luminanceTex; uniform sampler2D bloomTex; uniform sampler1D colorCorrectionTex; +uniform sampler2D prepassTex; uniform vec2 texSize0; uniform vec2 texSize2; @@ -47,6 +49,7 @@ uniform float Contrast; out vec4 OUT_col; + void main() { vec4 _sample = hdrDecode( texture( sceneTex, IN_uv0 ) ); @@ -85,7 +88,9 @@ void main() } // Add the bloom effect. - _sample += g_fBloomScale * bloom; + float depth = prepassUncondition( prepassTex, IN_uv0 ).w; + if (depth>0.9999) + _sample += g_fBloomScale * bloom; // Apply the color correction. _sample.r = texture( colorCorrectionTex, _sample.r ).r; @@ -94,12 +99,12 @@ void main() // Apply gamma correction _sample.rgb = pow( abs(_sample.rgb), vec3(g_fOneOverGamma) ); - + // Apply contrast _sample.rgb = ((_sample.rgb - 0.5f) * Contrast) + 0.5f; // Apply brightness _sample.rgb += Brightness; - + OUT_col = _sample; } diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/luminanceVisP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/luminanceVisP.hlsl index 593a24e7b..505d1b825 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/luminanceVisP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/luminanceVisP.hlsl @@ -22,15 +22,14 @@ #include "../postFx.hlsl" #include "../../torque.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float brightPassThreshold; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 sample = hdrDecode( tex2D( inputTex, IN.uv0 ) ); + float4 sample = hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 ) ); // Determine the brightness of this particular pixel. float lum = hdrLuminance( sample.rgb ); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl index 39fd9dccc..2e23ece1f 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl @@ -23,7 +23,7 @@ #include "../../torque.hlsl" #include "../postFx.hlsl" -uniform sampler2D inputTex : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 texSize0; uniform float g_fMinLuminace; @@ -36,7 +36,7 @@ static float2 gTapOffsets[9] = }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 tsize = 1.0 / texSize0; @@ -46,7 +46,7 @@ float4 main( PFXVertToPix IN ) : COLOR for ( int i = 0; i < 9; i++ ) { // Decode the hdr value. - sample = hdrDecode( tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * tsize ) ).rgb ); + sample = hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * tsize ) ).rgb ); // Get the luminance and add it to the average. float lum = max( hdrLuminance( sample ), g_fMinLuminace ); diff --git a/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl b/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl index 59e91f0db..46ed6fc70 100644 --- a/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl @@ -22,7 +22,7 @@ #include "../postFx.hlsl" -uniform sampler2D inputTex : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; @@ -34,7 +34,7 @@ static float2 gTapOffsets[16] = { -1.5, 1.5 }, { -0.5, 1.5 }, { 0.5, 1.5 }, { 1.5, 1.5 } }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 pixelSize = oneOverTargetSize; @@ -42,7 +42,7 @@ float4 main( PFXVertToPix IN ) : COLOR for ( int i = 0; i < 16; i++ ) { - float lum = tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * pixelSize ) ).r; + float lum = TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * pixelSize ) ).r; average += lum; } diff --git a/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl b/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl index e8870b3c4..b70bafa98 100644 --- a/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl @@ -20,29 +20,29 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "../postFx.hlsl" -uniform sampler2D backBuffer : register( s0 ); // The original backbuffer. -uniform sampler2D prepassTex : register( s1 ); // The pre-pass depth and normals. +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); uniform float brightScalar; static const float3 LUMINANCE_VECTOR = float3(0.3125f, 0.6154f, 0.0721f); -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 col = float4( 0, 0, 0, 1 ); // Get the depth at this pixel. - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; // If the depth is equal to 1.0, read from the backbuffer // and perform the exposure calculation on the result. if ( depth >= 0.999 ) { - col = tex2D( backBuffer, IN.uv0 ); + col = TORQUE_TEX2D( backBuffer, IN.uv0 ); //col = 1 - exp(-120000 * col); col += dot( col.rgb, LUMINANCE_VECTOR ) + 0.0001f; diff --git a/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayP.hlsl b/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayP.hlsl index ff44abfae..032894710 100644 --- a/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/lightRay/lightRayP.hlsl @@ -22,28 +22,29 @@ #include "../postFx.hlsl" -uniform sampler2D frameSampler : register( s0 ); -uniform sampler2D backBuffer : register( s1 ); +TORQUE_UNIFORM_SAMPLER2D(frameSampler, 0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 1); + uniform float3 camForward; +uniform int numSamples; uniform float3 lightDirection; +uniform float density; uniform float2 screenSunPos; uniform float2 oneOverTargetSize; -uniform int numSamples; -uniform float density; uniform float weight; uniform float decay; uniform float exposure; -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 texCoord = float4( IN.uv0.xy, 0, 0 ); // Store initial sample. - half3 color = (half3)tex2D( frameSampler, texCoord.xy ).rgb; + half3 color = (half3)TORQUE_TEX2D( frameSampler, texCoord.xy ).rgb; // Store original bb color. - float4 bbCol = tex2D( backBuffer, IN.uv1 ); + float4 bbCol = TORQUE_TEX2D( backBuffer, IN.uv1 ); // Set up illumination decay factor. half illuminationDecay = 1.0; @@ -68,7 +69,7 @@ float4 main( PFXVertToPix IN ) : COLOR0 texCoord.xy -= deltaTexCoord; // Retrieve sample at new location. - half3 sample = (half3)tex2Dlod( frameSampler, texCoord ); + half3 sample = (half3)TORQUE_TEX2DLOD( frameSampler, texCoord ); // Apply sample attenuation scale/decay factors. sample *= half(illuminationDecay * weight); diff --git a/Templates/Empty/game/shaders/common/postFx/motionBlurP.hlsl b/Templates/Empty/game/shaders/common/postFx/motionBlurP.hlsl index 348484f4d..8bc65fbc6 100644 --- a/Templates/Empty/game/shaders/common/postFx/motionBlurP.hlsl +++ b/Templates/Empty/game/shaders/common/postFx/motionBlurP.hlsl @@ -22,23 +22,22 @@ #include "./postFx.hlsl" #include "../torque.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../shaderModelAutoGen.hlsl" uniform float4x4 matPrevScreenToWorld; uniform float4x4 matWorldToScreen; // Passed in from setShaderConsts() uniform float velocityMultiplier; +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); -uniform sampler2D backBuffer : register(S0); -uniform sampler2D prepassTex : register(S1); - -float4 main(PFXVertToPix IN) : COLOR0 +float4 main(PFXVertToPix IN) : TORQUE_TARGET0 { float samples = 5; // First get the prepass texture for uv channel 0 - float4 prepass = prepassUncondition( prepassTex, IN.uv0 ); + float4 prepass = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ); // Next extract the depth float depth = prepass.a; @@ -58,12 +57,12 @@ float4 main(PFXVertToPix IN) : COLOR0 float2 velocity = ((screenPos - previousPos) / velocityMultiplier).xy; // Generate the motion blur - float4 color = tex2D(backBuffer, IN.uv0); + float4 color = TORQUE_TEX2D(backBuffer, IN.uv0); IN.uv0 += velocity; for(int i = 1; i= 10 && TORQUE_SM <=30) + // Semantics + #define TORQUE_POSITION POSITION + #define TORQUE_DEPTH DEPTH + #define TORQUE_TARGET0 COLOR0 + #define TORQUE_TARGET1 COLOR1 + #define TORQUE_TARGET2 COLOR2 + #define TORQUE_TARGET3 COLOR3 + + // Sampler uniforms + #define TORQUE_UNIFORM_SAMPLER1D(tex,regist) uniform sampler1D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER2D(tex,regist) uniform sampler2D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER3D(tex,regist) uniform sampler3D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLERCUBE(tex,regist) uniform samplerCUBE tex : register(S##regist) + // Sampling functions + #define TORQUE_TEX1D(tex,coords) tex1D(tex,coords) + #define TORQUE_TEX2D(tex,coords) tex2D(tex,coords) + #define TORQUE_TEX2DPROJ(tex,coords) tex2Dproj(tex,coords) //this really is sm 2 or later + #define TORQUE_TEX3D(tex,coords) tex3D(tex,coords) + #define TORQUE_TEXCUBE(tex,coords) texCUBE(tex,coords) + + //Shader model 3.0 only + #if TORQUE_SM == 30 + #define TORQUE_VPOS VPOS // This is a float2 + // The mipmap LOD is specified in coord.w + #define TORQUE_TEX2DLOD(tex,coords) tex2Dlod(tex,coords) + #endif + + //helper if you want to pass sampler/texture in a function + //2D + #define TORQUE_SAMPLER2D(tex) sampler2D tex + #define TORQUE_SAMPLER2D_MAKEARG(tex) tex + //Cube + #define TORQUE_SAMPLERCUBE(tex) samplerCUBE tex + #define TORQUE_SAMPLERCUBE_MAKEARG(tex) tex +// Shader model 4.0+ +#elif TORQUE_SM >= 40 + #define TORQUE_POSITION SV_Position + #define TORQUE_DEPTH SV_Depth + #define TORQUE_VPOS SV_Position //note float4 compared to SM 3 where it is a float2 + #define TORQUE_TARGET0 SV_Target0 + #define TORQUE_TARGET1 SV_Target1 + #define TORQUE_TARGET2 SV_Target2 + #define TORQUE_TARGET3 SV_Target3 + // Sampler uniforms + //1D is emulated to a 2D for now + #define TORQUE_UNIFORM_SAMPLER1D(tex,regist) uniform Texture2D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER2D(tex,regist) uniform Texture2D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER3D(tex,regist) uniform Texture3D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLERCUBE(tex,regist) uniform TextureCube texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + // Sampling functions + #define TORQUE_TEX1D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEX2D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEX2DPROJ(tex,coords) texture_##tex.Sample(tex,coords.xy / coords.w) + #define TORQUE_TEX3D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEXCUBE(tex,coords) texture_##tex.Sample(tex,coords) + // The mipmap LOD is specified in coord.w + #define TORQUE_TEX2DLOD(tex,coords) texture_##tex.SampleLevel(tex,coords.xy,coords.w) + + //helper if you want to pass sampler/texture in a function + //2D + #define TORQUE_SAMPLER2D(tex) Texture2D texture_##tex, SamplerState tex + #define TORQUE_SAMPLER2D_MAKEARG(tex) texture_##tex, tex + //Cube + #define TORQUE_SAMPLERCUBE(tex) TextureCube texture_##tex, SamplerState tex + #define TORQUE_SAMPLERCUBE_MAKEARG(tex) texture_##tex, tex +#endif + +#endif // _TORQUE_SHADERMODEL_ + diff --git a/Templates/Empty/game/shaders/common/shaderModelAutoGen.hlsl b/Templates/Empty/game/shaders/common/shaderModelAutoGen.hlsl new file mode 100644 index 000000000..4f2d8803f --- /dev/null +++ b/Templates/Empty/game/shaders/common/shaderModelAutoGen.hlsl @@ -0,0 +1,35 @@ +//----------------------------------------------------------------------------- +// 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 _TORQUE_SHADERMODEL_AUTOGEN_ +#define _TORQUE_SHADERMODEL_AUTOGEN_ + +#include "shadergen:/autogenConditioners.h" + +// Portability helpers for autogenConditioners +#if (TORQUE_SM >= 10 && TORQUE_SM <=30) + #define TORQUE_PREPASS_UNCONDITION(tex, coords) prepassUncondition(tex, coords) +#elif TORQUE_SM >= 40 + #define TORQUE_PREPASS_UNCONDITION(tex, coords) prepassUncondition(tex, texture_##tex, coords) +#endif + +#endif //_TORQUE_SHADERMODEL_AUTOGEN_ diff --git a/Templates/Empty/game/shaders/common/terrain/blendP.hlsl b/Templates/Empty/game/shaders/common/terrain/blendP.hlsl index f71088928..aeef9d6e3 100644 --- a/Templates/Empty/game/shaders/common/terrain/blendP.hlsl +++ b/Templates/Empty/game/shaders/common/terrain/blendP.hlsl @@ -21,25 +21,28 @@ //----------------------------------------------------------------------------- #include "terrain.hlsl" +#include "../shaderModel.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 layerCoord : TEXCOORD0; float2 texCoord : TEXCOORD1; }; -float4 main( ConnectData IN, - uniform sampler2D layerTex : register(S0), - uniform sampler2D textureMap : register(S1), - uniform float texId, - uniform float layerSize ) : COLOR +TORQUE_UNIFORM_SAMPLER2D(layerTex, 0); +TORQUE_UNIFORM_SAMPLER2D(textureMap, 1); + +uniform float texId; +uniform float layerSize; + +float4 main( ConnectData IN ) : TORQUE_TARGET0 { - float4 layerSample = round( tex2D( layerTex, IN.layerCoord ) * 255.0f ); + float4 layerSample = round( TORQUE_TEX2D( layerTex, IN.layerCoord ) * 255.0f ); float blend = calcBlend( texId, IN.layerCoord, layerSize, layerSample ); clip( blend - 0.0001 ); - return float4( tex2D( textureMap, IN.texCoord ).rgb, blend ); + return float4( TORQUE_TEX2D(textureMap, IN.texCoord).rgb, blend); } diff --git a/Templates/Empty/game/shaders/common/terrain/blendV.hlsl b/Templates/Empty/game/shaders/common/terrain/blendV.hlsl index 7a79d2de4..9ccd33301 100644 --- a/Templates/Empty/game/shaders/common/terrain/blendV.hlsl +++ b/Templates/Empty/game/shaders/common/terrain/blendV.hlsl @@ -23,6 +23,8 @@ /// The vertex shader used in the generation and caching of the /// base terrain texture. +#include "../shaderModel.hlsl" + struct VertData { float3 position : POSITION; @@ -31,17 +33,18 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 layerCoord : TEXCOORD0; float2 texCoord : TEXCOORD1; }; -ConnectData main( VertData IN, - uniform float2 texScale : register(C0) ) +uniform float2 texScale; + +ConnectData main( VertData IN ) { ConnectData OUT; - OUT.hpos = float4( IN.position.xyz, 1 ); + OUT.hpos = float4( IN.position, 1 ); OUT.layerCoord = IN.texCoord; OUT.texCoord = IN.texCoord * texScale; diff --git a/Templates/Empty/game/shaders/common/terrain/terrain.glsl b/Templates/Empty/game/shaders/common/terrain/terrain.glsl index 79f80888c..756edd553 100644 --- a/Templates/Empty/game/shaders/common/terrain/terrain.glsl +++ b/Templates/Empty/game/shaders/common/terrain/terrain.glsl @@ -32,6 +32,7 @@ float calcBlend( float texId, vec2 layerCoord, float layerSize, vec4 layerSample vec4 diff = clamp( abs( layerSample - texId ), 0.0, 1.0 ); float noBlend = float(any( bvec4(1 - diff) )); + // Check if any of the layer samples // match the current texture id. vec4 factors = vec4(0); for(int i = 0; i < 4; i++) diff --git a/Templates/Empty/game/shaders/common/terrain/terrain.hlsl b/Templates/Empty/game/shaders/common/terrain/terrain.hlsl index 8ce497012..b7c87e618 100644 --- a/Templates/Empty/game/shaders/common/terrain/terrain.hlsl +++ b/Templates/Empty/game/shaders/common/terrain/terrain.hlsl @@ -35,6 +35,7 @@ float calcBlend( float texId, float2 layerCoord, float layerSize, float4 layerSa // Check if any of the layer samples // match the current texture id. float4 factors = 0; + [unroll] for(int i = 0; i < 4; i++) if(layerSample[i] == texId) factors[i] = 1; diff --git a/Templates/Empty/game/shaders/common/torque.hlsl b/Templates/Empty/game/shaders/common/torque.hlsl index 1d253936b..3521042d4 100644 --- a/Templates/Empty/game/shaders/common/torque.hlsl +++ b/Templates/Empty/game/shaders/common/torque.hlsl @@ -23,6 +23,7 @@ #ifndef _TORQUE_HLSL_ #define _TORQUE_HLSL_ +#include "./shaderModel.hlsl" static float M_HALFPI_F = 1.57079632679489661923f; static float M_PI_F = 3.14159265358979323846f; @@ -137,29 +138,29 @@ float3x3 quatToMat( float4 quat ) /// @param negViewTS The negative view vector in tangent space. /// @param depthScale The parallax factor used to scale the depth result. /// -float2 parallaxOffset( sampler2D texMap, float2 texCoord, float3 negViewTS, float depthScale ) +float2 parallaxOffset(TORQUE_SAMPLER2D(texMap), float2 texCoord, float3 negViewTS, float depthScale) { - float depth = tex2D( texMap, texCoord ).a; - float2 offset = negViewTS.xy * ( depth * depthScale ); + float depth = TORQUE_TEX2D(texMap, texCoord).a; + float2 offset = negViewTS.xy * (depth * depthScale); - for ( int i=0; i < PARALLAX_REFINE_STEPS; i++ ) + for (int i = 0; i < PARALLAX_REFINE_STEPS; i++) { - depth = ( depth + tex2D( texMap, texCoord + offset ).a ) * 0.5; - offset = negViewTS.xy * ( depth * depthScale ); + depth = (depth + TORQUE_TEX2D(texMap, texCoord + offset).a) * 0.5; + offset = negViewTS.xy * (depth * depthScale); } return offset; } /// Same as parallaxOffset but for dxtnm where depth is stored in the red channel instead of the alpha -float2 parallaxOffsetDxtnm(sampler2D texMap, float2 texCoord, float3 negViewTS, float depthScale) +float2 parallaxOffsetDxtnm(TORQUE_SAMPLER2D(texMap), float2 texCoord, float3 negViewTS, float depthScale) { - float depth = tex2D(texMap, texCoord).r; + float depth = TORQUE_TEX2D(texMap, texCoord).r; float2 offset = negViewTS.xy * (depth * depthScale); for (int i = 0; i < PARALLAX_REFINE_STEPS; i++) { - depth = (depth + tex2D(texMap, texCoord + offset).r) * 0.5; + depth = (depth + TORQUE_TEX2D(texMap, texCoord + offset).r) * 0.5; offset = negViewTS.xy * (depth * depthScale); } @@ -277,5 +278,37 @@ void fizzle(float2 vpos, float visibility) clip( visibility - frac( determinant( m ) ) ); } +// Deferred Shading: Material Info Flag Check +bool getFlag(float flags, int num) +{ + int process = round(flags * 255); + int squareNum = pow(2, num); + return (fmod(process, pow(2, squareNum)) >= squareNum); +} + +// #define TORQUE_STOCK_GAMMA +#ifdef TORQUE_STOCK_GAMMA +// Sample in linear space. Decodes gamma. +float4 toLinear(float4 tex) +{ + return tex; +} +// Encodes gamma. +float4 toLinear(float4 tex) +{ + return tex; +} +#else +// Sample in linear space. Decodes gamma. +float4 toLinear(float4 tex) +{ + return float4(pow(abs(tex.rgb), 2.2), tex.a); +} +// Encodes gamma. +float4 toGamma(float4 tex) +{ + return float4(pow(abs(tex.rgb), 1.0/2.2), tex.a); +} +#endif // #endif // _TORQUE_HLSL_ diff --git a/Templates/Empty/game/shaders/common/water/gl/waterBasicP.glsl b/Templates/Empty/game/shaders/common/water/gl/waterBasicP.glsl index 82c421031..1d5a07c3f 100644 --- a/Templates/Empty/game/shaders/common/water/gl/waterBasicP.glsl +++ b/Templates/Empty/game/shaders/common/water/gl/waterBasicP.glsl @@ -120,6 +120,7 @@ void main() { // Modulate baseColor by the ambientColor. vec4 waterBaseColor = baseColor * vec4( ambientColor.rgb, 1 ); + waterBaseColor = toLinear(waterBaseColor); // Get the bumpNorm... vec3 bumpNorm = ( texture( bumpMap, IN_rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; diff --git a/Templates/Empty/game/shaders/common/water/gl/waterP.glsl b/Templates/Empty/game/shaders/common/water/gl/waterP.glsl index af151020a..a68ede84e 100644 --- a/Templates/Empty/game/shaders/common/water/gl/waterP.glsl +++ b/Templates/Empty/game/shaders/common/water/gl/waterP.glsl @@ -295,7 +295,7 @@ void main() foamColor.rgb *= FOAM_OPACITY * foamAmt * foamColor.a; // Get reflection map color. - vec4 refMapColor = hdrDecode( texture( reflectMap, reflectCoord ) ); + vec4 refMapColor = texture( reflectMap, reflectCoord ); // If we do not have a reflection texture then we use the cubemap. refMapColor = mix( refMapColor, texture( skyMap, reflectionVec ), NO_REFLECT ); @@ -324,6 +324,7 @@ void main() // Calculate the water "base" color based on depth. vec4 waterBaseColor = baseColor * texture( depthGradMap, saturate( delta / depthGradMax ) ); + waterBaseColor = toLinear(waterBaseColor); // Modulate baseColor by the ambientColor. waterBaseColor *= vec4( ambientColor.rgb, 1 ); diff --git a/Templates/Empty/game/shaders/common/water/waterBasicP.hlsl b/Templates/Empty/game/shaders/common/water/waterBasicP.hlsl index d27b28c67..efb437779 100644 --- a/Templates/Empty/game/shaders/common/water/waterBasicP.hlsl +++ b/Templates/Empty/game/shaders/common/water/waterBasicP.hlsl @@ -57,7 +57,7 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -92,11 +92,11 @@ float fresnel(float NdotV, float bias, float power) //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler bumpMap : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(bumpMap,0); //uniform sampler2D prepassTex : register( S1 ); -uniform sampler2D reflectMap : register( S2 ); -uniform sampler refractBuff : register( S3 ); -uniform samplerCUBE skyMap : register( S4 ); +TORQUE_UNIFORM_SAMPLER2D(reflectMap,2); +TORQUE_UNIFORM_SAMPLER2D(refractBuff,3); +TORQUE_UNIFORM_SAMPLERCUBE(skyMap,4); //uniform sampler foamMap : register( S5 ); uniform float4 baseColor; uniform float4 miscParams; @@ -113,15 +113,16 @@ uniform float4x4 modelMat; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Modulate baseColor by the ambientColor. float4 waterBaseColor = baseColor * float4( ambientColor.rgb, 1 ); + waterBaseColor = toLinear(waterBaseColor); // Get the bumpNorm... - float3 bumpNorm = ( tex2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord2 ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; + float3 bumpNorm = ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord2 ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; bumpNorm = normalize( bumpNorm ); bumpNorm = lerp( bumpNorm, float3(0,0,1), 1.0 - rippleMagnitude.w ); @@ -135,7 +136,7 @@ float4 main( ConnectData IN ) : COLOR distortPos.xy += bumpNorm.xy * distortAmt; #ifdef UNDERWATER - return hdrEncode( tex2Dproj( refractBuff, distortPos ) ); + return hdrEncode( TORQUE_TEX2DPROJ( refractBuff, distortPos ) ); #else float3 eyeVec = IN.objPos.xyz - eyePos; @@ -153,16 +154,16 @@ float4 main( ConnectData IN ) : COLOR float fakeColorAmt = ang; // Get reflection map color - float4 refMapColor = hdrDecode( tex2Dproj( reflectMap, distortPos ) ); + float4 refMapColor = hdrDecode( TORQUE_TEX2DPROJ( reflectMap, distortPos ) ); // If we do not have a reflection texture then we use the cubemap. - refMapColor = lerp( refMapColor, texCUBE( skyMap, reflectionVec ), NO_REFLECT ); + refMapColor = lerp( refMapColor, TORQUE_TEXCUBE( skyMap, reflectionVec ), NO_REFLECT ); // Combine reflection color and fakeColor. float4 reflectColor = lerp( refMapColor, fakeColor, fakeColorAmt ); //return refMapColor; // Get refract color - float4 refractColor = hdrDecode( tex2Dproj( refractBuff, distortPos ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2DPROJ( refractBuff, distortPos ) ); // calc "diffuse" color by lerping from the water color // to refraction image based on the water clarity. @@ -197,7 +198,7 @@ float4 main( ConnectData IN ) : COLOR // Fog it. float factor = computeSceneFog( eyePos, - IN.objPos, + IN.objPos.xyz, WORLD_Z, fogData.x, fogData.y, diff --git a/Templates/Empty/game/shaders/common/water/waterBasicV.hlsl b/Templates/Empty/game/shaders/common/water/waterBasicV.hlsl index 2c201e675..310647c90 100644 --- a/Templates/Empty/game/shaders/common/water/waterBasicV.hlsl +++ b/Templates/Empty/game/shaders/common/water/waterBasicV.hlsl @@ -20,12 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { - float4 position : POSITION; + float3 position : POSITION; float3 normal : NORMAL; float2 undulateData : TEXCOORD0; float4 horizonFactor : TEXCOORD1; @@ -33,7 +34,7 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -95,21 +96,21 @@ ConnectData main( VertData IN ) // IN.position.xy += offsetXY; // IN.undulateData += offsetXY; // } - - float4 worldPos = mul( modelMat, IN.position ); + float4 inPos = float4(IN.position, 1.0); + float4 worldPos = mul(modelMat, inPos); IN.position.z = lerp( IN.position.z, eyePos.z, IN.horizonFactor.x ); //OUT.objPos = worldPos; - OUT.objPos.xyz = IN.position.xyz; + OUT.objPos.xyz = IN.position; OUT.objPos.w = worldPos.z; // Send pre-undulation screenspace position - OUT.posPreWave = mul( modelview, IN.position ); + OUT.posPreWave = mul( modelview, inPos ); OUT.posPreWave = mul( texGen, OUT.posPreWave ); // Calculate the undulation amount for this vertex. - float2 undulatePos = mul( modelMat, float4( IN.undulateData.xy, 0, 1 ) ); + float2 undulatePos = mul( modelMat, float4( IN.undulateData.xy, 0, 1 )).xy; //if ( undulatePos.x < 0 ) // undulatePos = IN.position.xy; @@ -128,12 +129,12 @@ ConnectData main( VertData IN ) float undulateFade = 1; // Scale down wave magnitude amount based on distance from the camera. - float dist = distance( IN.position.xyz, eyePos ); + float dist = distance( IN.position, eyePos ); dist = clamp( dist, 1.0, undulateMaxDist ); undulateFade *= ( 1 - dist / undulateMaxDist ); // Also scale down wave magnitude if the camera is very very close. - undulateFade *= saturate( ( distance( IN.position.xyz, eyePos ) - 0.5 ) / 10.0 ); + undulateFade *= saturate( ( distance( IN.position, eyePos ) - 0.5 ) / 10.0 ); undulateAmt *= undulateFade; @@ -141,7 +142,7 @@ ConnectData main( VertData IN ) //undulateAmt = 0; // Apply wave undulation to the vertex. - OUT.posPostWave = IN.position; + OUT.posPostWave = inPos; OUT.posPostWave.xyz += IN.normal.xyz * undulateAmt; // Save worldSpace position of this pixel/vert @@ -210,7 +211,7 @@ ConnectData main( VertData IN ) for ( int i = 0; i < 3; i++ ) { binormal.z += undulateFade * waveDir[i].x * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); - tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); + tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); } binormal = normalize( binormal ); diff --git a/Templates/Empty/game/shaders/common/water/waterP.hlsl b/Templates/Empty/game/shaders/common/water/waterP.hlsl index 851fb471f..ac66e9b28 100644 --- a/Templates/Empty/game/shaders/common/water/waterP.hlsl +++ b/Templates/Empty/game/shaders/common/water/waterP.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../shaderModelAutoGen.hlsl" #include "../torque.hlsl" //----------------------------------------------------------------------------- @@ -69,7 +69,7 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -105,13 +105,13 @@ float fresnel(float NdotV, float bias, float power) //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler bumpMap : register( S0 ); -uniform sampler2D prepassTex : register( S1 ); -uniform sampler2D reflectMap : register( S2 ); -uniform sampler refractBuff : register( S3 ); -uniform samplerCUBE skyMap : register( S4 ); -uniform sampler foamMap : register( S5 ); -uniform sampler1D depthGradMap : register( S6 ); +TORQUE_UNIFORM_SAMPLER2D(bumpMap,0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); +TORQUE_UNIFORM_SAMPLER2D(reflectMap, 2); +TORQUE_UNIFORM_SAMPLER2D(refractBuff, 3); +TORQUE_UNIFORM_SAMPLERCUBE(skyMap, 4); +TORQUE_UNIFORM_SAMPLER2D(foamMap, 5); +TORQUE_UNIFORM_SAMPLER1D(depthGradMap, 6); uniform float4 specularParams; uniform float4 baseColor; uniform float4 miscParams; @@ -138,12 +138,12 @@ uniform float reflectivity; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Get the bumpNorm... - float3 bumpNorm = ( tex2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord2.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; + float3 bumpNorm = ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord2.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; bumpNorm = normalize( bumpNorm ); bumpNorm = lerp( bumpNorm, float3(0,0,1), 1.0 - rippleMagnitude.w ); @@ -155,7 +155,7 @@ float4 main( ConnectData IN ) : COLOR float2 prepassCoord = viewportCoordToRenderTarget( IN.posPostWave, rtParams1 ); - float startDepth = prepassUncondition( prepassTex, prepassCoord ).w; + float startDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; // The water depth in world units of the undistorted pixel. float startDelta = ( startDepth - pixelDepth ); @@ -180,7 +180,7 @@ float4 main( ConnectData IN ) : COLOR prepassCoord = viewportCoordToRenderTarget( distortPos, rtParams1 ); // Get prepass depth at the position of this distorted pixel. - float prepassDepth = prepassUncondition( prepassTex, prepassCoord ).w; + float prepassDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; if ( prepassDepth > 0.99 ) prepassDepth = 5.0; @@ -212,7 +212,7 @@ float4 main( ConnectData IN ) : COLOR prepassCoord = viewportCoordToRenderTarget( distortPos, rtParams1 ); // Get prepass depth at the position of this distorted pixel. - prepassDepth = prepassUncondition( prepassTex, prepassCoord ).w; + prepassDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; if ( prepassDepth > 0.99 ) prepassDepth = 5.0; delta = ( prepassDepth - pixelDepth ) * farPlaneDist; @@ -260,8 +260,8 @@ float4 main( ConnectData IN ) : COLOR IN.foamTexCoords.xy += foamRippleOffset; IN.foamTexCoords.zw += foamRippleOffset; - float4 foamColor = tex2D( foamMap, IN.foamTexCoords.xy ); - foamColor += tex2D( foamMap, IN.foamTexCoords.zw ); + float4 foamColor = TORQUE_TEX2D( foamMap, IN.foamTexCoords.xy ); + foamColor += TORQUE_TEX2D( foamMap, IN.foamTexCoords.zw ); foamColor = saturate( foamColor ); // Modulate foam color by ambient color @@ -282,18 +282,18 @@ float4 main( ConnectData IN ) : COLOR foamColor.rgb *= FOAM_OPACITY * foamAmt * foamColor.a; // Get reflection map color. - float4 refMapColor = hdrDecode( tex2D( reflectMap, reflectCoord ) ); + float4 refMapColor = TORQUE_TEX2D( reflectMap, reflectCoord ); // If we do not have a reflection texture then we use the cubemap. - refMapColor = lerp( refMapColor, texCUBE( skyMap, reflectionVec ), NO_REFLECT ); + refMapColor = lerp( refMapColor, TORQUE_TEXCUBE( skyMap, reflectionVec ), NO_REFLECT ); - fakeColor = ( texCUBE( skyMap, reflectionVec ) ); + fakeColor = ( TORQUE_TEXCUBE( skyMap, reflectionVec ) ); fakeColor.a = 1; // Combine reflection color and fakeColor. float4 reflectColor = lerp( refMapColor, fakeColor, fakeColorAmt ); // Get refract color - float4 refractColor = hdrDecode( tex2D( refractBuff, refractCoord ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2D( refractBuff, refractCoord ) ); // We darken the refraction color a bit to make underwater // elements look wet. We fade out this darkening near the @@ -310,7 +310,8 @@ float4 main( ConnectData IN ) : COLOR float fogAmt = 1.0 - saturate( exp( -FOG_DENSITY * fogDelta ) ); // Calculate the water "base" color based on depth. - float4 waterBaseColor = baseColor * tex1D( depthGradMap, saturate( delta / depthGradMax ) ); + float4 waterBaseColor = baseColor * TORQUE_TEX1D( depthGradMap, saturate( delta / depthGradMax ) ); + waterBaseColor = toLinear(waterBaseColor); // Modulate baseColor by the ambientColor. waterBaseColor *= float4( ambientColor.rgb, 1 ); @@ -353,7 +354,7 @@ float4 main( ConnectData IN ) : COLOR #else - float4 refractColor = hdrDecode( tex2D( refractBuff, refractCoord ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2D( refractBuff, refractCoord ) ); float4 OUT = refractColor; #endif diff --git a/Templates/Empty/game/shaders/common/water/waterV.hlsl b/Templates/Empty/game/shaders/common/water/waterV.hlsl index d2b097bc5..c869f0e9f 100644 --- a/Templates/Empty/game/shaders/common/water/waterV.hlsl +++ b/Templates/Empty/game/shaders/common/water/waterV.hlsl @@ -20,14 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { - float4 position : POSITION; + float3 position : POSITION; float3 normal : NORMAL; float2 undulateData : TEXCOORD0; float4 horizonFactor : TEXCOORD1; @@ -35,7 +35,7 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -94,12 +94,12 @@ ConnectData main( VertData IN ) 0.0, 0.0, 0.0, 1.0 }; IN.position.z = lerp( IN.position.z, eyePos.z, IN.horizonFactor.x ); - - OUT.objPos = IN.position; - OUT.objPos.w = mul( modelMat, IN.position ).z; + float4 inPos = float4( IN.position, 1.0); + OUT.objPos = inPos; + OUT.objPos.w = mul( modelMat, inPos ).z; // Send pre-undulation screenspace position - OUT.posPreWave = mul( modelview, IN.position ); + OUT.posPreWave = mul( modelview, inPos ); OUT.posPreWave = mul( texGen, OUT.posPreWave ); // Calculate the undulation amount for this vertex. @@ -132,7 +132,7 @@ ConnectData main( VertData IN ) OUT.rippleTexCoord2.w = saturate( OUT.rippleTexCoord2.w - 0.2 ) / 0.8; // Apply wave undulation to the vertex. - OUT.posPostWave = IN.position; + OUT.posPostWave = inPos; OUT.posPostWave.xyz += IN.normal.xyz * undulateAmt; // Convert to screen @@ -197,7 +197,7 @@ ConnectData main( VertData IN ) for ( int i = 0; i < 3; i++ ) { binormal.z += undulateFade * waveDir[i].x * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); - tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); + tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); } binormal = binormal; diff --git a/Templates/Empty/game/shaders/common/wavesP.hlsl b/Templates/Empty/game/shaders/common/wavesP.hlsl index 265842f1f..c51eb4b89 100644 --- a/Templates/Empty/game/shaders/common/wavesP.hlsl +++ b/Templates/Empty/game/shaders/common/wavesP.hlsl @@ -22,13 +22,14 @@ #define IN_HLSL #include "shdrConsts.h" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Data //----------------------------------------------------------------------------- struct v2f { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float2 TEX0 : TEXCOORD0; float4 tangentToCube0 : TEXCOORD1; float4 tangentToCube1 : TEXCOORD2; @@ -42,21 +43,23 @@ struct v2f struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +// Uniforms +TORQUE_UNIFORM_SAMPLER2D(diffMap,0); +//TORQUE_UNIFORM_SAMPLERCUBE(cubeMap, 1); not used? +TORQUE_UNIFORM_SAMPLER2D(bumpMap,2); + +uniform float4 specularColor : register(PC_MAT_SPECCOLOR); +uniform float4 ambient : register(PC_AMBIENT_COLOR); +uniform float specularPower : register(PC_MAT_SPECPOWER); +uniform float accumTime : register(PC_ACCUM_TIME); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main(v2f IN, - uniform sampler2D diffMap : register(S0), - uniform sampler2D bumpMap : register(S2), - uniform samplerCUBE cubeMap : register(S1), - uniform float4 specularColor : register(PC_MAT_SPECCOLOR), - uniform float specularPower : register(PC_MAT_SPECPOWER), - uniform float4 ambient : register(PC_AMBIENT_COLOR), - uniform float accumTime : register(PC_ACCUM_TIME) -) +Fragout main(v2f IN) { Fragout OUT; @@ -68,8 +71,8 @@ Fragout main(v2f IN, texOffset.y = IN.TEX0.y + cos( accumTime * 3.0 + IN.TEX0.x * 6.28319 * 2.0 ) * 0.05; - float4 bumpNorm = tex2D( bumpMap, texOffset ) * 2.0 - 1.0; - float4 diffuse = tex2D( diffMap, texOffset ); + float4 bumpNorm = TORQUE_TEX2D( bumpMap, texOffset ) * 2.0 - 1.0; + float4 diffuse = TORQUE_TEX2D( diffMap, texOffset ); OUT.col = diffuse * (saturate( dot( IN.lightVec, bumpNorm.xyz ) ) + ambient); diff --git a/Templates/Empty/game/shaders/common/wavesV.hlsl b/Templates/Empty/game/shaders/common/wavesV.hlsl index 6580daa5b..fccef9d25 100644 --- a/Templates/Empty/game/shaders/common/wavesV.hlsl +++ b/Templates/Empty/game/shaders/common/wavesV.hlsl @@ -22,7 +22,7 @@ #define IN_HLSL #include "shdrConsts.h" -#include "hlslStructs.h" +#include "hlslStructs.hlsl" //----------------------------------------------------------------------------- // Constants @@ -42,21 +42,20 @@ struct Conn }; +uniform float4x4 modelview : register(VC_WORLD_PROJ); +uniform float3x3 cubeTrans : register(VC_CUBE_TRANS); +uniform float3 cubeEyePos : register(VC_CUBE_EYE_POS); +uniform float3 inLightVec : register(VC_LIGHT_DIR1); +uniform float3 eyePos : register(VC_EYE_POS); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Conn main( VertexIn_PNTTTB In, - uniform float4x4 modelview : register(VC_WORLD_PROJ), - uniform float3x3 cubeTrans : register(VC_CUBE_TRANS), - uniform float3 cubeEyePos : register(VC_CUBE_EYE_POS), - uniform float3 inLightVec : register(VC_LIGHT_DIR1), - uniform float3 eyePos : register(VC_EYE_POS) -) +Conn main( VertexIn_PNTTTB In) { Conn Out; - Out.HPOS = mul(modelview, In.pos); + Out.HPOS = mul(modelview, float4(In.pos,1.0)); Out.TEX0 = In.uv0; diff --git a/Templates/Full/game/core/scripts/client/lighting/advanced/deferredShading.cs b/Templates/Full/game/core/scripts/client/lighting/advanced/deferredShading.cs index 8a1df2c67..d53e6965f 100644 --- a/Templates/Full/game/core/scripts/client/lighting/advanced/deferredShading.cs +++ b/Templates/Full/game/core/scripts/client/lighting/advanced/deferredShading.cs @@ -1,6 +1,6 @@ singleton ShaderData( ClearGBufferShader ) { - DXVertexShaderFile = "shaders/common/postFx/postFxV.hlsl"; + DXVertexShaderFile = "shaders/common/lighting/advanced/deferredClearGBufferV.hlsl"; DXPixelShaderFile = "shaders/common/lighting/advanced/deferredClearGBufferP.hlsl"; OGLVertexShaderFile = "shaders/common/postFx/gl/postFxV.glsl"; diff --git a/Templates/Full/game/shaders/common/VolumetricFog/VFogP.hlsl b/Templates/Full/game/shaders/common/VolumetricFog/VFogP.hlsl index aaadbf479..e900f7548 100644 --- a/Templates/Full/game/shaders/common/VolumetricFog/VFogP.hlsl +++ b/Templates/Full/game/shaders/common/VolumetricFog/VFogP.hlsl @@ -21,44 +21,44 @@ //----------------------------------------------------------------------------- // Volumetric Fog final pixel shader V2.00 - -#include "shadergen:/autogenConditioners.h" +#include "../shaderModel.hlsl" +#include "../shaderModelAutoGen.hlsl" #include "../torque.hlsl" -uniform sampler2D prepassTex : register(S0); -uniform sampler2D depthBuffer : register(S1); -uniform sampler2D frontBuffer : register(S2); -uniform sampler2D density : register(S3); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER2D(depthBuffer, 1); +TORQUE_UNIFORM_SAMPLER2D(frontBuffer, 2); +TORQUE_UNIFORM_SAMPLER2D(density, 3); +uniform float3 ambientColor; uniform float accumTime; uniform float4 fogColor; +uniform float4 modspeed;//xy speed layer 1, zw speed layer 2 +uniform float2 viewpoint; +uniform float2 texscale; uniform float fogDensity; uniform float preBias; uniform float textured; uniform float modstrength; -uniform float4 modspeed;//xy speed layer 1, zw speed layer 2 -uniform float2 viewpoint; -uniform float2 texscale; -uniform float3 ambientColor; uniform float numtiles; uniform float fadesize; uniform float2 PixelSize; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 htpos : TEXCOORD0; float2 uv0 : TEXCOORD1; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { float2 uvscreen=((IN.htpos.xy/IN.htpos.w) + 1.0 ) / 2.0; uvscreen.y = 1.0 - uvscreen.y; - float obj_test = prepassUncondition( prepassTex, uvscreen).w * preBias; - float depth = tex2D(depthBuffer,uvscreen).r; - float front = tex2D(frontBuffer,uvscreen).r; + float obj_test = TORQUE_PREPASS_UNCONDITION(prepassTex, uvscreen).w * preBias; + float depth = TORQUE_TEX2D(depthBuffer, uvscreen).r; + float front = TORQUE_TEX2D(frontBuffer, uvscreen).r; if (depth <= front) return float4(0,0,0,0); @@ -73,8 +73,8 @@ float4 main( ConnectData IN ) : COLOR0 { float2 offset = viewpoint + ((-0.5 + (texscale * uvscreen)) * numtiles); - float2 mod1 = tex2D(density,(offset + (modspeed.xy*accumTime))).rg; - float2 mod2= tex2D(density,(offset + (modspeed.zw*accumTime))).rg; + float2 mod1 = TORQUE_TEX2D(density, (offset + (modspeed.xy*accumTime))).rg; + float2 mod2 = TORQUE_TEX2D(density, (offset + (modspeed.zw*accumTime))).rg; diff = (mod2.r + mod1.r) * modstrength; col *= (2.0 - ((mod1.g + mod2.g) * fadesize))/2.0; } diff --git a/Templates/Full/game/shaders/common/VolumetricFog/VFogPreP.hlsl b/Templates/Full/game/shaders/common/VolumetricFog/VFogPreP.hlsl index bb06f5f7c..fdc839507 100644 --- a/Templates/Full/game/shaders/common/VolumetricFog/VFogPreP.hlsl +++ b/Templates/Full/game/shaders/common/VolumetricFog/VFogPreP.hlsl @@ -21,14 +21,15 @@ //----------------------------------------------------------------------------- // Volumetric Fog prepass pixel shader V1.00 +#include "../shaderModel.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { float OUT; diff --git a/Templates/Full/game/shaders/common/VolumetricFog/VFogPreV.hlsl b/Templates/Full/game/shaders/common/VolumetricFog/VFogPreV.hlsl index 2d13cdf01..aba7a745d 100644 --- a/Templates/Full/game/shaders/common/VolumetricFog/VFogPreV.hlsl +++ b/Templates/Full/game/shaders/common/VolumetricFog/VFogPreV.hlsl @@ -22,11 +22,12 @@ // Volumetric Fog prepass vertex shader V1.00 -#include "shaders/common/hlslstructs.h" +#include "../shaderModel.hlsl" +#include "../hlslStructs.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; @@ -35,12 +36,9 @@ uniform float4x4 modelView; ConnectData main( VertexIn_P IN) { ConnectData OUT; - - float4 inPos = IN.pos; - inPos.w = 1.0; - OUT.hpos = mul( modelView, inPos ); - OUT.pos = OUT.hpos; + OUT.hpos = mul(modelView, float4(IN.pos, 1.0)); + OUT.pos = OUT.hpos; - return OUT; + return OUT; } diff --git a/Templates/Full/game/shaders/common/VolumetricFog/VFogRefl.hlsl b/Templates/Full/game/shaders/common/VolumetricFog/VFogRefl.hlsl index bd9866cf8..380233b5f 100644 --- a/Templates/Full/game/shaders/common/VolumetricFog/VFogRefl.hlsl +++ b/Templates/Full/game/shaders/common/VolumetricFog/VFogRefl.hlsl @@ -21,17 +21,18 @@ //----------------------------------------------------------------------------- // Volumetric Fog Reflection pixel shader V1.00 +#include "../shaderModel.hlsl" uniform float4 fogColor; uniform float fogDensity; uniform float reflStrength; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 pos : TEXCOORD0; }; -float4 main( ConnectData IN ) : COLOR0 +float4 main( ConnectData IN ) : TORQUE_TARGET0 { return float4(fogColor.rgb,saturate(fogDensity*reflStrength)); } diff --git a/Templates/Full/game/shaders/common/VolumetricFog/VFogV.hlsl b/Templates/Full/game/shaders/common/VolumetricFog/VFogV.hlsl index 7f86802b5..167f83946 100644 --- a/Templates/Full/game/shaders/common/VolumetricFog/VFogV.hlsl +++ b/Templates/Full/game/shaders/common/VolumetricFog/VFogV.hlsl @@ -22,24 +22,25 @@ // Volumetric Fog final vertex shader V1.00 -#include "shaders/common/hlslstructs.h" +#include "../shaderModel.hlsl" +#include "../hlslStructs.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 htpos : TEXCOORD0; float2 uv0 : TEXCOORD1; }; uniform float4x4 modelView; -ConnectData main( VertexIn_PNT IN) +ConnectData main( VertexIn_PNTT IN) { - ConnectData OUT; + ConnectData OUT; - OUT.hpos = mul(modelView, IN.pos); + OUT.hpos = mul(modelView, float4(IN.pos,1.0)); OUT.htpos = OUT.hpos; OUT.uv0 = IN.uv0; - return OUT; + return OUT; } diff --git a/Templates/Full/game/shaders/common/basicCloudsP.hlsl b/Templates/Full/game/shaders/common/basicCloudsP.hlsl index 53b88d8b7..4b40e5e8c 100644 --- a/Templates/Full/game/shaders/common/basicCloudsP.hlsl +++ b/Templates/Full/game/shaders/common/basicCloudsP.hlsl @@ -24,14 +24,14 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; }; -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { - float4 col = tex2D( diffuseMap, IN.texCoord ); + float4 col = TORQUE_TEX2D(diffuseMap, IN.texCoord); return hdrEncode( col ); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/basicCloudsV.hlsl b/Templates/Full/game/shaders/common/basicCloudsV.hlsl index a3d4bb5fe..477f17d50 100644 --- a/Templates/Full/game/shaders/common/basicCloudsV.hlsl +++ b/Templates/Full/game/shaders/common/basicCloudsV.hlsl @@ -20,40 +20,40 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" + struct CloudVert { - float4 pos : POSITION; - float3 normal : NORMAL; - float3 binormal : BINORMAL; - float3 tangent : TANGENT; + float3 pos : POSITION; float2 uv0 : TEXCOORD0; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; }; uniform float4x4 modelview; -uniform float accumTime; -uniform float texScale; uniform float2 texDirection; uniform float2 texOffset; +uniform float accumTime; +uniform float texScale; + ConnectData main( CloudVert IN ) -{ +{ ConnectData OUT; - - OUT.hpos = mul(modelview, IN.pos); + + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); OUT.hpos.w = OUT.hpos.z; - + float2 uv = IN.uv0; uv += texOffset; uv *= texScale; uv += accumTime * texDirection; - OUT.texCoord = uv; - + OUT.texCoord = uv; + return OUT; } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/cloudLayerP.hlsl b/Templates/Full/game/shaders/common/cloudLayerP.hlsl index a3c2d06e8..efa8fe0b4 100644 --- a/Templates/Full/game/shaders/common/cloudLayerP.hlsl +++ b/Templates/Full/game/shaders/common/cloudLayerP.hlsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" #include "torque.hlsl" //----------------------------------------------------------------------------- @@ -27,7 +28,7 @@ //----------------------------------------------------------------------------- struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord12 : TEXCOORD0; float4 texCoord34 : TEXCOORD1; float3 vLightTS : TEXCOORD2; // light vector in tangent space, denormalized @@ -38,7 +39,7 @@ struct ConnectData //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler2D normalHeightMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(normalHeightMap, 0); uniform float3 ambientColor; uniform float3 sunColor; uniform float cloudCoverage; @@ -99,7 +100,7 @@ float3 ComputeIllumination( float2 texCoord, return finalColor; } -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Normalize the interpolated vectors: float3 vViewTS = normalize( IN.vViewTS ); @@ -109,11 +110,11 @@ float4 main( ConnectData IN ) : COLOR float2 texSample = IN.texCoord12.xy; - float4 noise1 = tex2D( normalHeightMap, IN.texCoord12.zw ); + float4 noise1 = TORQUE_TEX2D( normalHeightMap, IN.texCoord12.zw ); noise1 = normalize( ( noise1 - 0.5 ) * 2.0 ); //return noise1; - float4 noise2 = tex2D( normalHeightMap, IN.texCoord34.xy ); + float4 noise2 = TORQUE_TEX2D(normalHeightMap, IN.texCoord34.xy); noise2 = normalize( ( noise2 - 0.5 ) * 2.0 ); //return noise2; @@ -122,7 +123,7 @@ float4 main( ConnectData IN ) : COLOR float noiseHeight = noise1.a * noise2.a * ( cloudCoverage / 2.0 + 0.5 ); - float3 vNormalTS = normalize( tex2D( normalHeightMap, texSample ).xyz * 2.0 - 1.0 ); + float3 vNormalTS = normalize( TORQUE_TEX2D(normalHeightMap, texSample).xyz * 2.0 - 1.0); vNormalTS += noiseNormal; vNormalTS = normalize( vNormalTS ); @@ -130,7 +131,7 @@ float4 main( ConnectData IN ) : COLOR cResultColor.rgb = ComputeIllumination( texSample, vLightTS, vViewTS, vNormalTS ); float coverage = ( cloudCoverage - 0.5 ) * 2.0; - cResultColor.a = tex2D( normalHeightMap, texSample ).a + coverage + noiseHeight; + cResultColor.a = TORQUE_TEX2D(normalHeightMap, texSample).a + coverage + noiseHeight; if ( cloudCoverage > -1.0 ) cResultColor.a /= 1.0 + coverage; diff --git a/Templates/Full/game/shaders/common/cloudLayerV.hlsl b/Templates/Full/game/shaders/common/cloudLayerV.hlsl index c34a57c05..94f8b62cb 100644 --- a/Templates/Full/game/shaders/common/cloudLayerV.hlsl +++ b/Templates/Full/game/shaders/common/cloudLayerV.hlsl @@ -23,10 +23,11 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" struct CloudVert { - float4 pos : POSITION; + float3 pos : POSITION; float3 normal : NORMAL; float3 binormal : BINORMAL; float3 tangent : TANGENT; @@ -35,7 +36,7 @@ struct CloudVert struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord12 : TEXCOORD0; float4 texCoord34 : TEXCOORD1; float3 vLightTS : TEXCOORD2; // light vector in tangent space, denormalized @@ -60,9 +61,9 @@ uniform float3 texScale; ConnectData main( CloudVert IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.pos); + + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); OUT.hpos.w = OUT.hpos.z; - // Offset the uv so we don't have a seam directly over our head. float2 uv = IN.uv0 + float2( 0.5, 0.5 ); @@ -85,7 +86,7 @@ ConnectData main( CloudVert IN ) float3 vBinormalWS = -IN.binormal; // Compute position in world space: - float4 vPositionWS = IN.pos + float4( eyePosWorld, 1 ); //mul( IN.pos, objTrans ); + float4 vPositionWS = float4(IN.pos, 1.0) + float4(eyePosWorld, 1); //mul( IN.pos, objTrans ); // Compute and output the world view vector (unnormalized): float3 vViewWS = eyePosWorld - vPositionWS.xyz; diff --git a/Templates/Full/game/shaders/common/fixedFunction/addColorTextureP.hlsl b/Templates/Full/game/shaders/common/fixedFunction/addColorTextureP.hlsl index 52ae4e955..d0577428f 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/addColorTextureP.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/addColorTextureP.hlsl @@ -20,9 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, - float2 texCoord_in : TEXCOORD0, - uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return float4(color_in.rgb, color_in.a * tex2D(diffuseMap, texCoord_in).a); + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +float4 main( Conn IN ) : TORQUE_TARGET0 +{ + return float4(IN.color.rgb, IN.color.a * TORQUE_TEX2D(diffuseMap, IN.texCoord).a); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/fixedFunction/addColorTextureV.hlsl b/Templates/Full/game/shaders/common/fixedFunction/addColorTextureV.hlsl index 43a82dca6..8bf4e88d8 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/addColorTextureV.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/addColorTextureV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; Out.texCoord = In.texCoord; return Out; diff --git a/Templates/Full/game/shaders/common/fixedFunction/colorP.hlsl b/Templates/Full/game/shaders/common/fixedFunction/colorP.hlsl index 90bb08112..dd9990e07 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/colorP.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/colorP.hlsl @@ -20,7 +20,15 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return color_in; + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; +}; + +float4 main(Conn IN) : TORQUE_TARGET0 +{ + return IN.color; } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/fixedFunction/colorV.hlsl b/Templates/Full/game/shaders/common/fixedFunction/colorV.hlsl index f0efe1493..d16dfb863 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/colorV.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/colorV.hlsl @@ -20,20 +20,26 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; return Out; } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/fixedFunction/modColorTextureP.hlsl b/Templates/Full/game/shaders/common/fixedFunction/modColorTextureP.hlsl index ccf22845c..63afec2a4 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/modColorTextureP.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/modColorTextureP.hlsl @@ -20,9 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -float4 main( float4 color_in : COLOR0, - float2 texCoord_in : TEXCOORD0, - uniform sampler2D diffuseMap : register(S0) ) : COLOR0 +#include "../shaderModel.hlsl" + +struct Conn { - return tex2D(diffuseMap, texCoord_in) * color_in; + float4 HPOS : TORQUE_POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +float4 main( Conn IN ) : TORQUE_TARGET0 +{ + return TORQUE_TEX2D(diffuseMap, IN.texCoord) * IN.color; } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/fixedFunction/modColorTextureV.hlsl b/Templates/Full/game/shaders/common/fixedFunction/modColorTextureV.hlsl index 43a82dca6..8bf4e88d8 100644 --- a/Templates/Full/game/shaders/common/fixedFunction/modColorTextureV.hlsl +++ b/Templates/Full/game/shaders/common/fixedFunction/modColorTextureV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" + struct Appdata { - float4 position : POSITION; + float3 position : POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; + struct Conn { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float4 color : COLOR; float2 texCoord : TEXCOORD0; }; -Conn main( Appdata In, uniform float4x4 modelview : register(C0) ) + +uniform float4x4 modelview; + +Conn main( Appdata In ) { Conn Out; - Out.HPOS = mul(modelview, In.position); + Out.HPOS = mul(modelview, float4(In.position,1.0)); Out.color = In.color; Out.texCoord = In.texCoord; return Out; diff --git a/Templates/Full/game/shaders/common/fixedFunction/textureP.hlsl b/Templates/Full/game/shaders/common/fixedFunction/textureP.hlsl new file mode 100644 index 000000000..82dbd4ce9 --- /dev/null +++ b/Templates/Full/game/shaders/common/fixedFunction/textureP.hlsl @@ -0,0 +1,36 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../shaderModel.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); + +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; +}; + +float4 main(Conn IN) : TORQUE_TARGET0 +{ + return TORQUE_TEX2D(diffuseMap, IN.texCoord); +} \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/fixedFunction/textureV.hlsl b/Templates/Full/game/shaders/common/fixedFunction/textureV.hlsl new file mode 100644 index 000000000..204cf9514 --- /dev/null +++ b/Templates/Full/game/shaders/common/fixedFunction/textureV.hlsl @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../shaderModel.hlsl" + +struct Appdata +{ + float3 position : POSITION; + float4 color : COLOR; + float2 texCoord : TEXCOORD0; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; +}; + +uniform float4x4 modelview; + +Conn main( Appdata In ) +{ + Conn Out; + Out.hpos = mul(modelview, float4(In.position, 1.0)); + Out.texCoord = In.texCoord; + return Out; +} \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/foliage.hlsl b/Templates/Full/game/shaders/common/foliage.hlsl index e875bb23f..9952c29d6 100644 --- a/Templates/Full/game/shaders/common/foliage.hlsl +++ b/Templates/Full/game/shaders/common/foliage.hlsl @@ -30,11 +30,11 @@ #define MAX_COVERTYPES 8 +uniform float2 gc_fadeParams; +uniform float2 gc_windDir; uniform float3 gc_camRight; uniform float3 gc_camUp; uniform float4 gc_typeRects[MAX_COVERTYPES]; -uniform float2 gc_fadeParams; -uniform float2 gc_windDir; // .x = gust length // .y = premultiplied simulation time and gust frequency diff --git a/Templates/Full/game/shaders/common/fxFoliageReplicatorP.hlsl b/Templates/Full/game/shaders/common/fxFoliageReplicatorP.hlsl index dfa2e4de0..a8bb68e28 100644 --- a/Templates/Full/game/shaders/common/fxFoliageReplicatorP.hlsl +++ b/Templates/Full/game/shaders/common/fxFoliageReplicatorP.hlsl @@ -21,36 +21,39 @@ //----------------------------------------------------------------------------- #include "shdrConsts.h" - +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct ConnectData { - float2 texCoord : TEXCOORD0; - float4 lum : COLOR0; + float4 hpos : TORQUE_POSITION; + float2 outTexCoord : TEXCOORD0; + float4 color : COLOR0; float4 groundAlphaCoeff : COLOR1; float2 alphaLookup : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); +TORQUE_UNIFORM_SAMPLER2D(alphaMap, 1); + +uniform float4 groundAlpha; +uniform float4 ambient; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D diffuseMap : register(S0), - uniform sampler2D alphaMap : register(S1), - uniform float4 groundAlpha, - uniform float4 ambient ) +Fragout main( ConnectData IN ) { Fragout OUT; - float4 alpha = tex2D(alphaMap, IN.alphaLookup); - OUT.col = float4( ambient.rgb * IN.lum.rgb, 1.0 ) * tex2D(diffuseMap, IN.texCoord); + float4 alpha = TORQUE_TEX2D(alphaMap, IN.alphaLookup); + OUT.col = float4( ambient.rgb * IN.lum.rgb, 1.0 ) * TORQUE_TEX2D(diffuseMap, IN.texCoord); OUT.col.a = OUT.col.a * min(alpha, groundAlpha + IN.groundAlphaCoeff.x).x; return OUT; diff --git a/Templates/Full/game/shaders/common/fxFoliageReplicatorV.hlsl b/Templates/Full/game/shaders/common/fxFoliageReplicatorV.hlsl index 06a9cf5e5..70ec9ff4c 100644 --- a/Templates/Full/game/shaders/common/fxFoliageReplicatorV.hlsl +++ b/Templates/Full/game/shaders/common/fxFoliageReplicatorV.hlsl @@ -23,39 +23,42 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct VertData { - float2 texCoord : TEXCOORD0; - float2 waveScale : TEXCOORD1; + float3 position : POSITION; float3 normal : NORMAL; - float4 position : POSITION; + float2 texCoord : TEXCOORD0; + float2 waveScale : TEXCOORD1; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 outTexCoord : TEXCOORD0; float4 color : COLOR0; float4 groundAlphaCoeff : COLOR1; float2 alphaLookup : TEXCOORD1; }; +uniform float4x4 projection : register(C0); +uniform float4x4 world : register(C4); +uniform float GlobalSwayPhase : register(C8); +uniform float SwayMagnitudeSide : register(C9); +uniform float SwayMagnitudeFront : register(C10); +uniform float GlobalLightPhase : register(C11); +uniform float LuminanceMagnitude : register(C12); +uniform float LuminanceMidpoint : register(C13); +uniform float DistanceRange : register(C14); +uniform float3 CameraPos : register(C15); +uniform float TrueBillboard : register(C16); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertData IN, - uniform float4x4 projection : register(C0), - uniform float4x4 world : register(C4), - uniform float GlobalSwayPhase : register(C8), - uniform float SwayMagnitudeSide : register(C9), - uniform float SwayMagnitudeFront : register(C10), - uniform float GlobalLightPhase : register(C11), - uniform float LuminanceMagnitude : register(C12), - uniform float LuminanceMidpoint : register(C13), - uniform float DistanceRange : register(C14), - uniform float3 CameraPos : register(C15), - uniform float TrueBillboard : register(C16) -) +ConnectData main( VertData IN ) { ConnectData OUT; @@ -113,7 +116,7 @@ ConnectData main( VertData IN, float Luminance = LuminanceMidpoint + LuminanceMagnitude * cos(GlobalLightPhase + IN.normal.y); // Alpha - float3 worldPos = float3(IN.position.x, IN.position.y, IN.position.z); + float3 worldPos = IN.position; float alpha = abs(distance(worldPos, CameraPos)) / DistanceRange; alpha = clamp(alpha, 0.0f, 1.0f); //pass it through diff --git a/Templates/Full/game/shaders/common/guiMaterialV.hlsl b/Templates/Full/game/shaders/common/guiMaterialV.hlsl index 425da5da4..5d725338f 100644 --- a/Templates/Full/game/shaders/common/guiMaterialV.hlsl +++ b/Templates/Full/game/shaders/common/guiMaterialV.hlsl @@ -20,23 +20,25 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "hlslStructs.h" +#include "hlslStructs.hlsl" +#include "shaderModel.hlsl" struct MaterialDecoratorConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; +uniform float4x4 modelview : register(C0); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -MaterialDecoratorConnectV main( VertexIn_PCT IN, - uniform float4x4 modelview : register(C0) ) +MaterialDecoratorConnectV main( VertexIn_PCT IN ) { MaterialDecoratorConnectV OUT; - OUT.hpos = mul(modelview, IN.pos); + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); OUT.uv0 = IN.uv0; return OUT; diff --git a/Templates/Full/game/shaders/common/hlslStructs.hlsl b/Templates/Full/game/shaders/common/hlslStructs.hlsl new file mode 100644 index 000000000..ce0ca305c --- /dev/null +++ b/Templates/Full/game/shaders/common/hlslStructs.hlsl @@ -0,0 +1,114 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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. +//----------------------------------------------------------------------------- + +// The purpose of this file is to get all of our HLSL structures into one place. +// Please use the structures here instead of redefining input and output structures +// in each shader file. If structures are added, please adhere to the naming convention. + +//------------------------------------------------------------------------------ +// Vertex Input Structures +// +// These structures map to FVFs/Vertex Declarations in Torque. See gfxStructs.h +//------------------------------------------------------------------------------ + +// Notes +// +// Position should be specified as a float3 as our vertex structures in +// the engine output float3s for position. + +struct VertexIn_P +{ + float3 pos : POSITION; +}; + +struct VertexIn_PT +{ + float3 pos : POSITION; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PTTT +{ + float3 pos : POSITION; + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float2 uv2 : TEXCOORD2; +}; + +struct VertexIn_PC +{ + float3 pos : POSITION; + float4 color : DIFFUSE; +}; + +struct VertexIn_PNC +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float4 color : DIFFUSE; +}; + +struct VertexIn_PCT +{ + float3 pos : POSITION; + float4 color : DIFFUSE; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PN +{ + float3 pos : POSITION; + float3 normal : NORMAL; +}; + +struct VertexIn_PNT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNTT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float3 tangent : TANGENT; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNCT +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float4 color : DIFFUSE; + float2 uv0 : TEXCOORD0; +}; + +struct VertexIn_PNTTTB +{ + float3 pos : POSITION; + float3 normal : NORMAL; + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float3 T : TEXCOORD2; + float3 B : TEXCOORD3; +}; \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/lighting.hlsl b/Templates/Full/game/shaders/common/lighting.hlsl index a2c753618..a41b8a873 100644 --- a/Templates/Full/game/shaders/common/lighting.hlsl +++ b/Templates/Full/game/shaders/common/lighting.hlsl @@ -241,7 +241,7 @@ float4 AL_DeferredOutput( } //specular = color * map * spec^gloss - float specularOut = (specularColor * matInfo.b * min(pow(specular, max(( matInfo.a/ AL_ConstantSpecularPower),1.0f)),matInfo.a)).r; + float specularOut = (specularColor * matInfo.b * min(pow(abs(specular), max(( matInfo.a/ AL_ConstantSpecularPower),1.0f)),matInfo.a)).r; lightColor *= shadowAttenuation; lightColor += ambient.rgb; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/convexGeometryV.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/convexGeometryV.hlsl index c86cd4e89..064fcffa6 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/convexGeometryV.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/convexGeometryV.hlsl @@ -20,17 +20,24 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" +#include "../../shaderModel.hlsl" + +struct VertData +{ + float3 pos : POSITION; + float4 color : COLOR; +}; struct ConvexConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; }; -ConvexConnectV main( VertexIn_P IN, +ConvexConnectV main( VertData IN, uniform float4x4 modelview, uniform float4x4 objTrans, uniform float4x4 worldViewOnly, @@ -38,9 +45,9 @@ ConvexConnectV main( VertexIn_P IN, { ConvexConnectV OUT; - OUT.hpos = mul( modelview, IN.pos ); - OUT.wsEyeDir = mul( objTrans, IN.pos ) - float4( eyePosWorld, 0.0 ); - OUT.vsEyeDir = mul( worldViewOnly, IN.pos ); + OUT.hpos = mul( modelview, float4(IN.pos,1.0) ); + OUT.wsEyeDir = mul(objTrans, float4(IN.pos, 1.0)) - float4(eyePosWorld, 0.0); + OUT.vsEyeDir = mul(worldViewOnly, float4(IN.pos, 1.0)); OUT.ssPos = OUT.hpos; return OUT; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl index 349c943f9..ad3debbaf 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgColorBufferP.hlsl @@ -20,12 +20,11 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(colorBufferTex,0); -float4 main( PFXVertToPix IN, - uniform sampler2D colorBufferTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return float4(tex2D( colorBufferTex, IN.uv0 ).rgb, 1.0); + return float4(TORQUE_TEX2D( colorBufferTex, IN.uv0 ).rgb, 1.0); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl index a2b2b5d7d..68df09a78 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgDepthVisualizeP.hlsl @@ -20,14 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER1D(depthViz, 1); -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex : register(S0), - uniform sampler1D depthViz : register(S1) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; - return float4( tex1D( depthViz, depth ).rgb, 1.0 ); + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; + return float4( TORQUE_TEX1D( depthViz, depth ).rgb, 1.0 ); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl index 3c31c897e..257383659 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgGlowVisualizeP.hlsl @@ -20,12 +20,11 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(glowBuffer, 0); -float4 main( PFXVertToPix IN, - uniform sampler2D glowBuffer : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return tex2D(glowBuffer, IN.uv0); + return TORQUE_TEX2D(glowBuffer, IN.uv0); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl index e037ad8b9..ca6d8d677 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgLightColorVisualizeP.hlsl @@ -20,13 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,0); -float4 main( PFXVertToPix IN, - uniform sampler2D lightPrePassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 lightColor = tex2D( lightPrePassTex, IN.uv0 ); + float4 lightColor = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ); return float4( lightColor.rgb, 1.0 ); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl index 8e1074add..072f07e00 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgLightSpecularVisualizeP.hlsl @@ -20,13 +20,12 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,0); - -float4 main( PFXVertToPix IN, - uniform sampler2D lightPrePassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float specular = tex2D( lightPrePassTex, IN.uv0 ).a; + float specular = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ).a; return float4( specular, specular, specular, 1.0 ); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl index c160045b4..4f31d2c53 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgNormalVisualizeP.hlsl @@ -20,13 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float3 normal = prepassUncondition( prepassTex, IN.uv0 ).xyz; + float3 normal = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).xyz; return float4( ( normal + 1.0 ) * 0.5, 1.0 ); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl index b1f2bca29..b54833499 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgShadowVisualizeP.hlsl @@ -20,15 +20,19 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + struct MaterialDecoratorConnectV { + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; -float4 main( MaterialDecoratorConnectV IN, - uniform sampler2D shadowMap : register(S0), - uniform sampler1D depthViz : register(S1) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 0); +TORQUE_UNIFORM_SAMPLER1D(depthViz, 1); + +float4 main( MaterialDecoratorConnectV IN ) : TORQUE_TARGET0 { - float depth = saturate( tex2D( shadowMap, IN.uv0 ).r ); - return float4( tex1D( depthViz, depth ).rgb, 1 ); + float depth = saturate( TORQUE_TEX2D( shadowMap, IN.uv0 ).r ); + return float4( TORQUE_TEX1D( depthViz, depth ).rgb, 1 ); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl index ba5f2c0e1..eba38a879 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/dbgSpecMapVisualizeP.hlsl @@ -20,13 +20,12 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../postfx/postFx.hlsl" +TORQUE_UNIFORM_SAMPLER2D(matinfoTex,0); -float4 main( PFXVertToPix IN, - uniform sampler2D matinfoTex : register(S0) ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float specular = tex2D( matinfoTex, IN.uv0 ).b; + float specular = TORQUE_TEX2D( matinfoTex, IN.uv0 ).b; return float4( specular, specular, specular, 1.0 ); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl index df9870248..cefebe8c7 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferP.hlsl @@ -20,17 +20,24 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + +struct Conn +{ + float4 hpos : TORQUE_POSITION; +}; + struct Fragout { - float4 col : COLOR0; - float4 col1 : COLOR1; - float4 col2 : COLOR2; + float4 col : TORQUE_TARGET0; + float4 col1 : TORQUE_TARGET1; + float4 col2 : TORQUE_TARGET2; }; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ) +Fragout main( Conn IN ) { Fragout OUT; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl new file mode 100644 index 000000000..20ba4d509 --- /dev/null +++ b/Templates/Full/game/shaders/common/lighting/advanced/deferredClearGBufferV.hlsl @@ -0,0 +1,43 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2012 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 "../../shaderModel.hlsl" + +struct Appdata +{ + float3 pos : POSITION; + float4 color : COLOR; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; +}; + +uniform float4x4 modelview; + +Conn main( Appdata In ) +{ + Conn Out; + Out.hpos = float4(In.pos,1.0); + return Out; +} diff --git a/Templates/Full/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl index 5e6d0a984..d91d2eb38 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/deferredColorShaderP.hlsl @@ -20,11 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + struct Fragout { - float4 col : COLOR0; - float4 col1 : COLOR1; - float4 col2 : COLOR2; + float4 col : TORQUE_TARGET0; + float4 col1 : TORQUE_TARGET1; + float4 col2 : TORQUE_TARGET2; }; //----------------------------------------------------------------------------- diff --git a/Templates/Full/game/shaders/common/lighting/advanced/deferredShadingP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/deferredShadingP.hlsl index 80e6acde0..c710656f8 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/deferredShadingP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/deferredShadingP.hlsl @@ -20,22 +20,22 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "../../postfx/postFx.hlsl" #include "shaders/common/torque.hlsl" +TORQUE_UNIFORM_SAMPLER2D(colorBufferTex,0); +TORQUE_UNIFORM_SAMPLER2D(lightPrePassTex,1); +TORQUE_UNIFORM_SAMPLER2D(matInfoTex,2); +TORQUE_UNIFORM_SAMPLER2D(prepassTex,3); -float4 main( PFXVertToPix IN, - uniform sampler2D colorBufferTex : register(S0), - uniform sampler2D lightPrePassTex : register(S1), - uniform sampler2D matInfoTex : register(S2), - uniform sampler2D prepassTex : register(S3)) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 lightBuffer = tex2D( lightPrePassTex, IN.uv0 ); - float4 colorBuffer = tex2D( colorBufferTex, IN.uv0 ); - float4 matInfo = tex2D( matInfoTex, IN.uv0 ); + float4 lightBuffer = TORQUE_TEX2D( lightPrePassTex, IN.uv0 ); + float4 colorBuffer = TORQUE_TEX2D( colorBufferTex, IN.uv0 ); + float4 matInfo = TORQUE_TEX2D( matInfoTex, IN.uv0 ); float specular = saturate(lightBuffer.a); - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; if (depth>0.9999) return float4(0,0,0,0); diff --git a/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl index 567dd11ce..543e21677 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuad.hlsl @@ -19,10 +19,11 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" struct FarFrustumQuadConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; float3 vsEyeRay : TEXCOORD2; @@ -30,6 +31,7 @@ struct FarFrustumQuadConnectV struct FarFrustumQuadConnectP { + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; float3 vsEyeRay : TEXCOORD2; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl index 08cf61285..0167d901a 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/farFrustumQuadV.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" #include "farFrustumQuad.hlsl" @@ -36,8 +36,8 @@ FarFrustumQuadConnectV main( VertexIn_PNTT IN, // Interpolators will generate eye rays the // from far-frustum corners. - OUT.wsEyeRay = IN.tangent.xyz; - OUT.vsEyeRay = IN.normal.xyz; + OUT.wsEyeRay = IN.tangent; + OUT.vsEyeRay = IN.normal; return OUT; } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightP.hlsl index bc4784980..7ff5d50d2 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightP.hlsl @@ -20,35 +20,36 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" - #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" #include "../../lighting.hlsl" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 ssPos : TEXCOORD0; float3 vsEyeDir : TEXCOORD1; }; -float4 main( ConvexConnectP IN, - uniform sampler2D prePassBuffer : register(S0), - - uniform float4 lightPosition, - uniform float4 lightColor, - uniform float lightRange, - - uniform float4 vsFarPlane, - uniform float4 rtParams0 ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); + +uniform float4 lightPosition; +uniform float4 lightColor; +uniform float lightRange; +uniform float4 vsFarPlane; +uniform float4 rtParams0; + +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos(ssPos, rtParams0); // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition(prePassBuffer, uvScene); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION(prePassBuffer, uvScene); float3 normal = prepassSample.rgb; float depth = prepassSample.a; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightV.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightV.hlsl index f5dc9e444..faa2ec115 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightV.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/particlePointLightV.hlsl @@ -20,24 +20,26 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "../../hlslStructs.h" +#include "../../hlslStructs.hlsl" +#include "../../shaderModel.hlsl" struct ConvexConnectV { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 ssPos : TEXCOORD0; float3 vsEyeDir : TEXCOORD1; }; -ConvexConnectV main( VertexIn_P IN, - uniform float4x4 viewProj, - uniform float4x4 view, - uniform float3 particlePosWorld, - uniform float lightRange ) +uniform float4x4 viewProj; +uniform float4x4 view; +uniform float3 particlePosWorld; +uniform float lightRange; + +ConvexConnectV main( VertexIn_P IN ) { ConvexConnectV OUT; - - float4 vPosWorld = IN.pos + float4(particlePosWorld, 0.0) + float4(IN.pos.xyz, 0.0) * lightRange; + float4 pos = float4(IN.pos, 0.0); + float4 vPosWorld = pos + float4(particlePosWorld, 0.0) + pos * lightRange; OUT.hpos = mul(viewProj, vPosWorld); OUT.vsEyeDir = mul(view, vPosWorld); OUT.ssPos = OUT.hpos; diff --git a/Templates/Full/game/shaders/common/lighting/advanced/pointLightP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/pointLightP.hlsl index 9051ff09d..540fd65c7 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/pointLightP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/pointLightP.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" @@ -31,17 +31,17 @@ struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; - float4 color : COLOR0; }; #ifdef USE_COOKIE_TEX /// The texture for cookie rendering. -uniform samplerCUBE cookieMap : register(S3); +TORQUE_UNIFORM_SAMPLERCUBE(cookieMap, 3); #endif @@ -53,9 +53,9 @@ uniform samplerCUBE cookieMap : register(S3); return shadowCoord; } - float4 shadowSample( samplerCUBE shadowMap, float3 shadowCoord ) + float4 shadowSample( TORQUE_SAMPLERCUBE(shadowMap), float3 shadowCoord ) { - return texCUBE( shadowMap, shadowCoord ); + return TORQUE_TEXCUBE( shadowMap, shadowCoord ); } #else @@ -106,44 +106,44 @@ uniform samplerCUBE cookieMap : register(S3); #endif +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); -float4 main( ConvexConnectP IN, +#ifdef SHADOW_CUBE +TORQUE_UNIFORM_SAMPLERCUBE(shadowMap, 1); +#else +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap, 2); +#endif - uniform sampler2D prePassBuffer : register(S0), +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); - #ifdef SHADOW_CUBE - uniform samplerCUBE shadowMap : register(S1), - #else - uniform sampler2D shadowMap : register(S1), - uniform sampler2D dynamicShadowMap : register(S2), - #endif +uniform float4 rtParams0; +uniform float4 lightColor; - uniform sampler2D lightBuffer : register(S5), - uniform sampler2D colorBuffer : register(S6), - uniform sampler2D matInfoBuffer : register(S7), +uniform float lightBrightness; +uniform float3 lightPosition; - uniform float4 rtParams0, +uniform float4 lightMapParams; +uniform float4 vsFarPlane; +uniform float4 lightParams; - uniform float3 lightPosition, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float lightRange, - uniform float2 lightAttenuation, - uniform float4 lightMapParams, +uniform float lightRange; +uniform float shadowSoftness; +uniform float2 lightAttenuation; - uniform float4 vsFarPlane, - uniform float3x3 viewToLightProj, - uniform float3x3 dynamicViewToLightProj, +uniform float3x3 viewToLightProj; +uniform float3x3 dynamicViewToLightProj; - uniform float4 lightParams, - uniform float shadowSoftness ) : COLOR0 +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); // Emissive. - float4 matInfo = tex2D( matInfoBuffer, uvScene ); + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, uvScene ); bool emissive = getFlag( matInfo.r, 0 ); if ( emissive ) { @@ -151,7 +151,7 @@ float4 main( ConvexConnectP IN, } // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, uvScene ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -188,14 +188,14 @@ float4 main( ConvexConnectP IN, #ifdef SHADOW_CUBE // TODO: We need to fix shadow cube to handle soft shadows! - float occ = texCUBE( shadowMap, mul( viewToLightProj, -lightVec ) ).r; + float occ = TORQUE_TEXCUBE( shadowMap, mul( viewToLightProj, -lightVec ) ).r; float shadowed = saturate( exp( lightParams.y * ( occ - distToLight ) ) ); #else // Static float2 shadowCoord = decodeShadowCoord( mul( viewToLightProj, -lightVec ) ).xy; - float static_shadowed = softShadow_filter( shadowMap, + float static_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(shadowMap), ssPos.xy, shadowCoord, shadowSoftness, @@ -205,7 +205,7 @@ float4 main( ConvexConnectP IN, // Dynamic float2 dynamicShadowCoord = decodeShadowCoord( mul( dynamicViewToLightProj, -lightVec ) ).xy; - float dynamic_shadowed = softShadow_filter( dynamicShadowMap, + float dynamic_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), ssPos.xy, dynamicShadowCoord, shadowSoftness, @@ -223,7 +223,7 @@ float4 main( ConvexConnectP IN, #ifdef USE_COOKIE_TEX // Lookup the cookie sample. - float4 cookie = texCUBE( cookieMap, mul( viewToLightProj, -lightVec ) ); + float4 cookie = TORQUE_TEXCUBE( cookieMap, mul( viewToLightProj, -lightVec ) ); // Multiply the light with the cookie tex. lightcol *= cookie.rgb; @@ -263,6 +263,6 @@ float4 main( ConvexConnectP IN, addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - float4 colorSample = tex2D( colorBuffer, uvScene ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, uvScene ); return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/softShadow.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/softShadow.hlsl index 36bffbfd9..0faf3e1fb 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/softShadow.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/softShadow.hlsl @@ -20,6 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" #if defined( SOFTSHADOW ) && defined( SOFTSHADOW_HIGH_QUALITY ) @@ -69,10 +70,9 @@ static float2 sNonUniformTaps[NUM_PRE_TAPS] = /// The texture used to do per-pixel pseudorandom /// rotations of the filter taps. -uniform sampler2D gTapRotationTex : register(S4); +TORQUE_UNIFORM_SAMPLER2D(gTapRotationTex, 4); - -float softShadow_sampleTaps( sampler2D shadowMap, +float softShadow_sampleTaps( TORQUE_SAMPLER2D(shadowMap1), float2 sinCos, float2 shadowPos, float filterRadius, @@ -88,7 +88,7 @@ float softShadow_sampleTaps( sampler2D shadowMap, { tap.x = ( sNonUniformTaps[t].x * sinCos.y - sNonUniformTaps[t].y * sinCos.x ) * filterRadius; tap.y = ( sNonUniformTaps[t].y * sinCos.y + sNonUniformTaps[t].x * sinCos.x ) * filterRadius; - float occluder = tex2Dlod( shadowMap, float4( shadowPos + tap, 0, 0 ) ).r; + float occluder = TORQUE_TEX2DLOD( shadowMap1, float4( shadowPos + tap, 0, 0 ) ).r; float esm = saturate( exp( esmFactor * ( occluder - distToLight ) ) ); shadow += esm / float( endTap - startTap ); @@ -98,7 +98,7 @@ float softShadow_sampleTaps( sampler2D shadowMap, } -float softShadow_filter( sampler2D shadowMap, +float softShadow_filter( TORQUE_SAMPLER2D(shadowMap), float2 vpos, float2 shadowPos, float filterRadius, @@ -111,16 +111,15 @@ float softShadow_filter( sampler2D shadowMap, // If softshadow is undefined then we skip any complex // filtering... just do a single sample ESM. - float occluder = tex2Dlod( shadowMap, float4( shadowPos, 0, 0 ) ).r; + float occluder = TORQUE_TEX2DLOD(shadowMap, float4(shadowPos, 0, 0)).r; float shadow = saturate( exp( esmFactor * ( occluder - distToLight ) ) ); #else - // Lookup the random rotation for this screen pixel. - float2 sinCos = ( tex2Dlod( gTapRotationTex, float4( vpos * 16, 0, 0 ) ).rg - 0.5 ) * 2; + float2 sinCos = ( TORQUE_TEX2DLOD(gTapRotationTex, float4(vpos * 16, 0, 0)).rg - 0.5) * 2; // Do the prediction taps first. - float shadow = softShadow_sampleTaps( shadowMap, + float shadow = softShadow_sampleTaps( TORQUE_SAMPLER2D_MAKEARG(shadowMap), sinCos, shadowPos, filterRadius, @@ -137,7 +136,7 @@ float softShadow_filter( sampler2D shadowMap, // in a partially shadowed area. if ( shadow * ( 1.0 - shadow ) * max( dotNL, 0 ) > 0.06 ) { - shadow += softShadow_sampleTaps( shadowMap, + shadow += softShadow_sampleTaps( TORQUE_SAMPLER2D_MAKEARG(shadowMap), sinCos, shadowPos, filterRadius, diff --git a/Templates/Full/game/shaders/common/lighting/advanced/spotLightP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/spotLightP.hlsl index 226b9cfea..e1f3baf93 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/spotLightP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/spotLightP.hlsl @@ -20,7 +20,8 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "lightingUtils.hlsl" @@ -31,54 +32,55 @@ struct ConvexConnectP { + float4 pos : TORQUE_POSITION; float4 wsEyeDir : TEXCOORD0; float4 ssPos : TEXCOORD1; float4 vsEyeDir : TEXCOORD2; - float4 color : COLOR0; }; +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap,2); + #ifdef USE_COOKIE_TEX /// The texture for cookie rendering. -uniform sampler2D cookieMap : register(S3); +TORQUE_UNIFORM_SAMPLER2D(cookieMap, 3); #endif +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); -float4 main( ConvexConnectP IN, +uniform float4 rtParams0; - uniform sampler2D prePassBuffer : register(S0), - uniform sampler2D shadowMap : register(S1), - uniform sampler2D dynamicShadowMap : register(S2), +uniform float lightBrightness; +uniform float3 lightPosition; - uniform sampler2D lightBuffer : register(S5), - uniform sampler2D colorBuffer : register(S6), - uniform sampler2D matInfoBuffer : register(S7), +uniform float4 lightColor; - uniform float4 rtParams0, +uniform float lightRange; +uniform float3 lightDirection; - uniform float3 lightPosition, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float lightRange, - uniform float2 lightAttenuation, - uniform float3 lightDirection, - uniform float4 lightSpotParams, - uniform float4 lightMapParams, +uniform float4 lightSpotParams; +uniform float4 lightMapParams; +uniform float4 vsFarPlane; +uniform float4x4 viewToLightProj; +uniform float4 lightParams; +uniform float4x4 dynamicViewToLightProj; - uniform float4 vsFarPlane, - uniform float4x4 viewToLightProj, - uniform float4x4 dynamicViewToLightProj, +uniform float2 lightAttenuation; +uniform float shadowSoftness; - uniform float4 lightParams, - uniform float shadowSoftness ) : COLOR0 +float4 main( ConvexConnectP IN ) : TORQUE_TARGET0 { // Compute scene UV float3 ssPos = IN.ssPos.xyz / IN.ssPos.w; float2 uvScene = getUVFromSSPos( ssPos, rtParams0 ); // Emissive. - float4 matInfo = tex2D( matInfoBuffer, uvScene ); + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, uvScene ); bool emissive = getFlag( matInfo.r, 0 ); if ( emissive ) { @@ -86,7 +88,7 @@ float4 main( ConvexConnectP IN, } // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, uvScene ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, uvScene ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -130,7 +132,7 @@ float4 main( ConvexConnectP IN, // Get a linear depth from the light source. float distToLight = pxlPosLightProj.z / lightRange; - float static_shadowed = softShadow_filter( shadowMap, + float static_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(shadowMap), ssPos.xy, shadowCoord, shadowSoftness, @@ -138,7 +140,7 @@ float4 main( ConvexConnectP IN, nDotL, lightParams.y ); - float dynamic_shadowed = softShadow_filter( dynamicShadowMap, + float dynamic_shadowed = softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), ssPos.xy, dynshadowCoord, shadowSoftness, @@ -152,7 +154,7 @@ float4 main( ConvexConnectP IN, #ifdef USE_COOKIE_TEX // Lookup the cookie sample. - float4 cookie = tex2D( cookieMap, shadowCoord ); + float4 cookie = TORQUE_TEX2D( cookieMap, shadowCoord ); // Multiply the light with the cookie tex. lightcol *= cookie.rgb; @@ -192,6 +194,6 @@ float4 main( ConvexConnectP IN, addToResult = ( 1.0 - shadowed ) * abs(lightMapParams); } - float4 colorSample = tex2D( colorBuffer, uvScene ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, uvScene ); return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Full/game/shaders/common/lighting/advanced/vectorLightP.hlsl b/Templates/Full/game/shaders/common/lighting/advanced/vectorLightP.hlsl index 896576564..1a9726171 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/vectorLightP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/vectorLightP.hlsl @@ -20,7 +20,8 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" #include "farFrustumQuad.hlsl" #include "../../torque.hlsl" @@ -29,16 +30,55 @@ #include "../shadowMap/shadowMapIO_HLSL.h" #include "softShadow.hlsl" - -uniform sampler2D shadowMap : register(S1); -uniform sampler2D dynamicShadowMap : register(S2); +TORQUE_UNIFORM_SAMPLER2D(prePassBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1); +TORQUE_UNIFORM_SAMPLER2D(dynamicShadowMap, 2); #ifdef USE_SSAO_MASK -uniform sampler2D ssaoMask : register(S3); +TORQUE_UNIFORM_SAMPLER2D(ssaoMask, 3); uniform float4 rtParams3; #endif +//register 4? +TORQUE_UNIFORM_SAMPLER2D(lightBuffer, 5); +TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 6); +TORQUE_UNIFORM_SAMPLER2D(matInfoBuffer, 7); -float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, +uniform float lightBrightness; +uniform float3 lightDirection; + +uniform float4 lightColor; +uniform float4 lightAmbient; + +uniform float shadowSoftness; +uniform float3 eyePosWorld; + +uniform float4 atlasXOffset; +uniform float4 atlasYOffset; +uniform float4 zNearFarInvNearFar; +uniform float4 lightMapParams; +uniform float4 farPlaneScalePSSM; +uniform float4 overDarkPSSM; + +uniform float2 fadeStartLength; +uniform float2 atlasScale; + +uniform float4x4 eyeMat; + +// Static Shadows +uniform float4x4 worldToLightProj; +uniform float4 scaleX; +uniform float4 scaleY; +uniform float4 offsetX; +uniform float4 offsetY; +// Dynamic Shadows +uniform float4x4 dynamicWorldToLightProj; +uniform float4 dynamicScaleX; +uniform float4 dynamicScaleY; +uniform float4 dynamicOffsetX; +uniform float4 dynamicOffsetY; +uniform float4 dynamicFarPlaneScalePSSM; + +float4 AL_VectorLightShadowCast( TORQUE_SAMPLER2D(sourceShadowMap), float2 texCoord, float4x4 worldToLightProj, float4 worldPos, @@ -52,8 +92,7 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, float2 atlasScale, float shadowSoftness, float dotNL , - float4 overDarkPSSM -) + float4 overDarkPSSM) { // Compute shadow map coordinate float4 pxlPosLightProj = mul(worldToLightProj, worldPos); @@ -144,7 +183,7 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, distToLight *= farPlaneScale; return float4(debugColor, - softShadow_filter( sourceShadowMap, + softShadow_filter( TORQUE_SAMPLER2D_MAKEARG(sourceShadowMap), texCoord, shadowCoord, farPlaneScale * shadowSoftness, @@ -153,50 +192,10 @@ float4 AL_VectorLightShadowCast( sampler2D sourceShadowMap, dot( finalMask, overDarkPSSM ) ) ); }; -float4 main( FarFrustumQuadConnectP IN, - - uniform sampler2D prePassBuffer : register(S0), - - uniform sampler2D lightBuffer : register(S5), - uniform sampler2D colorBuffer : register(S6), - uniform sampler2D matInfoBuffer : register(S7), - - uniform float3 lightDirection, - uniform float4 lightColor, - uniform float lightBrightness, - uniform float4 lightAmbient, - uniform float4x4 eyeMat, - - uniform float3 eyePosWorld, - uniform float4 atlasXOffset, - uniform float4 atlasYOffset, - uniform float2 atlasScale, - uniform float4 zNearFarInvNearFar, - uniform float4 lightMapParams, - uniform float2 fadeStartLength, - uniform float4 overDarkPSSM, - uniform float shadowSoftness, - - // Static Shadows - uniform float4x4 worldToLightProj, - uniform float4 scaleX, - uniform float4 scaleY, - uniform float4 offsetX, - uniform float4 offsetY, - uniform float4 farPlaneScalePSSM, - - // Dynamic Shadows - uniform float4x4 dynamicWorldToLightProj, - uniform float4 dynamicScaleX, - uniform float4 dynamicScaleY, - uniform float4 dynamicOffsetX, - uniform float4 dynamicOffsetY, - uniform float4 dynamicFarPlaneScalePSSM - - ) : COLOR0 +float4 main( FarFrustumQuadConnectP IN ) : TORQUE_TARGET0 { // Emissive. - float4 matInfo = tex2D( matInfoBuffer, IN.uv0 ); + float4 matInfo = TORQUE_TEX2D( matInfoBuffer, IN.uv0 ); bool emissive = getFlag( matInfo.r, 0 ); if ( emissive ) { @@ -204,7 +203,7 @@ float4 main( FarFrustumQuadConnectP IN, } // Sample/unpack the normal/z data - float4 prepassSample = prepassUncondition( prePassBuffer, IN.uv0 ); + float4 prepassSample = TORQUE_PREPASS_UNCONDITION( prePassBuffer, IN.uv0 ); float3 normal = prepassSample.rgb; float depth = prepassSample.a; @@ -229,7 +228,7 @@ float4 main( FarFrustumQuadConnectP IN, #else - float4 static_shadowed_colors = AL_VectorLightShadowCast( shadowMap, + float4 static_shadowed_colors = AL_VectorLightShadowCast( TORQUE_SAMPLER2D_MAKEARG(shadowMap), IN.uv0.xy, worldToLightProj, worldPos, @@ -241,7 +240,7 @@ float4 main( FarFrustumQuadConnectP IN, shadowSoftness, dotNL, overDarkPSSM); - float4 dynamic_shadowed_colors = AL_VectorLightShadowCast( dynamicShadowMap, + float4 dynamic_shadowed_colors = AL_VectorLightShadowCast( TORQUE_SAMPLER2D_MAKEARG(dynamicShadowMap), IN.uv0.xy, dynamicWorldToLightProj, worldPos, @@ -307,7 +306,7 @@ float4 main( FarFrustumQuadConnectP IN, // Sample the AO texture. #ifdef USE_SSAO_MASK - float ao = 1.0 - tex2D( ssaoMask, viewportCoordToRenderTarget( IN.uv0.xy, rtParams3 ) ).r; + float ao = 1.0 - TORQUE_TEX2D( ssaoMask, viewportCoordToRenderTarget( IN.uv0.xy, rtParams3 ) ).r; addToResult *= ao; #endif @@ -315,6 +314,6 @@ float4 main( FarFrustumQuadConnectP IN, lightColorOut = debugColor; #endif - float4 colorSample = tex2D( colorBuffer, IN.uv0 ); + float4 colorSample = TORQUE_TEX2D( colorBuffer, IN.uv0 ); return AL_DeferredOutput(lightColorOut, colorSample.rgb, matInfo, addToResult, specular, Sat_NL_Att); } diff --git a/Templates/Full/game/shaders/common/lighting/basic/shadowFilterP.hlsl b/Templates/Full/game/shaders/common/lighting/basic/shadowFilterP.hlsl index f161fb5d3..b56aade8d 100644 --- a/Templates/Full/game/shaders/common/lighting/basic/shadowFilterP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/basic/shadowFilterP.hlsl @@ -22,11 +22,11 @@ #include "shaders/common/postFx/postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv : TEXCOORD0; }; @@ -35,15 +35,15 @@ static float weight[3] = { 0.2270270270, 0.3162162162, 0.0702702703 }; uniform float2 oneOverTargetSize; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { - float4 OUT = tex2D( diffuseMap, IN.uv ) * weight[0]; + float4 OUT = TORQUE_TEX2D( diffuseMap, IN.uv ) * weight[0]; for ( int i=1; i < 3; i++ ) { float2 sample = (BLUR_DIR * offset[i]) * oneOverTargetSize; - OUT += tex2D( diffuseMap, IN.uv + sample ) * weight[i]; - OUT += tex2D( diffuseMap, IN.uv - sample ) * weight[i]; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv + sample ) * weight[i]; + OUT += TORQUE_TEX2D(diffuseMap, IN.uv - sample) * weight[i]; } return OUT; diff --git a/Templates/Full/game/shaders/common/lighting/basic/shadowFilterV.hlsl b/Templates/Full/game/shaders/common/lighting/basic/shadowFilterV.hlsl index bf6a36249..c89af7357 100644 --- a/Templates/Full/game/shaders/common/lighting/basic/shadowFilterV.hlsl +++ b/Templates/Full/game/shaders/common/lighting/basic/shadowFilterV.hlsl @@ -27,7 +27,7 @@ float4 rtParams0; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv : TEXCOORD0; }; @@ -35,7 +35,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv = viewportCoordToRenderTarget( IN.uv, rtParams0 ); return OUT; diff --git a/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl b/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl index dd691de23..a187c3c63 100644 --- a/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl +++ b/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterP.hlsl @@ -23,10 +23,12 @@ //***************************************************************************** // Box Filter //***************************************************************************** +#include "../ShaderModel.hlsl" struct ConnectData { - float2 tex0 : TEXCOORD0; + float4 hpos : TORQUE_POSITION; + float2 tex0 : TEXCOORD0; }; // If not defined from ShaderData then define @@ -40,12 +42,12 @@ float log_conv ( float x0, float X, float y0, float Y ) return (X + log(x0 + (y0 * exp(Y - X)))); } -float4 main( ConnectData IN, - uniform sampler2D diffuseMap0 : register(S0), - uniform float texSize : register(C0), - uniform float2 blurDimension : register(C2), - uniform float2 blurBoundaries : register(C3) - ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(diffuseMap0, 0); +uniform float texSize : register(C0); +uniform float2 blurDimension : register(C2); +uniform float2 blurBoundaries : register(C3); + +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // 5x5 if (IN.tex0.x <= blurBoundaries.x) @@ -56,8 +58,8 @@ float4 main( ConnectData IN, float2 texCoord = IN.tex0; - float accum = log_conv(0.3125, tex2D(diffuseMap0, texCoord - sampleOffset), 0.375, tex2D(diffuseMap0, texCoord)); - accum = log_conv(1, accum, 0.3125, tex2D(diffuseMap0, texCoord + sampleOffset)); + float accum = log_conv(0.3125, TORQUE_TEX2D(diffuseMap0, texCoord - sampleOffset), 0.375, tex2D(diffuseMap0, texCoord)); + accum = log_conv(1, accum, 0.3125, TORQUE_TEX2D(diffuseMap0, texCoord + sampleOffset)); return accum; } else { @@ -73,7 +75,7 @@ float4 main( ConnectData IN, return accum; } else { - return tex2D(diffuseMap0, IN.tex0); + return TORQUE_TEX2D(diffuseMap0, IN.tex0); } } } diff --git a/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl b/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl index 75d9af000..3679e41bb 100644 --- a/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl +++ b/Templates/Full/game/shaders/common/lighting/shadowMap/boxFilterV.hlsl @@ -26,15 +26,18 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "../ShaderModel.hlsl" + struct VertData { - float2 texCoord : TEXCOORD0; - float4 position : POSITION; + float3 position : POSITION; + float2 texCoord : TEXCOORD0; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 tex0 : TEXCOORD0; }; @@ -47,7 +50,7 @@ ConnectData main( VertData IN, { ConnectData OUT; - OUT.hpos = mul(modelview, IN.position); + OUT.hpos = mul(modelview, float4(IN.position,1.0)); OUT.tex0 = IN.texCoord; return OUT; diff --git a/Templates/Full/game/shaders/common/particleCompositeP.hlsl b/Templates/Full/game/shaders/common/particleCompositeP.hlsl index 35c2cb4c5..6e26ddbdb 100644 --- a/Templates/Full/game/shaders/common/particleCompositeP.hlsl +++ b/Templates/Full/game/shaders/common/particleCompositeP.hlsl @@ -20,22 +20,30 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- #include "torque.hlsl" +#include "shaderModel.hlsl" -uniform sampler2D colorSource : register(S0); +TORQUE_UNIFORM_SAMPLER2D(colorSource, 0); uniform float4 offscreenTargetParams; #ifdef TORQUE_LINEAR_DEPTH #define REJECT_EDGES -uniform sampler2D edgeSource : register(S1); +TORQUE_UNIFORM_SAMPLER2D(edgeSource, 1); uniform float4 edgeTargetParams; #endif +struct Conn +{ + float4 hpos : TORQUE_POSITION; + float4 offscreenPos : TEXCOORD0; + float4 backbufferPos : TEXCOORD1; +}; -float4 main( float4 offscreenPos : TEXCOORD0, float4 backbufferPos : TEXCOORD1 ) : COLOR + +float4 main(Conn IN) : TORQUE_TARGET0 { // Off-screen particle source screenspace position in XY // Back-buffer screenspace position in ZW - float4 ssPos = float4(offscreenPos.xy / offscreenPos.w, backbufferPos.xy / backbufferPos.w); + float4 ssPos = float4(IN.offscreenPos.xy / IN.offscreenPos.w, IN.backbufferPos.xy / IN.backbufferPos.w); float4 uvScene = ( ssPos + 1.0 ) / 2.0; uvScene.yw = 1.0 - uvScene.yw; @@ -44,10 +52,10 @@ float4 main( float4 offscreenPos : TEXCOORD0, float4 backbufferPos : TEXCOORD1 ) #ifdef REJECT_EDGES // Cut out particles along the edges, this will create the stencil mask uvScene.zw = viewportCoordToRenderTarget(uvScene.zw, edgeTargetParams); - float edge = tex2D( edgeSource, uvScene.zw ).r; + float edge = TORQUE_TEX2D( edgeSource, uvScene.zw ).r; clip( -edge ); #endif // Sample offscreen target and return - return tex2D( colorSource, uvScene.xy ); + return TORQUE_TEX2D( colorSource, uvScene.xy ); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/particleCompositeV.hlsl b/Templates/Full/game/shaders/common/particleCompositeV.hlsl index 87fac0d94..c4c51204a 100644 --- a/Templates/Full/game/shaders/common/particleCompositeV.hlsl +++ b/Templates/Full/game/shaders/common/particleCompositeV.hlsl @@ -20,22 +20,28 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "hlslStructs.h" +#include "shaderModel.hlsl" -struct VertOut +struct Vertex { - float4 hpos : POSITION; + float3 pos : POSITION; + float4 uvCoord : COLOR0; +}; + +struct Conn +{ + float4 hpos : TORQUE_POSITION; float4 offscreenPos : TEXCOORD0; float4 backbufferPos : TEXCOORD1; }; uniform float4 screenRect; // point, extent -VertOut main( float4 uvCoord : COLOR ) +Conn main(Vertex IN) { - VertOut OUT; + Conn OUT; - OUT.hpos = float4(uvCoord.xy, 1.0, 1.0); + OUT.hpos = float4(IN.uvCoord.xy, 1.0, 1.0); OUT.hpos.xy *= screenRect.zw; OUT.hpos.xy += screenRect.xy; diff --git a/Templates/Full/game/shaders/common/particlesP.hlsl b/Templates/Full/game/shaders/common/particlesP.hlsl index 80e3c7105..37439c59a 100644 --- a/Templates/Full/game/shaders/common/particlesP.hlsl +++ b/Templates/Full/game/shaders/common/particlesP.hlsl @@ -21,7 +21,7 @@ //----------------------------------------------------------------------------- #include "torque.hlsl" - +#include "shaderModel.hlsl" // With advanced lighting we get soft particles. #ifdef TORQUE_LINEAR_DEPTH #define SOFTPARTICLES @@ -29,11 +29,11 @@ #ifdef SOFTPARTICLES - #include "shadergen:/autogenConditioners.h" + #include "shaderModelAutoGen.hlsl" uniform float oneOverSoftness; uniform float oneOverFar; - uniform sampler2D prepassTex : register(S1); + TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); //uniform float3 vEye; uniform float4 prePassTargetParams; #endif @@ -42,14 +42,14 @@ struct Conn { + float4 hpos : TORQUE_POSITION; float4 color : TEXCOORD0; float2 uv0 : TEXCOORD1; - float4 pos : TEXCOORD2; + float4 pos : TEXCOORD2; }; -uniform sampler2D diffuseMap : register(S0); - -uniform sampler2D paraboloidLightMap : register(S2); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); +TORQUE_UNIFORM_SAMPLER2D(paraboloidLightMap, 2); float4 lmSample( float3 nrm ) { @@ -69,14 +69,14 @@ float4 lmSample( float3 nrm ) // Atlasing front and back maps, so scale lmCoord.x *= 0.5; - return tex2D(paraboloidLightMap, lmCoord); + return TORQUE_TEX2D(paraboloidLightMap, lmCoord); } uniform float alphaFactor; uniform float alphaScale; -float4 main( Conn IN ) : COLOR +float4 main( Conn IN ) : TORQUE_TARGET0 { float softBlend = 1; @@ -84,7 +84,7 @@ float4 main( Conn IN ) : COLOR float2 tc = IN.pos.xy * float2(1.0, -1.0) / IN.pos.w; tc = viewportCoordToRenderTarget(saturate( ( tc + 1.0 ) * 0.5 ), prePassTargetParams); - float sceneDepth = prepassUncondition( prepassTex, tc ).w; + float sceneDepth = TORQUE_PREPASS_UNCONDITION(prepassTex, tc).w; float depth = IN.pos.w * oneOverFar; float diff = sceneDepth - depth; #ifdef CLIP_Z @@ -96,7 +96,7 @@ float4 main( Conn IN ) : COLOR softBlend = saturate( diff * oneOverSoftness ); #endif - float4 diffuse = tex2D( diffuseMap, IN.uv0 ); + float4 diffuse = TORQUE_TEX2D( diffuseMap, IN.uv0 ); //return float4( lmSample(float3(0, 0, -1)).rgb, IN.color.a * diffuse.a * softBlend * alphaScale); diff --git a/Templates/Full/game/shaders/common/particlesV.hlsl b/Templates/Full/game/shaders/common/particlesV.hlsl index f09604237..dbeff0cc2 100644 --- a/Templates/Full/game/shaders/common/particlesV.hlsl +++ b/Templates/Full/game/shaders/common/particlesV.hlsl @@ -20,16 +20,18 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "shaderModel.hlsl" + struct Vertex { - float4 pos : POSITION; + float3 pos : POSITION; float4 color : COLOR0; float2 uv0 : TEXCOORD0; }; struct Conn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 color : TEXCOORD0; float2 uv0 : TEXCOORD1; float4 pos : TEXCOORD2; @@ -43,8 +45,8 @@ Conn main( Vertex In ) { Conn Out; - Out.hpos = mul( modelViewProj, In.pos ); - Out.pos = mul( fsModelViewProj, In.pos ); + Out.hpos = mul( modelViewProj, float4(In.pos,1.0) ); + Out.pos = mul(fsModelViewProj, float4(In.pos, 1.0) ); Out.color = In.color; Out.uv0 = In.uv0; diff --git a/Templates/Full/game/shaders/common/planarReflectBumpP.hlsl b/Templates/Full/game/shaders/common/planarReflectBumpP.hlsl index a5057db50..d18331fb6 100644 --- a/Templates/Full/game/shaders/common/planarReflectBumpP.hlsl +++ b/Templates/Full/game/shaders/common/planarReflectBumpP.hlsl @@ -23,18 +23,26 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct ConnectData { - float4 texCoord : TEXCOORD0; - float2 tex2 : TEXCOORD1; + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; + float4 tex2 : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(texMap, 0); +TORQUE_UNIFORM_SAMPLER2D(refractMap, 1); +TORQUE_UNIFORM_SAMPLER2D(bumpMap, 2); + //----------------------------------------------------------------------------- // Fade edges of axis for texcoord passed in @@ -54,15 +62,11 @@ float fadeAxis( float val ) //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D refractMap : register(S1), - uniform sampler2D texMap : register(S0), - uniform sampler2D bumpMap : register(S2) -) +Fragout main( ConnectData IN ) { Fragout OUT; - float3 bumpNorm = tex2D( bumpMap, IN.tex2 ) * 2.0 - 1.0; + float3 bumpNorm = TORQUE_TEX2D( bumpMap, IN.tex2 ) * 2.0 - 1.0; float2 offset = float2( bumpNorm.x, bumpNorm.y ); float4 texIndex = IN.texCoord; @@ -74,8 +78,8 @@ Fragout main( ConnectData IN, const float distortion = 0.2; texIndex.xy += offset * distortion * fadeVal; - float4 reflectColor = tex2Dproj( refractMap, texIndex ); - float4 diffuseColor = tex2D( texMap, IN.tex2 ); + float4 reflectColor = TORQUE_TEX2DPROJ( refractMap, texIndex ); + float4 diffuseColor = TORQUE_TEX2D( texMap, IN.tex2 ); OUT.col = diffuseColor + reflectColor * diffuseColor.a; diff --git a/Templates/Full/game/shaders/common/planarReflectBumpV.hlsl b/Templates/Full/game/shaders/common/planarReflectBumpV.hlsl index 108f918ce..d45adb574 100644 --- a/Templates/Full/game/shaders/common/planarReflectBumpV.hlsl +++ b/Templates/Full/game/shaders/common/planarReflectBumpV.hlsl @@ -22,36 +22,37 @@ #define IN_HLSL #include "shdrConsts.h" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { + float3 position : POSITION; + float3 normal : NORMAL; float2 texCoord : TEXCOORD0; float2 lmCoord : TEXCOORD1; float3 T : TEXCOORD2; - float3 B : TEXCOORD3; - float3 normal : NORMAL; - float4 position : POSITION; + float3 B : TEXCOORD3; }; struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoord : TEXCOORD0; float2 tex2 : TEXCOORD1; }; +uniform float4x4 modelview; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertData IN, - uniform float4x4 modelview ) +ConnectData main( VertData IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.position); + OUT.hpos = mul(modelview, float4(IN.position,1.0)); float4x4 texGenTest = { 0.5, 0.0, 0.0, 0.5, 0.0, -0.5, 0.0, 0.5, diff --git a/Templates/Full/game/shaders/common/planarReflectP.hlsl b/Templates/Full/game/shaders/common/planarReflectP.hlsl index 981cc316d..43b420544 100644 --- a/Templates/Full/game/shaders/common/planarReflectP.hlsl +++ b/Templates/Full/game/shaders/common/planarReflectP.hlsl @@ -23,31 +23,34 @@ //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- + +#include "shaderModel.hlsl" + struct ConnectData { - float2 texCoord : TEXCOORD0; - float4 tex2 : TEXCOORD1; + float4 hpos : TORQUE_POSITION; + float2 texCoord : TEXCOORD0; + float4 tex2 : TEXCOORD1; }; struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +TORQUE_UNIFORM_SAMPLER2D(texMap, 0); +TORQUE_UNIFORM_SAMPLER2D(refractMap, 1); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main( ConnectData IN, - uniform sampler2D texMap : register(S0), - uniform sampler2D refractMap : register(S1) -) +Fragout main( ConnectData IN ) { Fragout OUT; - float4 diffuseColor = tex2D( texMap, IN.texCoord ); - float4 reflectColor = tex2Dproj( refractMap, IN.tex2 ); + float4 diffuseColor = TORQUE_TEX2D( texMap, IN.texCoord ); + float4 reflectColor = TORQUE_TEX2DPROJ(refractMap, IN.tex2); OUT.col = diffuseColor + reflectColor * diffuseColor.a; diff --git a/Templates/Full/game/shaders/common/planarReflectV.hlsl b/Templates/Full/game/shaders/common/planarReflectV.hlsl index cd8cb2d96..1f2ca9d4f 100644 --- a/Templates/Full/game/shaders/common/planarReflectV.hlsl +++ b/Templates/Full/game/shaders/common/planarReflectV.hlsl @@ -21,7 +21,8 @@ //----------------------------------------------------------------------------- #define IN_HLSL -#include "hlslStructs.h" +#include "hlslStructs.hlsl" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures @@ -29,20 +30,20 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 texCoord : TEXCOORD0; float4 tex2 : TEXCOORD1; }; +uniform float4x4 modelview; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -ConnectData main( VertexIn_PNTTTB IN, - uniform float4x4 modelview : register(C0) -) +ConnectData main( VertexIn_PNTTTB IN ) { ConnectData OUT; - OUT.hpos = mul(modelview, IN.pos); + OUT.hpos = mul(modelview, float4(IN.pos,1.0)); float4x4 texGenTest = { 0.5, 0.0, 0.0, 0.5, 0.0, -0.5, 0.0, 0.5, diff --git a/Templates/Full/game/shaders/common/postFx/VolFogGlowP.hlsl b/Templates/Full/game/shaders/common/postFx/VolFogGlowP.hlsl index 8a61b5928..c3adb3b55 100644 --- a/Templates/Full/game/shaders/common/postFx/VolFogGlowP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/VolFogGlowP.hlsl @@ -32,12 +32,12 @@ #include "./postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); uniform float strength; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -50,20 +50,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * strength; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Full/game/shaders/common/postFx/caustics/causticsP.hlsl b/Templates/Full/game/shaders/common/postFx/caustics/causticsP.hlsl index c7635027d..d2f4a058a 100644 --- a/Templates/Full/game/shaders/common/postFx/caustics/causticsP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/caustics/causticsP.hlsl @@ -21,25 +21,26 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" +uniform float accumTime; uniform float3 eyePosWorld; uniform float4 rtParams0; uniform float4 waterFogPlane; -uniform float accumTime; + +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); +TORQUE_UNIFORM_SAMPLER2D(causticsTex0, 1); +TORQUE_UNIFORM_SAMPLER2D(causticsTex1, 2); float distanceToPlane(float4 plane, float3 pos) { return (plane.x * pos.x + plane.y * pos.y + plane.z * pos.z) + plane.w; } -float4 main( PFXVertToPix IN, - uniform sampler2D prepassTex :register(S0), - uniform sampler2D causticsTex0 :register(S1), - uniform sampler2D causticsTex1 :register(S2) ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //Sample the pre-pass - float4 prePass = prepassUncondition( prepassTex, IN.uv0 ); + float4 prePass = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ); //Get depth float depth = prePass.w; @@ -65,12 +66,12 @@ float4 main( PFXVertToPix IN, causticsUV1.xy -= float2(accumTime*0.15, timeSin*0.15); //Sample caustics texture - float4 caustics = tex2D(causticsTex0, causticsUV0); - caustics *= tex2D(causticsTex1, causticsUV1); + float4 caustics = TORQUE_TEX2D(causticsTex0, causticsUV0); + caustics *= TORQUE_TEX2D(causticsTex1, causticsUV1); //Use normal Z to modulate caustics //float waterDepth = 1 - saturate(pos.z + waterFogPlane.w + 1); - caustics *= saturate(prePass.z) * pow(1-depth, 64) * waterDepth; + caustics *= saturate(prePass.z) * pow(abs(1-depth), 64) * waterDepth; return caustics; } diff --git a/Templates/Full/game/shaders/common/postFx/chromaticLens.hlsl b/Templates/Full/game/shaders/common/postFx/chromaticLens.hlsl index 5916e985a..8fdca72b7 100644 --- a/Templates/Full/game/shaders/common/postFx/chromaticLens.hlsl +++ b/Templates/Full/game/shaders/common/postFx/chromaticLens.hlsl @@ -26,14 +26,13 @@ #include "./postFx.hlsl" #include "./../torque.hlsl" - -uniform sampler2D backBuffer : register( s0 ); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); uniform float distCoeff; uniform float cubeDistort; uniform float3 colorDistort; -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 tex = IN.uv0; @@ -54,7 +53,7 @@ float4 main( PFXVertToPix IN ) : COLOR0 { float x = distort[i] * ( tex.x - 0.5 ) + 0.5; float y = distort[i] * ( tex.y - 0.5 ) + 0.5; - outColor[i] = tex2Dlod( backBuffer, float4(x,y,0,0) )[i]; + outColor[i] = TORQUE_TEX2DLOD( backBuffer, float4(x,y,0,0) )[i]; } return float4( outColor.rgb, 1 ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl index bc17a2c04..2f5835fc2 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_P.hlsl @@ -23,21 +23,22 @@ #include "./../postFx.hlsl" // These are set by the game engine. -uniform sampler2D shrunkSampler : register(S0); // Output of DofDownsample() -uniform sampler2D blurredSampler : register(S1); // Blurred version of the shrunk sampler +TORQUE_UNIFORM_SAMPLER2D(shrunkSampler, 0); // Output of DofDownsample() +TORQUE_UNIFORM_SAMPLER2D(blurredSampler, 1); // Blurred version of the shrunk sampler + // This is the pixel shader function that calculates the actual // value used for the near circle of confusion. // "texCoords" are 0 at the bottom left pixel and 1 at the top right. -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float3 color; float coc; half4 blurred; half4 shrunk; - shrunk = tex2D( shrunkSampler, IN.uv0 ); - blurred = tex2D( blurredSampler, IN.uv1 ); + shrunk = half4(TORQUE_TEX2D( shrunkSampler, IN.uv0 )); + blurred = half4(TORQUE_TEX2D( blurredSampler, IN.uv1 )); color = shrunk.rgb; //coc = shrunk.a; //coc = blurred.a; diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl index 40cec49de..8131e45cd 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_CalcCoC_V.hlsl @@ -57,7 +57,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl index 37e591f25..8c9028654 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_P.hlsl @@ -20,22 +20,23 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModel.hlsl" +#include "../../shaderModelAutoGen.hlsl" // These are set by the game engine. // The render target size is one-quarter the scene rendering size. -uniform sampler2D colorSampler : register(S0); -uniform sampler2D depthSampler : register(S1); -uniform float2 dofEqWorld; -uniform float depthOffset; +TORQUE_UNIFORM_SAMPLER2D(colorSampler, 0); +TORQUE_UNIFORM_SAMPLER2D(depthSampler, 1); +uniform float2 dofEqWorld; uniform float2 targetSize; +uniform float depthOffset; uniform float maxWorldCoC; //uniform float2 dofEqWeapon; //uniform float2 dofRowDelta; // float2( 0, 0.25 / renderTargetHeight ) struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float2 tcColor0 : TEXCOORD0; float2 tcColor1 : TEXCOORD1; float2 tcDepth0 : TEXCOORD2; @@ -44,7 +45,7 @@ struct Pixel float2 tcDepth3 : TEXCOORD5; }; -half4 main( Pixel IN ) : COLOR +half4 main( Pixel IN ) : TORQUE_TARGET0 { //return float4( 1.0, 0.0, 1.0, 1.0 ); @@ -69,57 +70,64 @@ half4 main( Pixel IN ) : COLOR // Use bilinear filtering to average 4 color samples for free. color = 0; - color += tex2D( colorSampler, IN.tcColor0.xy + rowOfs[0] ).rgb; - color += tex2D( colorSampler, IN.tcColor1.xy + rowOfs[0] ).rgb; - color += tex2D( colorSampler, IN.tcColor0.xy + rowOfs[2] ).rgb; - color += tex2D( colorSampler, IN.tcColor1.xy + rowOfs[2] ).rgb; + color += half3(TORQUE_TEX2D( colorSampler, IN.tcColor0.xy + rowOfs[0] ).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor1.xy + rowOfs[0]).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor0.xy + rowOfs[2]).rgb); + color += half3(TORQUE_TEX2D(colorSampler, IN.tcColor1.xy + rowOfs[2]).rgb); color /= 4; + //declare thse here to save doing it in each loop below + half4 zero4 = half4(0, 0, 0, 0); + coc = zero4; + half4 dofEqWorld4X = half4(dofEqWorld.xxxx); + half4 dofEqWorld4Y = half4(dofEqWorld.yyyy); + half4 maxWorldCoC4 = half4(maxWorldCoC, maxWorldCoC, maxWorldCoC, maxWorldCoC); // Process 4 samples at a time to use vector hardware efficiently. // The CoC will be 1 if the depth is negative, so use "min" to pick - // between "sceneCoc" and "viewCoc". - - for ( int i = 0; i < 4; i++ ) + // between "sceneCoc" and "viewCoc". + [unroll] // coc[i] causes this anyway + for (int i = 0; i < 4; i++) { - depth[0] = prepassUncondition( depthSampler, float4( IN.tcDepth0.xy + rowOfs[i], 0, 0 ) ).w; - depth[1] = prepassUncondition( depthSampler, float4( IN.tcDepth1.xy + rowOfs[i], 0, 0 ) ).w; - depth[2] = prepassUncondition( depthSampler, float4( IN.tcDepth2.xy + rowOfs[i], 0, 0 ) ).w; - depth[3] = prepassUncondition( depthSampler, float4( IN.tcDepth3.xy + rowOfs[i], 0, 0 ) ).w; - coc[i] = clamp( dofEqWorld.x * depth + dofEqWorld.y, 0.0, maxWorldCoC ); - } + depth[0] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth0.xy + rowOfs[i])).w; + depth[1] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth1.xy + rowOfs[i])).w; + depth[2] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth2.xy + rowOfs[i])).w; + depth[3] = TORQUE_PREPASS_UNCONDITION(depthSampler, (IN.tcDepth3.xy + rowOfs[i])).w; + + coc = max(coc, clamp(dofEqWorld4X * half4(depth)+dofEqWorld4Y, zero4, maxWorldCoC4)); + } /* - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[0] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[0] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[0] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[0] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[0] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[0] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[0] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[0] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = curCoc; - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[1] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[1] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[1] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[1] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[1] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[1] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[1] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[1] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = max( coc, curCoc ); - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[2] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[2] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[2] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[2] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[2] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[2] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[2] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[2] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); coc = max( coc, curCoc ); - depth[0] = tex2D( depthSampler, pixel.tcDepth0.xy + rowOfs[3] ).r; - depth[1] = tex2D( depthSampler, pixel.tcDepth1.xy + rowOfs[3] ).r; - depth[2] = tex2D( depthSampler, pixel.tcDepth2.xy + rowOfs[3] ).r; - depth[3] = tex2D( depthSampler, pixel.tcDepth3.xy + rowOfs[3] ).r; + depth[0] = TORQUE_TEX2D( depthSampler, pixel.tcDepth0.xy + rowOfs[3] ).r; + depth[1] = TORQUE_TEX2D( depthSampler, pixel.tcDepth1.xy + rowOfs[3] ).r; + depth[2] = TORQUE_TEX2D( depthSampler, pixel.tcDepth2.xy + rowOfs[3] ).r; + depth[3] = TORQUE_TEX2D( depthSampler, pixel.tcDepth3.xy + rowOfs[3] ).r; viewCoc = saturate( dofEqWeapon.x * -depth + dofEqWeapon.y ); sceneCoc = saturate( dofEqWorld.x * depth + dofEqWorld.y ); curCoc = min( viewCoc, sceneCoc ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl index da2a79fb4..0b3ec01e2 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_DownSample_V.hlsl @@ -25,14 +25,14 @@ struct Vert { - float4 pos : POSITION; + float3 pos : POSITION; float2 tc : TEXCOORD0; float3 wsEyeRay : TEXCOORD1; }; struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float2 tcColor0 : TEXCOORD0; float2 tcColor1 : TEXCOORD1; float2 tcDepth0 : TEXCOORD2; @@ -47,7 +47,7 @@ uniform float2 oneOverTargetSize; Pixel main( Vert IN ) { Pixel OUT; - OUT.position = IN.pos; + OUT.position = float4(IN.pos,1.0); float2 uv = viewportCoordToRenderTarget( IN.tc, rtParams0 ); //OUT.position = mul( IN.pos, modelView ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_P.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_P.hlsl index 36622495c..cb7342d40 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_P.hlsl @@ -20,13 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "./../postFx.hlsl" -uniform sampler2D colorSampler : register(S0); // Original source image -uniform sampler2D smallBlurSampler : register(S1); // Output of SmallBlurPS() -uniform sampler2D largeBlurSampler : register(S2); // Blurred output of DofDownsample() -uniform sampler2D depthSampler : register(S3); // +TORQUE_UNIFORM_SAMPLER2D(colorSampler,0); // Original source image +TORQUE_UNIFORM_SAMPLER2D(smallBlurSampler,1); // Output of SmallBlurPS() +TORQUE_UNIFORM_SAMPLER2D(largeBlurSampler,2); // Blurred output of DofDownsample() +TORQUE_UNIFORM_SAMPLER2D(depthSampler,3); + uniform float2 oneOverTargetSize; uniform float4 dofLerpScale; uniform float4 dofLerpBias; @@ -40,9 +41,9 @@ uniform float maxFarCoC; //static float4 dofLerpBias = float4( 1.0, (1.0 - d2) / d1, 1.0 / d2, (d2 - 1.0) / d2 ); //static float3 dofEqFar = float3( 2.0, 0.0, 1.0 ); -float4 tex2Doffset( sampler2D s, float2 tc, float2 offset ) +float4 tex2Doffset(TORQUE_SAMPLER2D(s), float2 tc, float2 offset) { - return tex2D( s, tc + offset * oneOverTargetSize ); + return TORQUE_TEX2D( s, tc + offset * oneOverTargetSize ); } half3 GetSmallBlurSample( float2 tc ) @@ -51,10 +52,10 @@ half3 GetSmallBlurSample( float2 tc ) const half weight = 4.0 / 17; sum = 0; // Unblurred sample done by alpha blending //sum += weight * tex2Doffset( colorSampler, tc, float2( 0, 0 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( +0.5, -1.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( -1.5, -0.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( -0.5, +1.5 ) ).rgb; - sum += weight * tex2Doffset( colorSampler, tc, float2( +1.5, +0.5 ) ).rgb; + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(+0.5, -1.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(-1.5, -0.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(-0.5, +1.5)).rgb); + sum += weight * half3(tex2Doffset(TORQUE_SAMPLER2D_MAKEARG(colorSampler), tc, float2(+1.5, +0.5)).rgb); return sum; } @@ -72,7 +73,7 @@ half4 InterpolateDof( half3 small, half3 med, half3 large, half t ) //float4 dofLerpScale = float4( -1 / d0, -1 / d1, -1 / d2, 1 / d2 ); //float4 dofLerpBias = float4( 1, (1 d2) / d1, 1 / d2, (d2 1) / d2 ); - weights = saturate( t * dofLerpScale + dofLerpBias ); + weights = half4(saturate( t * dofLerpScale + dofLerpBias )); weights.yz = min( weights.yz, 1 - weights.xy ); // Unblurred sample with weight "weights.x" done by alpha blending @@ -84,11 +85,11 @@ half4 InterpolateDof( half3 small, half3 med, half3 large, half t ) return half4( color, alpha ); } -half4 main( PFXVertToPix IN ) : COLOR +half4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //return half4( 1,0,1,1 ); - //return half4( tex2D( colorSampler, IN.uv0 ).rgb, 1.0 ); - //return half4( tex2D( colorSampler, texCoords ).rgb, 0 ); + //return half4( TORQUE_TEX2D( colorSampler, IN.uv0 ).rgb, 1.0 ); + //return half4( TORQUE_TEX2D( colorSampler, texCoords ).rgb, 0 ); half3 small; half4 med; half3 large; @@ -100,10 +101,10 @@ half4 main( PFXVertToPix IN ) : COLOR small = GetSmallBlurSample( IN.uv0 ); //small = half3( 1,0,0 ); //return half4( small, 1.0 ); - med = tex2D( smallBlurSampler, IN.uv1 ); + med = half4(TORQUE_TEX2D( smallBlurSampler, IN.uv1 )); //med.rgb = half3( 0,1,0 ); //return half4(med.rgb, 0.0); - large = tex2D( largeBlurSampler, IN.uv2 ).rgb; + large = half3(TORQUE_TEX2D(largeBlurSampler, IN.uv2).rgb); //large = half3( 0,0,1 ); //return large; //return half4(large.rgb,1.0); @@ -114,7 +115,7 @@ half4 main( PFXVertToPix IN ) : COLOR //med.rgb = large; //nearCoc = 0; - depth = prepassUncondition( depthSampler, float4( IN.uv3, 0, 0 ) ).w; + depth = half(TORQUE_PREPASS_UNCONDITION( depthSampler, IN.uv3 ).w); //return half4(depth.rrr,1); //return half4(nearCoc.rrr,1.0); @@ -128,8 +129,8 @@ half4 main( PFXVertToPix IN ) : COLOR // dofEqFar.x and dofEqFar.y specify the linear ramp to convert // to depth for the distant out-of-focus region. // dofEqFar.z is the ratio of the far to the near blur radius. - farCoc = clamp( dofEqFar.x * depth + dofEqFar.y, 0.0, maxFarCoC ); - coc = max( nearCoc, farCoc * dofEqFar.z ); + farCoc = half(clamp( dofEqFar.x * depth + dofEqFar.y, 0.0, maxFarCoC )); + coc = half(max( nearCoc, farCoc * dofEqFar.z )); //coc = nearCoc; } diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_V.hlsl index 91dfba0a2..86c93701a 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_Final_V.hlsl @@ -59,7 +59,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); // + float2( -5, 1 ) * oneOverTargetSize; OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl index 084a2c014..f4d29f3e1 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_P.hlsl @@ -22,11 +22,11 @@ #include "./../postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -39,20 +39,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * 0.5 / 1.3; //25f; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl index e29746e96..b2d4582e0 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_Gausian_V.hlsl @@ -24,13 +24,13 @@ #include "./../../torque.hlsl" -uniform float2 texSize0; uniform float4 rtParams0; +uniform float2 texSize0; uniform float2 oneOverTargetSize; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -47,7 +47,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); IN.uv = viewportCoordToRenderTarget( IN.uv, rtParams0 ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl index 40cec49de..8131e45cd 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_Passthrough_V.hlsl @@ -57,7 +57,7 @@ PFXVertToPix main( PFXVert IN ) */ - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); OUT.uv1 = viewportCoordToRenderTarget( IN.uv, rtParams1 ); OUT.uv2 = viewportCoordToRenderTarget( IN.uv, rtParams2 ); diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl index 6d4144576..175525a91 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_P.hlsl @@ -24,22 +24,23 @@ // colorMapSampler, which is the same size as the render target. // The sample weights are 1/16 in the corners, 2/16 on the edges, // and 4/16 in the center. +#include "../../shaderModel.hlsl" -uniform sampler2D colorSampler; // Output of DofNearCoc() +TORQUE_UNIFORM_SAMPLER2D(colorSampler, 0); // Output of DofNearCoc() struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float4 texCoords : TEXCOORD0; }; -float4 main( Pixel IN ) : COLOR +float4 main( Pixel IN ) : TORQUE_TARGET0 { float4 color; color = 0.0; - color += tex2D( colorSampler, IN.texCoords.xz ); - color += tex2D( colorSampler, IN.texCoords.yz ); - color += tex2D( colorSampler, IN.texCoords.xw ); - color += tex2D( colorSampler, IN.texCoords.yw ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.xz ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.yz ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.xw ); + color += TORQUE_TEX2D( colorSampler, IN.texCoords.yw ); return color / 4.0; } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl b/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl index 204f4639d..3edb1ec2a 100644 --- a/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/dof/DOF_SmallBlur_V.hlsl @@ -30,13 +30,13 @@ struct Vert { - float4 position : POSITION; + float3 position : POSITION; float2 texCoords : TEXCOORD0; }; struct Pixel { - float4 position : POSITION; + float4 position : TORQUE_POSITION; float4 texCoords : TEXCOORD0; }; @@ -47,7 +47,7 @@ Pixel main( Vert IN ) { Pixel OUT; const float4 halfPixel = { -0.5, 0.5, -0.5, 0.5 }; - OUT.position = IN.position; //Transform_ObjectToClip( IN.position ); + OUT.position = float4(IN.position,1.0); //Transform_ObjectToClip( IN.position ); //float2 uv = IN.texCoords + rtParams0.xy; float2 uv = viewportCoordToRenderTarget( IN.texCoords, rtParams0 ); diff --git a/Templates/Full/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl b/Templates/Full/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl index 90cf391dc..fbd529031 100644 --- a/Templates/Full/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/edgeaa/dbgEdgeDisplayP.hlsl @@ -21,10 +21,10 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -float4 main( PFXVertToPix IN, - uniform sampler2D edgeBuffer :register(S0) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(edgeBuffer); + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return float4( tex2D( edgeBuffer, IN.uv0 ).rrr, 1.0 ); + return float4( TORQUE_TEX2D( edgeBuffer, IN.uv0 ).rrr, 1.0 ); } \ No newline at end of file diff --git a/Templates/Full/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl b/Templates/Full/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl index e45684199..f5a71687d 100644 --- a/Templates/Full/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/edgeaa/edgeAAP.hlsl @@ -21,17 +21,17 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -float4 main( PFXVertToPix IN, - uniform sampler2D edgeBuffer : register(S0), - uniform sampler2D backBuffer : register(S1), - uniform float2 targetSize : register(C0) ) : COLOR0 +TORQUE_UNIFORM_SAMPLER2D(edgeBuffer,0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 1); +uniform float2 targetSize; + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 pixelSize = 1.0 / targetSize; // Sample edge buffer, bail if not on an edge - float edgeSample = tex2D(edgeBuffer, IN.uv0).r; + float edgeSample = TORQUE_TEX2D(edgeBuffer, IN.uv0).r; clip(edgeSample - 1e-6); // Ok we're on an edge, so multi-tap sample, average, and return @@ -58,7 +58,7 @@ float4 main( PFXVertToPix IN, float2 offsetUV = IN.uv1 + edgeSample * ( offsets[i] * 0.5 ) * pixelSize;//rtWidthHeightInvWidthNegHeight.zw; //offsetUV *= 0.999; - accumColor+= tex2D(backBuffer, offsetUV); + accumColor += TORQUE_TEX2D(backBuffer, offsetUV); } accumColor /= 9.0; diff --git a/Templates/Full/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl b/Templates/Full/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl index bc79516ee..2277126a8 100644 --- a/Templates/Full/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/edgeaa/edgeDetectP.hlsl @@ -21,10 +21,12 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" + +TORQUE_UNIFORM_SAMPLER2D(prepassBuffer,0); // GPU Gems 3, pg 443-444 -float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize) +float GetEdgeWeight(float2 uv0, in float2 targetSize) { float2 offsets[9] = { float2( 0.0, 0.0), @@ -44,10 +46,11 @@ float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize float Depth[9]; float3 Normal[9]; + [unroll] //no getting around this, may as well save the annoying warning message for(int i = 0; i < 9; i++) { float2 uv = uv0 + offsets[i] * PixelSize; - float4 gbSample = prepassUncondition( prepassBuffer, uv ); + float4 gbSample = TORQUE_PREPASS_UNCONDITION( prepassBuffer, uv ); Depth[i] = gbSample.a; Normal[i] = gbSample.rgb; } @@ -82,9 +85,9 @@ float GetEdgeWeight(float2 uv0, in sampler2D prepassBuffer, in float2 targetSize return dot(normalResults, float4(1.0, 1.0, 1.0, 1.0)) * 0.25; } -float4 main( PFXVertToPix IN, - uniform sampler2D prepassBuffer :register(S0), - uniform float2 targetSize : register(C0) ) : COLOR0 +uniform float2 targetSize; + +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - return GetEdgeWeight(IN.uv0, prepassBuffer, targetSize );//rtWidthHeightInvWidthNegHeight.zw); + return GetEdgeWeight(IN.uv0, targetSize);//rtWidthHeightInvWidthNegHeight.zw); } diff --git a/Templates/Full/game/shaders/common/postFx/flashP.hlsl b/Templates/Full/game/shaders/common/postFx/flashP.hlsl index 3d9c6c744..93daf3c26 100644 --- a/Templates/Full/game/shaders/common/postFx/flashP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/flashP.hlsl @@ -25,11 +25,11 @@ uniform float damageFlash; uniform float whiteOut; -uniform sampler2D backBuffer : register(S0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); -float4 main(PFXVertToPix IN) : COLOR0 +float4 main(PFXVertToPix IN) : TORQUE_TARGET0 { - float4 color1 = tex2D(backBuffer, IN.uv0); + float4 color1 = TORQUE_TEX2D(backBuffer, IN.uv0); float4 color2 = color1 * MUL_COLOR; float4 damage = lerp(color1,color2,damageFlash); return lerp(damage,WHITE_COLOR,whiteOut); diff --git a/Templates/Full/game/shaders/common/postFx/fogP.hlsl b/Templates/Full/game/shaders/common/postFx/fogP.hlsl index 0eba9a7b7..b54eea97a 100644 --- a/Templates/Full/game/shaders/common/postFx/fogP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/fogP.hlsl @@ -20,20 +20,21 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" + #include "./postFx.hlsl" #include "./../torque.hlsl" +#include "./../shaderModelAutoGen.hlsl" -uniform sampler2D prepassTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 0); uniform float3 eyePosWorld; uniform float4 fogColor; uniform float3 fogData; uniform float4 rtParams0; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { //float2 prepassCoord = ( IN.uv0.xy * rtParams0.zw ) + rtParams0.xy; - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; //return float4( depth, 0, 0, 0.7 ); float factor = computeSceneFog( eyePosWorld, diff --git a/Templates/Full/game/shaders/common/postFx/fxaa/fxaaP.hlsl b/Templates/Full/game/shaders/common/postFx/fxaa/fxaaP.hlsl index 357b794e4..269bfea67 100644 --- a/Templates/Full/game/shaders/common/postFx/fxaa/fxaaP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/fxaa/fxaaP.hlsl @@ -20,38 +20,53 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../../shaderModel.hlsl" + #define FXAA_PC 1 +#if (TORQUE_SM <= 30) #define FXAA_HLSL_3 1 +#elif TORQUE_SM < 49 +#define FXAA_HLSL_4 1 +#elif TORQUE_SM >=50 +#define FXAA_HLSL_5 1 +#endif #define FXAA_QUALITY__PRESET 12 #define FXAA_GREEN_AS_LUMA 1 #include "Fxaa3_11.h" -#include "../postFx.hlsl" struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; -uniform sampler2D colorTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(colorTex, 0); uniform float2 oneOverTargetSize; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { +#if (TORQUE_SM >= 10 && TORQUE_SM <=30) + FxaaTex tex = colorTex; +#elif TORQUE_SM >=40 + FxaaTex tex; + tex.smpl = colorTex; + tex.tex = texture_colorTex; +#endif + return FxaaPixelShader( IN.uv0, // vertex position 0, // Unused... console stuff - colorTex, // The color back buffer + tex, // The color back buffer - colorTex, // Used for 360 optimization + tex, // Used for 360 optimization - colorTex, // Used for 360 optimization + tex, // Used for 360 optimization oneOverTargetSize, diff --git a/Templates/Full/game/shaders/common/postFx/fxaa/fxaaV.hlsl b/Templates/Full/game/shaders/common/postFx/fxaa/fxaaV.hlsl index ea2c3d106..3bef0a4d3 100644 --- a/Templates/Full/game/shaders/common/postFx/fxaa/fxaaV.hlsl +++ b/Templates/Full/game/shaders/common/postFx/fxaa/fxaaV.hlsl @@ -25,7 +25,7 @@ struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; }; @@ -35,7 +35,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1); OUT.uv0 = viewportCoordToRenderTarget( IN.uv, rtParams0 ); return OUT; diff --git a/Templates/Full/game/shaders/common/postFx/gammaP.hlsl b/Templates/Full/game/shaders/common/postFx/gammaP.hlsl index 20196548b..6e284eb88 100644 --- a/Templates/Full/game/shaders/common/postFx/gammaP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/gammaP.hlsl @@ -24,21 +24,21 @@ #include "./postFx.hlsl" #include "../torque.hlsl" -uniform sampler2D backBuffer : register(S0); -uniform sampler1D colorCorrectionTex : register( s1 ); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 1); uniform float OneOverGamma; uniform float Brightness; uniform float Contrast; -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 color = tex2D(backBuffer, IN.uv0.xy); + float4 color = TORQUE_TEX2D(backBuffer, IN.uv0.xy); // Apply the color correction. - color.r = tex1D( colorCorrectionTex, color.r ).r; - color.g = tex1D( colorCorrectionTex, color.g ).g; - color.b = tex1D( colorCorrectionTex, color.b ).b; + color.r = TORQUE_TEX1D( colorCorrectionTex, color.r ).r; + color.g = TORQUE_TEX1D( colorCorrectionTex, color.g ).g; + color.b = TORQUE_TEX1D( colorCorrectionTex, color.b ).b; // Apply gamma correction color.rgb = pow( abs(color.rgb), OneOverGamma ); diff --git a/Templates/Full/game/shaders/common/postFx/glowBlurP.hlsl b/Templates/Full/game/shaders/common/postFx/glowBlurP.hlsl index 65ae96c6f..80f8ed02d 100644 --- a/Templates/Full/game/shaders/common/postFx/glowBlurP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/glowBlurP.hlsl @@ -22,11 +22,11 @@ #include "./postFx.hlsl" -uniform sampler2D diffuseMap : register(S0); +TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0); struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -39,20 +39,20 @@ struct VertToPix float2 uv7 : TEXCOORD7; }; -float4 main( VertToPix IN ) : COLOR +float4 main( VertToPix IN ) : TORQUE_TARGET0 { float4 kernel = float4( 0.175, 0.275, 0.375, 0.475 ) * 0.5f; float4 OUT = 0; - OUT += tex2D( diffuseMap, IN.uv0 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv1 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv2 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv3 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv0 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv1 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv2 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv3 ) * kernel.w; - OUT += tex2D( diffuseMap, IN.uv4 ) * kernel.x; - OUT += tex2D( diffuseMap, IN.uv5 ) * kernel.y; - OUT += tex2D( diffuseMap, IN.uv6 ) * kernel.z; - OUT += tex2D( diffuseMap, IN.uv7 ) * kernel.w; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv4 ) * kernel.x; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv5 ) * kernel.y; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv6 ) * kernel.z; + OUT += TORQUE_TEX2D( diffuseMap, IN.uv7 ) * kernel.w; // Calculate a lumenance value in the alpha so we // can use alpha test to save fillrate. diff --git a/Templates/Full/game/shaders/common/postFx/glowBlurV.hlsl b/Templates/Full/game/shaders/common/postFx/glowBlurV.hlsl index c9c9052ec..b8f5cf9c2 100644 --- a/Templates/Full/game/shaders/common/postFx/glowBlurV.hlsl +++ b/Templates/Full/game/shaders/common/postFx/glowBlurV.hlsl @@ -28,7 +28,7 @@ uniform float2 texSize0; struct VertToPix { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 uv0 : TEXCOORD0; float2 uv1 : TEXCOORD1; @@ -45,7 +45,7 @@ VertToPix main( PFXVert IN ) { VertToPix OUT; - OUT.hpos = IN.pos; + OUT.hpos = float4(IN.pos,1.0); float2 uv = IN.uv + (0.5f / texSize0); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl index c28f9eb83..77f4b9915 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurHP.hlsl @@ -21,9 +21,8 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; uniform float gaussMultiplier; uniform float gaussMean; @@ -48,7 +47,7 @@ float computeGaussianValue( float x, float mean, float std_deviation ) return tmp * tmp2; } -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 color = { 0.0f, 0.0f, 0.0f, 0.0f }; float offset = 0; @@ -62,7 +61,7 @@ float4 main( PFXVertToPix IN ) : COLOR offset = (i - 4.0) * oneOverTargetSize.x; x = (i - 4.0) / 4.0; weight = gaussMultiplier * computeGaussianValue( x, gaussMean, gaussStdDev ); - color += (tex2D( inputTex, IN.uv0 + float2( offset, 0.0f ) ) * weight ); + color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( offset, 0.0f ) ) * weight ); } return float4( color.rgb, 1.0f ); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl index 93e6b8382..8381f6a5d 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/bloomGaussBlurVP.hlsl @@ -21,9 +21,8 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; uniform float gaussMultiplier; uniform float gaussMean; @@ -47,7 +46,7 @@ float computeGaussianValue( float x, float mean, float std_deviation ) return tmp * tmp2; } -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 color = { 0.0f, 0.0f, 0.0f, 0.0f }; float offset = 0; @@ -61,7 +60,7 @@ float4 main( PFXVertToPix IN ) : COLOR offset = (fI - 4.0) * oneOverTargetSize.y; x = (fI - 4.0) / 4.0; weight = gaussMultiplier * computeGaussianValue( x, gaussMean, gaussStdDev ); - color += (tex2D( inputTex, IN.uv0 + float2( 0.0f, offset ) ) * weight ); + color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( 0.0f, offset ) ) * weight ); } return float4( color.rgb, 1.0f ); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl index c438a5153..9a8a93e97 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/brightPassFilterP.hlsl @@ -21,12 +21,11 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" #include "../../torque.hlsl" -uniform sampler2D inputTex : register(S0); -uniform sampler2D luminanceTex : register(S1); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); +TORQUE_UNIFORM_SAMPLER2D(luminanceTex, 1); uniform float2 oneOverTargetSize; uniform float brightPassThreshold; uniform float g_fMiddleGray; @@ -40,17 +39,17 @@ static float2 gTapOffsets[4] = { -0.5, -0.5 }, { 0.5, 0.5 } }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 average = { 0.0f, 0.0f, 0.0f, 0.0f }; // Combine and average 4 samples from the source HDR texture. for( int i = 0; i < 4; i++ ) - average += hdrDecode( tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * oneOverTargetSize ) ) ); + average += hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * oneOverTargetSize ) ) ); average *= 0.25f; // Determine the brightness of this particular pixel. - float adaptedLum = tex2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; + float adaptedLum = TORQUE_TEX2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; float lum = (g_fMiddleGray / (adaptedLum + 0.0001)) * hdrLuminance( average.rgb ); //float lum = hdrLuminance( average.rgb ); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl index 3f443611c..0f895070a 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/calculateAdaptedLumP.hlsl @@ -21,18 +21,17 @@ //----------------------------------------------------------------------------- #include "../postFx.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D currLum : register( S0 ); -uniform sampler2D lastAdaptedLum : register( S1 ); +TORQUE_UNIFORM_SAMPLER2D(currLum, 0); +TORQUE_UNIFORM_SAMPLER2D(lastAdaptedLum, 1); uniform float adaptRate; uniform float deltaTime; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float fAdaptedLum = tex2D( lastAdaptedLum, float2(0.5f, 0.5f) ).r; - float fCurrentLum = tex2D( currLum, float2(0.5f, 0.5f) ).r; + float fAdaptedLum = TORQUE_TEX2D( lastAdaptedLum, float2(0.5f, 0.5f) ).r; + float fCurrentLum = TORQUE_TEX2D( currLum, float2(0.5f, 0.5f) ).r; // The user's adapted luminance level is simulated by closing the gap between // adapted luminance and current luminance by 2% every frame, based on a diff --git a/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4P.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4P.hlsl index 3ce68452c..01998af0b 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4P.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4P.hlsl @@ -29,23 +29,24 @@ //----------------------------------------------------------------------------- struct VertIn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoords[8] : TEXCOORD0; }; + +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( VertIn IN, - uniform sampler2D inputTex : register(S0) ) : COLOR +float4 main( VertIn IN) : TORQUE_TARGET0 { // We calculate the texture coords // in the vertex shader as an optimization. float4 sample = 0.0f; for ( int i = 0; i < 8; i++ ) { - sample += tex2D( inputTex, IN.texCoords[i].xy ); - sample += tex2D( inputTex, IN.texCoords[i].zw ); + sample += TORQUE_TEX2D( inputTex, IN.texCoords[i].xy ); + sample += TORQUE_TEX2D( inputTex, IN.texCoords[i].zw ); } return sample / 16; diff --git a/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4V.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4V.hlsl index 88794204e..c9a34b7f4 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4V.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/downScale4x4V.hlsl @@ -29,19 +29,20 @@ struct Conn { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float4 texCoords[8] : TEXCOORD0; }; +uniform float2 targetSize; + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Conn main( PFXVert In, - uniform float2 targetSize : register(C0) ) +Conn main( PFXVert In ) { Conn Out; - Out.hpos = In.pos; + Out.hpos = float4(In.pos,1.0); // Sample from the 16 surrounding points. Since the center point will be in // the exact center of 16 texels, a 0.5f offset is needed to specify a texel diff --git a/Templates/Full/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl index cb71f01c2..b786b3f6a 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/finalPassCombineP.hlsl @@ -20,15 +20,15 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" #include "../../torque.hlsl" #include "../postFx.hlsl" +#include "../../shaderModelAutoGen.hlsl" -uniform sampler2D sceneTex : register( s0 ); -uniform sampler2D luminanceTex : register( s1 ); -uniform sampler2D bloomTex : register( s2 ); -uniform sampler1D colorCorrectionTex : register( s3 ); -uniform sampler2D prepassTex : register(S4); +TORQUE_UNIFORM_SAMPLER2D(sceneTex, 0); +TORQUE_UNIFORM_SAMPLER2D(luminanceTex, 1); +TORQUE_UNIFORM_SAMPLER2D(bloomTex, 2); +TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 3); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 4); uniform float2 texSize0; uniform float2 texSize2; @@ -36,22 +36,20 @@ uniform float2 texSize2; uniform float g_fEnableToneMapping; uniform float g_fMiddleGray; uniform float g_fWhiteCutoff; - uniform float g_fEnableBlueShift; -uniform float3 g_fBlueShiftColor; +uniform float3 g_fBlueShiftColor; uniform float g_fBloomScale; uniform float g_fOneOverGamma; uniform float Brightness; uniform float Contrast; - -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 sample = hdrDecode( tex2D( sceneTex, IN.uv0 ) ); - float adaptedLum = tex2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; - float4 bloom = tex2D( bloomTex, IN.uv0 ); + float4 sample = hdrDecode( TORQUE_TEX2D( sceneTex, IN.uv0 ) ); + float adaptedLum = TORQUE_TEX2D( luminanceTex, float2( 0.5f, 0.5f ) ).r; + float4 bloom = TORQUE_TEX2D( bloomTex, IN.uv0 ); // For very low light conditions, the rods will dominate the perception // of light, and therefore color will be desaturated and shifted @@ -85,14 +83,14 @@ float4 main( PFXVertToPix IN ) : COLOR0 } // Add the bloom effect. - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; if (depth>0.9999) sample += g_fBloomScale * bloom; // Apply the color correction. - sample.r = tex1D( colorCorrectionTex, sample.r ).r; - sample.g = tex1D( colorCorrectionTex, sample.g ).g; - sample.b = tex1D( colorCorrectionTex, sample.b ).b; + sample.r = TORQUE_TEX1D( colorCorrectionTex, sample.r ).r; + sample.g = TORQUE_TEX1D( colorCorrectionTex, sample.g ).g; + sample.b = TORQUE_TEX1D( colorCorrectionTex, sample.b ).b; // Apply gamma correction diff --git a/Templates/Full/game/shaders/common/postFx/hdr/luminanceVisP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/luminanceVisP.hlsl index 593a24e7b..505d1b825 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/luminanceVisP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/luminanceVisP.hlsl @@ -22,15 +22,14 @@ #include "../postFx.hlsl" #include "../../torque.hlsl" -#include "shadergen:/autogenConditioners.h" -uniform sampler2D inputTex : register(S0); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float brightPassThreshold; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { - float4 sample = hdrDecode( tex2D( inputTex, IN.uv0 ) ); + float4 sample = hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 ) ); // Determine the brightness of this particular pixel. float lum = hdrLuminance( sample.rgb ); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl index 39fd9dccc..2e23ece1f 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/sampleLumInitialP.hlsl @@ -23,7 +23,7 @@ #include "../../torque.hlsl" #include "../postFx.hlsl" -uniform sampler2D inputTex : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 texSize0; uniform float g_fMinLuminace; @@ -36,7 +36,7 @@ static float2 gTapOffsets[9] = }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 tsize = 1.0 / texSize0; @@ -46,7 +46,7 @@ float4 main( PFXVertToPix IN ) : COLOR for ( int i = 0; i < 9; i++ ) { // Decode the hdr value. - sample = hdrDecode( tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * tsize ) ).rgb ); + sample = hdrDecode( TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * tsize ) ).rgb ); // Get the luminance and add it to the average. float lum = max( hdrLuminance( sample ), g_fMinLuminace ); diff --git a/Templates/Full/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl b/Templates/Full/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl index 59e91f0db..46ed6fc70 100644 --- a/Templates/Full/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/hdr/sampleLumIterativeP.hlsl @@ -22,7 +22,7 @@ #include "../postFx.hlsl" -uniform sampler2D inputTex : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(inputTex, 0); uniform float2 oneOverTargetSize; @@ -34,7 +34,7 @@ static float2 gTapOffsets[16] = { -1.5, 1.5 }, { -0.5, 1.5 }, { 0.5, 1.5 }, { 1.5, 1.5 } }; -float4 main( PFXVertToPix IN ) : COLOR +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float2 pixelSize = oneOverTargetSize; @@ -42,7 +42,7 @@ float4 main( PFXVertToPix IN ) : COLOR for ( int i = 0; i < 16; i++ ) { - float lum = tex2D( inputTex, IN.uv0 + ( gTapOffsets[i] * pixelSize ) ).r; + float lum = TORQUE_TEX2D( inputTex, IN.uv0 + ( gTapOffsets[i] * pixelSize ) ).r; average += lum; } diff --git a/Templates/Full/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl b/Templates/Full/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl index e8870b3c4..b70bafa98 100644 --- a/Templates/Full/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/lightRay/lightRayOccludeP.hlsl @@ -20,29 +20,29 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../../shaderModelAutoGen.hlsl" #include "../postFx.hlsl" -uniform sampler2D backBuffer : register( s0 ); // The original backbuffer. -uniform sampler2D prepassTex : register( s1 ); // The pre-pass depth and normals. +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); uniform float brightScalar; static const float3 LUMINANCE_VECTOR = float3(0.3125f, 0.6154f, 0.0721f); -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 col = float4( 0, 0, 0, 1 ); // Get the depth at this pixel. - float depth = prepassUncondition( prepassTex, IN.uv0 ).w; + float depth = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ).w; // If the depth is equal to 1.0, read from the backbuffer // and perform the exposure calculation on the result. if ( depth >= 0.999 ) { - col = tex2D( backBuffer, IN.uv0 ); + col = TORQUE_TEX2D( backBuffer, IN.uv0 ); //col = 1 - exp(-120000 * col); col += dot( col.rgb, LUMINANCE_VECTOR ) + 0.0001f; diff --git a/Templates/Full/game/shaders/common/postFx/lightRay/lightRayP.hlsl b/Templates/Full/game/shaders/common/postFx/lightRay/lightRayP.hlsl index ff44abfae..032894710 100644 --- a/Templates/Full/game/shaders/common/postFx/lightRay/lightRayP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/lightRay/lightRayP.hlsl @@ -22,28 +22,29 @@ #include "../postFx.hlsl" -uniform sampler2D frameSampler : register( s0 ); -uniform sampler2D backBuffer : register( s1 ); +TORQUE_UNIFORM_SAMPLER2D(frameSampler, 0); +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 1); + uniform float3 camForward; +uniform int numSamples; uniform float3 lightDirection; +uniform float density; uniform float2 screenSunPos; uniform float2 oneOverTargetSize; -uniform int numSamples; -uniform float density; uniform float weight; uniform float decay; uniform float exposure; -float4 main( PFXVertToPix IN ) : COLOR0 +float4 main( PFXVertToPix IN ) : TORQUE_TARGET0 { float4 texCoord = float4( IN.uv0.xy, 0, 0 ); // Store initial sample. - half3 color = (half3)tex2D( frameSampler, texCoord.xy ).rgb; + half3 color = (half3)TORQUE_TEX2D( frameSampler, texCoord.xy ).rgb; // Store original bb color. - float4 bbCol = tex2D( backBuffer, IN.uv1 ); + float4 bbCol = TORQUE_TEX2D( backBuffer, IN.uv1 ); // Set up illumination decay factor. half illuminationDecay = 1.0; @@ -68,7 +69,7 @@ float4 main( PFXVertToPix IN ) : COLOR0 texCoord.xy -= deltaTexCoord; // Retrieve sample at new location. - half3 sample = (half3)tex2Dlod( frameSampler, texCoord ); + half3 sample = (half3)TORQUE_TEX2DLOD( frameSampler, texCoord ); // Apply sample attenuation scale/decay factors. sample *= half(illuminationDecay * weight); diff --git a/Templates/Full/game/shaders/common/postFx/motionBlurP.hlsl b/Templates/Full/game/shaders/common/postFx/motionBlurP.hlsl index 348484f4d..8bc65fbc6 100644 --- a/Templates/Full/game/shaders/common/postFx/motionBlurP.hlsl +++ b/Templates/Full/game/shaders/common/postFx/motionBlurP.hlsl @@ -22,23 +22,22 @@ #include "./postFx.hlsl" #include "../torque.hlsl" -#include "shadergen:/autogenConditioners.h" +#include "../shaderModelAutoGen.hlsl" uniform float4x4 matPrevScreenToWorld; uniform float4x4 matWorldToScreen; // Passed in from setShaderConsts() uniform float velocityMultiplier; +TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); -uniform sampler2D backBuffer : register(S0); -uniform sampler2D prepassTex : register(S1); - -float4 main(PFXVertToPix IN) : COLOR0 +float4 main(PFXVertToPix IN) : TORQUE_TARGET0 { float samples = 5; // First get the prepass texture for uv channel 0 - float4 prepass = prepassUncondition( prepassTex, IN.uv0 ); + float4 prepass = TORQUE_PREPASS_UNCONDITION( prepassTex, IN.uv0 ); // Next extract the depth float depth = prepass.a; @@ -58,12 +57,12 @@ float4 main(PFXVertToPix IN) : COLOR0 float2 velocity = ((screenPos - previousPos) / velocityMultiplier).xy; // Generate the motion blur - float4 color = tex2D(backBuffer, IN.uv0); + float4 color = TORQUE_TEX2D(backBuffer, IN.uv0); IN.uv0 += velocity; for(int i = 1; i= 10 && TORQUE_SM <=30) + // Semantics + #define TORQUE_POSITION POSITION + #define TORQUE_DEPTH DEPTH + #define TORQUE_TARGET0 COLOR0 + #define TORQUE_TARGET1 COLOR1 + #define TORQUE_TARGET2 COLOR2 + #define TORQUE_TARGET3 COLOR3 + + // Sampler uniforms + #define TORQUE_UNIFORM_SAMPLER1D(tex,regist) uniform sampler1D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER2D(tex,regist) uniform sampler2D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER3D(tex,regist) uniform sampler3D tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLERCUBE(tex,regist) uniform samplerCUBE tex : register(S##regist) + // Sampling functions + #define TORQUE_TEX1D(tex,coords) tex1D(tex,coords) + #define TORQUE_TEX2D(tex,coords) tex2D(tex,coords) + #define TORQUE_TEX2DPROJ(tex,coords) tex2Dproj(tex,coords) //this really is sm 2 or later + #define TORQUE_TEX3D(tex,coords) tex3D(tex,coords) + #define TORQUE_TEXCUBE(tex,coords) texCUBE(tex,coords) + + //Shader model 3.0 only + #if TORQUE_SM == 30 + #define TORQUE_VPOS VPOS // This is a float2 + // The mipmap LOD is specified in coord.w + #define TORQUE_TEX2DLOD(tex,coords) tex2Dlod(tex,coords) + #endif + + //helper if you want to pass sampler/texture in a function + //2D + #define TORQUE_SAMPLER2D(tex) sampler2D tex + #define TORQUE_SAMPLER2D_MAKEARG(tex) tex + //Cube + #define TORQUE_SAMPLERCUBE(tex) samplerCUBE tex + #define TORQUE_SAMPLERCUBE_MAKEARG(tex) tex +// Shader model 4.0+ +#elif TORQUE_SM >= 40 + #define TORQUE_POSITION SV_Position + #define TORQUE_DEPTH SV_Depth + #define TORQUE_VPOS SV_Position //note float4 compared to SM 3 where it is a float2 + #define TORQUE_TARGET0 SV_Target0 + #define TORQUE_TARGET1 SV_Target1 + #define TORQUE_TARGET2 SV_Target2 + #define TORQUE_TARGET3 SV_Target3 + // Sampler uniforms + //1D is emulated to a 2D for now + #define TORQUE_UNIFORM_SAMPLER1D(tex,regist) uniform Texture2D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER2D(tex,regist) uniform Texture2D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLER3D(tex,regist) uniform Texture3D texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + #define TORQUE_UNIFORM_SAMPLERCUBE(tex,regist) uniform TextureCube texture_##tex : register(T##regist); uniform SamplerState tex : register(S##regist) + // Sampling functions + #define TORQUE_TEX1D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEX2D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEX2DPROJ(tex,coords) texture_##tex.Sample(tex,coords.xy / coords.w) + #define TORQUE_TEX3D(tex,coords) texture_##tex.Sample(tex,coords) + #define TORQUE_TEXCUBE(tex,coords) texture_##tex.Sample(tex,coords) + // The mipmap LOD is specified in coord.w + #define TORQUE_TEX2DLOD(tex,coords) texture_##tex.SampleLevel(tex,coords.xy,coords.w) + + //helper if you want to pass sampler/texture in a function + //2D + #define TORQUE_SAMPLER2D(tex) Texture2D texture_##tex, SamplerState tex + #define TORQUE_SAMPLER2D_MAKEARG(tex) texture_##tex, tex + //Cube + #define TORQUE_SAMPLERCUBE(tex) TextureCube texture_##tex, SamplerState tex + #define TORQUE_SAMPLERCUBE_MAKEARG(tex) texture_##tex, tex +#endif + +#endif // _TORQUE_SHADERMODEL_ + diff --git a/Templates/Full/game/shaders/common/shaderModelAutoGen.hlsl b/Templates/Full/game/shaders/common/shaderModelAutoGen.hlsl new file mode 100644 index 000000000..4f2d8803f --- /dev/null +++ b/Templates/Full/game/shaders/common/shaderModelAutoGen.hlsl @@ -0,0 +1,35 @@ +//----------------------------------------------------------------------------- +// 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 _TORQUE_SHADERMODEL_AUTOGEN_ +#define _TORQUE_SHADERMODEL_AUTOGEN_ + +#include "shadergen:/autogenConditioners.h" + +// Portability helpers for autogenConditioners +#if (TORQUE_SM >= 10 && TORQUE_SM <=30) + #define TORQUE_PREPASS_UNCONDITION(tex, coords) prepassUncondition(tex, coords) +#elif TORQUE_SM >= 40 + #define TORQUE_PREPASS_UNCONDITION(tex, coords) prepassUncondition(tex, texture_##tex, coords) +#endif + +#endif //_TORQUE_SHADERMODEL_AUTOGEN_ diff --git a/Templates/Full/game/shaders/common/terrain/blendP.hlsl b/Templates/Full/game/shaders/common/terrain/blendP.hlsl index f71088928..aeef9d6e3 100644 --- a/Templates/Full/game/shaders/common/terrain/blendP.hlsl +++ b/Templates/Full/game/shaders/common/terrain/blendP.hlsl @@ -21,25 +21,28 @@ //----------------------------------------------------------------------------- #include "terrain.hlsl" +#include "../shaderModel.hlsl" struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 layerCoord : TEXCOORD0; float2 texCoord : TEXCOORD1; }; -float4 main( ConnectData IN, - uniform sampler2D layerTex : register(S0), - uniform sampler2D textureMap : register(S1), - uniform float texId, - uniform float layerSize ) : COLOR +TORQUE_UNIFORM_SAMPLER2D(layerTex, 0); +TORQUE_UNIFORM_SAMPLER2D(textureMap, 1); + +uniform float texId; +uniform float layerSize; + +float4 main( ConnectData IN ) : TORQUE_TARGET0 { - float4 layerSample = round( tex2D( layerTex, IN.layerCoord ) * 255.0f ); + float4 layerSample = round( TORQUE_TEX2D( layerTex, IN.layerCoord ) * 255.0f ); float blend = calcBlend( texId, IN.layerCoord, layerSize, layerSample ); clip( blend - 0.0001 ); - return float4( tex2D( textureMap, IN.texCoord ).rgb, blend ); + return float4( TORQUE_TEX2D(textureMap, IN.texCoord).rgb, blend); } diff --git a/Templates/Full/game/shaders/common/terrain/blendV.hlsl b/Templates/Full/game/shaders/common/terrain/blendV.hlsl index 7a79d2de4..9ccd33301 100644 --- a/Templates/Full/game/shaders/common/terrain/blendV.hlsl +++ b/Templates/Full/game/shaders/common/terrain/blendV.hlsl @@ -23,6 +23,8 @@ /// The vertex shader used in the generation and caching of the /// base terrain texture. +#include "../shaderModel.hlsl" + struct VertData { float3 position : POSITION; @@ -31,17 +33,18 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; float2 layerCoord : TEXCOORD0; float2 texCoord : TEXCOORD1; }; -ConnectData main( VertData IN, - uniform float2 texScale : register(C0) ) +uniform float2 texScale; + +ConnectData main( VertData IN ) { ConnectData OUT; - OUT.hpos = float4( IN.position.xyz, 1 ); + OUT.hpos = float4( IN.position, 1 ); OUT.layerCoord = IN.texCoord; OUT.texCoord = IN.texCoord * texScale; diff --git a/Templates/Full/game/shaders/common/terrain/terrain.hlsl b/Templates/Full/game/shaders/common/terrain/terrain.hlsl index 8ce497012..b7c87e618 100644 --- a/Templates/Full/game/shaders/common/terrain/terrain.hlsl +++ b/Templates/Full/game/shaders/common/terrain/terrain.hlsl @@ -35,6 +35,7 @@ float calcBlend( float texId, float2 layerCoord, float layerSize, float4 layerSa // Check if any of the layer samples // match the current texture id. float4 factors = 0; + [unroll] for(int i = 0; i < 4; i++) if(layerSample[i] == texId) factors[i] = 1; diff --git a/Templates/Full/game/shaders/common/torque.hlsl b/Templates/Full/game/shaders/common/torque.hlsl index f50832cb8..3521042d4 100644 --- a/Templates/Full/game/shaders/common/torque.hlsl +++ b/Templates/Full/game/shaders/common/torque.hlsl @@ -23,6 +23,7 @@ #ifndef _TORQUE_HLSL_ #define _TORQUE_HLSL_ +#include "./shaderModel.hlsl" static float M_HALFPI_F = 1.57079632679489661923f; static float M_PI_F = 3.14159265358979323846f; @@ -137,29 +138,29 @@ float3x3 quatToMat( float4 quat ) /// @param negViewTS The negative view vector in tangent space. /// @param depthScale The parallax factor used to scale the depth result. /// -float2 parallaxOffset( sampler2D texMap, float2 texCoord, float3 negViewTS, float depthScale ) +float2 parallaxOffset(TORQUE_SAMPLER2D(texMap), float2 texCoord, float3 negViewTS, float depthScale) { - float depth = tex2D( texMap, texCoord ).a; - float2 offset = negViewTS.xy * ( depth * depthScale ); + float depth = TORQUE_TEX2D(texMap, texCoord).a; + float2 offset = negViewTS.xy * (depth * depthScale); - for ( int i=0; i < PARALLAX_REFINE_STEPS; i++ ) + for (int i = 0; i < PARALLAX_REFINE_STEPS; i++) { - depth = ( depth + tex2D( texMap, texCoord + offset ).a ) * 0.5; - offset = negViewTS.xy * ( depth * depthScale ); + depth = (depth + TORQUE_TEX2D(texMap, texCoord + offset).a) * 0.5; + offset = negViewTS.xy * (depth * depthScale); } return offset; } /// Same as parallaxOffset but for dxtnm where depth is stored in the red channel instead of the alpha -float2 parallaxOffsetDxtnm(sampler2D texMap, float2 texCoord, float3 negViewTS, float depthScale) +float2 parallaxOffsetDxtnm(TORQUE_SAMPLER2D(texMap), float2 texCoord, float3 negViewTS, float depthScale) { - float depth = tex2D(texMap, texCoord).r; + float depth = TORQUE_TEX2D(texMap, texCoord).r; float2 offset = negViewTS.xy * (depth * depthScale); for (int i = 0; i < PARALLAX_REFINE_STEPS; i++) { - depth = (depth + tex2D(texMap, texCoord + offset).r) * 0.5; + depth = (depth + TORQUE_TEX2D(texMap, texCoord + offset).r) * 0.5; offset = negViewTS.xy * (depth * depthScale); } diff --git a/Templates/Full/game/shaders/common/water/waterBasicP.hlsl b/Templates/Full/game/shaders/common/water/waterBasicP.hlsl index 7ae933f6f..efb437779 100644 --- a/Templates/Full/game/shaders/common/water/waterBasicP.hlsl +++ b/Templates/Full/game/shaders/common/water/waterBasicP.hlsl @@ -57,7 +57,7 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -92,11 +92,11 @@ float fresnel(float NdotV, float bias, float power) //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler bumpMap : register( S0 ); +TORQUE_UNIFORM_SAMPLER2D(bumpMap,0); //uniform sampler2D prepassTex : register( S1 ); -uniform sampler2D reflectMap : register( S2 ); -uniform sampler refractBuff : register( S3 ); -uniform samplerCUBE skyMap : register( S4 ); +TORQUE_UNIFORM_SAMPLER2D(reflectMap,2); +TORQUE_UNIFORM_SAMPLER2D(refractBuff,3); +TORQUE_UNIFORM_SAMPLERCUBE(skyMap,4); //uniform sampler foamMap : register( S5 ); uniform float4 baseColor; uniform float4 miscParams; @@ -113,16 +113,16 @@ uniform float4x4 modelMat; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Modulate baseColor by the ambientColor. float4 waterBaseColor = baseColor * float4( ambientColor.rgb, 1 ); waterBaseColor = toLinear(waterBaseColor); // Get the bumpNorm... - float3 bumpNorm = ( tex2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord2 ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; + float3 bumpNorm = ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord2 ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; bumpNorm = normalize( bumpNorm ); bumpNorm = lerp( bumpNorm, float3(0,0,1), 1.0 - rippleMagnitude.w ); @@ -136,7 +136,7 @@ float4 main( ConnectData IN ) : COLOR distortPos.xy += bumpNorm.xy * distortAmt; #ifdef UNDERWATER - return hdrEncode( tex2Dproj( refractBuff, distortPos ) ); + return hdrEncode( TORQUE_TEX2DPROJ( refractBuff, distortPos ) ); #else float3 eyeVec = IN.objPos.xyz - eyePos; @@ -154,16 +154,16 @@ float4 main( ConnectData IN ) : COLOR float fakeColorAmt = ang; // Get reflection map color - float4 refMapColor = hdrDecode( tex2Dproj( reflectMap, distortPos ) ); + float4 refMapColor = hdrDecode( TORQUE_TEX2DPROJ( reflectMap, distortPos ) ); // If we do not have a reflection texture then we use the cubemap. - refMapColor = lerp( refMapColor, texCUBE( skyMap, reflectionVec ), NO_REFLECT ); + refMapColor = lerp( refMapColor, TORQUE_TEXCUBE( skyMap, reflectionVec ), NO_REFLECT ); // Combine reflection color and fakeColor. float4 reflectColor = lerp( refMapColor, fakeColor, fakeColorAmt ); //return refMapColor; // Get refract color - float4 refractColor = hdrDecode( tex2Dproj( refractBuff, distortPos ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2DPROJ( refractBuff, distortPos ) ); // calc "diffuse" color by lerping from the water color // to refraction image based on the water clarity. @@ -198,7 +198,7 @@ float4 main( ConnectData IN ) : COLOR // Fog it. float factor = computeSceneFog( eyePos, - IN.objPos, + IN.objPos.xyz, WORLD_Z, fogData.x, fogData.y, diff --git a/Templates/Full/game/shaders/common/water/waterBasicV.hlsl b/Templates/Full/game/shaders/common/water/waterBasicV.hlsl index 2c201e675..310647c90 100644 --- a/Templates/Full/game/shaders/common/water/waterBasicV.hlsl +++ b/Templates/Full/game/shaders/common/water/waterBasicV.hlsl @@ -20,12 +20,13 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- +#include "../shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { - float4 position : POSITION; + float3 position : POSITION; float3 normal : NORMAL; float2 undulateData : TEXCOORD0; float4 horizonFactor : TEXCOORD1; @@ -33,7 +34,7 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -95,21 +96,21 @@ ConnectData main( VertData IN ) // IN.position.xy += offsetXY; // IN.undulateData += offsetXY; // } - - float4 worldPos = mul( modelMat, IN.position ); + float4 inPos = float4(IN.position, 1.0); + float4 worldPos = mul(modelMat, inPos); IN.position.z = lerp( IN.position.z, eyePos.z, IN.horizonFactor.x ); //OUT.objPos = worldPos; - OUT.objPos.xyz = IN.position.xyz; + OUT.objPos.xyz = IN.position; OUT.objPos.w = worldPos.z; // Send pre-undulation screenspace position - OUT.posPreWave = mul( modelview, IN.position ); + OUT.posPreWave = mul( modelview, inPos ); OUT.posPreWave = mul( texGen, OUT.posPreWave ); // Calculate the undulation amount for this vertex. - float2 undulatePos = mul( modelMat, float4( IN.undulateData.xy, 0, 1 ) ); + float2 undulatePos = mul( modelMat, float4( IN.undulateData.xy, 0, 1 )).xy; //if ( undulatePos.x < 0 ) // undulatePos = IN.position.xy; @@ -128,12 +129,12 @@ ConnectData main( VertData IN ) float undulateFade = 1; // Scale down wave magnitude amount based on distance from the camera. - float dist = distance( IN.position.xyz, eyePos ); + float dist = distance( IN.position, eyePos ); dist = clamp( dist, 1.0, undulateMaxDist ); undulateFade *= ( 1 - dist / undulateMaxDist ); // Also scale down wave magnitude if the camera is very very close. - undulateFade *= saturate( ( distance( IN.position.xyz, eyePos ) - 0.5 ) / 10.0 ); + undulateFade *= saturate( ( distance( IN.position, eyePos ) - 0.5 ) / 10.0 ); undulateAmt *= undulateFade; @@ -141,7 +142,7 @@ ConnectData main( VertData IN ) //undulateAmt = 0; // Apply wave undulation to the vertex. - OUT.posPostWave = IN.position; + OUT.posPostWave = inPos; OUT.posPostWave.xyz += IN.normal.xyz * undulateAmt; // Save worldSpace position of this pixel/vert @@ -210,7 +211,7 @@ ConnectData main( VertData IN ) for ( int i = 0; i < 3; i++ ) { binormal.z += undulateFade * waveDir[i].x * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); - tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); + tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * IN.undulateData.x + waveDir[i].y * IN.undulateData.y + elapsedTime * waveData[i].x ); } binormal = normalize( binormal ); diff --git a/Templates/Full/game/shaders/common/water/waterP.hlsl b/Templates/Full/game/shaders/common/water/waterP.hlsl index c4edff0d7..ac66e9b28 100644 --- a/Templates/Full/game/shaders/common/water/waterP.hlsl +++ b/Templates/Full/game/shaders/common/water/waterP.hlsl @@ -20,7 +20,7 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../shaderModelAutoGen.hlsl" #include "../torque.hlsl" //----------------------------------------------------------------------------- @@ -69,7 +69,7 @@ struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -105,13 +105,13 @@ float fresnel(float NdotV, float bias, float power) //----------------------------------------------------------------------------- // Uniforms //----------------------------------------------------------------------------- -uniform sampler bumpMap : register( S0 ); -uniform sampler2D prepassTex : register( S1 ); -uniform sampler2D reflectMap : register( S2 ); -uniform sampler refractBuff : register( S3 ); -uniform samplerCUBE skyMap : register( S4 ); -uniform sampler foamMap : register( S5 ); -uniform sampler1D depthGradMap : register( S6 ); +TORQUE_UNIFORM_SAMPLER2D(bumpMap,0); +TORQUE_UNIFORM_SAMPLER2D(prepassTex, 1); +TORQUE_UNIFORM_SAMPLER2D(reflectMap, 2); +TORQUE_UNIFORM_SAMPLER2D(refractBuff, 3); +TORQUE_UNIFORM_SAMPLERCUBE(skyMap, 4); +TORQUE_UNIFORM_SAMPLER2D(foamMap, 5); +TORQUE_UNIFORM_SAMPLER1D(depthGradMap, 6); uniform float4 specularParams; uniform float4 baseColor; uniform float4 miscParams; @@ -138,12 +138,12 @@ uniform float reflectivity; //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -float4 main( ConnectData IN ) : COLOR +float4 main( ConnectData IN ) : TORQUE_TARGET0 { // Get the bumpNorm... - float3 bumpNorm = ( tex2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; - bumpNorm += ( tex2D( bumpMap, IN.rippleTexCoord2.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; + float3 bumpNorm = ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.x; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord01.zw ).rgb * 2.0 - 1.0 ) * rippleMagnitude.y; + bumpNorm += ( TORQUE_TEX2D( bumpMap, IN.rippleTexCoord2.xy ).rgb * 2.0 - 1.0 ) * rippleMagnitude.z; bumpNorm = normalize( bumpNorm ); bumpNorm = lerp( bumpNorm, float3(0,0,1), 1.0 - rippleMagnitude.w ); @@ -155,7 +155,7 @@ float4 main( ConnectData IN ) : COLOR float2 prepassCoord = viewportCoordToRenderTarget( IN.posPostWave, rtParams1 ); - float startDepth = prepassUncondition( prepassTex, prepassCoord ).w; + float startDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; // The water depth in world units of the undistorted pixel. float startDelta = ( startDepth - pixelDepth ); @@ -180,7 +180,7 @@ float4 main( ConnectData IN ) : COLOR prepassCoord = viewportCoordToRenderTarget( distortPos, rtParams1 ); // Get prepass depth at the position of this distorted pixel. - float prepassDepth = prepassUncondition( prepassTex, prepassCoord ).w; + float prepassDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; if ( prepassDepth > 0.99 ) prepassDepth = 5.0; @@ -212,7 +212,7 @@ float4 main( ConnectData IN ) : COLOR prepassCoord = viewportCoordToRenderTarget( distortPos, rtParams1 ); // Get prepass depth at the position of this distorted pixel. - prepassDepth = prepassUncondition( prepassTex, prepassCoord ).w; + prepassDepth = TORQUE_PREPASS_UNCONDITION( prepassTex, prepassCoord ).w; if ( prepassDepth > 0.99 ) prepassDepth = 5.0; delta = ( prepassDepth - pixelDepth ) * farPlaneDist; @@ -260,8 +260,8 @@ float4 main( ConnectData IN ) : COLOR IN.foamTexCoords.xy += foamRippleOffset; IN.foamTexCoords.zw += foamRippleOffset; - float4 foamColor = tex2D( foamMap, IN.foamTexCoords.xy ); - foamColor += tex2D( foamMap, IN.foamTexCoords.zw ); + float4 foamColor = TORQUE_TEX2D( foamMap, IN.foamTexCoords.xy ); + foamColor += TORQUE_TEX2D( foamMap, IN.foamTexCoords.zw ); foamColor = saturate( foamColor ); // Modulate foam color by ambient color @@ -282,18 +282,18 @@ float4 main( ConnectData IN ) : COLOR foamColor.rgb *= FOAM_OPACITY * foamAmt * foamColor.a; // Get reflection map color. - float4 refMapColor = tex2D( reflectMap, reflectCoord ); + float4 refMapColor = TORQUE_TEX2D( reflectMap, reflectCoord ); // If we do not have a reflection texture then we use the cubemap. - refMapColor = lerp( refMapColor, texCUBE( skyMap, reflectionVec ), NO_REFLECT ); + refMapColor = lerp( refMapColor, TORQUE_TEXCUBE( skyMap, reflectionVec ), NO_REFLECT ); - fakeColor = ( texCUBE( skyMap, reflectionVec ) ); + fakeColor = ( TORQUE_TEXCUBE( skyMap, reflectionVec ) ); fakeColor.a = 1; // Combine reflection color and fakeColor. float4 reflectColor = lerp( refMapColor, fakeColor, fakeColorAmt ); // Get refract color - float4 refractColor = hdrDecode( tex2D( refractBuff, refractCoord ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2D( refractBuff, refractCoord ) ); // We darken the refraction color a bit to make underwater // elements look wet. We fade out this darkening near the @@ -310,7 +310,7 @@ float4 main( ConnectData IN ) : COLOR float fogAmt = 1.0 - saturate( exp( -FOG_DENSITY * fogDelta ) ); // Calculate the water "base" color based on depth. - float4 waterBaseColor = baseColor * tex1D( depthGradMap, saturate( delta / depthGradMax ) ); + float4 waterBaseColor = baseColor * TORQUE_TEX1D( depthGradMap, saturate( delta / depthGradMax ) ); waterBaseColor = toLinear(waterBaseColor); // Modulate baseColor by the ambientColor. @@ -354,7 +354,7 @@ float4 main( ConnectData IN ) : COLOR #else - float4 refractColor = hdrDecode( tex2D( refractBuff, refractCoord ) ); + float4 refractColor = hdrDecode( TORQUE_TEX2D( refractBuff, refractCoord ) ); float4 OUT = refractColor; #endif diff --git a/Templates/Full/game/shaders/common/water/waterV.hlsl b/Templates/Full/game/shaders/common/water/waterV.hlsl index d2b097bc5..c869f0e9f 100644 --- a/Templates/Full/game/shaders/common/water/waterV.hlsl +++ b/Templates/Full/game/shaders/common/water/waterV.hlsl @@ -20,14 +20,14 @@ // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#include "shadergen:/autogenConditioners.h" +#include "../shaderModel.hlsl" //----------------------------------------------------------------------------- // Structures //----------------------------------------------------------------------------- struct VertData { - float4 position : POSITION; + float3 position : POSITION; float3 normal : NORMAL; float2 undulateData : TEXCOORD0; float4 horizonFactor : TEXCOORD1; @@ -35,7 +35,7 @@ struct VertData struct ConnectData { - float4 hpos : POSITION; + float4 hpos : TORQUE_POSITION; // TexCoord 0 and 1 (xy,zw) for ripple texture lookup float4 rippleTexCoord01 : TEXCOORD0; @@ -94,12 +94,12 @@ ConnectData main( VertData IN ) 0.0, 0.0, 0.0, 1.0 }; IN.position.z = lerp( IN.position.z, eyePos.z, IN.horizonFactor.x ); - - OUT.objPos = IN.position; - OUT.objPos.w = mul( modelMat, IN.position ).z; + float4 inPos = float4( IN.position, 1.0); + OUT.objPos = inPos; + OUT.objPos.w = mul( modelMat, inPos ).z; // Send pre-undulation screenspace position - OUT.posPreWave = mul( modelview, IN.position ); + OUT.posPreWave = mul( modelview, inPos ); OUT.posPreWave = mul( texGen, OUT.posPreWave ); // Calculate the undulation amount for this vertex. @@ -132,7 +132,7 @@ ConnectData main( VertData IN ) OUT.rippleTexCoord2.w = saturate( OUT.rippleTexCoord2.w - 0.2 ) / 0.8; // Apply wave undulation to the vertex. - OUT.posPostWave = IN.position; + OUT.posPostWave = inPos; OUT.posPostWave.xyz += IN.normal.xyz * undulateAmt; // Convert to screen @@ -197,7 +197,7 @@ ConnectData main( VertData IN ) for ( int i = 0; i < 3; i++ ) { binormal.z += undulateFade * waveDir[i].x * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); - tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); + tangent.z += undulateFade * waveDir[i].y * waveData[i].y * cos( waveDir[i].x * undulatePos.x + waveDir[i].y * undulatePos.y + elapsedTime * waveData[i].x ); } binormal = binormal; diff --git a/Templates/Full/game/shaders/common/wavesP.hlsl b/Templates/Full/game/shaders/common/wavesP.hlsl index 265842f1f..c51eb4b89 100644 --- a/Templates/Full/game/shaders/common/wavesP.hlsl +++ b/Templates/Full/game/shaders/common/wavesP.hlsl @@ -22,13 +22,14 @@ #define IN_HLSL #include "shdrConsts.h" +#include "shaderModel.hlsl" //----------------------------------------------------------------------------- // Data //----------------------------------------------------------------------------- struct v2f { - float4 HPOS : POSITION; + float4 HPOS : TORQUE_POSITION; float2 TEX0 : TEXCOORD0; float4 tangentToCube0 : TEXCOORD1; float4 tangentToCube1 : TEXCOORD2; @@ -42,21 +43,23 @@ struct v2f struct Fragout { - float4 col : COLOR0; + float4 col : TORQUE_TARGET0; }; +// Uniforms +TORQUE_UNIFORM_SAMPLER2D(diffMap,0); +//TORQUE_UNIFORM_SAMPLERCUBE(cubeMap, 1); not used? +TORQUE_UNIFORM_SAMPLER2D(bumpMap,2); + +uniform float4 specularColor : register(PC_MAT_SPECCOLOR); +uniform float4 ambient : register(PC_AMBIENT_COLOR); +uniform float specularPower : register(PC_MAT_SPECPOWER); +uniform float accumTime : register(PC_ACCUM_TIME); + //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Fragout main(v2f IN, - uniform sampler2D diffMap : register(S0), - uniform sampler2D bumpMap : register(S2), - uniform samplerCUBE cubeMap : register(S1), - uniform float4 specularColor : register(PC_MAT_SPECCOLOR), - uniform float specularPower : register(PC_MAT_SPECPOWER), - uniform float4 ambient : register(PC_AMBIENT_COLOR), - uniform float accumTime : register(PC_ACCUM_TIME) -) +Fragout main(v2f IN) { Fragout OUT; @@ -68,8 +71,8 @@ Fragout main(v2f IN, texOffset.y = IN.TEX0.y + cos( accumTime * 3.0 + IN.TEX0.x * 6.28319 * 2.0 ) * 0.05; - float4 bumpNorm = tex2D( bumpMap, texOffset ) * 2.0 - 1.0; - float4 diffuse = tex2D( diffMap, texOffset ); + float4 bumpNorm = TORQUE_TEX2D( bumpMap, texOffset ) * 2.0 - 1.0; + float4 diffuse = TORQUE_TEX2D( diffMap, texOffset ); OUT.col = diffuse * (saturate( dot( IN.lightVec, bumpNorm.xyz ) ) + ambient); diff --git a/Templates/Full/game/shaders/common/wavesV.hlsl b/Templates/Full/game/shaders/common/wavesV.hlsl index 6580daa5b..fccef9d25 100644 --- a/Templates/Full/game/shaders/common/wavesV.hlsl +++ b/Templates/Full/game/shaders/common/wavesV.hlsl @@ -22,7 +22,7 @@ #define IN_HLSL #include "shdrConsts.h" -#include "hlslStructs.h" +#include "hlslStructs.hlsl" //----------------------------------------------------------------------------- // Constants @@ -42,21 +42,20 @@ struct Conn }; +uniform float4x4 modelview : register(VC_WORLD_PROJ); +uniform float3x3 cubeTrans : register(VC_CUBE_TRANS); +uniform float3 cubeEyePos : register(VC_CUBE_EYE_POS); +uniform float3 inLightVec : register(VC_LIGHT_DIR1); +uniform float3 eyePos : register(VC_EYE_POS); //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- -Conn main( VertexIn_PNTTTB In, - uniform float4x4 modelview : register(VC_WORLD_PROJ), - uniform float3x3 cubeTrans : register(VC_CUBE_TRANS), - uniform float3 cubeEyePos : register(VC_CUBE_EYE_POS), - uniform float3 inLightVec : register(VC_LIGHT_DIR1), - uniform float3 eyePos : register(VC_EYE_POS) -) +Conn main( VertexIn_PNTTTB In) { Conn Out; - Out.HPOS = mul(modelview, In.pos); + Out.HPOS = mul(modelview, float4(In.pos,1.0)); Out.TEX0 = In.uv0; From 41e5caf22b6332c96197e8a83c0ac2e279a1af4c Mon Sep 17 00:00:00 2001 From: rextimmy Date: Sun, 20 Mar 2016 21:52:11 +1000 Subject: [PATCH 03/13] Direct3D11 Engine/source changes --- Engine/source/T3D/cameraSpline.cpp | 2 +- Engine/source/T3D/fx/precipitation.cpp | 2 +- Engine/source/T3D/fx/precipitation.h | 2 +- Engine/source/environment/VolumetricFog.cpp | 12 +- .../environment/VolumetricFogRTManager.cpp | 34 +-- .../environment/VolumetricFogRTManager.h | 1 - Engine/source/environment/scatterSky.cpp | 12 +- Engine/source/environment/sun.cpp | 10 +- Engine/source/environment/waterObject.cpp | 14 +- Engine/source/gfx/D3D9/gfxD3D9Device.cpp | 1 + Engine/source/gfx/D3D9/gfxD3D9Shader.cpp | 13 +- .../source/gfx/D3D9/gfxD3D9VertexBuffer.cpp | 3 +- .../gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp | 1 - Engine/source/gfx/D3D9/pc/gfxPCD3D9Device.cpp | 2 +- Engine/source/gfx/D3D9/screenshotD3D9.cpp | 2 +- Engine/source/gfx/D3D9/screenshotD3D9.h | 8 +- Engine/source/gfx/genericConstBuffer.h | 12 +- Engine/source/gfx/gfxAPI.cpp | 2 +- Engine/source/gfx/gfxDevice.cpp | 2 + Engine/source/gfx/gfxDrawUtil.cpp | 153 +++++++--- Engine/source/gfx/gfxEnums.h | 3 +- Engine/source/gfx/gfxInit.cpp | 49 ++-- Engine/source/gfx/gfxShader.cpp | 15 +- Engine/source/gfx/gfxShader.h | 13 +- Engine/source/gfx/gfxStringEnumTranslate.cpp | 1 - Engine/source/gfx/gfxVertexFormat.cpp | 15 + Engine/source/gfx/gfxVertexFormat.h | 11 +- Engine/source/gfx/gl/gfxGLDevice.cpp | 13 +- Engine/source/gfx/gl/gfxGLEnumTranslate.cpp | 1 - Engine/source/gfx/gl/gfxGLShader.cpp | 12 +- Engine/source/gfx/primBuilder.cpp | 2 - Engine/source/gui/3d/guiTSControl.cpp | 2 +- .../source/gui/controls/guiGradientCtrl.cpp | 120 ++++---- .../gui/controls/guiTextEditSliderCtrl.cpp | 2 +- Engine/source/gui/editor/guiEditCtrl.h | 2 +- Engine/source/gui/editor/guiFilterCtrl.cpp | 2 +- Engine/source/gui/editor/guiGraphCtrl.cpp | 2 +- Engine/source/gui/worldEditor/editTSCtrl.cpp | 2 +- Engine/source/gui/worldEditor/gizmo.cpp | 6 +- .../gui/worldEditor/guiTerrPreviewCtrl.cpp | 20 +- .../source/gui/worldEditor/terrainEditor.cpp | 26 +- Engine/source/gui/worldEditor/terrainEditor.h | 2 +- Engine/source/gui/worldEditor/worldEditor.cpp | 4 +- .../advanced/advancedLightBinManager.cpp | 32 +- .../glsl/deferredShadingFeaturesGLSL.cpp | 1 - .../advanced/glsl/gBufferConditionerGLSL.cpp | 2 +- .../hlsl/advancedLightingFeaturesHLSL.cpp | 131 +++++++-- .../hlsl/deferredShadingFeaturesHLSL.cpp | 29 +- .../advanced/hlsl/gBufferConditionerHLSL.cpp | 35 ++- Engine/source/lighting/common/blobShadow.cpp | 2 +- Engine/source/materials/miscShdrDat.h | 7 +- .../materials/processedShaderMaterial.cpp | 2 +- .../materials/processedShaderMaterial.h | 2 + Engine/source/materials/shaderData.cpp | 1 + .../platformWin32/videoInfo/wmiVideoInfo.cpp | 120 ++++---- .../platformWin32/videoInfo/wmiVideoInfo.h | 5 +- Engine/source/postFx/postEffect.cpp | 24 +- .../renderInstance/renderPrePassMgr.cpp | 1 - Engine/source/scene/reflectionManager.cpp | 14 +- Engine/source/scene/simPath.cpp | 4 +- Engine/source/scene/simPath.h | 2 +- .../source/shaderGen/HLSL/accuFeatureHLSL.cpp | 31 +- Engine/source/shaderGen/HLSL/bumpHLSL.cpp | 61 +++- .../source/shaderGen/HLSL/paraboloidHLSL.cpp | 10 +- .../source/shaderGen/HLSL/pixSpecularHLSL.cpp | 34 ++- .../source/shaderGen/HLSL/shaderCompHLSL.cpp | 110 +++---- Engine/source/shaderGen/HLSL/shaderCompHLSL.h | 2 + .../shaderGen/HLSL/shaderFeatureHLSL.cpp | 274 +++++++++++++++--- .../source/shaderGen/HLSL/shaderFeatureHLSL.h | 5 + .../source/shaderGen/HLSL/shaderGenHLSL.cpp | 36 ++- .../shaderGen/HLSL/shaderGenHLSLInit.cpp | 1 + Engine/source/shaderGen/langElement.cpp | 4 + Engine/source/shaderGen/langElement.h | 2 + Engine/source/shaderGen/shaderFeature.cpp | 5 + Engine/source/shaderGen/shaderFeature.h | 7 +- Engine/source/shaderGen/shaderGen.cpp | 7 +- .../source/terrain/glsl/terrFeatureGLSL.cpp | 4 - .../source/terrain/hlsl/terrFeatureHLSL.cpp | 254 +++++++++++++--- Engine/source/terrain/terrRender.cpp | 18 +- Engine/source/ts/tsMesh.cpp | 14 +- .../windowManager/win32/win32Window.cpp | 2 + 81 files changed, 1291 insertions(+), 617 deletions(-) diff --git a/Engine/source/T3D/cameraSpline.cpp b/Engine/source/T3D/cameraSpline.cpp index 144415015..9b0f93d5b 100644 --- a/Engine/source/T3D/cameraSpline.cpp +++ b/Engine/source/T3D/cameraSpline.cpp @@ -188,7 +188,7 @@ void CameraSpline::renderTimeMap() gBuilding = true; // Build vertex buffer - GFXVertexBufferHandle vb; + GFXVertexBufferHandle vb; vb.set(GFX, mTimeMap.size(), GFXBufferTypeVolatile); void *ptr = vb.lock(); if(!ptr) return; diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp index d7067c063..0cbcf7c7f 100644 --- a/Engine/source/T3D/fx/precipitation.cpp +++ b/Engine/source/T3D/fx/precipitation.cpp @@ -1557,7 +1557,7 @@ void Precipitation::renderObject(ObjectRenderInst *ri, SceneRenderState *state, Point3F pos; VectorF orthoDir, velocity, right, up, rightUp(0.0f, 0.0f, 0.0f), leftUp(0.0f, 0.0f, 0.0f); F32 distance = 0; - GFXVertexPT* vertPtr = NULL; + GFXVertexPCT* vertPtr = NULL; const Point2F *tc; // Do this here and we won't have to in the loop! diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h index 908d7005f..80f76f2bb 100644 --- a/Engine/source/T3D/fx/precipitation.h +++ b/Engine/source/T3D/fx/precipitation.h @@ -239,7 +239,7 @@ class Precipitation : public GameBase void destroySplash(Raindrop *drop); ///< Removes a drop from the splash list GFXPrimitiveBufferHandle mRainIB; - GFXVertexBufferHandle mRainVB; + GFXVertexBufferHandle mRainVB; bool onAdd(); void onRemove(); diff --git a/Engine/source/environment/VolumetricFog.cpp b/Engine/source/environment/VolumetricFog.cpp index e6be112dc..9087effee 100644 --- a/Engine/source/environment/VolumetricFog.cpp +++ b/Engine/source/environment/VolumetricFog.cpp @@ -317,8 +317,7 @@ void VolumetricFog::handleResize(VolumetricFogRTManager *RTM, bool resize) { F32 width = (F32)mPlatformWindow->getClientExtent().x; F32 height = (F32)mPlatformWindow->getClientExtent().y; - if (!mPlatformWindow->isFullscreen()) - height -= 20;//subtract caption bar from rendertarget size. + mTexScale.x = 2.0f - ((F32)mTexture.getWidth() / width); mTexScale.y = 2.0f - ((F32)mTexture.getHeight() / height); } @@ -1075,7 +1074,6 @@ void VolumetricFog::render(ObjectRenderInst *ri, SceneRenderState *state, BaseMa mPPShaderConsts->setSafe(mPPModelViewProjSC, xform); - LightInfo *lightinfo = LIGHTMGR->getSpecialLight(LightManager::slSunLightType); const ColorF &sunlight = state->getAmbientLightColor(); Point3F ambientColor(sunlight.red, sunlight.green, sunlight.blue); @@ -1160,6 +1158,11 @@ void VolumetricFog::render(ObjectRenderInst *ri, SceneRenderState *state, BaseMa GFX->setStateBlock(mStateblockF); GFX->drawPrimitive(0); + + // Ensure these two textures are bound to the pixel shader input on the second run as they are used as pixel shader outputs (render targets). + GFX->setTexture(1, NULL); //mDepthBuffer + GFX->setTexture(2, NULL); //mFrontBuffer + GFX->updateStates(); //update the dirty texture state we set above } void VolumetricFog::reflect_render(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat) @@ -1210,9 +1213,6 @@ void VolumetricFog::InitTexture() F32 width = (F32)mPlatformWindow->getClientExtent().x; F32 height = (F32)mPlatformWindow->getClientExtent().y; - if (!mPlatformWindow->isFullscreen()) - height -= 20;//subtract caption bar from rendertarget size. - mTexScale.x = 2.0f - ((F32)mTexture.getWidth() / width); mTexScale.y = 2.0f - ((F32)mTexture.getHeight() / height); } diff --git a/Engine/source/environment/VolumetricFogRTManager.cpp b/Engine/source/environment/VolumetricFogRTManager.cpp index 2a927cc09..8c98983b2 100644 --- a/Engine/source/environment/VolumetricFogRTManager.cpp +++ b/Engine/source/environment/VolumetricFogRTManager.cpp @@ -36,6 +36,7 @@ #include "windowManager/platformWindowMgr.h" #include "console/engineAPI.h" #include "gui/core/guiCanvas.h" +#include "gfx/gfxDevice.h" MODULE_BEGIN(VolumetricFogRTManager) @@ -127,10 +128,10 @@ void VolumetricFogRTManager::consoleInit() bool VolumetricFogRTManager::Init() { if (mIsInitialized) - { + { Con::errorf("VolumetricFogRTManager allready initialized!!"); return true; - } + } GuiCanvas* cv = dynamic_cast(Sim::findObject("Canvas")); if (cv == NULL) @@ -142,15 +143,11 @@ bool VolumetricFogRTManager::Init() mPlatformWindow = cv->getPlatformWindow(); mPlatformWindow->getScreenResChangeSignal().notify(this,&VolumetricFogRTManager::ResizeRT); - if (mTargetScale < 1) + if (mTargetScale < 1 || GFX->getAdapterType() == Direct3D11) mTargetScale = 1; mWidth = mFloor(mPlatformWindow->getClientExtent().x / mTargetScale); - mHeight = mPlatformWindow->getClientExtent().y; - mFullScreen = mPlatformWindow->isFullscreen(); - if (!mFullScreen) - mHeight -= 20;//subtract caption bar from rendertarget size. - mHeight = mFloor(mHeight / mTargetScale); + mHeight = mFloor(mPlatformWindow->getClientExtent().y / mTargetScale); mDepthBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F, &GFXDefaultRenderTargetProfile, avar("%s() - mDepthBuffer (line %d)", __FUNCTION__, __LINE__)); @@ -221,14 +218,11 @@ void VolumetricFogRTManager::FogAnswered() bool VolumetricFogRTManager::Resize() { - if (mTargetScale < 1) + if (mTargetScale < 1 || GFX->getAdapterType() == Direct3D11) mTargetScale = 1; + mWidth = mFloor(mPlatformWindow->getClientExtent().x / mTargetScale); - mHeight = mPlatformWindow->getClientExtent().y; - - if (!mPlatformWindow->isFullscreen()) - mHeight -= 20;//subtract caption bar from rendertarget size. - mHeight = mFloor(mHeight / mTargetScale); + mHeight = mFloor(mPlatformWindow->getClientExtent().y / mTargetScale); if (mWidth < 16 || mHeight < 16) return false; @@ -248,19 +242,19 @@ bool VolumetricFogRTManager::Resize() mFrontBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F, &GFXDefaultRenderTargetProfile, avar("%s() - mFrontBuffer (line %d)", __FUNCTION__, __LINE__)); if (!mFrontBuffer.isValid()) - { + { Con::errorf("VolumetricFogRTManager::Resize() Fatal Error: Unable to create front buffer"); return false; - } + } mFrontTarget.setTexture(mFrontBuffer); mDepthBuffer = GFXTexHandle(mWidth, mHeight, GFXFormatR32F, &GFXDefaultRenderTargetProfile, avar("%s() - mDepthBuffer (line %d)", __FUNCTION__, __LINE__)); if (!mDepthBuffer.isValid()) - { - Con::errorf("VolumetricFogRTManager::Resize() Fatal Error: Unable to create Depthbuffer"); - return false; - } + { + Con::errorf("VolumetricFogRTManager::Resize() Fatal Error: Unable to create Depthbuffer"); + return false; + } mDepthTarget.setTexture(mDepthBuffer); return true; } diff --git a/Engine/source/environment/VolumetricFogRTManager.h b/Engine/source/environment/VolumetricFogRTManager.h index d69bed6bd..8000a4447 100644 --- a/Engine/source/environment/VolumetricFogRTManager.h +++ b/Engine/source/environment/VolumetricFogRTManager.h @@ -62,7 +62,6 @@ class VolumetricFogRTManager : public SceneObject U32 mFogHasAnswered; U32 mWidth; U32 mHeight; - bool mFullScreen; void onRemove(); void onSceneRemove(); diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp index dbdeef48b..7607246f4 100644 --- a/Engine/source/environment/scatterSky.cpp +++ b/Engine/source/environment/scatterSky.cpp @@ -1067,17 +1067,17 @@ void ScatterSky::_renderMoon( ObjectRenderInst *ri, SceneRenderState *state, Bas // Initialize points with basic info Point3F points[4]; - points[0] = Point3F(-BBRadius, 0.0, -BBRadius); + points[0] = Point3F( -BBRadius, 0.0, -BBRadius); points[1] = Point3F( -BBRadius, 0.0, BBRadius); - points[2] = Point3F( BBRadius, 0.0, BBRadius); - points[3] = Point3F( BBRadius, 0.0, -BBRadius); + points[2] = Point3F( BBRadius, 0.0, -BBRadius); + points[3] = Point3F( BBRadius, 0.0, BBRadius); static const Point2F sCoords[4] = { Point2F( 0.0f, 0.0f ), Point2F( 0.0f, 1.0f ), - Point2F( 1.0f, 1.0f ), - Point2F( 1.0f, 0.0f ) + Point2F( 1.0f, 0.0f ), + Point2F( 1.0f, 1.0f ) }; // Get info we need to adjust points @@ -1126,7 +1126,7 @@ void ScatterSky::_renderMoon( ObjectRenderInst *ri, SceneRenderState *state, Bas mMoonMatInst->setSceneInfo( state, sgData ); GFX->setVertexBuffer( vb ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); } } diff --git a/Engine/source/environment/sun.cpp b/Engine/source/environment/sun.cpp index d79d923d6..729e3b57b 100644 --- a/Engine/source/environment/sun.cpp +++ b/Engine/source/environment/sun.cpp @@ -467,15 +467,15 @@ void Sun::_renderCorona( ObjectRenderInst *ri, SceneRenderState *state, BaseMatI Point3F points[4]; points[0] = Point3F(-BBRadius, 0.0, -BBRadius); points[1] = Point3F( -BBRadius, 0.0, BBRadius); - points[2] = Point3F( BBRadius, 0.0, BBRadius); - points[3] = Point3F( BBRadius, 0.0, -BBRadius); + points[2] = Point3F( BBRadius, 0.0, -BBRadius); + points[3] = Point3F(BBRadius, 0.0, BBRadius); static const Point2F sCoords[4] = { Point2F( 0.0f, 0.0f ), Point2F( 0.0f, 1.0f ), - Point2F( 1.0f, 1.0f ), - Point2F( 1.0f, 0.0f ) + Point2F( 1.0f, 0.0f ), + Point2F(1.0f, 1.0f) }; // Get info we need to adjust points @@ -525,7 +525,7 @@ void Sun::_renderCorona( ObjectRenderInst *ri, SceneRenderState *state, BaseMatI mCoronaMatInst->setSceneInfo( state, sgData ); GFX->setVertexBuffer( vb ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); } } diff --git a/Engine/source/environment/waterObject.cpp b/Engine/source/environment/waterObject.cpp index 9b527e4c8..1dab7ca74 100644 --- a/Engine/source/environment/waterObject.cpp +++ b/Engine/source/environment/waterObject.cpp @@ -826,25 +826,25 @@ void WaterObject::drawUnderwaterFilter( SceneRenderState *state ) // draw quad - GFXVertexBufferHandle verts( GFX, 4, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts( GFX, 4, GFXBufferTypeVolatile ); verts.lock(); - verts[0].point.set( -1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0 ); + verts[0].point.set(1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0); verts[0].color = mUnderwaterColor; - verts[1].point.set( -1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0 ); + verts[1].point.set(1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0); verts[1].color = mUnderwaterColor; - verts[2].point.set( 1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0 ); + verts[2].point.set(-1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0); verts[2].color = mUnderwaterColor; - verts[3].point.set( 1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0 ); + verts[3].point.set(-1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0); verts[3].color = mUnderwaterColor; verts.unlock(); GFX->setVertexBuffer( verts ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); // reset states / transforms GFX->setProjectionMatrix( proj ); @@ -1141,7 +1141,7 @@ bool WaterObject::initMaterial( S32 idx ) else mat = MATMGR->createMatInstance( mSurfMatName[idx] ); - const GFXVertexFormat *flags = getGFXVertexFormat(); + const GFXVertexFormat *flags = getGFXVertexFormat(); if ( mat && mat->init( MATMGR->getDefaultFeatures(), flags ) ) { diff --git a/Engine/source/gfx/D3D9/gfxD3D9Device.cpp b/Engine/source/gfx/D3D9/gfxD3D9Device.cpp index d3eb8ed8a..c6610ed14 100644 --- a/Engine/source/gfx/D3D9/gfxD3D9Device.cpp +++ b/Engine/source/gfx/D3D9/gfxD3D9Device.cpp @@ -826,6 +826,7 @@ GFXVertexBuffer * GFXD3D9Device::allocVertexBuffer( U32 numVerts, switch(bufferType) { + case GFXBufferTypeImmutable: case GFXBufferTypeStatic: pool = isD3D9Ex() ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED; break; diff --git a/Engine/source/gfx/D3D9/gfxD3D9Shader.cpp b/Engine/source/gfx/D3D9/gfxD3D9Shader.cpp index 2af7a9abd..657797319 100644 --- a/Engine/source/gfx/D3D9/gfxD3D9Shader.cpp +++ b/Engine/source/gfx/D3D9/gfxD3D9Shader.cpp @@ -1307,10 +1307,15 @@ void GFXD3D9Shader::_buildSamplerShaderConstantHandles( VectorgetElementCount(); i++ ) { - const GFXVertexElement &element = mInstancingFormat.getElement( i ); + const GFXVertexElement &element = mInstancingFormat->getElement( i ); String constName = String::ToString( "$%s", element.getSemantic().c_str() ); @@ -1347,9 +1352,9 @@ void GFXD3D9Shader::_buildInstancingShaderConstantHandles() // 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++ ) + for ( ; i < mInstancingFormat->getElementCount(); i++ ) { - const GFXVertexElement &nextElement = mInstancingFormat.getElement( i ); + const GFXVertexElement &nextElement = mInstancingFormat->getElement( i ); if ( nextElement.getSemantic() != element.getSemantic() ) { i--; diff --git a/Engine/source/gfx/D3D9/gfxD3D9VertexBuffer.cpp b/Engine/source/gfx/D3D9/gfxD3D9VertexBuffer.cpp index d31e93870..0da7a3895 100644 --- a/Engine/source/gfx/D3D9/gfxD3D9VertexBuffer.cpp +++ b/Engine/source/gfx/D3D9/gfxD3D9VertexBuffer.cpp @@ -55,6 +55,7 @@ void GFXD3D9VertexBuffer::lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr) switch( mBufferType ) { + case GFXBufferTypeImmutable: case GFXBufferTypeStatic: break; @@ -203,7 +204,7 @@ void GFXD3D9VertexBuffer::zombify() { AssertFatal(lockedVertexStart == 0 && lockedVertexEnd == 0, "GFXD3D9VertexBuffer::zombify - Cannot zombify a locked buffer!"); // Static buffers are managed by D3D9 so we don't deal with them. - if(mBufferType == GFXBufferTypeDynamic) + if(mBufferType == GFXBufferTypeDynamic || mBufferType == GFXBufferTypeImmutable) { SAFE_RELEASE(vb); } diff --git a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp b/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp index 29063f4e4..77ea67041 100644 --- a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp +++ b/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp @@ -302,7 +302,6 @@ void GFXD3D9EnumTranslate::init() GFXD3D9PrimType[GFXLineStrip] = D3DPT_LINESTRIP; GFXD3D9PrimType[GFXTriangleList] = D3DPT_TRIANGLELIST; GFXD3D9PrimType[GFXTriangleStrip] = D3DPT_TRIANGLESTRIP; - GFXD3D9PrimType[GFXTriangleFan] = D3DPT_TRIANGLEFAN; VALIDATE_LOOKUPTABLE( GFXD3D9PrimType, GFXPT ); //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ diff --git a/Engine/source/gfx/D3D9/pc/gfxPCD3D9Device.cpp b/Engine/source/gfx/D3D9/pc/gfxPCD3D9Device.cpp index 3dfcfe1d4..d113bf70b 100644 --- a/Engine/source/gfx/D3D9/pc/gfxPCD3D9Device.cpp +++ b/Engine/source/gfx/D3D9/pc/gfxPCD3D9Device.cpp @@ -514,7 +514,7 @@ void GFXPCD3D9Device::init( const GFXVideoMode &mode, PlatformWindow *window /* mCardProfiler = new GFXD3D9CardProfiler(mAdapterIndex); mCardProfiler->init(); - gScreenShot = new ScreenShotD3D; + gScreenShot = new ScreenShotD3D9; // Set the video capture frame grabber. mVideoFrameGrabber = new VideoFrameGrabberD3D9(); diff --git a/Engine/source/gfx/D3D9/screenshotD3D9.cpp b/Engine/source/gfx/D3D9/screenshotD3D9.cpp index b6b5e0500..c7d3ff3cb 100644 --- a/Engine/source/gfx/D3D9/screenshotD3D9.cpp +++ b/Engine/source/gfx/D3D9/screenshotD3D9.cpp @@ -30,7 +30,7 @@ #include -GBitmap* ScreenShotD3D::_captureBackBuffer() +GBitmap* ScreenShotD3D9::_captureBackBuffer() { #ifdef TORQUE_OS_XENON return NULL; diff --git a/Engine/source/gfx/D3D9/screenshotD3D9.h b/Engine/source/gfx/D3D9/screenshotD3D9.h index d017591d6..023fa1562 100644 --- a/Engine/source/gfx/D3D9/screenshotD3D9.h +++ b/Engine/source/gfx/D3D9/screenshotD3D9.h @@ -19,15 +19,15 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS // IN THE SOFTWARE. //----------------------------------------------------------------------------- -#ifndef _SCREENSHOTD3D_H_ -#define _SCREENSHOTD3D_H_ +#ifndef _SCREENSHOTD3D9_H_ +#define _SCREENSHOTD3D9_H_ #include "gfx/screenshot.h" //************************************************************************** // D3D implementation of screenshot //************************************************************************** -class ScreenShotD3D : public ScreenShot +class ScreenShotD3D9 : public ScreenShot { protected: @@ -36,4 +36,4 @@ protected: }; -#endif // _SCREENSHOTD3D_H_ +#endif // _SCREENSHOTD3D9_H_ diff --git a/Engine/source/gfx/genericConstBuffer.h b/Engine/source/gfx/genericConstBuffer.h index b8a012159..c38947541 100644 --- a/Engine/source/gfx/genericConstBuffer.h +++ b/Engine/source/gfx/genericConstBuffer.h @@ -106,7 +106,7 @@ public: virtual ~GenericConstBufferLayout() {} /// Add a parameter to the buffer - void addParameter(const String& name, const GFXShaderConstType constType, const U32 offset, const U32 size, const U32 arraySize, const U32 alignValue); + virtual void addParameter(const String& name, const GFXShaderConstType constType, const U32 offset, const U32 size, const U32 arraySize, const U32 alignValue); /// Get the size of the buffer inline U32 getBufferSize() const { return mBufferSize; } @@ -210,6 +210,9 @@ public: /// state at the same time. inline const U8* getDirtyBuffer( U32 *start, U32 *size ); + /// Gets the entire buffer ignoring dirty range + inline const U8* getEntireBuffer(); + /// Sets the entire buffer as dirty or clears the dirty state. inline void setDirty( bool dirty ); @@ -348,6 +351,13 @@ inline const U8* GenericConstBuffer::getDirtyBuffer( U32 *start, U32 *size ) return buffer; } +inline const U8* GenericConstBuffer::getEntireBuffer() +{ + AssertFatal(mBuffer, "GenericConstBuffer::getDirtyBuffer() - Buffer is empty!"); + + return mBuffer; +} + inline bool GenericConstBuffer::isEqual( const GenericConstBuffer *buffer ) const { U32 bsize = mLayout->getBufferSize(); diff --git a/Engine/source/gfx/gfxAPI.cpp b/Engine/source/gfx/gfxAPI.cpp index 91a9974df..b41b1297b 100644 --- a/Engine/source/gfx/gfxAPI.cpp +++ b/Engine/source/gfx/gfxAPI.cpp @@ -41,7 +41,7 @@ ImplementEnumType( GFXAdapterType, "Back-end graphics API used by the GFX subsystem.\n\n" "@ingroup GFX" ) { OpenGL, "OpenGL", "OpenGL." }, - { Direct3D8, "D3D8", "Direct3D 8." }, + { Direct3D11, "D3D11", "Direct3D 11." }, { Direct3D9, "D3D9", "Direct3D 9." }, { NullDevice, "NullDevice", "Null device for dedicated servers." }, { Direct3D9_360, "Xenon", "Direct3D 9 on Xbox 360." } diff --git a/Engine/source/gfx/gfxDevice.cpp b/Engine/source/gfx/gfxDevice.cpp index 3f63fb884..5158f2992 100644 --- a/Engine/source/gfx/gfxDevice.cpp +++ b/Engine/source/gfx/gfxDevice.cpp @@ -514,6 +514,8 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/) mStateBlockDirty = false; } + _updateRenderTargets(); + if( mTexturesDirty ) { mTexturesDirty = false; diff --git a/Engine/source/gfx/gfxDrawUtil.cpp b/Engine/source/gfx/gfxDrawUtil.cpp index 34b1c8872..3adbfb7b7 100644 --- a/Engine/source/gfx/gfxDrawUtil.cpp +++ b/Engine/source/gfx/gfxDrawUtil.cpp @@ -458,7 +458,7 @@ void GFXDrawUtil::drawRect( const Point2F &upperLeft, const Point2F &lowerRight, Point2F nw(-0.5f,-0.5f); /* \ */ Point2F ne(0.5f,-0.5f); /* / */ - GFXVertexBufferHandle verts (mDevice, 10, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts (mDevice, 10, GFXBufferTypeVolatile ); verts.lock(); F32 ulOffset = 0.5f - mDevice->getFillConventionOffset(); @@ -521,12 +521,12 @@ void GFXDrawUtil::drawRectFill( const Point2F &upperLeft, const Point2F &lowerRi Point2F nw(-0.5,-0.5); /* \ */ Point2F ne(0.5,-0.5); /* / */ - GFXVertexBufferHandle verts(mDevice, 4, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 4, GFXBufferTypeVolatile); verts.lock(); F32 ulOffset = 0.5f - mDevice->getFillConventionOffset(); - verts[0].point.set( upperLeft.x + nw.x + ulOffset, upperLeft.y + nw.y + ulOffset, 0.0f); + verts[0].point.set( upperLeft.x+nw.x + ulOffset, upperLeft.y+nw.y + ulOffset, 0.0f ); verts[1].point.set( lowerRight.x + ne.x + ulOffset, upperLeft.y + ne.y + ulOffset, 0.0f); verts[2].point.set( upperLeft.x - ne.x + ulOffset, lowerRight.y - ne.y + ulOffset, 0.0f); verts[3].point.set( lowerRight.x - nw.x + ulOffset, lowerRight.y - nw.y + ulOffset, 0.0f); @@ -548,7 +548,7 @@ void GFXDrawUtil::draw2DSquare( const Point2F &screenPoint, F32 width, F32 spinA Point3F offset( screenPoint.x, screenPoint.y, 0.0 ); - GFXVertexBufferHandle verts( mDevice, 4, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts( mDevice, 4, GFXBufferTypeVolatile ); verts.lock(); verts[0].point.set( -width, -width, 0.0f ); @@ -608,7 +608,7 @@ void GFXDrawUtil::drawLine( F32 x1, F32 y1, F32 x2, F32 y2, const ColorI &color void GFXDrawUtil::drawLine( F32 x1, F32 y1, F32 z1, F32 x2, F32 y2, F32 z2, const ColorI &color ) { - GFXVertexBufferHandle verts( mDevice, 2, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts( mDevice, 2, GFXBufferTypeVolatile ); verts.lock(); verts[0].point.set( x1, y1, z1 ); @@ -647,7 +647,7 @@ void GFXDrawUtil::drawSphere( const GFXStateBlockDesc &desc, F32 radius, const P const SphereMesh::TriangleMesh * sphereMesh = gSphere.getMesh(2); S32 numPoly = sphereMesh->numPoly; S32 totalPoly = 0; - GFXVertexBufferHandle verts(mDevice, numPoly*3, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, numPoly*3, GFXBufferTypeVolatile); verts.lock(); S32 vertexIndex = 0; for (S32 i=0; i verts(mDevice, 4, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 4, GFXBufferTypeVolatile); verts.lock(); // Set up the line strip @@ -745,7 +745,7 @@ void GFXDrawUtil::_drawWireTriangle( const GFXStateBlockDesc &desc, const Point3 void GFXDrawUtil::_drawSolidTriangle( const GFXStateBlockDesc &desc, const Point3F &p0, const Point3F &p1, const Point3F &p2, const ColorI &color, const MatrixF *xfm ) { - GFXVertexBufferHandle verts(mDevice, 3, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 3, GFXBufferTypeVolatile); verts.lock(); // Set up the line strip @@ -778,7 +778,7 @@ void GFXDrawUtil::drawPolygon( const GFXStateBlockDesc& desc, const Point3F* poi { const bool isWireframe = ( desc.fillMode == GFXFillWireframe ); const U32 numVerts = isWireframe ? numPoints + 1 : numPoints; - GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numVerts, GFXBufferTypeVolatile ); + GFXVertexBufferHandle< GFXVertexPCT > verts( mDevice, numVerts, GFXBufferTypeVolatile ); verts.lock(); for( U32 i = 0; i < numPoints; ++ i ) @@ -809,7 +809,7 @@ void GFXDrawUtil::drawPolygon( const GFXStateBlockDesc& desc, const Point3F* poi if( desc.fillMode == GFXFillWireframe ) mDevice->drawPrimitive( GFXLineStrip, 0, numPoints ); else - mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints - 2 ); + mDevice->drawPrimitive( GFXTriangleStrip, 0, numPoints - 2 ); } void GFXDrawUtil::drawCube( const GFXStateBlockDesc &desc, const Box3F &box, const ColorI &color, const MatrixF *xfm ) @@ -827,7 +827,7 @@ void GFXDrawUtil::drawCube( const GFXStateBlockDesc &desc, const Point3F &size, void GFXDrawUtil::_drawWireCube( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const ColorI &color, const MatrixF *xfm ) { - GFXVertexBufferHandle verts(mDevice, 30, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 30, GFXBufferTypeVolatile); verts.lock(); Point3F halfSize = size * 0.5f; @@ -870,7 +870,7 @@ void GFXDrawUtil::_drawWireCube( const GFXStateBlockDesc &desc, const Point3F &s void GFXDrawUtil::_drawSolidCube( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const ColorI &color, const MatrixF *xfm ) { - GFXVertexBufferHandle verts(mDevice, 36, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 36, GFXBufferTypeVolatile); verts.lock(); Point3F halfSize = size * 0.5f; @@ -950,7 +950,7 @@ void GFXDrawUtil::_drawWirePolyhedron( const GFXStateBlockDesc &desc, const AnyP // Allocate a temporary vertex buffer. - GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numEdges * 2, GFXBufferTypeVolatile); + GFXVertexBufferHandle< GFXVertexPCT > verts( mDevice, numEdges * 2, GFXBufferTypeVolatile); // Fill it with the vertices for the edges. @@ -997,7 +997,7 @@ void GFXDrawUtil::_drawSolidPolyhedron( const GFXStateBlockDesc &desc, const Any // Create a temp buffer for the vertices and // put all the polyhedron's points in there. - GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numPoints, GFXBufferTypeVolatile ); + GFXVertexBufferHandle< GFXVertexPCT > verts( mDevice, numPoints, GFXBufferTypeVolatile ); verts.lock(); for( U32 i = 0; i < numPoints; ++ i ) @@ -1071,7 +1071,7 @@ void GFXDrawUtil::_drawSolidPolyhedron( const GFXStateBlockDesc &desc, const Any for( U32 i = 0; i < numPolys; ++ i ) { U32 numVerts = numIndicesForPoly[ i ]; - mDevice->drawIndexedPrimitive( GFXTriangleFan, 0, 0, numPoints, startIndex, numVerts - 2 ); + mDevice->drawIndexedPrimitive( GFXTriangleStrip, 0, 0, numPoints, startIndex, numVerts - 2 ); startIndex += numVerts; } } @@ -1119,7 +1119,7 @@ void GFXDrawUtil::drawObjectBox( const GFXStateBlockDesc &desc, const Point3F &s PrimBuild::end(); } -static const Point2F circlePoints[] = +static const Point2F circlePoints[] = { Point2F(0.707107f, 0.707107f), Point2F(0.923880f, 0.382683f), @@ -1156,7 +1156,7 @@ void GFXDrawUtil::_drawSolidCapsule( const GFXStateBlockDesc &desc, const Point3 mat = MatrixF::Identity; S32 numPoints = sizeof(circlePoints)/sizeof(Point2F); - GFXVertexBufferHandle verts(mDevice, numPoints * 2 + 2, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, numPoints * 2 + 2, GFXBufferTypeVolatile); verts.lock(); for (S32 i=0; imultWorld(mat); S32 numPoints = sizeof(circlePoints)/sizeof(Point2F); - GFXVertexBufferHandle verts(mDevice, numPoints, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, numPoints, GFXBufferTypeVolatile); verts.lock(); for (S32 i=0; i< numPoints; i++) { @@ -1268,27 +1268,57 @@ void GFXDrawUtil::drawCone( const GFXStateBlockDesc &desc, const Point3F &basePn mDevice->multWorld(mat); S32 numPoints = sizeof(circlePoints)/sizeof(Point2F); - GFXVertexBufferHandle verts(mDevice, numPoints + 2, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, numPoints * 3 + 2, GFXBufferTypeVolatile); verts.lock(); - verts[0].point = Point3F(0.0f,0.0f,1.0f); - verts[0].color = color; - for (S32 i=0; isetStateBlockByDesc( desc ); mDevice->setVertexBuffer( verts ); - mDevice->setupGenericShaders( GFXDevice::GSModColorTexture ); + mDevice->setupGenericShaders(); - mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints ); - mDevice->drawPrimitive( GFXTriangleFan, 1, numPoints-1 ); + mDevice->drawPrimitive(GFXTriangleStrip, 0, numPoints - 2); + mDevice->drawPrimitive(GFXTriangleStrip, numPoints, numPoints * 2); mDevice->popWorldMatrix(); + } void GFXDrawUtil::drawCylinder( const GFXStateBlockDesc &desc, const Point3F &basePnt, const Point3F &tipPnt, F32 radius, const ColorI &color ) @@ -1307,32 +1337,59 @@ void GFXDrawUtil::drawCylinder( const GFXStateBlockDesc &desc, const Point3F &ba mDevice->pushWorldMatrix(); mDevice->multWorld(mat); - S32 numPoints = sizeof(circlePoints)/sizeof(Point2F); - GFXVertexBufferHandle verts(mDevice, numPoints * 4 + 4, GFXBufferTypeVolatile); + S32 numPoints = sizeof(circlePoints) / sizeof(Point2F); + GFXVertexBufferHandle verts(mDevice, numPoints *4 + 2, GFXBufferTypeVolatile); verts.lock(); - for (S32 i=0; isetStateBlockByDesc( desc ); mDevice->setVertexBuffer( verts ); - mDevice->setupGenericShaders( GFXDevice::GSModColorTexture ); + mDevice->setupGenericShaders(); - mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints ); - mDevice->drawPrimitive( GFXTriangleFan, numPoints + 1, numPoints ); - mDevice->drawPrimitive( GFXTriangleStrip, 2 * numPoints + 2, 2 * numPoints); + mDevice->drawPrimitive( GFXTriangleStrip, 0, numPoints-2 ); + mDevice->drawPrimitive( GFXTriangleStrip, numPoints, numPoints - 2); + mDevice->drawPrimitive( GFXTriangleStrip, numPoints*2, numPoints * 2); mDevice->popWorldMatrix(); } @@ -1393,7 +1450,7 @@ void GFXDrawUtil::drawFrustum( const Frustum &f, const ColorI &color ) void GFXDrawUtil::drawSolidPlane( const GFXStateBlockDesc &desc, const Point3F &pos, const Point2F &size, const ColorI &color ) { - GFXVertexBufferHandle verts(mDevice, 4, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(mDevice, 4, GFXBufferTypeVolatile); verts.lock(); verts[0].point = pos + Point3F( -size.x / 2.0f, -size.y / 2.0f, 0 ); @@ -1412,7 +1469,7 @@ void GFXDrawUtil::drawSolidPlane( const GFXStateBlockDesc &desc, const Point3F & mDevice->setVertexBuffer( verts ); mDevice->setupGenericShaders(); - mDevice->drawPrimitive( GFXTriangleFan, 0, 2 ); + mDevice->drawPrimitive( GFXTriangleStrip, 0, 2 ); } void GFXDrawUtil::drawPlaneGrid( const GFXStateBlockDesc &desc, const Point3F &pos, const Point2F &size, const Point2F &step, const ColorI &color, Plane plane ) @@ -1449,7 +1506,7 @@ void GFXDrawUtil::drawPlaneGrid( const GFXStateBlockDesc &desc, const Point3F &p break; } - GFXVertexBufferHandle verts( mDevice, numVertices, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts( mDevice, numVertices, GFXBufferTypeVolatile ); verts.lock(); U32 vertCount = 0; @@ -1541,7 +1598,7 @@ void GFXDrawUtil::drawTransform( const GFXStateBlockDesc &desc, const MatrixF &m GFX->multWorld( mat ); - GFXVertexBufferHandle verts( mDevice, 6, GFXBufferTypeVolatile ); + GFXVertexBufferHandle verts( mDevice, 6, GFXBufferTypeVolatile ); verts.lock(); const static ColorI defColors[3] = diff --git a/Engine/source/gfx/gfxEnums.h b/Engine/source/gfx/gfxEnums.h index e0c560ac8..0e3878154 100644 --- a/Engine/source/gfx/gfxEnums.h +++ b/Engine/source/gfx/gfxEnums.h @@ -68,7 +68,6 @@ enum GFXPrimitiveType GFXLineStrip, GFXTriangleList, GFXTriangleStrip, - GFXTriangleFan, GFXPT_COUNT }; @@ -277,8 +276,8 @@ enum GFXBlend enum GFXAdapterType { OpenGL = 0, + Direct3D11, Direct3D9, - Direct3D8, NullDevice, Direct3D9_360, GFXAdapterType_Count diff --git a/Engine/source/gfx/gfxInit.cpp b/Engine/source/gfx/gfxInit.cpp index 3b0ef44e1..09d503d10 100644 --- a/Engine/source/gfx/gfxInit.cpp +++ b/Engine/source/gfx/gfxInit.cpp @@ -77,8 +77,8 @@ inline static void _GFXInitReportAdapters(Vector &adapters) case NullDevice: Con::printf(" Null device found"); break; - case Direct3D8: - Con::printf(" Direct 3D (version 8.1) device found"); + case Direct3D11: + Con::printf(" Direct 3D (version 11.x) device found"); break; default : Con::printf(" Unknown device found"); @@ -221,7 +221,8 @@ GFXAdapter* GFXInit::chooseAdapter( GFXAdapterType type, const char* outputDevic const char* GFXInit::getAdapterNameFromType(GFXAdapterType type) { - static const char* _names[] = { "OpenGL", "D3D9", "D3D8", "NullDevice", "Xenon" }; + // must match GFXAdapterType order + static const char* _names[] = { "OpenGL", "D3D11", "D3D9", "NullDevice", "Xenon" }; if( type < 0 || type >= GFXAdapterType_Count ) { @@ -268,51 +269,53 @@ GFXAdapter *GFXInit::getBestAdapterChoice() // // If D3D is unavailable, we're not on windows, so GL is de facto the // best choice! - F32 highestSM9 = 0.f, highestSMGL = 0.f; - GFXAdapter *foundAdapter8 = NULL, *foundAdapter9 = NULL, - *foundAdapterGL = NULL; + F32 highestSMDX = 0.f, highestSMGL = 0.f; + GFXAdapter *foundAdapter9 = NULL, *foundAdapterGL = NULL, *foundAdapter11 = NULL; - for(S32 i=0; imType) + switch (currAdapter->mType) { - case Direct3D9: - if(currAdapter->mShaderModel > highestSM9) + case Direct3D11: + if (currAdapter->mShaderModel > highestSMDX) { - highestSM9 = currAdapter->mShaderModel; + highestSMDX = currAdapter->mShaderModel; + foundAdapter11 = currAdapter; + } + break; + + case Direct3D9: + if (currAdapter->mShaderModel > highestSMDX) + { + highestSMDX = currAdapter->mShaderModel; foundAdapter9 = currAdapter; } break; case OpenGL: - if(currAdapter->mShaderModel > highestSMGL) + if (currAdapter->mShaderModel > highestSMGL) { highestSMGL = currAdapter->mShaderModel; foundAdapterGL = currAdapter; } break; - case Direct3D8: - if(!foundAdapter8) - foundAdapter8 = currAdapter; - break; - default: break; } } - // Return best found in order DX9, GL, DX8. - if(foundAdapter9) + // Return best found in order DX11,DX9, GL + if (foundAdapter11) + return foundAdapter11; + + if (foundAdapter9) return foundAdapter9; - if(foundAdapterGL) + if (foundAdapterGL) return foundAdapterGL; - if(foundAdapter8) - return foundAdapter8; - // Uh oh - we didn't find anything. Grab whatever we can that's not Null... for(S32 i=0; imType != NullDevice) diff --git a/Engine/source/gfx/gfxShader.cpp b/Engine/source/gfx/gfxShader.cpp index 5e81d8a10..54f1893e6 100644 --- a/Engine/source/gfx/gfxShader.cpp +++ b/Engine/source/gfx/gfxShader.cpp @@ -35,7 +35,8 @@ bool GFXShader::smLogWarnings = true; GFXShader::GFXShader() : mPixVersion( 0.0f ), - mReloadKey( 0 ) + mReloadKey( 0 ), + mInstancingFormat( NULL ) { } @@ -43,6 +44,8 @@ GFXShader::~GFXShader() { Torque::FS::RemoveChangeNotification( mVertexFile, this, &GFXShader::_onFileChanged ); Torque::FS::RemoveChangeNotification( mPixelFile, this, &GFXShader::_onFileChanged ); + + SAFE_DELETE(mInstancingFormat); } #ifndef TORQUE_OPENGL @@ -60,8 +63,16 @@ bool GFXShader::init( const Torque::Path &vertFile, const Torque::Path &pixFile, F32 pixVersion, const Vector ¯os, - const Vector &samplerNames) + const Vector &samplerNames, + GFXVertexFormat *instanceFormat) { + // Take care of instancing + if (instanceFormat) + { + mInstancingFormat = new GFXVertexFormat; + mInstancingFormat->copy(*instanceFormat); + } + // Store the inputs for use in reloading. mVertexFile = vertFile; mPixelFile = pixFile; diff --git a/Engine/source/gfx/gfxShader.h b/Engine/source/gfx/gfxShader.h index 318ab5ec0..f9059fbc0 100644 --- a/Engine/source/gfx/gfxShader.h +++ b/Engine/source/gfx/gfxShader.h @@ -262,13 +262,12 @@ protected: /// their destructor. Vector mActiveBuffers; + GFXVertexFormat *mInstancingFormat; + /// A protected constructor so it cannot be instantiated. GFXShader(); -public: - - // TODO: Add this into init(). - GFXVertexFormat mInstancingFormat; +public: /// Adds a global shader macro which will be merged with /// the script defined macros on every shader reload. @@ -312,7 +311,8 @@ public: const Torque::Path &pixFile, F32 pixVersion, const Vector ¯os, - const Vector &samplerNames); + const Vector &samplerNames, + GFXVertexFormat *instanceFormat = NULL ); /// Reloads the shader from disk. bool reload(); @@ -358,6 +358,9 @@ public: // GFXResource const String describeSelf() const { return mDescription; } + // Get instancing vertex format + GFXVertexFormat *getInstancingFormat() { return mInstancingFormat; } + protected: /// Called when the shader files change on disk. diff --git a/Engine/source/gfx/gfxStringEnumTranslate.cpp b/Engine/source/gfx/gfxStringEnumTranslate.cpp index 38fe29c7a..c564fbb29 100644 --- a/Engine/source/gfx/gfxStringEnumTranslate.cpp +++ b/Engine/source/gfx/gfxStringEnumTranslate.cpp @@ -347,7 +347,6 @@ void GFXStringEnumTranslate::init() GFX_STRING_ASSIGN_MACRO( GFXStringPrimType, GFXLineStrip ); GFX_STRING_ASSIGN_MACRO( GFXStringPrimType, GFXTriangleList ); GFX_STRING_ASSIGN_MACRO( GFXStringPrimType, GFXTriangleStrip ); - GFX_STRING_ASSIGN_MACRO( GFXStringPrimType, GFXTriangleFan ); VALIDATE_LOOKUPTABLE( GFXStringPrimType, GFXPT ); //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ diff --git a/Engine/source/gfx/gfxVertexFormat.cpp b/Engine/source/gfx/gfxVertexFormat.cpp index fe1a2cf46..15f16a4d4 100644 --- a/Engine/source/gfx/gfxVertexFormat.cpp +++ b/Engine/source/gfx/gfxVertexFormat.cpp @@ -70,6 +70,7 @@ GFXVertexFormat::GFXVertexFormat() mHasColor( false ), mHasNormal( false ), mHasTangent( false ), + mHasInstancing( false ), mTexCoordCount( 0 ), mSizeInBytes( 0 ), mDecl( NULL ) @@ -83,6 +84,7 @@ void GFXVertexFormat::copy( const GFXVertexFormat &format ) mHasNormal = format.mHasNormal; mHasTangent = format.mHasTangent; mHasColor = format.mHasColor; + mHasInstancing = format.mHasInstancing; mTexCoordCount = format.mTexCoordCount; mSizeInBytes = format.mSizeInBytes; mDescription = format.mDescription; @@ -161,6 +163,14 @@ bool GFXVertexFormat::hasColor() const return mHasColor; } +bool GFXVertexFormat::hasInstancing() const +{ + if (mDirty) + const_cast(this)->_updateDirty(); + + return mHasInstancing; +} + U32 GFXVertexFormat::getTexCoordCount() const { if ( mDirty ) @@ -177,6 +187,11 @@ U32 GFXVertexFormat::getSizeInBytes() const return mSizeInBytes; } +void GFXVertexFormat::enableInstancing() +{ + mHasInstancing = true; +} + void GFXVertexFormat::_updateDirty() { PROFILE_SCOPE( GFXVertexFormat_updateDirty ); diff --git a/Engine/source/gfx/gfxVertexFormat.h b/Engine/source/gfx/gfxVertexFormat.h index 0f32e085e..09934e0df 100644 --- a/Engine/source/gfx/gfxVertexFormat.h +++ b/Engine/source/gfx/gfxVertexFormat.h @@ -153,6 +153,9 @@ public: /// The copy constructor. GFXVertexFormat( const GFXVertexFormat &format ) { copy( format ); } + /// Tell this format it has instancing + void enableInstancing(); + /// Copy the other vertex format. void copy( const GFXVertexFormat &format ); @@ -163,7 +166,7 @@ public: const String& getDescription() const; /// Clears all the vertex elements. - void clear(); + void clear(); /// Adds a vertex element to the format. /// @@ -182,6 +185,9 @@ public: /// Returns true if there is a COLOR semantic in this vertex format. bool hasColor() const; + /// Return true if instancing is used with this vertex format. + bool hasInstancing() const; + /// Returns the texture coordinate count by /// counting the number of TEXCOORD semantics. U32 getTexCoordCount() const; @@ -225,6 +231,9 @@ protected: /// Is true if there is a COLOR semantic in this vertex format. bool mHasColor; + /// Is instaning used with this vertex format. + bool mHasInstancing; + /// The texture coordinate count by counting the /// number of "TEXCOORD" semantics. U32 mTexCoordCount; diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp index 01bbd02ea..8d3b8e93a 100644 --- a/Engine/source/gfx/gl/gfxGLDevice.cpp +++ b/Engine/source/gfx/gl/gfxGLDevice.cpp @@ -513,9 +513,6 @@ inline GLsizei GFXGLDevice::primCountToIndexCount(GFXPrimitiveType primType, U32 case GFXTriangleStrip : return 2 + primitiveCount; break; - case GFXTriangleFan : - return 2 + primitiveCount; - break; default: AssertFatal(false, "GFXGLDevice::primCountToIndexCount - unrecognized prim type"); break; @@ -789,7 +786,8 @@ void GFXGLDevice::setupGenericShaders( GenericShaderType type ) shaderData->registerObject(); mGenericShader[GSColor] = shaderData->getShader(); mGenericShaderBuffer[GSColor] = mGenericShader[GSColor]->allocConstBuffer(); - mModelViewProjSC[GSColor] = mGenericShader[GSColor]->getShaderConstHandle( "$modelView" ); + mModelViewProjSC[GSColor] = mGenericShader[GSColor]->getShaderConstHandle( "$modelView" ); + Sim::getRootGroup()->addObject(shaderData); shaderData = new ShaderData(); shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/modColorTextureV.glsl"); @@ -799,7 +797,8 @@ void GFXGLDevice::setupGenericShaders( GenericShaderType type ) shaderData->registerObject(); mGenericShader[GSModColorTexture] = shaderData->getShader(); mGenericShaderBuffer[GSModColorTexture] = mGenericShader[GSModColorTexture]->allocConstBuffer(); - mModelViewProjSC[GSModColorTexture] = mGenericShader[GSModColorTexture]->getShaderConstHandle( "$modelView" ); + mModelViewProjSC[GSModColorTexture] = mGenericShader[GSModColorTexture]->getShaderConstHandle( "$modelView" ); + Sim::getRootGroup()->addObject(shaderData); shaderData = new ShaderData(); shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/addColorTextureV.glsl"); @@ -809,7 +808,8 @@ void GFXGLDevice::setupGenericShaders( GenericShaderType type ) shaderData->registerObject(); mGenericShader[GSAddColorTexture] = shaderData->getShader(); mGenericShaderBuffer[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->allocConstBuffer(); - mModelViewProjSC[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->getShaderConstHandle( "$modelView" ); + mModelViewProjSC[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->getShaderConstHandle( "$modelView" ); + Sim::getRootGroup()->addObject(shaderData); shaderData = new ShaderData(); shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/textureV.glsl"); @@ -820,6 +820,7 @@ void GFXGLDevice::setupGenericShaders( GenericShaderType type ) mGenericShader[GSTexture] = shaderData->getShader(); mGenericShaderBuffer[GSTexture] = mGenericShader[GSTexture]->allocConstBuffer(); mModelViewProjSC[GSTexture] = mGenericShader[GSTexture]->getShaderConstHandle( "$modelView" ); + Sim::getRootGroup()->addObject(shaderData); } MatrixF tempMatrix = mProjectionMatrix * mViewMatrix * mWorldMatrix[mWorldStackSize]; diff --git a/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp b/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp index e78d807c1..7955590e1 100644 --- a/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp +++ b/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp @@ -53,7 +53,6 @@ void GFXGLEnumTranslate::init() GFXGLPrimType[GFXLineStrip] = GL_LINE_STRIP; GFXGLPrimType[GFXTriangleList] = GL_TRIANGLES; GFXGLPrimType[GFXTriangleStrip] = GL_TRIANGLE_STRIP; - GFXGLPrimType[GFXTriangleFan] = GL_TRIANGLE_FAN; // Blend GFXGLBlend[GFXBlendZero] = GL_ZERO; diff --git a/Engine/source/gfx/gl/gfxGLShader.cpp b/Engine/source/gfx/gl/gfxGLShader.cpp index 8de562d9d..2e63c61fe 100644 --- a/Engine/source/gfx/gl/gfxGLShader.cpp +++ b/Engine/source/gfx/gl/gfxGLShader.cpp @@ -664,10 +664,14 @@ void GFXGLShader::initHandles() glUseProgram(0); //instancing + if (!mInstancingFormat) + return; + U32 offset = 0; - for ( U32 i=0; i < mInstancingFormat.getElementCount(); i++ ) + + for ( U32 i=0; i < mInstancingFormat->getElementCount(); i++ ) { - const GFXVertexElement &element = mInstancingFormat.getElement( i ); + const GFXVertexElement &element = mInstancingFormat->getElement( i ); String constName = String::ToString( "$%s", element.getSemantic().c_str() ); @@ -702,9 +706,9 @@ void GFXGLShader::initHandles() // 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++ ) + for ( ; i < mInstancingFormat->getElementCount(); i++ ) { - const GFXVertexElement &nextElement = mInstancingFormat.getElement( i ); + const GFXVertexElement &nextElement = mInstancingFormat->getElement( i ); if ( nextElement.getSemantic() != element.getSemantic() ) { i--; diff --git a/Engine/source/gfx/primBuilder.cpp b/Engine/source/gfx/primBuilder.cpp index af33d3a41..0c661a8e8 100644 --- a/Engine/source/gfx/primBuilder.cpp +++ b/Engine/source/gfx/primBuilder.cpp @@ -117,7 +117,6 @@ GFXVertexBuffer * endToBuffer( U32 &numPrims ) } case GFXTriangleStrip: - case GFXTriangleFan: { numPrims = mCurVertIndex - 2; break; @@ -171,7 +170,6 @@ void end( bool useGenericShaders ) } case GFXTriangleStrip: - case GFXTriangleFan: { stripStart = 2; vertStride = 1; diff --git a/Engine/source/gui/3d/guiTSControl.cpp b/Engine/source/gui/3d/guiTSControl.cpp index cbb520433..02d93690f 100644 --- a/Engine/source/gui/3d/guiTSControl.cpp +++ b/Engine/source/gui/3d/guiTSControl.cpp @@ -110,7 +110,7 @@ namespace start -= lineVec; end += lineVec; - GFXVertexBufferHandle verts(GFX, 4, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(GFX, 4, GFXBufferTypeVolatile); verts.lock(); verts[0].point.set( start.x+perp.x, start.y+perp.y, z1 ); diff --git a/Engine/source/gui/controls/guiGradientCtrl.cpp b/Engine/source/gui/controls/guiGradientCtrl.cpp index e137fabd9..cf29e3996 100644 --- a/Engine/source/gui/controls/guiGradientCtrl.cpp +++ b/Engine/source/gui/controls/guiGradientCtrl.cpp @@ -319,81 +319,79 @@ void GuiGradientCtrl::renderColorBox(RectI &bounds) void GuiGradientCtrl::drawBlendRangeBox(RectI &bounds, bool vertical, Vector colorRange) { GFX->setStateBlock(mStateBlock); - - // Create new global dimensions + + // Create new global dimensions S32 l = bounds.point.x + mSwatchFactor, r = bounds.point.x + bounds.extent.x - mSwatchFactor; S32 t = bounds.point.y, b = bounds.point.y + bounds.extent.y - mSwatchFactor; - - // Draw border using new global dimensions - if (mProfile->mBorder) - GFX->getDrawUtil()->drawRect( RectI( Point2I(l,t),Point2I(r,b) ), mProfile->mBorderColor); - - // Update local dimensions - mBlendRangeBox.point = globalToLocalCoord(Point2I(l, t)); - mBlendRangeBox.extent = globalToLocalCoord(Point2I(r, b)); - ColorRange& firstColorRange = colorRange.first(); - - if(colorRange.size() == 1) // Only one color to draw - { - PrimBuild::begin( GFXTriangleFan, 4 ); + // Draw border using new global dimensions + if (mProfile->mBorder) + GFX->getDrawUtil()->drawRect(RectI(Point2I(l, t), Point2I(r, b)), mProfile->mBorderColor); - PrimBuild::color(firstColorRange.swatch->getColor()); - PrimBuild::vertex2i( l, t ); - PrimBuild::vertex2i( l, b ); + // Update local dimensions + mBlendRangeBox.point = globalToLocalCoord(Point2I(l, t)); + mBlendRangeBox.extent = globalToLocalCoord(Point2I(r, b)); - PrimBuild::color(firstColorRange.swatch->getColor()); - PrimBuild::vertex2i( r, b ); - PrimBuild::vertex2i( r, t ); + if (colorRange.size() == 1) // Only one color to draw + { + PrimBuild::begin(GFXTriangleStrip, 4); - PrimBuild::end(); - } - else - { - PrimBuild::begin( GFXTriangleFan, 4 ); + PrimBuild::color(colorRange.first().swatch->getColor()); + PrimBuild::vertex2i(l, t); + PrimBuild::vertex2i(r, t); - PrimBuild::color(firstColorRange.swatch->getColor()); - PrimBuild::vertex2i( l, t ); - PrimBuild::vertex2i( l, b ); + PrimBuild::color(colorRange.first().swatch->getColor()); + PrimBuild::vertex2i(l, b); + PrimBuild::vertex2i(r, b); - PrimBuild::color(firstColorRange.swatch->getColor()); - PrimBuild::vertex2i(l + firstColorRange.swatch->getPosition().x, b); - PrimBuild::vertex2i(l + firstColorRange.swatch->getPosition().x, t); + PrimBuild::end(); + } + else + { + PrimBuild::begin(GFXTriangleStrip, 4); - PrimBuild::end(); + PrimBuild::color(colorRange.first().swatch->getColor()); + PrimBuild::vertex2i(l, t); + PrimBuild::vertex2i(l + colorRange.first().swatch->getPosition().x, t); - for( U16 i = 0;i < colorRange.size() - 1; i++ ) - { - PrimBuild::begin( GFXTriangleFan, 4 ); - if (!vertical) // Horizontal (+x) - { - // First color - PrimBuild::color( colorRange[i].swatch->getColor() ); - PrimBuild::vertex2i( l + colorRange[i].swatch->getPosition().x, t ); - PrimBuild::vertex2i( l + colorRange[i].swatch->getPosition().x, b ); - - // First color - PrimBuild::color( colorRange[i+1].swatch->getColor() ); - PrimBuild::vertex2i( l + colorRange[i+1].swatch->getPosition().x, b ); - PrimBuild::vertex2i( l + colorRange[i+1].swatch->getPosition().x, t ); - } - PrimBuild::end(); - } + PrimBuild::color(colorRange.first().swatch->getColor()); + PrimBuild::vertex2i(l, b); + PrimBuild::vertex2i(l + colorRange.first().swatch->getPosition().x, b); - ColorRange& lastColorRange = colorRange.last(); + PrimBuild::end(); - PrimBuild::begin( GFXTriangleFan, 4 ); + for (U16 i = 0; i < colorRange.size() - 1; i++) + { + PrimBuild::begin(GFXTriangleStrip, 4); + if (!vertical) // Horizontal (+x) + { + // First color + PrimBuild::color(colorRange[i].swatch->getColor()); + PrimBuild::vertex2i(l + colorRange[i].swatch->getPosition().x, t); + PrimBuild::color(colorRange[i + 1].swatch->getColor()); + PrimBuild::vertex2i(l + colorRange[i + 1].swatch->getPosition().x, t); - PrimBuild::color(lastColorRange.swatch->getColor()); - PrimBuild::vertex2i(l + lastColorRange.swatch->getPosition().x, t); - PrimBuild::vertex2i(l + lastColorRange.swatch->getPosition().x, b); - - PrimBuild::color(lastColorRange.swatch->getColor()); - PrimBuild::vertex2i( r, b ); - PrimBuild::vertex2i( r, t ); + // First color + PrimBuild::color(colorRange[i].swatch->getColor()); + PrimBuild::vertex2i(l + colorRange[i].swatch->getPosition().x, b); + PrimBuild::color(colorRange[i + 1].swatch->getColor()); + PrimBuild::vertex2i(l + colorRange[i + 1].swatch->getPosition().x, b); + } + PrimBuild::end(); + } - PrimBuild::end(); - } + PrimBuild::begin(GFXTriangleStrip, 4); + + PrimBuild::color(colorRange.last().swatch->getColor()); + PrimBuild::vertex2i(l + colorRange.last().swatch->getPosition().x, t); + PrimBuild::vertex2i(r, t); + + PrimBuild::color(colorRange.last().swatch->getColor()); + PrimBuild::vertex2i(l + colorRange.last().swatch->getPosition().x, b); + PrimBuild::vertex2i(r, b); + + PrimBuild::end(); + } } void GuiGradientCtrl::onMouseDown(const GuiEvent &event) diff --git a/Engine/source/gui/controls/guiTextEditSliderCtrl.cpp b/Engine/source/gui/controls/guiTextEditSliderCtrl.cpp index 5d89ec0e2..a3e9c884f 100644 --- a/Engine/source/gui/controls/guiTextEditSliderCtrl.cpp +++ b/Engine/source/gui/controls/guiTextEditSliderCtrl.cpp @@ -355,7 +355,7 @@ void GuiTextEditSliderCtrl::onRender(Point2I offset, const RectI &updateRect) Point2I(start.x+14,midPoint.y), mProfile->mFontColor); - GFXVertexBufferHandle verts(GFX, 6, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(GFX, 6, GFXBufferTypeVolatile); verts.lock(); verts[0].color.set( 0, 0, 0 ); diff --git a/Engine/source/gui/editor/guiEditCtrl.h b/Engine/source/gui/editor/guiEditCtrl.h index 7731545f1..38a1ddf34 100644 --- a/Engine/source/gui/editor/guiEditCtrl.h +++ b/Engine/source/gui/editor/guiEditCtrl.h @@ -114,7 +114,7 @@ class GuiEditCtrl : public GuiControl SimSet* mSelectedSet; // grid drawing - GFXVertexBufferHandle mDots; + GFXVertexBufferHandle mDots; GFXStateBlockRef mDotSB; mouseModes mMouseDownMode; diff --git a/Engine/source/gui/editor/guiFilterCtrl.cpp b/Engine/source/gui/editor/guiFilterCtrl.cpp index a3ea707e8..39f16a99b 100644 --- a/Engine/source/gui/editor/guiFilterCtrl.cpp +++ b/Engine/source/gui/editor/guiFilterCtrl.cpp @@ -196,7 +196,7 @@ void GuiFilterCtrl::onRender(Point2I offset, const RectI &updateRect) } // draw the curv - GFXVertexBufferHandle verts(GFX, ext.x, GFXBufferTypeVolatile); + GFXVertexBufferHandle verts(GFX, ext.x, GFXBufferTypeVolatile); verts.lock(); diff --git a/Engine/source/gui/editor/guiGraphCtrl.cpp b/Engine/source/gui/editor/guiGraphCtrl.cpp index e00998b0b..6dc224365 100644 --- a/Engine/source/gui/editor/guiGraphCtrl.cpp +++ b/Engine/source/gui/editor/guiGraphCtrl.cpp @@ -177,7 +177,7 @@ void GuiGraphCtrl::onRender(Point2I offset, const RectI &updateRect) for( S32 sample = 0; sample < numSamples; ++ sample ) { - PrimBuild::begin( GFXTriangleFan, 4 ); + PrimBuild::begin( GFXTriangleStrip, 4 ); PrimBuild::color( mGraphColor[ k ] ); F32 offset = F32( getExtent().x ) / F32( MaxDataPoints ) * F32( sample + 1 ); diff --git a/Engine/source/gui/worldEditor/editTSCtrl.cpp b/Engine/source/gui/worldEditor/editTSCtrl.cpp index 7781525c6..928cbfbf1 100644 --- a/Engine/source/gui/worldEditor/editTSCtrl.cpp +++ b/Engine/source/gui/worldEditor/editTSCtrl.cpp @@ -1315,7 +1315,7 @@ DefineEngineMethod( EditTSCtrl, renderCircle, void, ( Point3F pos, Point3F norma { PrimBuild::color( object->mConsoleFillColor ); - PrimBuild::begin( GFXTriangleFan, points.size() + 2 ); + PrimBuild::begin( GFXTriangleStrip, points.size() + 2 ); // Center point PrimBuild::vertex3fv( pos ); diff --git a/Engine/source/gui/worldEditor/gizmo.cpp b/Engine/source/gui/worldEditor/gizmo.cpp index 7ae32519c..c95533bd6 100644 --- a/Engine/source/gui/worldEditor/gizmo.cpp +++ b/Engine/source/gui/worldEditor/gizmo.cpp @@ -1403,7 +1403,7 @@ void Gizmo::renderGizmo(const MatrixF &cameraTransform, F32 cameraFOV ) for(U32 j = 0; j < 6; j++) { - PrimBuild::begin( GFXTriangleFan, 4 ); + PrimBuild::begin( GFXTriangleStrip, 4 ); PrimBuild::vertex3fv( sgCenterBoxPnts[sgBoxVerts[j][0]] * tipScale); PrimBuild::vertex3fv( sgCenterBoxPnts[sgBoxVerts[j][1]] * tipScale); @@ -1599,7 +1599,7 @@ void Gizmo::_renderAxisBoxes() for(U32 j = 0; j < 6; j++) { - PrimBuild::begin( GFXTriangleFan, 4 ); + PrimBuild::begin( GFXTriangleStrip, 4 ); PrimBuild::vertex3fv( sgCenterBoxPnts[sgBoxVerts[j][0]] * tipScale + sgAxisVectors[axisIdx] * pos ); PrimBuild::vertex3fv( sgCenterBoxPnts[sgBoxVerts[j][1]] * tipScale + sgAxisVectors[axisIdx] * pos ); @@ -1663,7 +1663,7 @@ void Gizmo::_renderAxisCircles() ColorI color = mProfile->inActiveColor; color.alpha = 100; PrimBuild::color( color ); - PrimBuild::begin( GFXTriangleFan, segments+2 ); + PrimBuild::begin( GFXTriangleStrip, segments+2 ); PrimBuild::vertex3fv( Point3F(0,0,0) ); diff --git a/Engine/source/gui/worldEditor/guiTerrPreviewCtrl.cpp b/Engine/source/gui/worldEditor/guiTerrPreviewCtrl.cpp index b5d5d2524..37dd68952 100644 --- a/Engine/source/gui/worldEditor/guiTerrPreviewCtrl.cpp +++ b/Engine/source/gui/worldEditor/guiTerrPreviewCtrl.cpp @@ -265,18 +265,18 @@ void GuiTerrPreviewCtrl::onRender(Point2I offset, const RectI &updateRect) // the texture if flipped horz to reflect how the terrain is really drawn PrimBuild::color3f(1.0f, 1.0f, 1.0f); - PrimBuild::begin(GFXTriangleFan, 4); - PrimBuild::texCoord2f(textureP1.x, textureP2.y); - PrimBuild::vertex2f(screenP1.x, screenP2.y); // left bottom + PrimBuild::begin(GFXTriangleStrip, 4); + PrimBuild::texCoord2f(textureP1.x, textureP1.y); + PrimBuild::vertex2f(screenP1.x, screenP1.y); // left top - - PrimBuild::texCoord2f(textureP2.x, textureP2.y); - PrimBuild::vertex2f(screenP2.x, screenP2.y); // right bottom - PrimBuild::texCoord2f(textureP2.x, textureP1.y); - PrimBuild::vertex2f(screenP2.x, screenP1.y); // right top + PrimBuild::texCoord2f(textureP2.x, textureP1.y); + PrimBuild::vertex2f(screenP2.x, screenP1.y); // right top - PrimBuild::texCoord2f(textureP1.x, textureP1.y); - PrimBuild::vertex2f(screenP1.x, screenP1.y); // left top + PrimBuild::texCoord2f(textureP1.x, textureP2.y); + PrimBuild::vertex2f(screenP1.x, screenP2.y); // left bottom + + PrimBuild::texCoord2f(textureP2.x, textureP2.y); + PrimBuild::vertex2f(screenP2.x, screenP2.y); // right bottom PrimBuild::end(); } } diff --git a/Engine/source/gui/worldEditor/terrainEditor.cpp b/Engine/source/gui/worldEditor/terrainEditor.cpp index 0ff51f37a..cf80218e3 100644 --- a/Engine/source/gui/worldEditor/terrainEditor.cpp +++ b/Engine/source/gui/worldEditor/terrainEditor.cpp @@ -658,7 +658,7 @@ void SelectionBrush::rebuild() //... move the selection } -void SelectionBrush::render(Vector & vertexBuffer, S32 & verts, S32 & elems, S32 & prims, const ColorF & inColorFull, const ColorF & inColorNone, const ColorF & outColorFull, const ColorF & outColorNone) const +void SelectionBrush::render(Vector & vertexBuffer, S32 & verts, S32 & elems, S32 & prims, const ColorF & inColorFull, const ColorF & inColorNone, const ColorF & outColorFull, const ColorF & outColorNone) const { //... render the selection } @@ -1342,8 +1342,8 @@ void TerrainEditor::renderPoints( const Vector &pointList ) U32 vertsThisDrawCall = getMin( (U32)vertsLeft, (U32)MAX_DYNAMIC_VERTS ); vertsLeft -= vertsThisDrawCall; - GFXVertexBufferHandle vbuff( GFX, vertsThisDrawCall, GFXBufferTypeVolatile ); - GFXVertexPC *vert = vbuff.lock(); + GFXVertexBufferHandle vbuff( GFX, vertsThisDrawCall, GFXBufferTypeVolatile ); + GFXVertexPCT *vert = vbuff.lock(); const U32 loops = vertsThisDrawCall / 6; @@ -1394,7 +1394,7 @@ void TerrainEditor::renderSelection( const Selection & sel, const ColorF & inCol if(sel.size() == 0) return; - Vector vertexBuffer; + Vector vertexBuffer; ColorF color; ColorI iColor; @@ -1430,15 +1430,15 @@ void TerrainEditor::renderSelection( const Selection & sel, const ColorF & inCol // iColor = color; - GFXVertexPC *verts = &(vertexBuffer[i * 5]); + GFXVertexPCT *verts = &(vertexBuffer[i * 5]); - verts[0].point = wPos + Point3F(-squareSize, -squareSize, 0); + verts[0].point = wPos + Point3F(-squareSize, squareSize, 0); verts[0].color = iColor; - verts[1].point = wPos + Point3F( squareSize, -squareSize, 0); + verts[1].point = wPos + Point3F( squareSize, squareSize, 0); verts[1].color = iColor; - verts[2].point = wPos + Point3F( squareSize, squareSize, 0); + verts[2].point = wPos + Point3F( -squareSize, -squareSize, 0); verts[2].color = iColor; - verts[3].point = wPos + Point3F(-squareSize, squareSize, 0); + verts[3].point = wPos + Point3F( squareSize, -squareSize, 0); verts[3].color = iColor; verts[4].point = verts[0].point; verts[4].color = iColor; @@ -1452,7 +1452,7 @@ void TerrainEditor::renderSelection( const Selection & sel, const ColorF & inCol GridPoint selectedGridPoint = sel[i].mGridPoint; Point2I gPos = selectedGridPoint.gridPos; - GFXVertexPC *verts = &(vertexBuffer[i * 5]); + GFXVertexPCT *verts = &(vertexBuffer[i * 5]); bool center = gridToWorld(selectedGridPoint, verts[0].point); gridToWorld(Point2I(gPos.x + 1, gPos.y), verts[1].point, selectedGridPoint.terrainBlock); @@ -1503,12 +1503,12 @@ void TerrainEditor::renderSelection( const Selection & sel, const ColorF & inCol // Render this bad boy, by stuffing everything into a volatile buffer // and rendering... - GFXVertexBufferHandle selectionVB(GFX, vertexBuffer.size(), GFXBufferTypeStatic); + GFXVertexBufferHandle selectionVB(GFX, vertexBuffer.size(), GFXBufferTypeStatic); selectionVB.lock(0, vertexBuffer.size()); // Copy stuff - dMemcpy((void*)&selectionVB[0], (void*)&vertexBuffer[0], sizeof(GFXVertexPC) * vertexBuffer.size()); + dMemcpy((void*)&selectionVB[0], (void*)&vertexBuffer[0], sizeof(GFXVertexPCT) * vertexBuffer.size()); selectionVB.unlock(); @@ -1518,7 +1518,7 @@ void TerrainEditor::renderSelection( const Selection & sel, const ColorF & inCol if(renderFill) for(U32 i=0; i < sel.size(); i++) - GFX->drawPrimitive( GFXTriangleFan, i*5, 4); + GFX->drawPrimitive( GFXTriangleStrip, i*5, 4); if(renderFrame) for(U32 i=0; i < sel.size(); i++) diff --git a/Engine/source/gui/worldEditor/terrainEditor.h b/Engine/source/gui/worldEditor/terrainEditor.h index 1b5d7cc15..53c2aa79d 100644 --- a/Engine/source/gui/worldEditor/terrainEditor.h +++ b/Engine/source/gui/worldEditor/terrainEditor.h @@ -173,7 +173,7 @@ public: const char *getType() const { return "selection"; } void rebuild(); - void render(Vector & vertexBuffer, S32 & verts, S32 & elems, S32 & prims, const ColorF & inColorFull, const ColorF & inColorNone, const ColorF & outColorFull, const ColorF & outColorNone) const; + void render(Vector & vertexBuffer, S32 & verts, S32 & elems, S32 & prims, const ColorF & inColorFull, const ColorF & inColorNone, const ColorF & outColorFull, const ColorF & outColorNone) const; void setSize(const Point2I &){} protected: diff --git a/Engine/source/gui/worldEditor/worldEditor.cpp b/Engine/source/gui/worldEditor/worldEditor.cpp index 6065b233e..7f39a598b 100644 --- a/Engine/source/gui/worldEditor/worldEditor.cpp +++ b/Engine/source/gui/worldEditor/worldEditor.cpp @@ -1303,7 +1303,7 @@ void WorldEditor::renderObjectFace(SceneObject * obj, const VectorF & normal, co PrimBuild::color( col ); - PrimBuild::begin( GFXTriangleFan, 4 ); + PrimBuild::begin( GFXTriangleStrip, 4 ); for(U32 k = 0; k < 4; k++) { PrimBuild::vertex3f(projPnts[k].x, projPnts[k].y, projPnts[k].z); @@ -1503,7 +1503,7 @@ void WorldEditor::renderSplinePath(SimPath::Path *path) if(vCount > 4000) batchSize = 4000; - GFXVertexBufferHandle vb; + GFXVertexBufferHandle vb; vb.set(GFX, 3*batchSize, GFXBufferTypeVolatile); void *lockPtr = vb.lock(); if(!lockPtr) return; diff --git a/Engine/source/lighting/advanced/advancedLightBinManager.cpp b/Engine/source/lighting/advanced/advancedLightBinManager.cpp index 98330a5de..bec9afb8a 100644 --- a/Engine/source/lighting/advanced/advancedLightBinManager.cpp +++ b/Engine/source/lighting/advanced/advancedLightBinManager.cpp @@ -305,7 +305,7 @@ void AdvancedLightBinManager::render( SceneRenderState *state ) { vectorMatInfo->matInstance->setSceneInfo( state, sgData ); vectorMatInfo->matInstance->setTransforms( matrixSet, state ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); } } @@ -482,24 +482,24 @@ void AdvancedLightBinManager::_setupPerFrameParameters( const SceneRenderState * // passes.... this is a volatile VB and updates every frame. FarFrustumQuadVert verts[4]; { - verts[0].point.set( wsFrustumPoints[Frustum::FarBottomLeft] - cameraPos ); - invCam.mulP( wsFrustumPoints[Frustum::FarBottomLeft], &verts[0].normal ); - verts[0].texCoord.set( -1.0, -1.0 ); - verts[0].tangent.set(wsFrustumPoints[Frustum::FarBottomLeft] - cameraOffsetPos); + verts[0].point.set(wsFrustumPoints[Frustum::FarTopLeft] - cameraPos); + invCam.mulP(wsFrustumPoints[Frustum::FarTopLeft], &verts[0].normal); + verts[0].texCoord.set(-1.0, 1.0); + verts[0].tangent.set(wsFrustumPoints[Frustum::FarTopLeft] - cameraOffsetPos); - verts[1].point.set( wsFrustumPoints[Frustum::FarTopLeft] - cameraPos ); - invCam.mulP( wsFrustumPoints[Frustum::FarTopLeft], &verts[1].normal ); - verts[1].texCoord.set( -1.0, 1.0 ); - verts[1].tangent.set(wsFrustumPoints[Frustum::FarTopLeft] - cameraOffsetPos); + verts[1].point.set(wsFrustumPoints[Frustum::FarTopRight] - cameraPos); + invCam.mulP(wsFrustumPoints[Frustum::FarTopRight], &verts[1].normal); + verts[1].texCoord.set(1.0, 1.0); + verts[1].tangent.set(wsFrustumPoints[Frustum::FarTopRight] - cameraOffsetPos); - verts[2].point.set( wsFrustumPoints[Frustum::FarTopRight] - cameraPos ); - invCam.mulP( wsFrustumPoints[Frustum::FarTopRight], &verts[2].normal ); - verts[2].texCoord.set( 1.0, 1.0 ); - verts[2].tangent.set(wsFrustumPoints[Frustum::FarTopRight] - cameraOffsetPos); + verts[2].point.set(wsFrustumPoints[Frustum::FarBottomLeft] - cameraPos); + invCam.mulP(wsFrustumPoints[Frustum::FarBottomLeft], &verts[2].normal); + verts[2].texCoord.set(-1.0, -1.0); + verts[2].tangent.set(wsFrustumPoints[Frustum::FarBottomLeft] - cameraOffsetPos); - verts[3].point.set( wsFrustumPoints[Frustum::FarBottomRight] - cameraPos ); - invCam.mulP( wsFrustumPoints[Frustum::FarBottomRight], &verts[3].normal ); - verts[3].texCoord.set( 1.0, -1.0 ); + verts[3].point.set(wsFrustumPoints[Frustum::FarBottomRight] - cameraPos); + invCam.mulP(wsFrustumPoints[Frustum::FarBottomRight], &verts[3].normal); + verts[3].texCoord.set(1.0, -1.0); verts[3].tangent.set(wsFrustumPoints[Frustum::FarBottomRight] - cameraOffsetPos); } mFarFrustumQuadVerts.set( GFX, 4 ); diff --git a/Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.cpp b/Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.cpp index 1dc906989..bfa39779e 100644 --- a/Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.cpp +++ b/Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.cpp @@ -62,7 +62,6 @@ void DeferredSpecMapGLSL::processPix( Vector &componentList, c specularMap->uniform = true; specularMap->sampler = true; specularMap->constNum = Var::getTexUnitNum(); - LangElement *texOp = new GenOp( "tex2D(@, @)", specularMap, texCoord ); //matinfo.g slot reserved for AO later meta->addStatement(new GenOp(" @.g = 1.0;\r\n", material)); meta->addStatement(new GenOp(" @.b = dot(tex2D(@, @).rgb, vec3(0.3, 0.59, 0.11));\r\n", material, specularMap, texCoord)); diff --git a/Engine/source/lighting/advanced/glsl/gBufferConditionerGLSL.cpp b/Engine/source/lighting/advanced/glsl/gBufferConditionerGLSL.cpp index d2d383148..095f4ea9e 100644 --- a/Engine/source/lighting/advanced/glsl/gBufferConditionerGLSL.cpp +++ b/Engine/source/lighting/advanced/glsl/gBufferConditionerGLSL.cpp @@ -114,7 +114,7 @@ void GBufferConditionerGLSL::processVert( Vector &componentLis // TODO: Total hack because Conditioner is directly derived // from ShaderFeature and not from ShaderFeatureGLSL. NamedFeatureGLSL dummy( String::EmptyString ); - dummy.mInstancingFormat = mInstancingFormat; + dummy.setInstancingFormat( mInstancingFormat ); Var *worldViewOnly = dummy.getWorldView( componentList, fd.features[MFT_UseInstancing], meta ); meta->addStatement( new GenOp(" @ = tMul(@, float4( normalize(@), 0.0 ) ).xyz;\r\n", diff --git a/Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp b/Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp index 0bfbed42a..172eb65c8 100644 --- a/Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp +++ b/Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp @@ -126,6 +126,18 @@ void DeferredRTLightingFeatHLSL::processPix( Vector &component lightInfoBuffer->sampler = true; lightInfoBuffer->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var* lightBufferTex = NULL; + if (mIsDirect3D11) + { + lightInfoBuffer->setType("SamplerState"); + lightBufferTex = new Var; + lightBufferTex->setName("lightInfoBufferTex"); + lightBufferTex->setType("Texture2D"); + lightBufferTex->uniform = true; + lightBufferTex->texture = true; + lightBufferTex->constNum = lightInfoBuffer->constNum; + } + // Declare the RTLighting variables in this feature, they will either be assigned // in this feature, or in the tonemap/lightmap feature Var *d_lightcolor = new Var( "d_lightcolor", "float3" ); @@ -140,8 +152,12 @@ void DeferredRTLightingFeatHLSL::processPix( Vector &component // Perform the uncondition here. String unconditionLightInfo = String::ToLower( AdvancedLightBinManager::smBufferName ) + "Uncondition"; - meta->addStatement( new GenOp( avar( " %s(tex2D(@, @), @, @, @);\r\n", - unconditionLightInfo.c_str() ), lightInfoBuffer, uvScene, d_lightcolor, d_NL_Att, d_specular ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(avar(" %s(@.Sample(@, @), @, @, @);\r\n", + unconditionLightInfo.c_str()), lightBufferTex, lightInfoBuffer, uvScene, d_lightcolor, d_NL_Att, d_specular)); + else + meta->addStatement(new GenOp(avar(" %s(tex2D(@, @), @, @, @);\r\n", + unconditionLightInfo.c_str()), lightInfoBuffer, uvScene, d_lightcolor, d_NL_Att, d_specular)); // If this has an interlaced pre-pass, do averaging here if( fd.features[MFT_InterlacedPrePass] ) @@ -157,8 +173,12 @@ void DeferredRTLightingFeatHLSL::processPix( Vector &component } meta->addStatement( new GenOp( " float id_NL_Att, id_specular;\r\n float3 id_lightcolor;\r\n" ) ); - meta->addStatement( new GenOp( avar( " %s(tex2D(@, @ + float2(0.0, @.y)), id_lightcolor, id_NL_Att, id_specular);\r\n", - unconditionLightInfo.c_str() ), lightInfoBuffer, uvScene, oneOverTargetSize ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(avar(" %s(@.Sample(@, @ + float2(0.0, @.y)), id_lightcolor, id_NL_Att, id_specular);\r\n", + unconditionLightInfo.c_str()), lightBufferTex, lightInfoBuffer, uvScene, oneOverTargetSize)); + else + meta->addStatement(new GenOp(avar(" %s(tex2D(@, @ + float2(0.0, @.y)), id_lightcolor, id_NL_Att, id_specular);\r\n", + unconditionLightInfo.c_str()), lightInfoBuffer, uvScene, oneOverTargetSize)); meta->addStatement( new GenOp(" @ = lerp(@, id_lightcolor, 0.5);\r\n", d_lightcolor, d_lightcolor ) ); meta->addStatement( new GenOp(" @ = lerp(@, id_NL_Att, 0.5);\r\n", d_NL_Att, d_NL_Att ) ); @@ -272,8 +292,17 @@ void DeferredBumpFeatHLSL::processPix( Vector &componentList, // create texture var Var *bumpMap = getNormalMapTex(); - Var *texCoord = getInTexCoord( "texCoord", "float2", true, componentList ); - LangElement *texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + Var *texCoord = getInTexCoord("texCoord", "float2", true, componentList); + + LangElement *texOp = NULL; + + if (mIsDirect3D11) + { + Var *bumpMapTex = (Var*)LangElement::find("bumpMapTex"); + texOp = new GenOp("@.Sample(@, @)", bumpMapTex, bumpMap, texCoord); + } + else + texOp = new GenOp("tex2D(@, @)", bumpMap, texCoord); // create bump normal Var *bumpNorm = new Var; @@ -295,8 +324,25 @@ void DeferredBumpFeatHLSL::processPix( Vector &componentList, bumpMap->sampler = true; bumpMap->constNum = Var::getTexUnitNum(); - texCoord = getInTexCoord( "detCoord", "float2", true, componentList ); - texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + Var* detailNormalTex = NULL; + if (mIsDirect3D11) + { + bumpMap->setType("SamplerState"); + detailNormalTex = new Var; + detailNormalTex->setName("detailBumpMapTex"); + detailNormalTex->setType("Texture2D"); + detailNormalTex->uniform = true; + detailNormalTex->texture = true; + detailNormalTex->constNum = bumpMap->constNum; + } + + + texCoord = getInTexCoord("detCoord", "float2", true, componentList); + + if (mIsDirect3D11) + texOp = new GenOp("@.Sample(@, @)", detailNormalTex, bumpMap, texCoord); + else + texOp = new GenOp("tex2D(@, @)", bumpMap, texCoord); Var *detailBump = new Var; detailBump->setName( "detailBump" ); @@ -333,25 +379,32 @@ void DeferredBumpFeatHLSL::processPix( Vector &componentList, else if (fd.features[MFT_AccuMap]) { Var *bumpSample = (Var *)LangElement::find( "bumpSample" ); - if( bumpSample == NULL ) + if (bumpSample == NULL) { MultiLine *meta = new MultiLine; - Var *texCoord = getInTexCoord( "texCoord", "float2", true, componentList ); + Var *texCoord = getInTexCoord("texCoord", "float2", true, componentList); Var *bumpMap = getNormalMapTex(); bumpSample = new Var; - bumpSample->setType( "float4" ); - bumpSample->setName( "bumpSample" ); - LangElement *bumpSampleDecl = new DecOp( bumpSample ); + bumpSample->setType("float4"); + bumpSample->setName("bumpSample"); + LangElement *bumpSampleDecl = new DecOp(bumpSample); - meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", bumpSampleDecl, bumpMap, texCoord ) ); + if (mIsDirect3D11) + { + Var *bumpMapTex = (Var *)LangElement::find("bumpMapTex"); + output = new GenOp(" @ = @.Sample(@, @);\r\n", bumpSampleDecl, bumpMapTex, bumpMap, texCoord); + } + else + output = new GenOp(" @ = tex2D(@, @);\r\n", bumpSampleDecl, bumpMap, texCoord); if ( fd.features.hasFeature( MFT_DetailNormalMap ) ) { Var *bumpMap = (Var*)LangElement::find( "detailBumpMap" ); - if ( !bumpMap ) { + if ( !bumpMap ) + { bumpMap = new Var; bumpMap->setType( "sampler2D" ); bumpMap->setName( "detailBumpMap" ); @@ -360,8 +413,24 @@ void DeferredBumpFeatHLSL::processPix( Vector &componentList, bumpMap->constNum = Var::getTexUnitNum(); } + Var* bumpMapTex = (Var*)LangElement::find("detailBumpMap"); + if (mIsDirect3D11 && !bumpMapTex) + { + bumpMap->setType("SamplerState"); + bumpMapTex = new Var; + bumpMapTex->setName("detailBumpMapTex"); + bumpMapTex->setType("Texture2D"); + bumpMapTex->uniform = true; + bumpMapTex->texture = true; + bumpMapTex->constNum = bumpMap->constNum; + } + texCoord = getInTexCoord( "detCoord", "float2", true, componentList ); - LangElement *texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + LangElement *texOp = NULL; + if (mIsDirect3D11) + texOp = new GenOp("@.Sample(@, @)", bumpMap, bumpMapTex, texCoord); + else + texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); Var *detailBump = new Var; detailBump->setName( "detailBump" ); @@ -402,7 +471,14 @@ void DeferredBumpFeatHLSL::processPix( Vector &componentList, bumpSample->setName( "bumpSample" ); LangElement *bumpSampleDecl = new DecOp( bumpSample ); - output = new GenOp( " @ = tex2D(@, @);\r\n", bumpSampleDecl, bumpMap, texCoord ); + if (mIsDirect3D11) + { + Var *bumpMapTex = (Var *)LangElement::find("bumpMapTex"); + output = new GenOp(" @ = @.Sample(@, @);\r\n", bumpSampleDecl, bumpMapTex, bumpMap, texCoord); + } + else + output = new GenOp(" @ = tex2D(@, @);\r\n", bumpSampleDecl, bumpMap, texCoord); + return; } } @@ -547,7 +623,8 @@ void DeferredPixelSpecularHLSL::processPix( Vector &component AssertFatal( lightInfoSamp && d_specular && d_NL_Att, "DeferredPixelSpecularHLSL::processPix - Something hosed the deferred features!" ); - if (fd.features[ MFT_AccuMap ]) { + if (fd.features[ MFT_AccuMap ]) + { // change specularity where the accu texture is applied Var *accuPlc = (Var*) LangElement::find( "plc" ); Var *accuSpecular = (Var*)LangElement::find( "accuSpecular" ); @@ -671,6 +748,18 @@ void DeferredMinnaertHLSL::processPix( Vector &componentList, prepassBuffer->sampler = true; prepassBuffer->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var* prePassTex = NULL; + if (mIsDirect3D11) + { + prepassBuffer->setType("SamplerState"); + prePassTex = new Var; + prePassTex->setName("prePassTex"); + prePassTex->setType("Texture2D"); + prePassTex->uniform = true; + prePassTex->texture = true; + prePassTex->constNum = prepassBuffer->constNum; + } + // Texture coord Var *uvScene = (Var*) LangElement::find( "uvScene" ); AssertFatal(uvScene != NULL, "Unable to find UVScene, no RTLighting feature?"); @@ -684,7 +773,11 @@ void DeferredMinnaertHLSL::processPix( Vector &componentList, Var *d_NL_Att = (Var*)LangElement::find( "d_NL_Att" ); - meta->addStatement( new GenOp( avar( " float4 normalDepth = %s(@, @);\r\n", unconditionPrePassMethod.c_str() ), prepassBuffer, uvScene ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(avar(" float4 normalDepth = %s(@, ,@, @);\r\n", unconditionPrePassMethod.c_str()), prepassBuffer, prePassTex, uvScene)); + else + meta->addStatement(new GenOp(avar(" float4 normalDepth = %s(@, @);\r\n", unconditionPrePassMethod.c_str()), prepassBuffer, uvScene)); + meta->addStatement( new GenOp( " float vDotN = dot(normalDepth.xyz, @);\r\n", wsViewVec ) ); meta->addStatement( new GenOp( " float Minnaert = pow( @, @) * pow(vDotN, 1.0 - @);\r\n", d_NL_Att, minnaertConstant, minnaertConstant ) ); meta->addStatement( new GenOp( " @;\r\n", assignColor( new GenOp( "float4(Minnaert, Minnaert, Minnaert, 1.0)" ), Material::Mul ) ) ); diff --git a/Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.cpp b/Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.cpp index 3e42af953..25c86b7bc 100644 --- a/Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.cpp +++ b/Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.cpp @@ -62,12 +62,35 @@ void DeferredSpecMapHLSL::processPix( Vector &componentList, c specularMap->uniform = true; specularMap->sampler = true; specularMap->constNum = Var::getTexUnitNum(); - LangElement *texOp = new GenOp( "tex2D(@, @)", specularMap, texCoord ); + + Var* specularMapTex = NULL; + if (mIsDirect3D11) + { + specularMap->setType("SamplerState"); + specularMapTex = new Var; + specularMapTex->setName("specularMapTex"); + specularMapTex->setType("Texture2D"); + specularMapTex->uniform = true; + specularMapTex->texture = true; + specularMapTex->constNum = specularMap->constNum; + } //matinfo.g slot reserved for AO later + Var* specColor = new Var; + specColor->setName("specColor"); + specColor->setType("float4"); + LangElement *specColorElem = new DecOp(specColor); + meta->addStatement(new GenOp(" @.g = 1.0;\r\n", material)); - meta->addStatement(new GenOp(" @.b = dot(tex2D(@, @).rgb, float3(0.3, 0.59, 0.11));\r\n", material, specularMap, texCoord)); - meta->addStatement(new GenOp(" @.a = tex2D(@, @).a;\r\n", material, specularMap, texCoord)); + //sample specular map + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @ = @.Sample(@, @);\r\n", specColorElem, specularMapTex, specularMap, texCoord)); + else + meta->addStatement(new GenOp(" @ = tex2D(@, @);\r\n", specColorElem, specularMap, texCoord)); + + meta->addStatement(new GenOp(" @.b = dot(@.rgb, float3(0.3, 0.59, 0.11));\r\n", material, specColor)); + meta->addStatement(new GenOp(" @.a = @.a;\r\n", material, specColor)); + output = meta; } diff --git a/Engine/source/lighting/advanced/hlsl/gBufferConditionerHLSL.cpp b/Engine/source/lighting/advanced/hlsl/gBufferConditionerHLSL.cpp index 6f99d035c..d03a40ecd 100644 --- a/Engine/source/lighting/advanced/hlsl/gBufferConditionerHLSL.cpp +++ b/Engine/source/lighting/advanced/hlsl/gBufferConditionerHLSL.cpp @@ -28,7 +28,7 @@ #include "materials/materialFeatureTypes.h" #include "materials/materialFeatureData.h" #include "shaderGen/hlsl/shaderFeatureHLSL.h" - +#include "gfx/gfxDevice.h" GBufferConditionerHLSL::GBufferConditionerHLSL( const GFXFormat bufferFormat, const NormalSpace nrmSpace ) : Parent( bufferFormat ) @@ -114,7 +114,7 @@ void GBufferConditionerHLSL::processVert( Vector &componentLis // TODO: Total hack because Conditioner is directly derived // from ShaderFeature and not from ShaderFeatureHLSL. NamedFeatureHLSL dummy( String::EmptyString ); - dummy.mInstancingFormat = mInstancingFormat; + dummy.setInstancingFormat( mInstancingFormat ); Var *worldViewOnly = dummy.getWorldView( componentList, fd.features[MFT_UseInstancing], meta ); meta->addStatement( new GenOp(" @ = mul(@, float4( normalize(@), 0.0 ) ).xyz;\r\n", @@ -222,6 +222,7 @@ Var* GBufferConditionerHLSL::printMethodHeader( MethodType methodType, const Str retVal = Parent::printMethodHeader( methodType, methodName, stream, meta ); else { + const bool isDirect3D11 = GFX->getAdapterType() == Direct3D11; Var *methodVar = new Var; methodVar->setName(methodName); methodVar->setType("inline float4"); @@ -237,12 +238,28 @@ Var* GBufferConditionerHLSL::printMethodHeader( MethodType methodType, const Str screenUV->setType("float2"); DecOp *screenUVDecl = new DecOp(screenUV); + Var *prepassTex = NULL; + DecOp *prepassTexDecl = NULL; + if (isDirect3D11) + { + prepassSampler->setType("SamplerState"); + prepassTex = new Var; + prepassTex->setName("prepassTexVar"); + prepassTex->setType("Texture2D"); + prepassTex->texture = true; + prepassTex->constNum = prepassSampler->constNum; + prepassTexDecl = new DecOp(prepassTex); + } + Var *bufferSample = new Var; bufferSample->setName("bufferSample"); bufferSample->setType("float4"); DecOp *bufferSampleDecl = new DecOp(bufferSample); - meta->addStatement( new GenOp( "@(@, @)\r\n", methodDecl, prepassSamplerDecl, screenUVDecl ) ); + if (isDirect3D11) + meta->addStatement(new GenOp("@(@, @, @)\r\n", methodDecl, prepassSamplerDecl, prepassTexDecl, screenUVDecl)); + else + meta->addStatement( new GenOp( "@(@, @)\r\n", methodDecl, prepassSamplerDecl, screenUVDecl ) ); meta->addStatement( new GenOp( "{\r\n" ) ); @@ -255,10 +272,14 @@ Var* GBufferConditionerHLSL::printMethodHeader( MethodType methodType, const Str // The gbuffer has no mipmaps, so use tex2dlod when // possible so that the shader compiler can optimize. meta->addStatement( new GenOp( " #if TORQUE_SM >= 30\r\n" ) ); - meta->addStatement( new GenOp( " @ = tex2Dlod(@, float4(@,0,0));\r\n", bufferSampleDecl, prepassSampler, screenUV ) ); - meta->addStatement( new GenOp( " #else\r\n" ) ); - meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", bufferSampleDecl, prepassSampler, screenUV ) ); - meta->addStatement( new GenOp( " #endif\r\n\r\n" ) ); + if (isDirect3D11) + meta->addStatement(new GenOp(" @ = @.SampleLevel(@, @,0);\r\n", bufferSampleDecl, prepassTex, prepassSampler, screenUV)); + else + meta->addStatement(new GenOp(" @ = tex2Dlod(@, float4(@,0,0));\r\n", bufferSampleDecl, prepassSampler, screenUV)); + + meta->addStatement(new GenOp(" #else\r\n")); + meta->addStatement(new GenOp(" @ = tex2D(@, @);\r\n", bufferSampleDecl, prepassSampler, screenUV)); + meta->addStatement(new GenOp(" #endif\r\n\r\n")); #endif // We don't use this way of passing var's around, so this should cause a crash diff --git a/Engine/source/lighting/common/blobShadow.cpp b/Engine/source/lighting/common/blobShadow.cpp index 9756757e9..48bfb1e52 100644 --- a/Engine/source/lighting/common/blobShadow.cpp +++ b/Engine/source/lighting/common/blobShadow.cpp @@ -338,7 +338,7 @@ void BlobShadow::render( F32 camDist, const TSRenderState &rdata ) GFX->setVertexBuffer(mShadowBuffer); for(U32 p=0; pdrawPrimitive(GFXTriangleFan, mPartition[p].vertexStart, (mPartition[p].vertexCount - 2)); + GFX->drawPrimitive(GFXTriangleStrip, mPartition[p].vertexStart, (mPartition[p].vertexCount - 2)); // This is a bad nasty hack which forces the shadow to reconstruct itself every frame. mPartition.clear(); diff --git a/Engine/source/materials/miscShdrDat.h b/Engine/source/materials/miscShdrDat.h index 25422008d..9ebaa6f46 100644 --- a/Engine/source/materials/miscShdrDat.h +++ b/Engine/source/materials/miscShdrDat.h @@ -22,10 +22,6 @@ #ifndef _MISCSHDRDAT_H_ #define _MISCSHDRDAT_H_ -#ifndef _PLATFORM_H_ -#include "platform/platform.h" -#endif - //************************************************************************** // This file is an attempt to keep certain classes from having to know about // the ShaderGen class @@ -45,6 +41,7 @@ enum RegisterType RT_COLOR, RT_TEXCOORD, RT_VPOS, + RT_SVPOSITION }; enum Components @@ -52,7 +49,7 @@ enum Components C_VERT_STRUCT = 0, C_CONNECTOR, C_VERT_MAIN, - C_PIX_MAIN, + C_PIX_MAIN }; #endif // _MISCSHDRDAT_H_ diff --git a/Engine/source/materials/processedShaderMaterial.cpp b/Engine/source/materials/processedShaderMaterial.cpp index 37f745253..185c9f0b9 100644 --- a/Engine/source/materials/processedShaderMaterial.cpp +++ b/Engine/source/materials/processedShaderMaterial.cpp @@ -209,7 +209,7 @@ bool ProcessedShaderMaterial::init( const FeatureSet &features, if ( mFeatures.hasFeature( MFT_UseInstancing ) ) { mInstancingState = new InstancingState(); - mInstancingState->setFormat( &_getRPD( 0 )->shader->mInstancingFormat, mVertexFormat ); + mInstancingState->setFormat( _getRPD( 0 )->shader->getInstancingFormat(), mVertexFormat ); } return true; } diff --git a/Engine/source/materials/processedShaderMaterial.h b/Engine/source/materials/processedShaderMaterial.h index 9bcc0eec7..4f7c67023 100644 --- a/Engine/source/materials/processedShaderMaterial.h +++ b/Engine/source/materials/processedShaderMaterial.h @@ -167,6 +167,8 @@ protected: mInstFormat = instFormat; mDeclFormat.copy( *vertexFormat ); mDeclFormat.append( *mInstFormat, 1 ); + // Let the declaration know we have instancing. + mDeclFormat.enableInstancing(); mDeclFormat.getDecl(); delete [] mBuffer; diff --git a/Engine/source/materials/shaderData.cpp b/Engine/source/materials/shaderData.cpp index 36e0a3994..e8c1dbb3b 100644 --- a/Engine/source/materials/shaderData.cpp +++ b/Engine/source/materials/shaderData.cpp @@ -236,6 +236,7 @@ GFXShader* ShaderData::_createShader( const Vector ¯os ) { case Direct3D9_360: case Direct3D9: + case Direct3D11: { success = shader->init( mDXVertexShaderName, mDXPixelShaderName, diff --git a/Engine/source/platformWin32/videoInfo/wmiVideoInfo.cpp b/Engine/source/platformWin32/videoInfo/wmiVideoInfo.cpp index 23f63635d..b4fecbba3 100644 --- a/Engine/source/platformWin32/videoInfo/wmiVideoInfo.cpp +++ b/Engine/source/platformWin32/videoInfo/wmiVideoInfo.cpp @@ -25,6 +25,7 @@ //#include #include //#include +#include #pragma comment(lib, "comsuppw.lib") #pragma comment(lib, "wbemuuid.lib") @@ -53,58 +54,6 @@ struct MYGUID : public GUID } }; -//------------------------------------------------------------------------------ -// DXGI decls for retrieving device info on Vista. We manually declare that -// stuff here, so we don't depend on headers and compile on any setup. At -// run-time, it depends on whether we can successfully load the DXGI DLL; if -// not, nothing of this here will be used. - -struct IDXGIObject; -struct IDXGIFactory; -struct IDXGIAdapter; -struct IDXGIOutput; - -struct DXGI_SWAP_CHAIN_DESC; -struct DXGI_ADAPTER_DESC; - -struct IDXGIObject : public IUnknown -{ - virtual HRESULT STDMETHODCALLTYPE SetPrivateData( REFGUID, UINT, const void* ) = 0; - virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( REFGUID, const IUnknown* ) = 0; - virtual HRESULT STDMETHODCALLTYPE GetPrivateData( REFGUID, UINT*, void* ) = 0; - virtual HRESULT STDMETHODCALLTYPE GetParent( REFIID, void** ) = 0; -}; - -struct IDXGIFactory : public IDXGIObject -{ - virtual HRESULT STDMETHODCALLTYPE EnumAdapters( UINT, IDXGIAdapter** ) = 0; - virtual HRESULT STDMETHODCALLTYPE MakeWindowAssociation( HWND, UINT ) = 0; - virtual HRESULT STDMETHODCALLTYPE GetWindowAssociation( HWND ) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateSwapChain( IUnknown*, DXGI_SWAP_CHAIN_DESC* ) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter( HMODULE, IDXGIAdapter** ) = 0; -}; - -struct IDXGIAdapter : public IDXGIObject -{ - virtual HRESULT STDMETHODCALLTYPE EnumOutputs( UINT, IDXGIOutput** ) = 0; - virtual HRESULT STDMETHODCALLTYPE GetDesc( DXGI_ADAPTER_DESC* ) = 0; - virtual HRESULT STDMETHODCALLTYPE CheckInterfaceSupport( REFGUID, LARGE_INTEGER* ) = 0; -}; - -struct DXGI_ADAPTER_DESC -{ - WCHAR Description[ 128 ]; - UINT VendorId; - UINT DeviceId; - UINT SubSysId; - UINT Revision; - SIZE_T DedicatedVideoMemory; - SIZE_T DedicatedSystemMemory; - SIZE_T SharedSystemMemory; - LUID AdapterLuid; -}; - -static MYGUID IID_IDXGIFactory( 0x7b7166ec, 0x21c7, 0x44ae, 0xb2, 0x1a, 0xc9, 0xae, 0x32, 0x1a, 0xe3, 0x69 ); //------------------------------------------------------------------------------ // DXDIAG declarations. @@ -184,6 +133,26 @@ WMIVideoInfo::~WMIVideoInfo() //------------------------------------------------------------------------------ +String WMIVideoInfo::_lookUpVendorId(U32 vendorId) +{ + String vendor; + switch (vendorId) + { + case 0x10DE: + vendor = "NVIDIA"; + break; + case 0x1002: + vendor = "AMD"; + break; + case 0x8086: + vendor = "INTEL"; + break; + } + return vendor; +} + +//------------------------------------------------------------------------------ + bool WMIVideoInfo::_initialize() { // Init COM @@ -282,16 +251,15 @@ bool WMIVideoInfo::_initializeWMI() bool WMIVideoInfo::_initializeDXGI() { - // Try going for DXGI. Will only succeed on Vista. -#if 0 + // Try using for DXGI 1.1, will only succeed on Windows 7+. mDXGIModule = ( HMODULE ) LoadLibrary( L"dxgi.dll" ); if( mDXGIModule != 0 ) { - typedef HRESULT (* CreateDXGIFactoryFuncType )( REFIID, void** ); + typedef HRESULT (WINAPI* CreateDXGIFactoryFuncType )( REFIID, void** ); CreateDXGIFactoryFuncType factoryFunction = - ( CreateDXGIFactoryFuncType ) GetProcAddress( ( HMODULE ) mDXGIModule, "CreateDXGIFactory" ); + ( CreateDXGIFactoryFuncType ) GetProcAddress( ( HMODULE ) mDXGIModule, "CreateDXGIFactory1" ); - if( factoryFunction && factoryFunction( IID_IDXGIFactory, ( void** ) &mDXGIFactory ) == S_OK ) + if( factoryFunction && factoryFunction( IID_IDXGIFactory1, ( void** ) &mDXGIFactory ) == S_OK ) return true; else { @@ -299,7 +267,7 @@ bool WMIVideoInfo::_initializeDXGI() mDXGIModule = 0; } } -#endif + return false; } @@ -483,20 +451,36 @@ bool WMIVideoInfo::_queryPropertyDxDiag( const PVIQueryType queryType, const U32 bool WMIVideoInfo::_queryPropertyDXGI( const PVIQueryType queryType, const U32 adapterId, String *outValue ) { -#if 0 + if( mDXGIFactory ) { - IDXGIAdapter* adapter; - if( mDXGIFactory->EnumAdapters( adapterId, &adapter ) != S_OK ) + // Special case to deal with PVI_NumAdapters + if (queryType == PVI_NumAdapters) + { + U32 count = 0; + IDXGIAdapter1 *adapter; + while (mDXGIFactory->EnumAdapters1(count, &adapter) != DXGI_ERROR_NOT_FOUND) + { + ++count; + adapter->Release(); + } + + String value = String::ToString("%d", count); + *outValue = value; + return true; + } + + IDXGIAdapter1* adapter; + if( mDXGIFactory->EnumAdapters1( adapterId, &adapter ) != S_OK ) return false; - DXGI_ADAPTER_DESC desc; - if( adapter->GetDesc( &desc ) != S_OK ) + DXGI_ADAPTER_DESC1 desc; + if( adapter->GetDesc1( &desc ) != S_OK ) { adapter->Release(); return false; } - + String value; switch( queryType ) { @@ -511,15 +495,17 @@ bool WMIVideoInfo::_queryPropertyDXGI( const PVIQueryType queryType, const U32 a case PVI_VRAM: value = String( avar( "%i", desc.DedicatedVideoMemory / 1048576 ) ); break; - - //RDTODO + case PVI_ChipSet: + value = _lookUpVendorId(desc.VendorId); + break; + //TODO PVI_DriverVersion } adapter->Release(); *outValue = value; return true; } -#endif + return false; } diff --git a/Engine/source/platformWin32/videoInfo/wmiVideoInfo.h b/Engine/source/platformWin32/videoInfo/wmiVideoInfo.h index 6d5457039..3b71d97fc 100644 --- a/Engine/source/platformWin32/videoInfo/wmiVideoInfo.h +++ b/Engine/source/platformWin32/videoInfo/wmiVideoInfo.h @@ -28,7 +28,7 @@ struct IWbemLocator; struct IWbemServices; -struct IDXGIFactory; +struct IDXGIFactory1; struct IDxDiagProvider; class WMIVideoInfo : public PlatformVideoInfo @@ -39,7 +39,7 @@ private: bool mComInitialized; void* mDXGIModule; - IDXGIFactory* mDXGIFactory; + IDXGIFactory1* mDXGIFactory; IDxDiagProvider* mDxDiagProvider; bool _initializeDXGI(); @@ -54,6 +54,7 @@ protected: static WCHAR *smPVIQueryTypeToWMIString []; bool _queryProperty( const PVIQueryType queryType, const U32 adapterId, String *outValue ); bool _initialize(); + String _lookUpVendorId(U32 vendorId); public: WMIVideoInfo(); diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp index 62c35baf6..c388e0abe 100644 --- a/Engine/source/postFx/postEffect.cpp +++ b/Engine/source/postFx/postEffect.cpp @@ -510,23 +510,23 @@ void PostEffect::_updateScreenGeometry( const Frustum &frustum, PFXVertex *vert = outVB->lock(); - vert->point.set( -1.0, -1.0, 0.0 ); - vert->texCoord.set( 0.0f, 1.0f ); - vert->wsEyeRay = frustumPoints[Frustum::FarBottomLeft] - cameraOffsetPos; - vert++; - - vert->point.set( -1.0, 1.0, 0.0 ); - vert->texCoord.set( 0.0f, 0.0f ); + vert->point.set(-1.0, 1.0, 0.0); + vert->texCoord.set(0.0f, 0.0f); vert->wsEyeRay = frustumPoints[Frustum::FarTopLeft] - cameraOffsetPos; vert++; - vert->point.set( 1.0, 1.0, 0.0 ); - vert->texCoord.set( 1.0f, 0.0f ); + vert->point.set(1.0, 1.0, 0.0); + vert->texCoord.set(1.0f, 0.0f); vert->wsEyeRay = frustumPoints[Frustum::FarTopRight] - cameraOffsetPos; vert++; - vert->point.set( 1.0, -1.0, 0.0 ); - vert->texCoord.set( 1.0f, 1.0f ); + vert->point.set(-1.0, -1.0, 0.0); + vert->texCoord.set(0.0f, 1.0f); + vert->wsEyeRay = frustumPoints[Frustum::FarBottomLeft] - cameraOffsetPos; + vert++; + + vert->point.set(1.0, -1.0, 0.0); + vert->texCoord.set(1.0f, 1.0f); vert->wsEyeRay = frustumPoints[Frustum::FarBottomRight] - cameraOffsetPos; vert++; @@ -1275,7 +1275,7 @@ void PostEffect::process( const SceneRenderState *state, // Draw it. GFX->setVertexBuffer( vb ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); // Allow PostEffecVis to hook in. PFXVIS->onPFXProcessed( this ); diff --git a/Engine/source/renderInstance/renderPrePassMgr.cpp b/Engine/source/renderInstance/renderPrePassMgr.cpp index 4f08dc6ea..6e7a8f3ef 100644 --- a/Engine/source/renderInstance/renderPrePassMgr.cpp +++ b/Engine/source/renderInstance/renderPrePassMgr.cpp @@ -385,7 +385,6 @@ void RenderPrePassMgr::render( SceneRenderState *state ) GFXTextureObject *lastLM = NULL; GFXCubemap *lastCubemap = NULL; GFXTextureObject *lastReflectTex = NULL; - GFXTextureObject *lastMiscTex = NULL; GFXTextureObject *lastAccuTex = NULL; // Next render all the meshes. diff --git a/Engine/source/scene/reflectionManager.cpp b/Engine/source/scene/reflectionManager.cpp index 323e11c8a..5536b4fa5 100644 --- a/Engine/source/scene/reflectionManager.cpp +++ b/Engine/source/scene/reflectionManager.cpp @@ -248,8 +248,18 @@ GFXTextureObject* ReflectionManager::getRefractTex( bool forceUpdate ) const U32 desWidth = targetSize.x; const U32 desHeight = targetSize.y; #else - const U32 desWidth = mFloor( (F32)targetSize.x * smRefractTexScale ); - const U32 desHeight = mFloor( ( F32)targetSize.y * smRefractTexScale ); + U32 desWidth, desHeight; + // D3D11 needs to be the same size as the active target + if (GFX->getAdapterType() == Direct3D11) + { + desWidth = targetSize.x; + desHeight = targetSize.y; + } + else + { + desWidth = mFloor((F32)targetSize.x * smRefractTexScale); + desHeight = mFloor((F32)targetSize.y * smRefractTexScale); + } #endif if ( mRefractTex.isNull() || diff --git a/Engine/source/scene/simPath.cpp b/Engine/source/scene/simPath.cpp index c25764ad1..d38ea914f 100644 --- a/Engine/source/scene/simPath.cpp +++ b/Engine/source/scene/simPath.cpp @@ -273,7 +273,7 @@ DefineEngineMethod( Path, getPathId, S32, (),, //-------------------------------------------------------------------------- GFXStateBlockRef Marker::smStateBlock; -GFXVertexBufferHandle Marker::smVertexBuffer; +GFXVertexBufferHandle Marker::smVertexBuffer; GFXPrimitiveBufferHandle Marker::smPrimitiveBuffer; static Point3F wedgePoints[4] = { @@ -295,7 +295,7 @@ void Marker::initGFXResources() smStateBlock = GFX->createStateBlock(d); smVertexBuffer.set(GFX, 4, GFXBufferTypeStatic); - GFXVertexPC* verts = smVertexBuffer.lock(); + GFXVertexPCT* verts = smVertexBuffer.lock(); verts[0].point = wedgePoints[0] * 0.25f; verts[1].point = wedgePoints[1] * 0.25f; verts[2].point = wedgePoints[2] * 0.25f; diff --git a/Engine/source/scene/simPath.h b/Engine/source/scene/simPath.h index 9e172bdf4..4633e0a10 100644 --- a/Engine/source/scene/simPath.h +++ b/Engine/source/scene/simPath.h @@ -132,7 +132,7 @@ class Marker : public SceneObject static void initGFXResources(); static GFXStateBlockRef smStateBlock; - static GFXVertexBufferHandle smVertexBuffer; + static GFXVertexBufferHandle smVertexBuffer; static GFXPrimitiveBufferHandle smPrimitiveBuffer; public: diff --git a/Engine/source/shaderGen/HLSL/accuFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/accuFeatureHLSL.cpp index 2bafc06f4..6010c8283 100644 --- a/Engine/source/shaderGen/HLSL/accuFeatureHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/accuFeatureHLSL.cpp @@ -85,7 +85,8 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, // accu constants Var *accuScale = (Var*)LangElement::find( "accuScale" ); - if ( !accuScale ) { + if ( !accuScale ) + { accuScale = new Var; accuScale->setType( "float" ); accuScale->setName( "accuScale" ); @@ -94,7 +95,8 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, accuScale->constSortPos = cspPotentialPrimitive; } Var *accuDirection = (Var*)LangElement::find( "accuDirection" ); - if ( !accuDirection ) { + if ( !accuDirection ) + { accuDirection = new Var; accuDirection->setType( "float" ); accuDirection->setName( "accuDirection" ); @@ -103,7 +105,8 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, accuDirection->constSortPos = cspPotentialPrimitive; } Var *accuStrength = (Var*)LangElement::find( "accuStrength" ); - if ( !accuStrength ) { + if ( !accuStrength ) + { accuStrength = new Var; accuStrength->setType( "float" ); accuStrength->setName( "accuStrength" ); @@ -112,7 +115,8 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, accuStrength->constSortPos = cspPotentialPrimitive; } Var *accuCoverage = (Var*)LangElement::find( "accuCoverage" ); - if ( !accuCoverage ) { + if ( !accuCoverage ) + { accuCoverage = new Var; accuCoverage->setType( "float" ); accuCoverage->setName( "accuCoverage" ); @@ -121,7 +125,8 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, accuCoverage->constSortPos = cspPotentialPrimitive; } Var *accuSpecular = (Var*)LangElement::find( "accuSpecular" ); - if ( !accuSpecular ) { + if ( !accuSpecular ) + { accuSpecular = new Var; accuSpecular->setType( "float" ); accuSpecular->setName( "accuSpecular" ); @@ -133,14 +138,26 @@ void AccuTexFeatHLSL::processPix( Vector &componentList, Var *inTex = getInTexCoord( "texCoord", "float2", true, componentList ); Var *accuVec = getInTexCoord( "accuVec", "float3", true, componentList ); Var *bumpNorm = (Var *)LangElement::find( "bumpSample" ); - if( bumpNorm == NULL ) { + if( bumpNorm == NULL ) + { bumpNorm = (Var *)LangElement::find( "bumpNormal" ); if (!bumpNorm) return; } // get the accu pixel color - meta->addStatement( new GenOp( " @ = tex2D(@, @ * @);\r\n", colorAccuDecl, accuMap, inTex, accuScale ) ); + if (mIsDirect3D11) + { + Var *accuMapTex = new Var; + accuMapTex->setType("Texture2D"); + accuMapTex->setName("accuMapTex"); + accuMapTex->uniform = true; + accuMapTex->texture = true; + accuMapTex->constNum = accuMap->constNum; + meta->addStatement(new GenOp(" @ = @.Sample(@, @ * @);\r\n", colorAccuDecl, accuMapTex, accuMap, inTex, accuScale)); + } + else + meta->addStatement(new GenOp(" @ = tex2D(@, @ * @);\r\n", colorAccuDecl, accuMap, inTex, accuScale)); // scale up normals meta->addStatement( new GenOp( " @.xyz = @.xyz * 2.0 - 0.5;\r\n", bumpNorm, bumpNorm ) ); diff --git a/Engine/source/shaderGen/HLSL/bumpHLSL.cpp b/Engine/source/shaderGen/HLSL/bumpHLSL.cpp index 327e7ad6f..ee34f3e66 100644 --- a/Engine/source/shaderGen/HLSL/bumpHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/bumpHLSL.cpp @@ -70,6 +70,13 @@ void BumpFeatHLSL::processPix( Vector &componentList, Var *bumpMap = getNormalMapTex(); LangElement *texOp = NULL; + //if it's D3D11 let's create the texture object + Var* bumpMapTex = NULL; + if (mIsDirect3D11) + { + bumpMapTex = (Var*)LangElement::find("bumpMapTex"); + } + // Handle atlased textures // http://www.infinity-universe.com/Infinity/index.php?option=com_content&task=view&id=65&Itemid=47 if(fd.features[MFT_NormalMapAtlas]) @@ -127,18 +134,25 @@ void BumpFeatHLSL::processPix( Vector &componentList, // Add a newline meta->addStatement( new GenOp( "\r\n" ) ); - if(is_sm3) + if (mIsDirect3D11) { - texOp = new GenOp( "tex2Dlod(@, float4(@, 0.0, mipLod_bump))", bumpMap, texCoord ); + texOp = new GenOp("@.SampleLevel(@, @, mipLod_bump)", bumpMapTex, bumpMap, texCoord); + } + else if (is_sm3) + { + texOp = new GenOp("tex2Dlod(@, float4(@, 0.0, mipLod_bump))", bumpMap, texCoord); } else { - texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + texOp = new GenOp("tex2D(@, @)", bumpMap, texCoord); } } else { - texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + if (mIsDirect3D11) + texOp = new GenOp("@.Sample(@, @)", bumpMapTex, bumpMap, texCoord); + else + texOp = new GenOp("tex2D(@, @)", bumpMap, texCoord); } Var *bumpNorm = new Var( "bumpNormal", "float4" ); @@ -156,8 +170,26 @@ void BumpFeatHLSL::processPix( Vector &componentList, bumpMap->sampler = true; bumpMap->constNum = Var::getTexUnitNum(); + Var* detailBumpTex = NULL; + if (mIsDirect3D11) + { + bumpMap->setType("SamplerState"); + detailBumpTex = new Var; + detailBumpTex->setName("detailBumpTex"); + detailBumpTex->setType("Texture2D"); + detailBumpTex->uniform = true; + detailBumpTex->texture = true; + detailBumpTex->constNum = bumpMap->constNum; + } + else + bumpMap->setType("sampler2D"); + texCoord = getInTexCoord( "detCoord", "float2", true, componentList ); - texOp = new GenOp( "tex2D(@, @)", bumpMap, texCoord ); + + if (mIsDirect3D11) + texOp = new GenOp("@.Sample(@, @)", detailBumpTex, bumpMap, texCoord); + else + texOp = new GenOp("tex2D(@, @)", bumpMap, texCoord); Var *detailBump = new Var; detailBump->setName( "detailBump" ); @@ -345,17 +377,26 @@ void ParallaxFeatHLSL::processPix( Vector &componentList, // Get the rest of our inputs. Var *parallaxInfo = _getUniformVar( "parallaxInfo", "float", cspPotentialPrimitive ); Var *normalMap = getNormalMapTex(); + Var *bumpMapTexture = (Var*)LangElement::find("bumpMapTex"); // Call the library function to do the rest. - if(fd.features.hasFeature( MFT_IsDXTnm, getProcessIndex() )) + if (fd.features.hasFeature(MFT_IsDXTnm, getProcessIndex())) { - meta->addStatement( new GenOp( " @.xy += parallaxOffsetDxtnm( @, @.xy, @, @ );\r\n", - texCoord, normalMap, texCoord, negViewTS, parallaxInfo ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @.xy += parallaxOffsetDxtnm( @, @, @.xy, @, @ );\r\n", + texCoord, bumpMapTexture, normalMap, texCoord, negViewTS, parallaxInfo)); + else + meta->addStatement(new GenOp(" @.xy += parallaxOffsetDxtnm( @, @.xy, @, @ );\r\n", + texCoord, normalMap, texCoord, negViewTS, parallaxInfo)); } else { - meta->addStatement( new GenOp( " @.xy += parallaxOffset( @, @.xy, @, @ );\r\n", - texCoord, normalMap, texCoord, negViewTS, parallaxInfo ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @.xy += parallaxOffset( @, @, @.xy, @, @ );\r\n", + texCoord, bumpMapTexture, normalMap, texCoord, negViewTS, parallaxInfo)); + else + meta->addStatement(new GenOp(" @.xy += parallaxOffset( @, @.xy, @, @ );\r\n", + texCoord, normalMap, texCoord, negViewTS, parallaxInfo)); } // TODO: Fix second UV maybe? diff --git a/Engine/source/shaderGen/HLSL/paraboloidHLSL.cpp b/Engine/source/shaderGen/HLSL/paraboloidHLSL.cpp index a5afa00e0..105e3c100 100644 --- a/Engine/source/shaderGen/HLSL/paraboloidHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/paraboloidHLSL.cpp @@ -46,9 +46,13 @@ void ParaboloidVertTransformHLSL::processVert( Vector &compon ShaderConnector *connectComp = dynamic_cast( componentList[C_CONNECTOR] ); // Grab connector out position. - Var *outPosition = connectComp->getElement( RT_POSITION ); - outPosition->setName( "hpos" ); - outPosition->setStructName( "OUT" ); + RegisterType type = RT_POSITION; + if (mIsDirect3D11) + type = RT_SVPOSITION; + + Var *outPosition = connectComp->getElement(type); + outPosition->setName("hpos"); + outPosition->setStructName("OUT"); // Get the atlas scale. Var *atlasScale = new Var; diff --git a/Engine/source/shaderGen/HLSL/pixSpecularHLSL.cpp b/Engine/source/shaderGen/HLSL/pixSpecularHLSL.cpp index 8b65a9491..b5a5a98b1 100644 --- a/Engine/source/shaderGen/HLSL/pixSpecularHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/pixSpecularHLSL.cpp @@ -77,8 +77,12 @@ void PixelSpecularHLSL::processPix( Vector &componentList, { LangElement * lightMap = LangElement::find( "lightMap" ); LangElement * lmCoord = LangElement::find( "texCoord2" ); + LangElement * lightMapTex = LangElement::find("lightMapTex"); //used only DX11 shaders - lmColor = new GenOp( "tex2D(@, @)", lightMap, lmCoord ); + if (lightMapTex) + lmColor = new GenOp("@.Sample(@, @)", lightMapTex, lightMap, lmCoord); + else + lmColor = new GenOp("tex2D(@, @)", lightMap, lmCoord); } final = new GenOp( "@ * float4(@.rgb,0)", specMul, lmColor ); @@ -138,11 +142,33 @@ void SpecularMapHLSL::processPix( Vector &componentList, const specularMap->uniform = true; specularMap->sampler = true; specularMap->constNum = Var::getTexUnitNum(); - LangElement *texOp = new GenOp( "tex2D(@, @)", specularMap, texCoord ); + Var *specularMapTex = NULL; - Var *specularColor = new Var( "specularColor", "float4" ); + if (mIsDirect3D11) + { + specularMap->setType("SamplerState"); + specularMapTex = new Var; + specularMapTex->setName("specularMapTex"); + specularMapTex->setType("Texture2D"); + specularMapTex->uniform = true; + specularMapTex->texture = true; + specularMapTex->constNum = specularMap->constNum; + } + else + { + specularMap->setType("sampler2D"); + } - output = new GenOp( " @ = @;\r\n", new DecOp( specularColor ), texOp ); + LangElement *texOp = NULL; + + if (specularMapTex) + texOp = new GenOp("@.Sample(@, @)", specularMapTex, specularMap, texCoord); + else + texOp = new GenOp("tex2D(@, @)", specularMap, texCoord); + + Var *specularColor = new Var("specularColor", "float4"); + + output = new GenOp(" @ = @;\r\n", new DecOp(specularColor), texOp); } ShaderFeature::Resources SpecularMapHLSL::getResources( const MaterialFeatureData &fd ) diff --git a/Engine/source/shaderGen/HLSL/shaderCompHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderCompHLSL.cpp index 2d7b80bc9..6aece4ef0 100644 --- a/Engine/source/shaderGen/HLSL/shaderCompHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/shaderCompHLSL.cpp @@ -55,6 +55,25 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 Var *newVar = new Var; mElementList.push_back( newVar ); newVar->setConnectName( "POSITION" ); + newVar->rank = 0; + return newVar; + } + + case RT_VPOS: + { + Var *newVar = new Var; + mElementList.push_back(newVar); + newVar->setConnectName("VPOS"); + newVar->rank = 0; + return newVar; + } + + case RT_SVPOSITION: + { + Var *newVar = new Var; + mElementList.push_back(newVar); + newVar->setConnectName("SV_Position"); + newVar->rank = 0; return newVar; } @@ -63,6 +82,7 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 Var *newVar = new Var; mElementList.push_back( newVar ); newVar->setConnectName( "NORMAL" ); + newVar->rank = 1; return newVar; } @@ -71,6 +91,7 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 Var *newVar = new Var; mElementList.push_back( newVar ); newVar->setConnectName( "BINORMAL" ); + newVar->rank = 2; return newVar; } @@ -79,6 +100,7 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 Var *newVar = new Var; mElementList.push_back( newVar ); newVar->setConnectName( "TANGENT" ); + newVar->rank = 3; return newVar; } @@ -87,14 +109,7 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 Var *newVar = new Var; mElementList.push_back( newVar ); newVar->setConnectName( "COLOR" ); - return newVar; - } - - case RT_VPOS: - { - Var *newVar = new Var; - mElementList.push_back( newVar ); - newVar->setConnectName( "VPOS" ); + newVar->rank = 4; return newVar; } @@ -113,6 +128,7 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 newVar->setConnectName( out ); newVar->constNum = index; newVar->arraySize = numElements; + newVar->rank = 5 + index; return newVar; } @@ -124,67 +140,27 @@ Var * ShaderConnectorHLSL::getIndexedElement( U32 index, RegisterType type, U32 return NULL; } + + +S32 QSORT_CALLBACK ShaderConnectorHLSL::_hlsl4VarSort(const void* e1, const void* e2) +{ + Var* a = *((Var **)e1); + Var* b = *((Var **)e2); + + return a->rank - b->rank; +} + void ShaderConnectorHLSL::sortVars() { - if ( GFX->getPixelShaderVersion() >= 2.0 ) + + // If shader model 4+ than we gotta sort the vars to make sure the order is consistent + if (GFX->getPixelShaderVersion() >= 4.f) + { + dQsort((void *)&mElementList[0], mElementList.size(), sizeof(Var *), _hlsl4VarSort); return; - - // Sort connector variables - They must be sorted on hardware that is running - // ps 1.4 and below. The reason is that texture coordinate registers MUST - // map exactly to their respective texture stage. Ie. if you have fog - // coordinates being passed into a pixel shader in texture coordinate register - // number 4, the fog texture MUST reside in texture stage 4 for it to work. - // The problem is solved by pushing non-texture coordinate data to the end - // of the structure so that the texture coodinates are all at the "top" of the - // structure in the order that the features are processed. - - // create list of just the texCoords, sorting by 'mapsToSampler' - Vector< Var * > texCoordList; - - // - first pass is just coords mapped to a sampler - for( U32 i=0; imapsToSampler ) - { - texCoordList.push_back( var ); - } - } - - // - next pass is for the others - for( U32 i=0; iconnectName, "TEX" ) && - !var->mapsToSampler ) - { - texCoordList.push_back( var ); - } - } - - // rename the connectNames - for( U32 i=0; isetConnectName( out ); } - // write new, sorted list over old one - if( texCoordList.size() ) - { - U32 index = 0; - - for( U32 i=0; iconnectName, "TEX" ) ) - { - mElementList[i] = texCoordList[index]; - index++; - } - } - } + return; } void ShaderConnectorHLSL::setName( char *newName ) @@ -246,7 +222,7 @@ void ParamsDefHLSL::assignConstantNumbers() Var *var = dynamic_cast(LangElement::elementList[i]); if( var ) { - bool shaderConst = var->uniform && !var->sampler; + bool shaderConst = var->uniform && !var->sampler && !var->texture; AssertFatal((!shaderConst) || var->constSortPos != cspUninit, "Const sort position has not been set, variable will not receive a constant number!!"); if( shaderConst && var->constSortPos == bin) { @@ -328,6 +304,10 @@ void PixelParamsDefHLSL::print( Stream &stream, bool isVerterShader ) { dSprintf( (char*)varNum, sizeof(varNum), ": register(S%d)", var->constNum ); } + else if (var->texture) + { + dSprintf((char*)varNum, sizeof(varNum), ": register(T%d)", var->constNum); + } else { dSprintf( (char*)varNum, sizeof(varNum), ": register(C%d)", var->constNum ); diff --git a/Engine/source/shaderGen/HLSL/shaderCompHLSL.h b/Engine/source/shaderGen/HLSL/shaderCompHLSL.h index 0a3ead4ed..cb4ae5ad1 100644 --- a/Engine/source/shaderGen/HLSL/shaderCompHLSL.h +++ b/Engine/source/shaderGen/HLSL/shaderCompHLSL.h @@ -30,6 +30,8 @@ class ShaderConnectorHLSL : public ShaderConnector { +private: + static S32 QSORT_CALLBACK _hlsl4VarSort(const void* e1, const void* e2); public: // ShaderConnector diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp index 2ab6a75f0..8878f2600 100644 --- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp @@ -173,6 +173,7 @@ LangElement *ShaderFeatureHLSL::expandNormalMap( LangElement *sampleNormalOp, ShaderFeatureHLSL::ShaderFeatureHLSL() { output = NULL; + mIsDirect3D11 = GFX->getAdapterType() == Direct3D11; } Var * ShaderFeatureHLSL::getVertTexCoord( const String &name ) @@ -354,7 +355,7 @@ Var* ShaderFeatureHLSL::getOutTexCoord( const char *name, if ( useTexAnim ) { - inTex->setType( "float4" ); + inTex->setType( "float2" ); // create texture mat var Var *texMat = new Var; @@ -365,7 +366,7 @@ Var* ShaderFeatureHLSL::getOutTexCoord( const char *name, // Statement allows for casting of different types which // eliminates vector truncation problems. - String statement = String::ToString( " @ = (%s)mul(@, @).xy;\r\n", type ); + String statement = String::ToString(" @ = (%s)mul(@, float4(@,1,1));\r\n", type); meta->addStatement( new GenOp( statement, texCoord, texMat, inTex ) ); } else @@ -464,7 +465,17 @@ Var* ShaderFeatureHLSL::getInVpos( MultiLine *meta, ShaderConnector *connectComp = dynamic_cast( componentList[C_CONNECTOR] ); - if ( GFX->getPixelShaderVersion() >= 3.0f ) + F32 pixelShaderVer = GFX->getPixelShaderVersion(); + + if ( pixelShaderVer >= 4.0f ) + { + inVpos = connectComp->getElement( RT_SVPOSITION ); + inVpos->setName( "vpos" ); + inVpos->setStructName( "IN" ); + inVpos->setType( "float4" ); + return inVpos; + } + else if ( pixelShaderVer >= 3.0f ) { inVpos = connectComp->getElement( RT_VPOS ); inVpos->setName( "vpos" ); @@ -516,15 +527,30 @@ Var* ShaderFeatureHLSL::getInViewToTangent( Vector &componentL Var* ShaderFeatureHLSL::getNormalMapTex() { - Var *normalMap = (Var*)LangElement::find( "bumpMap" ); - if ( !normalMap ) + Var *normalMap = (Var*)LangElement::find("bumpMap"); + if (!normalMap) { normalMap = new Var; - normalMap->setType( "sampler2D" ); - normalMap->setName( "bumpMap" ); + normalMap->setType("sampler2D"); + normalMap->setName("bumpMap"); normalMap->uniform = true; normalMap->sampler = true; normalMap->constNum = Var::getTexUnitNum(); + + // D3D11 + Var* normalMapTex = NULL; + if (GFX->getAdapterType() == Direct3D11) + { + normalMap->setType("SamplerState"); + normalMapTex = new Var; + normalMapTex->setName("bumpMapTex"); + normalMapTex->setType("Texture2D"); + normalMapTex->uniform = true; + normalMapTex->texture = true; + normalMapTex->constNum = normalMap->constNum; + } + + } return normalMap; @@ -780,6 +806,7 @@ Var* ShaderFeatureHLSL::addOutDetailTexCoord( Vector &compon // Grab incoming texture coords. Var *inTex = getVertTexCoord( "texCoord" ); + inTex->setType("float2"); // create detail variable Var *detScale = new Var; @@ -798,8 +825,6 @@ Var* ShaderFeatureHLSL::addOutDetailTexCoord( Vector &compon if ( useTexAnim ) { - inTex->setType( "float4" ); - // Find or create the texture matrix. Var *texMat = (Var*)LangElement::find( "texMat" ); if ( !texMat ) @@ -811,7 +836,7 @@ Var* ShaderFeatureHLSL::addOutDetailTexCoord( Vector &compon texMat->constSortPos = cspPass; } - meta->addStatement( new GenOp( " @ = mul(@, @).xy * @;\r\n", outTex, texMat, inTex, detScale ) ); + meta->addStatement(new GenOp(" @ = mul(@, float4(@,1,1)).xy * @;\r\n", outTex, texMat, inTex, detScale)); } else { @@ -869,6 +894,19 @@ void DiffuseMapFeatHLSL::processPix( Vector &componentList, diffuseMap->sampler = true; diffuseMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var* diffuseMapTex = NULL; + if (mIsDirect3D11) + { + diffuseMap->setType("SamplerState"); + + diffuseMapTex = new Var; + diffuseMapTex->setName("diffuseMapTex"); + diffuseMapTex->setType("Texture2D"); + diffuseMapTex->uniform = true; + diffuseMapTex->texture = true; + diffuseMapTex->constNum = diffuseMap->constNum; + } + // create sample color Var *diffColor = new Var; diffColor->setType("float4"); @@ -880,13 +918,14 @@ void DiffuseMapFeatHLSL::processPix( Vector &componentList, if ( fd.features[MFT_CubeMap] ) { - meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", - colorDecl, - diffuseMap, - inTex ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @ = @.Sample(@, @);\r\n", colorDecl, diffuseMapTex, diffuseMap, inTex)); + else + meta->addStatement(new GenOp(" @ = tex2D(@, @);\r\n", colorDecl, diffuseMap, inTex)); + if (!fd.features[MFT_Imposter]) meta->addStatement(new GenOp(" @ = toLinear(@);\r\n", diffColor, diffColor)); - + meta->addStatement(new GenOp(" @;\r\n", assignColor(diffColor, Material::Mul, NULL, targ))); } else if(fd.features[MFT_DiffuseMapAtlas]) @@ -958,15 +997,19 @@ void DiffuseMapFeatHLSL::processPix( Vector &componentList, return; } #endif - - if(is_sm3) + if (mIsDirect3D11) + { + meta->addStatement(new GenOp(" @ = @.SampleLevel(@,@,mipLod);\r\n", + new DecOp(diffColor), diffuseMapTex, diffuseMap, inTex)); + } + else if(is_sm3) { meta->addStatement(new GenOp( " @ = tex2Dlod(@, float4(@, 0.0, mipLod));\r\n", new DecOp(diffColor), diffuseMap, inTex)); } else { - meta->addStatement(new GenOp( " @ = tex2D(@, @);\r\n", + meta->addStatement(new GenOp( " @ = tex2D(@, @);\r\n", new DecOp(diffColor), diffuseMap, inTex)); } if (!fd.features[MFT_Imposter]) @@ -976,7 +1019,11 @@ void DiffuseMapFeatHLSL::processPix( Vector &componentList, } else { - meta->addStatement(new GenOp("@ = tex2D(@, @);\r\n", colorDecl, diffuseMap, inTex)); + if (mIsDirect3D11) + meta->addStatement(new GenOp("@ = @.Sample(@, @);\r\n", colorDecl, diffuseMapTex, diffuseMap, inTex)); + else + meta->addStatement(new GenOp("@ = tex2D(@, @);\r\n", colorDecl, diffuseMap, inTex)); + if (!fd.features[MFT_Imposter]) meta->addStatement(new GenOp(" @ = toLinear(@);\r\n", diffColor, diffColor)); meta->addStatement(new GenOp(" @;\r\n", assignColor(diffColor, Material::Mul, NULL, targ))); @@ -1067,7 +1114,24 @@ void OverlayTexFeatHLSL::processPix( Vector &componentList, diffuseMap->sampler = true; diffuseMap->constNum = Var::getTexUnitNum(); // used as texture unit num here - LangElement *statement = new GenOp( "tex2D(@, @)", diffuseMap, inTex ); + Var* diffuseMapTex = NULL; + if (mIsDirect3D11) + { + diffuseMap->setType("SamplerState"); + diffuseMapTex = new Var; + diffuseMapTex->setName("overlayMapTex"); + diffuseMapTex->setType("Texture2D"); + diffuseMapTex->uniform = true; + diffuseMapTex->texture = true; + diffuseMapTex->constNum = diffuseMap->constNum; + } + + LangElement *statement = NULL; + if (mIsDirect3D11) + statement = new GenOp("@.Sample(@, @)", diffuseMapTex, diffuseMap, inTex); + else + statement = new GenOp("tex2D(@, @)", diffuseMap, inTex); + output = new GenOp( " @;\r\n", assignColor( statement, Material::LerpAlpha ) ); } @@ -1240,6 +1304,17 @@ void LightmapFeatHLSL::processPix( Vector &componentList, lightMap->sampler = true; lightMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var *lightMapTex = NULL; + if (mIsDirect3D11) + { + lightMap->setType("SamplerState"); + lightMapTex->setName("lightMapTex"); + lightMapTex->setType("Texture2D"); + lightMapTex->uniform = true; + lightMapTex->texture = true; + lightMapTex->constNum = lightMap->constNum; + } + // argh, pixel specular should prob use this too if( fd.features[MFT_NormalMap] ) @@ -1249,7 +1324,10 @@ void LightmapFeatHLSL::processPix( Vector &componentList, lmColor->setType( "float4" ); LangElement *lmColorDecl = new DecOp( lmColor ); - output = new GenOp( " @ = tex2D(@, @);\r\n", lmColorDecl, lightMap, inTex ); + if (mIsDirect3D11) + output = new GenOp(" @ = @.Sample(@, @);\r\n", lmColorDecl, lightMapTex, lightMap, inTex); + else + output = new GenOp(" @ = tex2D(@, @);\r\n", lmColorDecl, lightMap, inTex); return; } @@ -1269,16 +1347,26 @@ void LightmapFeatHLSL::processPix( Vector &componentList, // Lightmap has already been included in the advanced light bin, so // no need to do any sampling or anything - if(bPreProcessedLighting) - statement = new GenOp( "float4(@, 1.0)", inColor ); + if (bPreProcessedLighting) + statement = new GenOp("float4(@, 1.0)", inColor); else - statement = new GenOp( "tex2D(@, @) + float4(@.rgb, 0.0)", lightMap, inTex, inColor ); + { + if (mIsDirect3D11) + statement = new GenOp("@.Sample(@, @) + float4(@.rgb, 0.0)", lightMapTex, lightMap, inTex, inColor); + else + statement = new GenOp("tex2D(@, @) + float4(@.rgb, 0.0)", lightMap, inTex, inColor); + } } } // If we still don't have it... then just sample the lightmap. - if ( !statement ) - statement = new GenOp( "tex2D(@, @)", lightMap, inTex ); + if (!statement) + { + if (mIsDirect3D11) + statement = new GenOp("@.Sample(@, @)", lightMapTex, lightMap, inTex); + else + statement = new GenOp("tex2D(@, @)", lightMap, inTex); + } // Assign to proper render target MultiLine *meta = new MultiLine; @@ -1365,6 +1453,18 @@ void TonemapFeatHLSL::processPix( Vector &componentList, toneMap->sampler = true; toneMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var *toneMapTex = NULL; + if (mIsDirect3D11) + { + toneMap->setType("SamplerState"); + toneMapTex = new Var; + toneMapTex->setName("toneMapTex"); + toneMapTex->setType("Texture2D"); + toneMapTex->uniform = true; + toneMapTex->texture = true; + toneMapTex->constNum = toneMap->constNum; + } + MultiLine * meta = new MultiLine; // First get the toneMap color @@ -1373,7 +1473,10 @@ void TonemapFeatHLSL::processPix( Vector &componentList, toneMapColor->setName( "toneMapColor" ); LangElement *toneMapColorDecl = new DecOp( toneMapColor ); - meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", toneMapColorDecl, toneMap, inTex2 ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @ = @.Sample(@, @);\r\n", toneMapColorDecl, toneMapTex, toneMap, inTex2)); + else + meta->addStatement(new GenOp(" @ = tex2D(@, @);\r\n", toneMapColorDecl, toneMap, inTex2)); // We do a different calculation if there is a diffuse map or not Material::BlendOp blendOp = Material::Mul; @@ -1602,6 +1705,18 @@ void DetailFeatHLSL::processPix( Vector &componentList, detailMap->sampler = true; detailMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var* detailMapTex = NULL; + if (mIsDirect3D11) + { + detailMap->setType("SamplerState"); + detailMapTex = new Var; + detailMapTex->setName("detailMapTex"); + detailMapTex->setType("Texture2D"); + detailMapTex->uniform = true; + detailMapTex->texture = true; + detailMapTex->constNum = detailMap->constNum; + } + // We're doing the standard greyscale detail map // technique which can darken and lighten the // diffuse texture. @@ -1609,7 +1724,12 @@ void DetailFeatHLSL::processPix( Vector &componentList, // TODO: We could add a feature to toggle between this // and a simple multiplication with the detail map. - LangElement *statement = new GenOp( "( tex2D(@, @) * 2.0 ) - 1.0", detailMap, inTex ); + LangElement *statement = NULL; + if (mIsDirect3D11) + statement = new GenOp("( @.Sample(@, @) * 2.0 ) - 1.0", detailMapTex, detailMap, inTex); + else + statement = new GenOp("( tex2D(@, @) * 2.0 ) - 1.0", detailMap, inTex); + if ( fd.features[MFT_isDeferred]) output = new GenOp( " @;\r\n", assignColor( statement, Material::Add, NULL, ShaderFeature::RenderTarget1 ) ); else @@ -1665,7 +1785,12 @@ void VertPositionHLSL::processVert( Vector &componentList, // grab connector position ShaderConnector *connectComp = dynamic_cast( componentList[C_CONNECTOR] ); - Var *outPosition = connectComp->getElement( RT_POSITION ); + Var *outPosition = NULL; + if (mIsDirect3D11) + outPosition = connectComp->getElement(RT_SVPOSITION); + else + outPosition = connectComp->getElement(RT_POSITION); + outPosition->setName( "hpos" ); outPosition->setStructName( "OUT" ); @@ -1679,6 +1804,19 @@ void VertPositionHLSL::processVert( Vector &componentList, output = meta; } +void VertPositionHLSL::processPix( Vector &componentList, + const MaterialFeatureData &fd) +{ + if (mIsDirect3D11) + { + // grab connector position + ShaderConnector *connectComp = dynamic_cast(componentList[C_CONNECTOR]); + Var *outPosition = connectComp->getElement(RT_SVPOSITION); + outPosition->setName("vpos"); + outPosition->setStructName("IN"); + } +} + //**************************************************************************** // Reflect Cubemap @@ -1738,8 +1876,11 @@ void ReflectCubeFeatHLSL::processVert( Vector &componentList, cubeNormal->setType( "float3" ); LangElement *cubeNormDecl = new DecOp( cubeNormal ); - meta->addStatement( new GenOp( " @ = normalize( mul(@, float4(normalize(@),0.0)).xyz );\r\n", - cubeNormDecl, cubeTrans, inNormal ) ); + meta->addStatement(new GenOp(" @ = ( mul( (@), float4(@, 0) ) ).xyz;\r\n", + cubeNormDecl, cubeTrans, inNormal)); + + meta->addStatement(new GenOp(" @ = bool(length(@)) ? normalize(@) : @;\r\n", + cubeNormal, cubeNormal, cubeNormal, cubeNormal)); // grab the eye position Var *eyePos = (Var*)LangElement::find( "eyePosWorld" ); @@ -1782,10 +1923,10 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, // current pass - we need to add one to the current pass to use // its alpha channel as a gloss map. if( !fd.features[MFT_DiffuseMap] && - !fd.features[MFT_NormalMap] ) + !fd.features[MFT_NormalMap]) { if( fd.materialFeatures[MFT_DiffuseMap] || - fd.materialFeatures[MFT_NormalMap] ) + fd.materialFeatures[MFT_NormalMap]) { // grab connector texcoord register Var *inTex = getInTexCoord( "texCoord", "float2", true, componentList ); @@ -1797,6 +1938,19 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, newMap->uniform = true; newMap->sampler = true; newMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + + Var* glowMapTex = NULL; + if (mIsDirect3D11) + { + newMap->setType("SamplerState"); + + glowMapTex = new Var; + glowMapTex->setName("glowMapTex"); + glowMapTex->setType("Texture2D"); + glowMapTex->uniform = true; + glowMapTex->texture = true; + glowMapTex->constNum = newMap->constNum; + } // create sample color Var *color = new Var; @@ -1806,7 +1960,10 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, glossColor = color; - meta->addStatement( new GenOp( " @ = tex2D( @, @ );\r\n", colorDecl, newMap, inTex ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @ = @.Sample( @, @ );\r\n", colorDecl, glowMapTex, newMap, inTex)); + else + meta->addStatement(new GenOp(" @ = tex2D( @, @ );\r\n", colorDecl, newMap, inTex)); } } else @@ -1837,6 +1994,18 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, cubeMap->sampler = true; cubeMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + Var* cubeMapTex = NULL; + if (mIsDirect3D11) + { + cubeMap->setType("SamplerState"); + cubeMapTex = new Var; + cubeMapTex->setName("cubeMapTex"); + cubeMapTex->setType("TextureCube"); // cubeMapTex->setType("TextureCube"); + cubeMapTex->uniform = true; + cubeMapTex->texture = true; + cubeMapTex->constNum = cubeMap->constNum; + } + // TODO: Restore the lighting attenuation here! Var *attn = NULL; //if ( fd.materialFeatures[MFT_DynamicLight] ) @@ -1855,15 +2024,37 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, //LangElement *texCube = new GenOp( "texCUBElod( @, float4(@, min((1.0 - (@ / 128.0)) * 11.0 + 1.0, 8.0)) )", cubeMap, reflectVec, specPower ); if (fd.features[MFT_DeferredSpecMap]) - texCube = new GenOp("texCUBElod( @, float4(@, (@.a*5)) )", cubeMap, reflectVec, matinfo); + { + if (mIsDirect3D11) + texCube = new GenOp("@.SampleLevel( @, @, @.a*5)", cubeMapTex, cubeMap, reflectVec, matinfo); + else + texCube = new GenOp("texCUBElod( @, float4(@, (@.a*5)) )", cubeMap, reflectVec, matinfo); + } else - texCube = new GenOp("texCUBElod( @, float4(@, ((1.0-@.a)*6)) )", cubeMap, reflectVec, matinfo); + { + if (mIsDirect3D11) + texCube = new GenOp("@.SampleLevel( @, @, (1.0-@.a)*6 )", cubeMapTex, cubeMap, reflectVec, matinfo); + else + texCube = new GenOp("texCUBElod( @, float4(@, ((1.0-@.a)*6)) )", cubeMap, reflectVec, matinfo); + } } else + { if (glossColor) //failing that, rtry and find color data - texCube = new GenOp("texCUBElod( @, float4(@, @.a*5))", cubeMap, reflectVec, glossColor); + { + if (mIsDirect3D11) + texCube = new GenOp("@.SampleLevel( @, @, @.a*5)", cubeMapTex, cubeMap, reflectVec, glossColor); + else + texCube = new GenOp("texCUBElod( @, float4(@, @.a*5))", cubeMap, reflectVec, glossColor); + } else //failing *that*, just draw the cubemap - texCube = new GenOp("texCUBE( @, @)", cubeMap, reflectVec); + { + if (mIsDirect3D11) + texCube = new GenOp("@.Sample( @, @ )", cubeMapTex, cubeMap, reflectVec); + else + texCube = new GenOp("texCUBE( @, @ )", cubeMap, reflectVec); + } + } LangElement *lerpVal = NULL; Material::BlendOp blendOp = Material::LerpAlpha; @@ -1898,7 +2089,7 @@ void ReflectCubeFeatHLSL::processPix( Vector &componentList, if (fd.features[MFT_DeferredSpecMap]) meta->addStatement(new GenOp(" @.rgb = lerp( @.rgb, (@).rgb, (@.b));\r\n", targ, targ, texCube, lerpVal)); else - meta->addStatement(new GenOp(" @.rgb = lerp( @.rgb, (@).rgb, (@.b));\r\n", targ, targ, texCube, lerpVal)); + meta->addStatement(new GenOp(" @.rgb = lerp( @.rgb, (@).rgb, (@.b*128/5));\r\n", targ, targ, texCube, lerpVal)); } else meta->addStatement( new GenOp( " @;\r\n", assignColor( texCube, blendOp, lerpVal ) ) ); @@ -1951,7 +2142,7 @@ void ReflectCubeFeatHLSL::setTexData( Material::StageData &stageDat, } } } - + if( stageDat.getCubemap() ) { passData.mCubeMap = stageDat.getCubemap(); @@ -2397,7 +2588,8 @@ void VisibilityFeatHLSL::processPix( Vector &componentList, // Everything else does a fizzle. Var *vPos = getInVpos( meta, componentList ); - meta->addStatement( new GenOp( " fizzle( @, @ );\r\n", vPos, visibility ) ); + // vpos is a float4 in d3d11 + meta->addStatement( new GenOp( " fizzle( @.xy, @ );\r\n", vPos, visibility ) ); } ShaderFeature::Resources VisibilityFeatHLSL::getResources( const MaterialFeatureData &fd ) diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.h b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.h index b09d4d561..673970945 100644 --- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.h +++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.h @@ -33,6 +33,8 @@ struct RenderPassData; class ShaderFeatureHLSL : public ShaderFeature { +protected: + bool mIsDirect3D11; public: ShaderFeatureHLSL(); @@ -188,6 +190,9 @@ class VertPositionHLSL : public ShaderFeatureHLSL public: virtual void processVert( Vector &componentList, const MaterialFeatureData &fd ); + + virtual void processPix( Vector &componentList, + const MaterialFeatureData &fd); virtual String getName() { diff --git a/Engine/source/shaderGen/HLSL/shaderGenHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderGenHLSL.cpp index 23ca8137d..49487624f 100644 --- a/Engine/source/shaderGen/HLSL/shaderGenHLSL.cpp +++ b/Engine/source/shaderGen/HLSL/shaderGenHLSL.cpp @@ -63,21 +63,33 @@ void ShaderGenPrinterHLSL::printPixelShaderOutputStruct(Stream& stream, const Ma for( U32 i = 0; i < FEATUREMGR->getFeatureCount(); i++ ) { const FeatureInfo &info = FEATUREMGR->getAt( i ); - if( featureData.features.hasFeature( *info.type ) ) + if ( featureData.features.hasFeature( *info.type ) ) numMRTs |= info.feature->getOutputTargets( featureData ); } - WRITESTR( "struct Fragout\r\n" ); - WRITESTR( "{\r\n" ); - WRITESTR( " float4 col : COLOR0;\r\n" ); - for( U32 i = 1; i < 4; i++ ) + WRITESTR("struct Fragout\r\n"); + WRITESTR("{\r\n"); + if (GFX->getAdapterType() == Direct3D11) { - if( numMRTs & 1 << i ) - WRITESTR( avar( " float4 col%d : COLOR%d;\r\n", i, i ) ); + WRITESTR(" float4 col : SV_Target0;\r\n"); + for (U32 i = 1; i < 4; i++) + { + if (numMRTs & 1 << i) + WRITESTR(avar(" float4 col%d : SV_Target%d;\r\n", i, i)); + } } - WRITESTR( "};\r\n" ); - WRITESTR( "\r\n" ); - WRITESTR( "\r\n" ); + else + { + WRITESTR(" float4 col : COLOR0;\r\n"); + for (U32 i = 1; i < 4; i++) + { + if (numMRTs & 1 << i) + WRITESTR(avar(" float4 col%d : COLOR%d;\r\n", i, i)); + } + } + WRITESTR("};\r\n"); + WRITESTR("\r\n"); + WRITESTR("\r\n"); } void ShaderGenPrinterHLSL::printPixelShaderCloser(Stream& stream) @@ -141,8 +153,8 @@ ShaderComponent* ShaderGenComponentFactoryHLSL::createVertexInputConnector( cons } else if ( element.isSemantic( GFXSemantic::TANGENTW ) ) { - var = vertComp->getIndexedElement( element.getSemanticIndex(), RT_TEXCOORD ); - var->setName( "tangentW" ); + var = vertComp->getIndexedElement(element.getSemanticIndex(), RT_TEXCOORD); + var->setName("tangentW"); } else if ( element.isSemantic( GFXSemantic::BINORMAL ) ) { diff --git a/Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp b/Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp index fd30656bd..9e3805cdc 100644 --- a/Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp +++ b/Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp @@ -119,6 +119,7 @@ MODULE_BEGIN( ShaderGenHLSL ) sInitDelegate.bind(_initShaderGenHLSL); SHADERGEN->registerInitDelegate(Direct3D9, sInitDelegate); SHADERGEN->registerInitDelegate(Direct3D9_360, sInitDelegate); + SHADERGEN->registerInitDelegate(Direct3D11, sInitDelegate); } MODULE_END; diff --git a/Engine/source/shaderGen/langElement.cpp b/Engine/source/shaderGen/langElement.cpp index 9989eb2d2..9a38cdd31 100644 --- a/Engine/source/shaderGen/langElement.cpp +++ b/Engine/source/shaderGen/langElement.cpp @@ -99,6 +99,8 @@ Var::Var() sampler = false; mapsToSampler = false; arraySize = 1; + texture = false; + rank = 0; } Var::Var( const char *inName, const char *inType ) @@ -113,6 +115,8 @@ Var::Var( const char *inName, const char *inType ) texCoordNum = 0; constSortPos = cspUninit; arraySize = 1; + texture = false; + rank = 0; setName( inName ); setType( inType ); diff --git a/Engine/source/shaderGen/langElement.h b/Engine/source/shaderGen/langElement.h index c338aacb8..a1e8c96ad 100644 --- a/Engine/source/shaderGen/langElement.h +++ b/Engine/source/shaderGen/langElement.h @@ -120,8 +120,10 @@ struct Var : public LangElement bool vertData; // argument coming from vertex data bool connector; // variable that will be passed to pixel shader bool sampler; // texture + bool texture; //for D3D11 texture variables bool mapsToSampler; // for ps 1.x shaders - texcoords must be mapped to same sampler stage U32 arraySize; // 1 = no array, > 1 array of "type" + U32 rank; // optional rank system to assist in sorting vars if needed static U32 texUnitCount; static U32 getTexUnitNum(U32 numElements = 1); diff --git a/Engine/source/shaderGen/shaderFeature.cpp b/Engine/source/shaderGen/shaderFeature.cpp index 7e22f72ad..113b05a42 100644 --- a/Engine/source/shaderGen/shaderFeature.cpp +++ b/Engine/source/shaderGen/shaderFeature.cpp @@ -84,4 +84,9 @@ Var* ShaderFeature::findOrCreateLocal( const char *name, } return outVar; +} + +void ShaderFeature::setInstancingFormat(GFXVertexFormat *format) +{ + mInstancingFormat = format; } \ No newline at end of file diff --git a/Engine/source/shaderGen/shaderFeature.h b/Engine/source/shaderGen/shaderFeature.h index c6ac4955d..03426b733 100644 --- a/Engine/source/shaderGen/shaderFeature.h +++ b/Engine/source/shaderGen/shaderFeature.h @@ -99,11 +99,10 @@ protected: /// S32 mProcessIndex; -public: - - // TODO: Make this protected and give it a proper API. GFXVertexFormat *mInstancingFormat; +public: + //************************************************************************** /*! The Resources structure is used by ShaderFeature to indicate how many @@ -293,6 +292,8 @@ public: static Var* findOrCreateLocal( const char *name, const char *type, MultiLine *multi ); + // Set the instancing format + void setInstancingFormat(GFXVertexFormat *format); }; #endif // _SHADERFEATURE_H_ diff --git a/Engine/source/shaderGen/shaderGen.cpp b/Engine/source/shaderGen/shaderGen.cpp index 81e7f644f..eb7685b39 100644 --- a/Engine/source/shaderGen/shaderGen.cpp +++ b/Engine/source/shaderGen/shaderGen.cpp @@ -264,7 +264,7 @@ void ShaderGen::_processVertFeatures( Vector ¯os, bool macro if ( macrosOnly ) continue; - feature->mInstancingFormat = &mInstancingFormat; + feature->setInstancingFormat( &mInstancingFormat ); feature->processVert( mComponents, mFeatureData ); String line; @@ -304,7 +304,7 @@ void ShaderGen::_processPixFeatures( Vector ¯os, bool macros if ( macrosOnly ) continue; - feature->mInstancingFormat = &mInstancingFormat; + feature->setInstancingFormat( &mInstancingFormat ); feature->processPix( mComponents, mFeatureData ); String line; @@ -488,8 +488,7 @@ GFXShader* ShaderGen::getShader( const MaterialFeatureData &featureData, const G generateShader( featureData, vertFile, pixFile, &pixVersion, vertexFormat, cacheKey, shaderMacros ); GFXShader *shader = GFX->createShader(); - shader->mInstancingFormat.copy( mInstancingFormat ); // TODO: Move to init() below! - if ( !shader->init( vertFile, pixFile, pixVersion, shaderMacros, samplers ) ) + if (!shader->init(vertFile, pixFile, pixVersion, shaderMacros, samplers, &mInstancingFormat)) { delete shader; return NULL; diff --git a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp index 7761a8545..4945d4c88 100644 --- a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp +++ b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp @@ -396,9 +396,6 @@ void TerrainDetailMapFeatGLSL::processPix( Vector &component const S32 detailIndex = getProcessIndex(); Var *inTex = getVertTexCoord( "texCoord" ); - // new terrain - bool hasNormal = fd.features.hasFeature(MFT_TerrainNormalMap, detailIndex); - MultiLine *meta = new MultiLine; // We need the negative tangent space view vector @@ -490,7 +487,6 @@ void TerrainDetailMapFeatGLSL::processPix( Vector &component blendDepth->constSortPos = cspPrimitive; } - Var *baseColor = (Var*)LangElement::find("baseColor"); ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget; if(fd.features.hasFeature( MFT_DeferredTerrainDetailMap )) diff --git a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp index b0e16bb64..772c822b1 100644 --- a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp +++ b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp @@ -38,7 +38,7 @@ namespace { void register_hlsl_shader_features_for_terrain(GFXAdapterType type) { - if(type != Direct3D9 && type != Direct3D9_360) + if (type != Direct3D9 && type != Direct3D9_360 && type != Direct3D11) return; FEATUREMGR->registerFeature( MFT_TerrainBaseMap, new TerrainBaseMapFeatHLSL ); @@ -70,9 +70,9 @@ MODULE_END; TerrainFeatHLSL::TerrainFeatHLSL() : mTorqueDep( "shaders/common/torque.hlsl" ) - { +{ addDependency( &mTorqueDep ); - } +} Var* TerrainFeatHLSL::_getUniformVar( const char *name, const char *type, ConstantSortPosition csp ) { @@ -129,14 +129,18 @@ Var* TerrainFeatHLSL::_getInMacroCoord( Vector &componentList Var* TerrainFeatHLSL::_getNormalMapTex() { - String name( String::ToString( "normalMap%d", getProcessIndex() ) ); - Var *normalMap = (Var*)LangElement::find( name ); + String name(String::ToString("normalMap%d", getProcessIndex())); + Var *normalMap = (Var*)LangElement::find(name); - if ( !normalMap ) + if (!normalMap) { normalMap = new Var; - normalMap->setType( "sampler2D" ); - normalMap->setName( name ); + if (mIsDirect3D11) + normalMap->setType("SamplerState"); + else + normalMap->setType("sampler2D"); + + normalMap->setName(name); normalMap->uniform = true; normalMap->sampler = true; normalMap->constNum = Var::getTexUnitNum(); @@ -267,12 +271,27 @@ void TerrainBaseMapFeatHLSL::processPix( Vector &componentLis Var *baseColor = new Var; baseColor->setType( "float4" ); baseColor->setName( "baseColor" ); - meta->addStatement( new GenOp( " @ = tex2D( @, @.xy );\r\n", new DecOp( baseColor ), diffuseMap, texCoord ) ); + if (mIsDirect3D11) + { + diffuseMap->setType("SamplerState"); + Var *diffuseTex = new Var; + diffuseTex->setType("Texture2D"); + diffuseTex->setName("baseTexture"); + diffuseTex->uniform = true; + diffuseTex->texture = true; + diffuseTex->constNum = diffuseMap->constNum; + meta->addStatement(new GenOp(" @ = @.Sample( @, @.xy );\r\n", new DecOp(baseColor), diffuseTex, diffuseMap, texCoord)); + } + else + { + meta->addStatement(new GenOp(" @ = tex2D( @, @.xy );\r\n", new DecOp(baseColor), diffuseMap, texCoord)); + } + meta->addStatement(new GenOp(" @ = toLinear(@);\r\n", baseColor, baseColor)); - ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget; + ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget; - if (fd.features.hasFeature(MFT_isDeferred)) + if (fd.features.hasFeature(MFT_isDeferred)) { target= ShaderFeature::RenderTarget1; } @@ -433,9 +452,25 @@ void TerrainDetailMapFeatHLSL::processPix( Vector &component layerTex->sampler = true; layerTex->constNum = Var::getTexUnitNum(); - // Read the layer texture to get the samples. - meta->addStatement( new GenOp( " @ = round( tex2D( @, @.xy ) * 255.0f );\r\n", - new DecOp( layerSample ), layerTex, inTex ) ); + if (mIsDirect3D11) + { + layerTex->setType("SamplerState"); + Var* layerTexObj = new Var; + layerTexObj->setName("layerTexObj"); + layerTexObj->setType("Texture2D"); + layerTexObj->uniform = true; + layerTexObj->texture = true; + layerTexObj->constNum = layerTex->constNum; + // Read the layer texture to get the samples. + meta->addStatement(new GenOp(" @ = round( @.Sample( @, @.xy ) * 255.0f );\r\n", + new DecOp(layerSample), layerTexObj, layerTex, inTex)); + } + else + { + // Read the layer texture to get the samples. + meta->addStatement(new GenOp(" @ = round( tex2D( @, @.xy ) * 255.0f );\r\n", + new DecOp(layerSample), layerTex, inTex)); + } } Var *layerSize = (Var*)LangElement::find( "layerSize" ); @@ -478,21 +513,52 @@ void TerrainDetailMapFeatHLSL::processPix( Vector &component // If we had a parallax feature... then factor in the parallax // amount so that it fades out with the layer blending. - if ( fd.features.hasFeature( MFT_TerrainParallaxMap, detailIndex ) ) + if (fd.features.hasFeature(MFT_TerrainParallaxMap, detailIndex)) { // Get the rest of our inputs. Var *normalMap = _getNormalMapTex(); - // Call the library function to do the rest. - if(fd.features.hasFeature( MFT_IsDXTnm, detailIndex ) ) + if (mIsDirect3D11) { - meta->addStatement( new GenOp( " @.xy += parallaxOffsetDxtnm( @, @.xy, @, @.z * @ );\r\n", - inDet, normalMap, inDet, negViewTS, detailInfo, detailBlend ) ); + String name(String::ToString("normalMapTex%d", getProcessIndex())); + Var *normalMapTex = (Var*)LangElement::find(name); + + if (!normalMapTex) + { + normalMapTex = new Var; + normalMapTex->setName(String::ToString("normalMapTex%d", getProcessIndex())); + normalMapTex->setType("Texture2D"); + normalMapTex->uniform = true; + normalMapTex->texture = true; + normalMapTex->constNum = normalMap->constNum; + } + + // Call the library function to do the rest. + if (fd.features.hasFeature(MFT_IsDXTnm, detailIndex)) + { + meta->addStatement(new GenOp(" @.xy += parallaxOffsetDxtnm( @, @, @.xy, @, @.z * @ );\r\n", + inDet, normalMapTex, normalMap, inDet, negViewTS, detailInfo, detailBlend)); + } + else + { + meta->addStatement(new GenOp(" @.xy += parallaxOffset( @, @, @.xy, @, @.z * @ );\r\n", + inDet, normalMapTex, normalMap, inDet, negViewTS, detailInfo, detailBlend)); + } + } else { - meta->addStatement( new GenOp( " @.xy += parallaxOffset( @, @.xy, @, @.z * @ );\r\n", - inDet, normalMap, inDet, negViewTS, detailInfo, detailBlend ) ); + // Call the library function to do the rest. + if (fd.features.hasFeature(MFT_IsDXTnm, detailIndex)) + { + meta->addStatement(new GenOp(" @.xy += parallaxOffsetDxtnm( @, @.xy, @, @.z * @ );\r\n", + inDet, normalMap, inDet, negViewTS, detailInfo, detailBlend)); + } + else + { + meta->addStatement(new GenOp(" @.xy += parallaxOffset( @, @.xy, @, @.z * @ );\r\n", + inDet, normalMap, inDet, negViewTS, detailInfo, detailBlend)); + } } } @@ -531,27 +597,46 @@ void TerrainDetailMapFeatHLSL::processPix( Vector &component // //Sampled detail texture that is not expanded - Var *detailTex = new Var; - detailTex->setType("float4"); - detailTex->setName("detailTex"); - meta->addStatement( new GenOp( " @;\r\n", new DecOp( detailTex ) ) ); - - if ( fd.features.hasFeature( MFT_TerrainSideProject, detailIndex ) ) + if (mIsDirect3D11) { - meta->addStatement( new GenOp(" @ = lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z);\r\n",detailTex,detailMap,inDet,detailMap,inDet,inTex)); - meta->addStatement( new GenOp( " @ = ( @ * 2.0 ) - 1.0;\r\n", detailColor, detailTex) ); + detailMap->setType("SamplerState"); + Var* detailTex = new Var; + detailTex->setName(String::ToString("detailTex%d", detailIndex)); + detailTex->setType("Texture2D"); + detailTex->uniform = true; + detailTex->texture = true; + detailTex->constNum = detailMap->constNum; + + if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex)) + { + + meta->addStatement(new GenOp(" @ = ( lerp( @.Sample( @, @.yz ), @.Sample( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", + detailColor, detailTex, detailMap, inDet, detailTex, detailMap, inDet, inTex)); + } + else + { + meta->addStatement(new GenOp(" @ = ( @.Sample( @, @.xy ) * 2.0 ) - 1.0;\r\n", + detailColor, detailTex, detailMap, inDet)); + } } else { - meta->addStatement( new GenOp(" @ = tex2D(@,@.xy);\r\n",detailTex,detailMap,inDet)); - meta->addStatement( new GenOp( " @ = ( @ * 2.0 ) - 1.0;\r\n", - detailColor, detailTex) ); + if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex)) + { + + meta->addStatement(new GenOp(" @ = ( lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", + detailColor, detailMap, inDet, detailMap, inDet, inTex)); + } + else + { + meta->addStatement(new GenOp(" @ = ( tex2D( @, @.xy ) * 2.0 ) - 1.0;\r\n", + detailColor, detailMap, inDet)); + } } meta->addStatement( new GenOp( " @ *= @.y * @.w;\r\n", detailColor, detailInfo, inDet ) ); - Var *baseColor = (Var*)LangElement::find( "baseColor" ); ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget; if(fd.features.hasFeature( MFT_DeferredTerrainDetailMap )) @@ -718,8 +803,21 @@ void TerrainMacroMapFeatHLSL::processPix( Vector &componentL layerTex->constNum = Var::getTexUnitNum(); // Read the layer texture to get the samples. - meta->addStatement( new GenOp( " @ = round( tex2D( @, @.xy ) * 255.0f );\r\n", - new DecOp( layerSample ), layerTex, inTex ) ); + if (mIsDirect3D11) + { + layerTex->setType("SamplerState"); + Var *layerTexObj = new Var; + layerTexObj->setType("Texture2D"); + layerTexObj->setName("macroLayerTexObj"); + layerTexObj->uniform = true; + layerTexObj->texture = true; + layerTexObj->constNum = layerTex->constNum; + meta->addStatement(new GenOp(" @ = round( @.Sample( @, @.xy ) * 255.0f );\r\n", + new DecOp(layerSample), layerTexObj, layerTex, inTex)); + } + else + meta->addStatement(new GenOp(" @ = round( tex2D( @, @.xy ) * 255.0f );\r\n", + new DecOp(layerSample), layerTex, inTex)); } Var *layerSize = (Var*)LangElement::find( "layerSize" ); @@ -752,7 +850,6 @@ void TerrainMacroMapFeatHLSL::processPix( Vector &componentL if ( !blendTotal ) { blendTotal = new Var; - //blendTotal->setName( "blendTotal" ); blendTotal->setName( "blendTotal" ); blendTotal->setType( "float" ); meta->addStatement( new GenOp( " @ = 0;\r\n", new DecOp( blendTotal ) ) ); @@ -778,6 +875,20 @@ void TerrainMacroMapFeatHLSL::processPix( Vector &componentL detailMap->sampler = true; detailMap->constNum = Var::getTexUnitNum(); // used as texture unit num here + //Create texture object for directx 11 + Var *detailTex = NULL; + if (mIsDirect3D11) + { + detailMap->setType("SamplerState"); + detailTex = new Var; + detailTex->setName(String::ToString("macroMapTex%d", detailIndex)); + detailTex->setType("Texture2D"); + detailTex->uniform = true; + detailTex->texture = true; + detailTex->constNum = detailMap->constNum; + + } + // If we're using SM 3.0 then take advantage of // dynamic branching to skip layers per-pixel. if ( GFX->getPixelShaderVersion() >= 3.0f ) @@ -792,22 +903,30 @@ void TerrainMacroMapFeatHLSL::processPix( Vector &componentL // We take two color samples and lerp between them for // side projection layers... else a single sample. // - if ( fd.features.hasFeature( MFT_TerrainSideProject, detailIndex ) ) + if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex)) { - meta->addStatement( new GenOp( " @ = ( lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", - detailColor, detailMap, inDet, detailMap, inDet, inTex ) ); + if (mIsDirect3D11) + { + meta->addStatement(new GenOp(" @ = ( lerp( @.Sample( @, @.yz ), @.Sample( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", + detailColor, detailTex, detailMap, inDet, detailTex, detailMap, inDet, inTex)); + } + else + meta->addStatement(new GenOp(" @ = ( lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", + detailColor, detailMap, inDet, detailMap, inDet, inTex)); } else { - meta->addStatement( new GenOp( " @ = ( tex2D( @, @.xy ) * 2.0 ) - 1.0;\r\n", - detailColor, detailMap, inDet ) ); + if (mIsDirect3D11) + meta->addStatement(new GenOp(" @ = ( @.Sample( @, @.xy ) * 2.0 ) - 1.0;\r\n", + detailColor, detailTex, detailMap, inDet)); + else + meta->addStatement(new GenOp(" @ = ( tex2D( @, @.xy ) * 2.0 ) - 1.0;\r\n", + detailColor, detailMap, inDet)); } meta->addStatement( new GenOp( " @ *= @.y * @.w;\r\n", detailColor, detailInfo, inDet ) ); - Var *baseColor = (Var*)LangElement::find( "baseColor" ); - ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget; if(fd.features.hasFeature(MFT_DeferredTerrainMacroMap)) @@ -907,13 +1026,39 @@ void TerrainNormalMapFeatHLSL::processPix( Vector &component // We take two normal samples and lerp between them for // side projection layers... else a single sample. LangElement *texOp; - if ( fd.features.hasFeature( MFT_TerrainSideProject, normalIndex ) ) + if (mIsDirect3D11) { - texOp = new GenOp( "lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z )", - normalMap, inDet, normalMap, inDet, inTex ); + String name(String::ToString("normalMapTex%d", getProcessIndex())); + Var *normalMapTex = (Var*)LangElement::find(name); + if (!normalMapTex) + { + normalMapTex = new Var; + normalMapTex->setName(String::ToString("normalMapTex%d", getProcessIndex())); + normalMapTex->setType("Texture2D"); + normalMapTex->uniform = true; + normalMapTex->texture = true; + normalMapTex->constNum = normalMap->constNum; + } + if (fd.features.hasFeature(MFT_TerrainSideProject, normalIndex)) + { + texOp = new GenOp("lerp( @.Sample( @, @.yz ), @.Sample( @, @.xz ), @.z )", + normalMapTex, normalMap, inDet, normalMapTex, normalMap, inDet, inTex); + } + else + texOp = new GenOp("@.Sample(@, @.xy)", normalMapTex, normalMap, inDet); + } + else - texOp = new GenOp( "tex2D(@, @.xy)", normalMap, inDet ); + { + if (fd.features.hasFeature(MFT_TerrainSideProject, normalIndex)) + { + texOp = new GenOp("lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z )", + normalMap, inDet, normalMap, inDet, inTex); + } + else + texOp = new GenOp("tex2D(@, @.xy)", normalMap, inDet); + } // create bump normal Var *bumpNorm = new Var; @@ -991,7 +1136,20 @@ void TerrainLightMapFeatHLSL::processPix( Vector &componentLis meta->addStatement( new GenOp( " @ = 1;\r\n", new DecOp( lightMask ) ) ); } - meta->addStatement( new GenOp( " @[0] = tex2D( @, @.xy ).r;\r\n", lightMask, lightMap, inTex ) ); + if (mIsDirect3D11) + { + lightMap->setType("SamplerState"); + Var* lightMapTex = new Var; + lightMapTex->setName("lightMapTexObj"); + lightMapTex->setType("Texture2D"); + lightMapTex->uniform = true; + lightMapTex->texture = true; + lightMapTex->constNum = lightMap->constNum; + meta->addStatement(new GenOp(" @[0] = @.Sample( @, @.xy ).r;\r\n", lightMask, lightMapTex, lightMap, inTex)); + } + else + meta->addStatement(new GenOp(" @[0] = tex2D( @, @.xy ).r;\r\n", lightMask, lightMap, inTex)); + output = meta; } diff --git a/Engine/source/terrain/terrRender.cpp b/Engine/source/terrain/terrRender.cpp index 14280e067..4883d9600 100644 --- a/Engine/source/terrain/terrRender.cpp +++ b/Engine/source/terrain/terrRender.cpp @@ -208,14 +208,14 @@ void TerrainBlock::_updateBaseTexture(bool writeToCache) F32 copyOffsetY = 2.0f * GFX->getFillConventionOffset() / (F32)destSize.y; GFXVertexPT points[4]; - points[0].point = Point3F( -1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0 ); - points[0].texCoord = Point2F( 0.0, 1.0f ); - points[1].point = Point3F( -1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0 ); - points[1].texCoord = Point2F( 0.0, 0.0f ); - points[2].point = Point3F( 1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0 ); - points[2].texCoord = Point2F( 1.0, 0.0f ); - points[3].point = Point3F( 1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0 ); - points[3].texCoord = Point2F( 1.0, 1.0f ); + points[0].point = Point3F(1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0); + points[0].texCoord = Point2F(1.0, 1.0f); + points[1].point = Point3F(1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0); + points[1].texCoord = Point2F(1.0, 0.0f); + points[2].point = Point3F(-1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0); + points[2].texCoord = Point2F(0.0, 1.0f); + points[3].point = Point3F(-1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0); + points[3].texCoord = Point2F(0.0, 0.0f); vb.set( GFX, 4, GFXBufferTypeVolatile ); GFXVertexPT *ptr = vb.lock(); @@ -274,7 +274,7 @@ void TerrainBlock::_updateBaseTexture(bool writeToCache) mBaseShaderConsts->setSafe( mBaseTexScaleConst, Point2F( scale, -scale ) ); mBaseShaderConsts->setSafe( mBaseTexIdConst, (F32)i ); - GFX->drawPrimitive( GFXTriangleFan, 0, 2 ); + GFX->drawPrimitive( GFXTriangleStrip, 0, 2 ); } mBaseTarget->resolve(); diff --git a/Engine/source/ts/tsMesh.cpp b/Engine/source/ts/tsMesh.cpp index 72ee74461..47a60124d 100644 --- a/Engine/source/ts/tsMesh.cpp +++ b/Engine/source/ts/tsMesh.cpp @@ -57,7 +57,7 @@ # include "platformXbox/platformXbox.h" #endif -GFXPrimitiveType drawTypes[] = { GFXTriangleList, GFXTriangleStrip, GFXTriangleFan }; +GFXPrimitiveType drawTypes[] = { GFXTriangleList, GFXTriangleStrip }; #define getDrawType(a) (drawTypes[a]) @@ -2442,7 +2442,6 @@ void TSMesh::_createVBIB( TSVertexBufferHandle &vb, GFXPrimitiveBufferHandle &pb break; case GFXTriangleStrip: - case GFXTriangleFan: pInfo.type = drawType; pInfo.numPrimitives = draw.numElements - 2; pInfo.startIndex = draw.start; @@ -3006,17 +3005,6 @@ void TSMesh::createTangents(const Vector &_verts, const Vector } break; } - case GFXTriangleFan: - { - p1Index = baseIdx[0]; - p2Index = baseIdx[1]; - for( U32 j = 2; j < numElements; j++ ) - { - findTangent( p1Index, p2Index, baseIdx[j], tan0.address(), tan1, _verts ); - p2Index = baseIdx[j]; - } - break; - } default: AssertFatal( false, "TSMesh::createTangents: unknown primitive type!" ); diff --git a/Engine/source/windowManager/win32/win32Window.cpp b/Engine/source/windowManager/win32/win32Window.cpp index c714586b9..7d287cebd 100644 --- a/Engine/source/windowManager/win32/win32Window.cpp +++ b/Engine/source/windowManager/win32/win32Window.cpp @@ -805,6 +805,8 @@ LRESULT PASCAL Win32Window::WindowProc( HWND hWnd, UINT message, WPARAM wParam, Con::warnf("Win32Window::WindowProc - resetting device due to window size change."); window->getGFXTarget()->resetMode(); } + + window->getScreenResChangeSignal().trigger(window, true); } return 0; From bd60f3be1a6038a396cc4f109a5f8d780e0d4d5e Mon Sep 17 00:00:00 2001 From: rextimmy Date: Sun, 20 Mar 2016 21:55:40 +1000 Subject: [PATCH 04/13] Direct3D11 CMake and Project Generator files. --- Tools/CMake/torque3d.cmake | 9 +++++-- Tools/projectGenerator/modules/d3d11.inc | 33 ++++++++++++++++++++++++ projects.xml | 1 + 3 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 Tools/projectGenerator/modules/d3d11.inc diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake index 83cf63623..7581a6dbb 100644 --- a/Tools/CMake/torque3d.cmake +++ b/Tools/CMake/torque3d.cmake @@ -83,6 +83,10 @@ else() option(TORQUE_DEDICATED "Torque dedicated" OFF) endif() +if(WIN32) + option(TORQUE_D3D11 "Allow Direct3D 11 render" OFF) +endif() + ############################################################################### # options ############################################################################### @@ -391,8 +395,9 @@ if(WIN32) addPath("${srcDir}/platformWin32/videoInfo") addPath("${srcDir}/platformWin32/minidump") addPath("${srcDir}/windowManager/win32") - #addPath("${srcDir}/gfx/D3D8") - addPath("${srcDir}/gfx/D3D") + if(TORQUE_D3D11) + addPath("${srcDir}/gfx/D3D11") + endif() addPath("${srcDir}/gfx/D3D9") addPath("${srcDir}/gfx/D3D9/pc") addPath("${srcDir}/shaderGen/HLSL") diff --git a/Tools/projectGenerator/modules/d3d11.inc b/Tools/projectGenerator/modules/d3d11.inc new file mode 100644 index 000000000..1bfae5092 --- /dev/null +++ b/Tools/projectGenerator/modules/d3d11.inc @@ -0,0 +1,33 @@ + diff --git a/projects.xml b/projects.xml index 18ace6299..1fb3d2fd2 100644 --- a/projects.xml +++ b/projects.xml @@ -29,6 +29,7 @@ Here are some examples: OpenGL Rendering + Direct3D 11 Rendering FMod Sound Engine Leap Motion Controller Razer Hydra Controller From e9efc05ebb45dc1619b827539d8d158596312977 Mon Sep 17 00:00:00 2001 From: Jeff Hutchinson Date: Thu, 24 Mar 2016 14:22:45 -0400 Subject: [PATCH 05/13] fix release build compile with MSVC 2015 (finally) --- Tools/CMake/CMakeLists.txt | 3 +++ Tools/CMake/torque3d.cmake | 7 +++++++ 2 files changed, 10 insertions(+) diff --git a/Tools/CMake/CMakeLists.txt b/Tools/CMake/CMakeLists.txt index 741cc6b1c..cdf6e832b 100644 --- a/Tools/CMake/CMakeLists.txt +++ b/Tools/CMake/CMakeLists.txt @@ -20,6 +20,9 @@ # IN THE SOFTWARE. # ----------------------------------------------------------------------------- +# JTH: We require CMake 3.1.4 for MSVC14 compatibility check +cmake_minimum_required(VERSION 3.1.4) + include(basics.cmake) setupVersionNumbers() diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake index 83cf63623..eff52e2e8 100644 --- a/Tools/CMake/torque3d.cmake +++ b/Tools/CMake/torque3d.cmake @@ -541,6 +541,13 @@ if(WIN32) if(TORQUE_OPENGL) addLib(OpenGL32.lib) endif() + + # JTH: DXSDK is compiled with older runtime, and MSVC 2015+ is when __vsnprintf is undefined. + # This is a workaround by linking with the older legacy library functions. + # See this for more info: http://stackoverflow.com/a/34230122 + if (MSVC14) + addLib(legacy_stdio_definitions.lib) + endif() endif() if(UNIX) From df3cb6cb4444585b81eabf4d05495c04297e75f5 Mon Sep 17 00:00:00 2001 From: Azaezel Date: Fri, 25 Mar 2016 18:46:25 -0500 Subject: [PATCH 06/13] case sensitivity typofix --- .../shaders/common/lighting/advanced/gl/deferredShadingP.glsl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Templates/Full/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl b/Templates/Full/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl index 4ee4b1d81..8af37ef0c 100644 --- a/Templates/Full/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl +++ b/Templates/Full/game/shaders/common/lighting/advanced/gl/deferredShadingP.glsl @@ -22,7 +22,7 @@ #include "../../../gl/hlslCompat.glsl" #include "shadergen:/autogenConditioners.h" -#include "../../../postfx/gl/postFx.glsl" +#include "../../../postFx/gl/postFX.glsl" #include "../../../gl/torque.glsl" uniform sampler2D colorBufferTex; From 12621f876b42683c6ef46a62a6b3cfc79fd278a4 Mon Sep 17 00:00:00 2001 From: rextimmy Date: Mon, 28 Mar 2016 10:05:16 +1000 Subject: [PATCH 07/13] Added GFXFormatR8G8B8A8_SRGB format. --- Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp | 1 + Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp | 1 + Engine/source/gfx/gfxEnums.h | 3 +++ Engine/source/gfx/gl/gfxGLEnumTranslate.cpp | 2 ++ 4 files changed, 7 insertions(+) diff --git a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp index 24f195247..54c43fa38 100644 --- a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp +++ b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp @@ -72,6 +72,7 @@ void GFXD3D11EnumTranslate::init() GFXD3D11TextureFormat[GFXFormatD24S8] = DXGI_FORMAT_D24_UNORM_S8_UINT; GFXD3D11TextureFormat[GFXFormatD24FS8] = DXGI_FORMAT_UNKNOWN; GFXD3D11TextureFormat[GFXFormatD16] = DXGI_FORMAT_D16_UNORM; + GFXD3D11TextureFormat[GFXFormatR8G8B8A8_SRGB] = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ GFXD3D11TextureFilter[GFXTextureFilterNone] = D3D11_FILTER_MIN_MAG_MIP_POINT; diff --git a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp b/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp index 77ea67041..93bc86ee9 100644 --- a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp +++ b/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp @@ -114,6 +114,7 @@ void GFXD3D9EnumTranslate::init() GFXD3D9TextureFormat[GFXFormatD24S8] = D3DFMT_D24S8; GFXD3D9TextureFormat[GFXFormatD24FS8] = D3DFMT_D24FS8; GFXD3D9TextureFormat[GFXFormatD16] = D3DFMT_D16; + GFXD3D9TextureFormat[GFXFormatR8G8B8A8_SRGB] = D3DFMT_UNKNOWN; VALIDATE_LOOKUPTABLE( GFXD3D9TextureFormat, GFXFormat); //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ diff --git a/Engine/source/gfx/gfxEnums.h b/Engine/source/gfx/gfxEnums.h index 0e3878154..238af2f94 100644 --- a/Engine/source/gfx/gfxEnums.h +++ b/Engine/source/gfx/gfxEnums.h @@ -205,6 +205,9 @@ enum GFXFormat GFXFormatDXT4, GFXFormatDXT5, + // sRGB formats + GFXFormatR8G8B8A8_SRGB, + GFXFormat_COUNT, GFXFormat_8BIT = GFXFormatA8, diff --git a/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp b/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp index 7955590e1..c5af360bd 100644 --- a/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp +++ b/Engine/source/gfx/gl/gfxGLEnumTranslate.cpp @@ -190,6 +190,8 @@ void GFXGLEnumTranslate::init() GFXGLTextureType[GFXFormatDXT4] = GL_ZERO; GFXGLTextureType[GFXFormatDXT5] = GL_UNSIGNED_BYTE; + GFXGLTextureType[GFXFormatR8G8B8A8_SRGB] = GL_SRGB8_ALPHA8; + static GLint Swizzle_GFXFormatA8[] = { GL_NONE, GL_NONE, GL_NONE, GL_RED }; static GLint Swizzle_GFXFormatL[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; GFXGLTextureSwizzle[GFXFormatA8] = Swizzle_GFXFormatA8; // old GL_ALPHA8 From b9d8df5a4a49c1eb68c03a9f09064b3b599c713a Mon Sep 17 00:00:00 2001 From: Areloch Date: Mon, 28 Mar 2016 22:47:22 -0500 Subject: [PATCH 08/13] Includes a formatting fix for the SimPath change to make it compatible with DX11. --- Engine/source/scene/simPath.cpp | 4 ++-- Engine/source/scene/simPath.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Engine/source/scene/simPath.cpp b/Engine/source/scene/simPath.cpp index edf7b1051..906eb10b7 100644 --- a/Engine/source/scene/simPath.cpp +++ b/Engine/source/scene/simPath.cpp @@ -273,7 +273,7 @@ DefineEngineMethod( Path, getPathId, S32, (),, //-------------------------------------------------------------------------- GFXStateBlockRef Marker::smStateBlock; -GFXVertexBufferHandle Marker::smVertexBuffer; +GFXVertexBufferHandle Marker::smVertexBuffer; GFXPrimitiveBufferHandle Marker::smPrimitiveBuffer; static Point3F wedgePoints[4] = { @@ -295,7 +295,7 @@ void Marker::initGFXResources() smStateBlock = GFX->createStateBlock(d); smVertexBuffer.set(GFX, 4, GFXBufferTypeStatic); - GFXVertexPC* verts = smVertexBuffer.lock(); + GFXVertexPCT* verts = smVertexBuffer.lock(); verts[0].point = wedgePoints[0] * 1.25f; verts[1].point = wedgePoints[1] * 1.25f; verts[2].point = wedgePoints[2] * 1.25f; diff --git a/Engine/source/scene/simPath.h b/Engine/source/scene/simPath.h index 9e172bdf4..4633e0a10 100644 --- a/Engine/source/scene/simPath.h +++ b/Engine/source/scene/simPath.h @@ -132,7 +132,7 @@ class Marker : public SceneObject static void initGFXResources(); static GFXStateBlockRef smStateBlock; - static GFXVertexBufferHandle smVertexBuffer; + static GFXVertexBufferHandle smVertexBuffer; static GFXPrimitiveBufferHandle smPrimitiveBuffer; public: From 4d190b1982be1a61378451a108baa2c071928de3 Mon Sep 17 00:00:00 2001 From: Areloch Date: Tue, 29 Mar 2016 00:08:18 -0500 Subject: [PATCH 09/13] Roll back the changes to simPath temporarily in order to merge in DX11 --- Engine/source/scene/simPath.cpp | 18 ++++++++---------- Engine/source/scene/simPath.h | 2 +- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/Engine/source/scene/simPath.cpp b/Engine/source/scene/simPath.cpp index 906eb10b7..c25764ad1 100644 --- a/Engine/source/scene/simPath.cpp +++ b/Engine/source/scene/simPath.cpp @@ -273,7 +273,7 @@ DefineEngineMethod( Path, getPathId, S32, (),, //-------------------------------------------------------------------------- GFXStateBlockRef Marker::smStateBlock; -GFXVertexBufferHandle Marker::smVertexBuffer; +GFXVertexBufferHandle Marker::smVertexBuffer; GFXPrimitiveBufferHandle Marker::smPrimitiveBuffer; static Point3F wedgePoints[4] = { @@ -295,14 +295,12 @@ void Marker::initGFXResources() smStateBlock = GFX->createStateBlock(d); smVertexBuffer.set(GFX, 4, GFXBufferTypeStatic); - GFXVertexPCT* verts = smVertexBuffer.lock(); - verts[0].point = wedgePoints[0] * 1.25f; - verts[1].point = wedgePoints[1] * 1.25f; - verts[2].point = wedgePoints[2] * 1.25f; - verts[3].point = wedgePoints[3] * 1.25f; - verts[1].color = GFXVertexColor(ColorI(255, 0, 0, 255)); - verts[0].color = verts[2].color = verts[3].color = GFXVertexColor(ColorI(0, 0, 255, 255)); - + GFXVertexPC* verts = smVertexBuffer.lock(); + verts[0].point = wedgePoints[0] * 0.25f; + verts[1].point = wedgePoints[1] * 0.25f; + verts[2].point = wedgePoints[2] * 0.25f; + verts[3].point = wedgePoints[3] * 0.25f; + verts[0].color = verts[1].color = verts[2].color = verts[3].color = GFXVertexColor(ColorI(0, 255, 0, 255)); smVertexBuffer.unlock(); smPrimitiveBuffer.set(GFX, 24, 12, GFXBufferTypeStatic); @@ -419,7 +417,7 @@ bool Marker::onAdd() if(!Parent::onAdd()) return false; - mObjBox = Box3F(Point3F(-1.25, -1.25, -1.25), Point3F(1.25, 1.25, 1.25)); + mObjBox = Box3F(Point3F(-.25, -.25, -.25), Point3F(.25, .25, .25)); resetWorldBox(); if(gEditingMission) diff --git a/Engine/source/scene/simPath.h b/Engine/source/scene/simPath.h index 4633e0a10..9e172bdf4 100644 --- a/Engine/source/scene/simPath.h +++ b/Engine/source/scene/simPath.h @@ -132,7 +132,7 @@ class Marker : public SceneObject static void initGFXResources(); static GFXStateBlockRef smStateBlock; - static GFXVertexBufferHandle smVertexBuffer; + static GFXVertexBufferHandle smVertexBuffer; static GFXPrimitiveBufferHandle smPrimitiveBuffer; public: From 2073a94a7a9e189a27f3d343766dad0a7814b183 Mon Sep 17 00:00:00 2001 From: rextimmy Date: Sat, 2 Apr 2016 22:30:56 +1000 Subject: [PATCH 10/13] ScreenShotD3D11 delete fix. --- Engine/source/gfx/D3D11/screenshotD3D11.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Engine/source/gfx/D3D11/screenshotD3D11.cpp b/Engine/source/gfx/D3D11/screenshotD3D11.cpp index 89fa5f90c..264c8b5fe 100644 --- a/Engine/source/gfx/D3D11/screenshotD3D11.cpp +++ b/Engine/source/gfx/D3D11/screenshotD3D11.cpp @@ -52,7 +52,7 @@ GBitmap* ScreenShotD3D11::_captureBackBuffer() if (FAILED(hr)) { //cleanup - SAFE_DELETE(pData); + SAFE_DELETE_ARRAY(pData); SAFE_RELEASE(pNewTexture); return NULL; } @@ -88,7 +88,7 @@ GBitmap* ScreenShotD3D11::_captureBackBuffer() } //cleanup - SAFE_DELETE(pData); + SAFE_DELETE_ARRAY(pData); SAFE_RELEASE(pNewTexture); From 131090f1b7933637626d3bc67e7535ee3eceb02a Mon Sep 17 00:00:00 2001 From: Areloch Date: Wed, 6 Apr 2016 21:21:55 -0500 Subject: [PATCH 11/13] Made the cmake SDL flag a regular, non-advanced option so that it's not hidden from the base setup on Windows. --- Tools/CMake/torque3d.cmake | 1 - 1 file changed, 1 deletion(-) diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake index 7b846d6a1..fd95bbf86 100644 --- a/Tools/CMake/torque3d.cmake +++ b/Tools/CMake/torque3d.cmake @@ -64,7 +64,6 @@ option(TORQUE_EXTENDED_MOVE "Extended move support" OFF) mark_as_advanced(TORQUE_EXTENDED_MOVE) if(WIN32) option(TORQUE_SDL "Use SDL for window and input" OFF) - mark_as_advanced(TORQUE_SDL) else() set(TORQUE_SDL ON) # we need sdl to work on Linux/Mac endif() From b63ef177f4d64a7aa27e820820510f28b2a729e1 Mon Sep 17 00:00:00 2001 From: Areloch Date: Thu, 7 Apr 2016 00:40:06 -0500 Subject: [PATCH 12/13] Updates SDL to version 2.0.4, which makes it compatible with VS2015. --- Engine/lib/sdl/Android.mk | 6 +- Engine/lib/sdl/CMakeLists.txt | 348 +- Engine/lib/sdl/COPYING.txt | 2 +- Engine/lib/sdl/INSTALL.txt | 8 +- Engine/lib/sdl/Makefile.in | 32 +- Engine/lib/sdl/Makefile.wiz | 4 +- Engine/lib/sdl/README-android.txt | 438 - Engine/lib/sdl/README-cmake.txt | 31 - Engine/lib/sdl/README-directfb.txt | 106 - Engine/lib/sdl/README-dynapi.txt | 130 - Engine/lib/sdl/README-gesture.txt | 72 - Engine/lib/sdl/README-hg.txt | 23 - Engine/lib/sdl/README-ios.txt | 222 - Engine/lib/sdl/README-linux.txt | 80 - Engine/lib/sdl/README-macosx.txt | 226 - Engine/lib/sdl/README-pandora.txt | 16 - Engine/lib/sdl/README-platforms.txt | 30 - Engine/lib/sdl/README-porting.txt | 61 - Engine/lib/sdl/README-psp.txt | 17 - Engine/lib/sdl/README-raspberrypi.txt | 161 - Engine/lib/sdl/README-touch.txt | 84 - Engine/lib/sdl/README-wince.txt | 8 - Engine/lib/sdl/README-windows.txt | 42 - Engine/lib/sdl/README.txt | 25 +- Engine/lib/sdl/SDL2.spec | 16 +- Engine/lib/sdl/SDL2.spec.in | 14 +- Engine/lib/sdl/VisualC.html | 10 +- Engine/lib/sdl/VisualC/clean.sh | 9 +- Engine/lib/sdl/WhatsNew.txt | 91 + Engine/lib/sdl/Xcode-iOS/Demos/Default.png | Bin 18383 -> 0 bytes .../Demos/Demos.xcodeproj/project.pbxproj | 1019 -- Engine/lib/sdl/Xcode-iOS/Demos/Icon.png | Bin 2409 -> 0 bytes Engine/lib/sdl/Xcode-iOS/Demos/Info.plist | 30 - Engine/lib/sdl/Xcode-iOS/Demos/README | 43 - .../Demos/data/bitmapfont/kromasky_16x16.bmp | Bin 45368 -> 0 bytes .../Demos/data/bitmapfont/license.txt | 258 - .../Demos/data/drums/ds_brush_snare.wav | Bin 194604 -> 0 bytes .../Xcode-iOS/Demos/data/drums/ds_china.wav | Bin 984604 -> 0 bytes .../Demos/data/drums/ds_kick_big_amb.wav | Bin 307080 -> 0 bytes .../Demos/data/drums/ds_loose_skin_mute.wav | Bin 127052 -> 0 bytes Engine/lib/sdl/Xcode-iOS/Demos/data/ship.bmp | Bin 12344 -> 0 bytes Engine/lib/sdl/Xcode-iOS/Demos/data/space.bmp | Bin 460856 -> 0 bytes .../lib/sdl/Xcode-iOS/Demos/data/stroke.bmp | Bin 3128 -> 0 bytes .../sdl/Xcode-iOS/Demos/src/accelerometer.c | 239 - Engine/lib/sdl/Xcode-iOS/Demos/src/common.c | 36 - Engine/lib/sdl/Xcode-iOS/Demos/src/common.h | 12 - .../lib/sdl/Xcode-iOS/Demos/src/fireworks.c | 475 - Engine/lib/sdl/Xcode-iOS/Demos/src/happy.c | 177 - Engine/lib/sdl/Xcode-iOS/Demos/src/keyboard.c | 310 - Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c | 353 - .../lib/sdl/Xcode-iOS/Demos/src/rectangles.c | 81 - Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c | 125 - .../SDL/SDL.xcodeproj/project.pbxproj | 1335 -- .../SDL2test.xcodeproj/project.pbxproj | 272 - .../Template/SDL iOS Application/Default.png | Bin 18383 -> 0 bytes .../Template/SDL iOS Application/Icon.png | Bin 2409 -> 0 bytes .../Template/SDL iOS Application/Info.plist | 28 - .../TemplateIcon.icns | Bin 34248 -> 0 bytes .../TemplateInfo.plist | 10 - .../project.pbxproj | 403 - .../Template/SDL iOS Application/main.c | 98 - Engine/lib/sdl/Xcode-iOS/Test/Info.plist | 28 - Engine/lib/sdl/Xcode-iOS/Test/README | 22 - .../TestiPhoneOS.xcodeproj/project.pbxproj | 2267 --- Engine/lib/sdl/Xcode/SDL/Info-Framework.plist | 4 +- .../Xcode/SDL/SDL.xcodeproj/project.pbxproj | 126 +- .../SDL/pkg-support/codesign-frameworks.sh | 43 - .../SDL/pkg-support/resources/License.txt | 2 +- .../SDLTest/SDLTest.xcodeproj/project.pbxproj | 396 +- Engine/lib/sdl/acinclude/libtool.m4 | 17 +- .../sdl/android-project/AndroidManifest.xml | 44 - Engine/lib/sdl/android-project/ant.properties | 17 - .../lib/sdl/android-project/build.properties | 17 - Engine/lib/sdl/android-project/build.xml | 93 - .../sdl/android-project/default.properties | 11 - Engine/lib/sdl/android-project/jni/Android.mk | 1 - .../sdl/android-project/jni/Application.mk | 6 - .../sdl/android-project/jni/src/Android.mk | 19 - .../android-project/jni/src/Android_static.mk | 12 - .../sdl/android-project/proguard-project.txt | 20 - .../sdl/android-project/project.properties | 14 - .../res/drawable-hdpi/ic_launcher.png | Bin 2683 -> 0 bytes .../res/drawable-mdpi/ic_launcher.png | Bin 1698 -> 0 bytes .../res/drawable-xhdpi/ic_launcher.png | Bin 3872 -> 0 bytes .../res/drawable-xxhdpi/ic_launcher.png | Bin 6874 -> 0 bytes .../sdl/android-project/res/layout/main.xml | 13 - .../android-project/res/values/strings.xml | 4 - .../src/org/libsdl/app/SDLActivity.java | 1074 -- Engine/lib/sdl/build-scripts/androidbuild.sh | 2 +- .../lib/sdl/build-scripts/checker-buildbot.sh | 93 + Engine/lib/sdl/build-scripts/config.guess | 1 + Engine/lib/sdl/build-scripts/config.sub | 29 + .../sdl/build-scripts/emscripten-buildbot.sh | 72 + Engine/lib/sdl/build-scripts/g++-fat.sh | 4 +- Engine/lib/sdl/build-scripts/gcc-fat.sh | 2 +- Engine/lib/sdl/build-scripts/nacl-buildbot.sh | 57 + Engine/lib/sdl/build-scripts/naclbuild.sh | 105 + .../sdl/build-scripts/raspberrypi-buildbot.sh | 6 +- .../lib/sdl/build-scripts/update-copyright.sh | 9 + .../build-scripts/windows-buildbot-zipper.bat | 31 + Engine/lib/sdl/build-scripts/winrtbuild.bat | 8 + Engine/lib/sdl/build-scripts/winrtbuild.ps1 | 294 + Engine/lib/sdl/cmake/macros.cmake | 2 +- Engine/lib/sdl/cmake/sdlchecks.cmake | 398 +- Engine/lib/sdl/cmake_uninstall.cmake.in | 18 + Engine/lib/sdl/configure | 802 +- Engine/lib/sdl/configure.in | 507 +- Engine/lib/sdl/debian/control | 1 + Engine/lib/sdl/debian/copyright | 12 +- Engine/lib/sdl/include/SDL.h | 47 +- Engine/lib/sdl/include/SDL_assert.h | 45 +- Engine/lib/sdl/include/SDL_atomic.h | 12 +- Engine/lib/sdl/include/SDL_audio.h | 109 +- Engine/lib/sdl/include/SDL_bits.h | 2 +- Engine/lib/sdl/include/SDL_blendmode.h | 4 +- Engine/lib/sdl/include/SDL_clipboard.h | 2 +- Engine/lib/sdl/include/SDL_config.h | 2 +- Engine/lib/sdl/include/SDL_config.h.cmake | 46 +- Engine/lib/sdl/include/SDL_config.h.in | 32 +- Engine/lib/sdl/include/SDL_config_android.h | 13 +- Engine/lib/sdl/include/SDL_config_iphoneos.h | 19 +- Engine/lib/sdl/include/SDL_config_macosx.h | 6 +- Engine/lib/sdl/include/SDL_config_minimal.h | 2 +- Engine/lib/sdl/include/SDL_config_pandora.h | 5 +- Engine/lib/sdl/include/SDL_config_psp.h | 5 +- Engine/lib/sdl/include/SDL_config_windows.h | 13 +- Engine/lib/sdl/include/SDL_config_winrt.h | 42 +- Engine/lib/sdl/include/SDL_config_wiz.h | 6 +- Engine/lib/sdl/include/SDL_copying.h | 2 +- Engine/lib/sdl/include/SDL_cpuinfo.h | 7 +- Engine/lib/sdl/include/SDL_egl.h | 1909 ++- Engine/lib/sdl/include/SDL_endian.h | 6 +- Engine/lib/sdl/include/SDL_error.h | 4 +- Engine/lib/sdl/include/SDL_events.h | 43 +- Engine/lib/sdl/include/SDL_filesystem.h | 4 +- Engine/lib/sdl/include/SDL_gamecontroller.h | 17 +- Engine/lib/sdl/include/SDL_gesture.h | 2 +- Engine/lib/sdl/include/SDL_haptic.h | 34 +- Engine/lib/sdl/include/SDL_hints.h | 228 +- Engine/lib/sdl/include/SDL_joystick.h | 30 +- Engine/lib/sdl/include/SDL_keyboard.h | 2 +- Engine/lib/sdl/include/SDL_keycode.h | 2 +- Engine/lib/sdl/include/SDL_loadso.h | 2 +- Engine/lib/sdl/include/SDL_log.h | 18 +- Engine/lib/sdl/include/SDL_main.h | 20 +- Engine/lib/sdl/include/SDL_messagebox.h | 2 +- Engine/lib/sdl/include/SDL_mouse.h | 78 +- Engine/lib/sdl/include/SDL_mutex.h | 2 +- Engine/lib/sdl/include/SDL_name.h | 2 +- Engine/lib/sdl/include/SDL_opengl.h | 13058 +++------------- Engine/lib/sdl/include/SDL_opengl_glext.h | 11177 +++++++++++++ Engine/lib/sdl/include/SDL_opengles.h | 2 +- Engine/lib/sdl/include/SDL_opengles2.h | 2756 +--- Engine/lib/sdl/include/SDL_opengles2_gl2.h | 621 + Engine/lib/sdl/include/SDL_opengles2_gl2ext.h | 2050 +++ .../sdl/include/SDL_opengles2_gl2platform.h | 30 + .../sdl/include/SDL_opengles2_khrplatform.h | 282 + Engine/lib/sdl/include/SDL_pixels.h | 33 +- Engine/lib/sdl/include/SDL_platform.h | 27 +- Engine/lib/sdl/include/SDL_power.h | 2 +- Engine/lib/sdl/include/SDL_quit.h | 2 +- Engine/lib/sdl/include/SDL_rect.h | 12 +- Engine/lib/sdl/include/SDL_render.h | 26 +- Engine/lib/sdl/include/SDL_revision.h | 4 +- Engine/lib/sdl/include/SDL_rwops.h | 5 +- Engine/lib/sdl/include/SDL_scancode.h | 2 +- Engine/lib/sdl/include/SDL_shape.h | 2 +- Engine/lib/sdl/include/SDL_stdinc.h | 156 +- Engine/lib/sdl/include/SDL_surface.h | 2 +- Engine/lib/sdl/include/SDL_system.h | 55 +- Engine/lib/sdl/include/SDL_syswm.h | 47 +- Engine/lib/sdl/include/SDL_test.h | 4 +- Engine/lib/sdl/include/SDL_test_assert.h | 10 +- Engine/lib/sdl/include/SDL_test_common.h | 2 +- Engine/lib/sdl/include/SDL_test_compare.h | 6 +- Engine/lib/sdl/include/SDL_test_crc32.h | 26 +- Engine/lib/sdl/include/SDL_test_font.h | 2 +- Engine/lib/sdl/include/SDL_test_fuzzer.h | 6 +- Engine/lib/sdl/include/SDL_test_harness.h | 2 +- Engine/lib/sdl/include/SDL_test_images.h | 2 +- Engine/lib/sdl/include/SDL_test_log.h | 6 +- Engine/lib/sdl/include/SDL_test_md5.h | 20 +- Engine/lib/sdl/include/SDL_test_random.h | 2 +- Engine/lib/sdl/include/SDL_thread.h | 6 +- Engine/lib/sdl/include/SDL_timer.h | 4 +- Engine/lib/sdl/include/SDL_touch.h | 2 +- Engine/lib/sdl/include/SDL_types.h | 2 +- Engine/lib/sdl/include/SDL_version.h | 4 +- Engine/lib/sdl/include/SDL_video.h | 168 +- Engine/lib/sdl/include/begin_code.h | 12 +- Engine/lib/sdl/include/close_code.h | 2 +- Engine/lib/sdl/include/doxyfile | 1555 -- Engine/lib/sdl/sdl2-config.cmake.in | 10 + Engine/lib/sdl/src/SDL.c | 8 +- Engine/lib/sdl/src/SDL_assert.c | 2 +- Engine/lib/sdl/src/SDL_assert_c.h | 2 +- Engine/lib/sdl/src/SDL_error.c | 42 +- Engine/lib/sdl/src/SDL_error_c.h | 2 +- Engine/lib/sdl/src/SDL_hints.c | 8 +- Engine/lib/sdl/src/SDL_internal.h | 2 +- Engine/lib/sdl/src/SDL_log.c | 31 +- Engine/lib/sdl/src/atomic/SDL_atomic.c | 29 +- Engine/lib/sdl/src/atomic/SDL_spinlock.c | 21 +- Engine/lib/sdl/src/audio/SDL_audio.c | 930 +- Engine/lib/sdl/src/audio/SDL_audio_c.h | 2 +- Engine/lib/sdl/src/audio/SDL_audiocvt.c | 2 +- Engine/lib/sdl/src/audio/SDL_audiodev.c | 36 +- Engine/lib/sdl/src/audio/SDL_audiodev_c.h | 5 +- Engine/lib/sdl/src/audio/SDL_audiomem.h | 2 +- Engine/lib/sdl/src/audio/SDL_audiotypecvt.c | 202 +- Engine/lib/sdl/src/audio/SDL_mixer.c | 2 +- Engine/lib/sdl/src/audio/SDL_sysaudio.h | 81 +- Engine/lib/sdl/src/audio/SDL_wave.c | 17 +- Engine/lib/sdl/src/audio/SDL_wave.h | 4 +- .../lib/sdl/src/audio/alsa/SDL_alsa_audio.c | 6 +- .../lib/sdl/src/audio/alsa/SDL_alsa_audio.h | 2 +- .../sdl/src/audio/android/SDL_androidaudio.c | 50 +- .../sdl/src/audio/android/SDL_androidaudio.h | 4 +- Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c | 8 +- Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h | 2 +- Engine/lib/sdl/src/audio/bsd/SDL_bsdaudio.c | 14 +- Engine/lib/sdl/src/audio/bsd/SDL_bsdaudio.h | 2 +- .../sdl/src/audio/coreaudio/SDL_coreaudio.c | 337 +- .../sdl/src/audio/coreaudio/SDL_coreaudio.h | 2 +- .../src/audio/directsound/SDL_directsound.c | 67 +- .../src/audio/directsound/SDL_directsound.h | 4 +- Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c | 19 +- Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h | 2 +- Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c | 12 +- Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h | 2 +- .../lib/sdl/src/audio/dummy/SDL_dummyaudio.c | 4 +- .../lib/sdl/src/audio/dummy/SDL_dummyaudio.h | 2 +- .../audio/emscripten/SDL_emscriptenaudio.c | 279 + .../audio/emscripten/SDL_emscriptenaudio.h | 42 + Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c | 8 +- Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h | 2 +- .../sdl/src/audio/fusionsound/SDL_fsaudio.c | 6 +- .../sdl/src/audio/fusionsound/SDL_fsaudio.h | 2 +- .../lib/sdl/src/audio/haiku/SDL_haikuaudio.cc | 4 +- .../lib/sdl/src/audio/haiku/SDL_haikuaudio.h | 2 +- Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c | 152 + Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h | 41 + Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c | 4 +- Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h | 2 +- Engine/lib/sdl/src/audio/paudio/SDL_paudio.c | 10 +- Engine/lib/sdl/src/audio/paudio/SDL_paudio.h | 2 +- Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c | 10 +- Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h | 4 +- .../sdl/src/audio/pulseaudio/SDL_pulseaudio.c | 467 +- .../sdl/src/audio/pulseaudio/SDL_pulseaudio.h | 5 +- Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c | 114 +- Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h | 2 +- Engine/lib/sdl/src/audio/sdlgenaudiocvt.pl | 5 +- .../lib/sdl/src/audio/sndio/SDL_sndioaudio.c | 41 +- .../lib/sdl/src/audio/sndio/SDL_sndioaudio.h | 2 +- Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c | 14 +- Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h | 2 +- Engine/lib/sdl/src/audio/winmm/SDL_winmm.c | 65 +- Engine/lib/sdl/src/audio/winmm/SDL_winmm.h | 2 +- .../lib/sdl/src/audio/xaudio2/SDL_xaudio2.c | 107 +- .../lib/sdl/src/audio/xaudio2/SDL_xaudio2.h | 386 + .../xaudio2/SDL_xaudio2_winrthelpers.cpp | 2 +- .../audio/xaudio2/SDL_xaudio2_winrthelpers.h | 2 +- Engine/lib/sdl/src/core/android/SDL_android.c | 284 +- Engine/lib/sdl/src/core/android/SDL_android.h | 26 +- Engine/lib/sdl/src/core/linux/SDL_dbus.c | 239 + Engine/lib/sdl/src/core/linux/SDL_dbus.h | 82 + Engine/lib/sdl/src/core/linux/SDL_evdev.c | 51 +- Engine/lib/sdl/src/core/linux/SDL_evdev.h | 2 +- Engine/lib/sdl/src/core/linux/SDL_ibus.c | 680 + Engine/lib/sdl/src/core/linux/SDL_ibus.h | 58 + Engine/lib/sdl/src/core/linux/SDL_udev.c | 148 +- Engine/lib/sdl/src/core/linux/SDL_udev.h | 4 +- .../directx.h => core/windows/SDL_directx.h} | 21 +- Engine/lib/sdl/src/core/windows/SDL_windows.c | 40 +- Engine/lib/sdl/src/core/windows/SDL_windows.h | 5 +- Engine/lib/sdl/src/core/windows/SDL_xinput.c | 139 + .../windows/SDL_xinput.h} | 144 +- .../src/core/winrt/SDL_winrtapp_common.cpp | 2 +- .../sdl/src/core/winrt/SDL_winrtapp_common.h | 2 +- .../src/core/winrt/SDL_winrtapp_direct3d.cpp | 511 +- .../src/core/winrt/SDL_winrtapp_direct3d.h | 18 +- .../sdl/src/core/winrt/SDL_winrtapp_xaml.cpp | 2 +- .../sdl/src/core/winrt/SDL_winrtapp_xaml.h | 4 +- Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c | 126 +- Engine/lib/sdl/src/dynapi/SDL_dynapi.c | 41 +- Engine/lib/sdl/src/dynapi/SDL_dynapi.h | 11 +- .../lib/sdl/src/dynapi/SDL_dynapi_overrides.h | 24 +- Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h | 69 +- Engine/lib/sdl/src/dynapi/gendynapi.pl | 2 +- .../lib/sdl/src/events/SDL_clipboardevents.c | 2 +- .../sdl/src/events/SDL_clipboardevents_c.h | 2 +- Engine/lib/sdl/src/events/SDL_dropevents.c | 2 +- Engine/lib/sdl/src/events/SDL_dropevents_c.h | 2 +- Engine/lib/sdl/src/events/SDL_events.c | 43 +- Engine/lib/sdl/src/events/SDL_events_c.h | 5 +- Engine/lib/sdl/src/events/SDL_gesture.c | 79 +- Engine/lib/sdl/src/events/SDL_gesture_c.h | 2 +- Engine/lib/sdl/src/events/SDL_keyboard.c | 159 +- Engine/lib/sdl/src/events/SDL_keyboard_c.h | 5 +- Engine/lib/sdl/src/events/SDL_mouse.c | 154 +- Engine/lib/sdl/src/events/SDL_mouse_c.h | 15 +- Engine/lib/sdl/src/events/SDL_quit.c | 50 +- Engine/lib/sdl/src/events/SDL_sysevents.h | 2 +- Engine/lib/sdl/src/events/SDL_touch.c | 7 +- Engine/lib/sdl/src/events/SDL_touch_c.h | 2 +- Engine/lib/sdl/src/events/SDL_windowevents.c | 4 +- .../lib/sdl/src/events/SDL_windowevents_c.h | 2 +- Engine/lib/sdl/src/events/blank_cursor.h | 2 +- Engine/lib/sdl/src/events/default_cursor.h | 4 +- Engine/lib/sdl/src/events/scancodes_darwin.h | 2 +- Engine/lib/sdl/src/events/scancodes_linux.h | 2 +- Engine/lib/sdl/src/events/scancodes_windows.h | 6 +- Engine/lib/sdl/src/events/scancodes_xfree86.h | 18 +- Engine/lib/sdl/src/file/SDL_rwops.c | 10 +- .../src/file/cocoa/SDL_rwopsbundlesupport.h | 2 +- .../src/file/cocoa/SDL_rwopsbundlesupport.m | 22 +- .../filesystem/android/SDL_sysfilesystem.c | 62 + .../src/filesystem/cocoa/SDL_sysfilesystem.m | 17 +- .../src/filesystem/dummy/SDL_sysfilesystem.c | 2 +- .../filesystem/emscripten/SDL_sysfilesystem.c | 69 + .../src/filesystem/haiku/SDL_sysfilesystem.cc | 2 +- .../nacl/SDL_sysfilesystem.c} | 38 +- .../src/filesystem/unix/SDL_sysfilesystem.c | 4 +- .../filesystem/windows/SDL_sysfilesystem.c | 54 +- .../filesystem/winrt/SDL_sysfilesystem.cpp | 89 +- Engine/lib/sdl/src/haptic/SDL_haptic.c | 5 +- Engine/lib/sdl/src/haptic/SDL_haptic_c.h | 2 +- Engine/lib/sdl/src/haptic/SDL_syshaptic.h | 14 +- .../lib/sdl/src/haptic/darwin/SDL_syshaptic.c | 172 +- .../sdl/src/haptic/darwin/SDL_syshaptic_c.h | 2 +- .../lib/sdl/src/haptic/dummy/SDL_syshaptic.c | 4 +- .../lib/sdl/src/haptic/linux/SDL_syshaptic.c | 120 +- .../{SDL_syshaptic.c => SDL_dinputhaptic.c} | 1178 +- .../src/haptic/windows/SDL_dinputhaptic_c.h | 47 + .../src/haptic/windows/SDL_windowshaptic.c | 449 + .../src/haptic/windows/SDL_windowshaptic_c.h | 88 + .../sdl/src/haptic/windows/SDL_xinputhaptic.c | 495 + .../src/haptic/windows/SDL_xinputhaptic_c.h | 47 + .../lib/sdl/src/joystick/SDL_gamecontroller.c | 717 +- .../sdl/src/joystick/SDL_gamecontrollerdb.h | 52 +- Engine/lib/sdl/src/joystick/SDL_joystick.c | 191 +- Engine/lib/sdl/src/joystick/SDL_joystick_c.h | 7 +- Engine/lib/sdl/src/joystick/SDL_sysjoystick.h | 25 +- .../src/joystick/android/SDL_sysjoystick.c | 32 +- .../src/joystick/android/SDL_sysjoystick_c.h | 4 +- .../sdl/src/joystick/bsd/SDL_sysjoystick.c | 59 +- .../sdl/src/joystick/darwin/SDL_sysjoystick.c | 270 +- .../src/joystick/darwin/SDL_sysjoystick_c.h | 7 +- .../sdl/src/joystick/dummy/SDL_sysjoystick.c | 16 +- .../src/joystick/emscripten/SDL_sysjoystick.c | 427 + .../joystick/emscripten/SDL_sysjoystick_c.h | 52 + .../src/joystick/haiku/SDL_haikujoystick.cc | 15 +- .../iphoneos/SDLUIAccelerationDelegate.m | 141 - .../src/joystick/iphoneos/SDL_sysjoystick.m | 604 +- .../src/joystick/iphoneos/SDL_sysjoystick_c.h | 55 + .../sdl/src/joystick/linux/SDL_sysjoystick.c | 38 +- .../src/joystick/linux/SDL_sysjoystick_c.h | 2 +- .../sdl/src/joystick/psp/SDL_sysjoystick.c | 24 +- .../lib/sdl/src/joystick/sort_controllers.py | 16 +- .../src/joystick/windows/SDL_dinputjoystick.c | 906 ++ .../joystick/windows/SDL_dinputjoystick_c.h | 30 + .../sdl/src/joystick/windows/SDL_dxjoystick.c | 1683 -- .../sdl/src/joystick/windows/SDL_mmjoystick.c | 16 +- .../joystick/windows/SDL_windowsjoystick.c | 569 + .../joystick/windows/SDL_windowsjoystick_c.h | 88 + .../src/joystick/windows/SDL_xinputjoystick.c | 425 + .../joystick/windows/SDL_xinputjoystick_c.h | 33 + .../src/joystick/winrt/SDL_xinputjoystick.c | 537 - Engine/lib/sdl/src/libm/k_rem_pio2.c | 5 + Engine/lib/sdl/src/libm/k_tan.c | 118 + Engine/lib/sdl/src/libm/math_libm.h | 3 +- Engine/lib/sdl/src/libm/math_private.h | 1 + Engine/lib/sdl/src/libm/s_tan.c | 67 + .../lib/sdl/src/loadso/dlopen/SDL_sysloadso.c | 2 +- .../lib/sdl/src/loadso/dummy/SDL_sysloadso.c | 2 +- .../lib/sdl/src/loadso/haiku/SDL_sysloadso.c | 2 +- .../sdl/src/loadso/windows/SDL_sysloadso.c | 2 +- .../sdl/src/main/android/SDL_android_main.c | 54 +- Engine/lib/sdl/src/main/haiku/SDL_BApp.h | 4 +- Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc | 2 +- Engine/lib/sdl/src/main/haiku/SDL_BeApp.h | 2 +- Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c | 93 + Engine/lib/sdl/src/main/psp/SDL_psp_main.c | 7 + .../sdl/src/main/windows/SDL_windows_main.c | 76 +- Engine/lib/sdl/src/main/windows/version.rc | 10 +- Engine/lib/sdl/src/power/SDL_power.c | 12 +- .../lib/sdl/src/power/android/SDL_syspower.c | 2 +- .../sdl/src/power/emscripten/SDL_syspower.c | 62 + Engine/lib/sdl/src/power/haiku/SDL_syspower.c | 2 +- Engine/lib/sdl/src/power/linux/SDL_syspower.c | 106 +- .../lib/sdl/src/power/macosx/SDL_syspower.c | 6 +- Engine/lib/sdl/src/power/psp/SDL_syspower.c | 2 +- Engine/lib/sdl/src/power/uikit/SDL_syspower.h | 2 +- Engine/lib/sdl/src/power/uikit/SDL_syspower.m | 39 +- .../lib/sdl/src/power/windows/SDL_syspower.c | 2 +- .../lib/sdl/src/power/winrt/SDL_syspower.cpp | 2 +- Engine/lib/sdl/src/render/SDL_d3dmath.c | 7 +- Engine/lib/sdl/src/render/SDL_d3dmath.h | 5 +- Engine/lib/sdl/src/render/SDL_render.c | 74 +- Engine/lib/sdl/src/render/SDL_sysrender.h | 6 +- Engine/lib/sdl/src/render/SDL_yuv_mmx.c | 2 +- Engine/lib/sdl/src/render/SDL_yuv_sw.c | 9 +- Engine/lib/sdl/src/render/SDL_yuv_sw_c.h | 2 +- .../sdl/src/render/direct3d/SDL_render_d3d.c | 479 +- .../src/render/direct3d11/SDL_render_d3d11.c | 182 +- .../render/direct3d11/SDL_render_winrt.cpp | 9 +- .../src/render/direct3d11/SDL_render_winrt.h | 2 +- .../lib/sdl/src/render/opengl/SDL_glfuncs.h | 2 +- .../lib/sdl/src/render/opengl/SDL_render_gl.c | 210 +- .../sdl/src/render/opengl/SDL_shaders_gl.c | 119 +- .../sdl/src/render/opengl/SDL_shaders_gl.h | 6 +- .../sdl/src/render/opengles/SDL_glesfuncs.h | 2 +- .../sdl/src/render/opengles/SDL_render_gles.c | 132 +- .../sdl/src/render/opengles2/SDL_gles2funcs.h | 10 +- .../src/render/opengles2/SDL_render_gles2.c | 888 +- .../src/render/opengles2/SDL_shaders_gles2.c | 147 +- .../src/render/opengles2/SDL_shaders_gles2.h | 7 +- .../lib/sdl/src/render/psp/SDL_render_psp.c | 4 +- .../src/render/software/SDL_blendfillrect.c | 2 +- .../src/render/software/SDL_blendfillrect.h | 2 +- .../sdl/src/render/software/SDL_blendline.c | 2 +- .../sdl/src/render/software/SDL_blendline.h | 2 +- .../sdl/src/render/software/SDL_blendpoint.c | 2 +- .../sdl/src/render/software/SDL_blendpoint.h | 2 +- Engine/lib/sdl/src/render/software/SDL_draw.h | 5 +- .../sdl/src/render/software/SDL_drawline.c | 2 +- .../sdl/src/render/software/SDL_drawline.h | 2 +- .../sdl/src/render/software/SDL_drawpoint.c | 2 +- .../sdl/src/render/software/SDL_drawpoint.h | 2 +- .../sdl/src/render/software/SDL_render_sw.c | 203 +- .../sdl/src/render/software/SDL_render_sw_c.h | 2 +- .../lib/sdl/src/render/software/SDL_rotate.c | 71 +- .../lib/sdl/src/render/software/SDL_rotate.h | 2 +- Engine/lib/sdl/src/stdlib/SDL_getenv.c | 42 +- Engine/lib/sdl/src/stdlib/SDL_iconv.c | 10 +- Engine/lib/sdl/src/stdlib/SDL_malloc.c | 8 +- Engine/lib/sdl/src/stdlib/SDL_qsort.c | 5 + Engine/lib/sdl/src/stdlib/SDL_stdlib.c | 84 +- Engine/lib/sdl/src/stdlib/SDL_string.c | 59 +- Engine/lib/sdl/src/test/SDL_test_assert.c | 12 +- Engine/lib/sdl/src/test/SDL_test_common.c | 53 +- Engine/lib/sdl/src/test/SDL_test_compare.c | 10 +- Engine/lib/sdl/src/test/SDL_test_crc32.c | 2 +- Engine/lib/sdl/src/test/SDL_test_font.c | 2 +- Engine/lib/sdl/src/test/SDL_test_fuzzer.c | 3 +- Engine/lib/sdl/src/test/SDL_test_harness.c | 16 +- Engine/lib/sdl/src/test/SDL_test_imageBlit.c | 2 +- .../sdl/src/test/SDL_test_imageBlitBlend.c | 2 +- Engine/lib/sdl/src/test/SDL_test_imageFace.c | 2 +- .../sdl/src/test/SDL_test_imagePrimitives.c | 2 +- .../src/test/SDL_test_imagePrimitivesBlend.c | 2 +- Engine/lib/sdl/src/test/SDL_test_log.c | 6 +- Engine/lib/sdl/src/test/SDL_test_md5.c | 2 +- Engine/lib/sdl/src/test/SDL_test_random.c | 2 +- Engine/lib/sdl/src/thread/SDL_systhread.h | 2 +- Engine/lib/sdl/src/thread/SDL_thread.c | 8 +- Engine/lib/sdl/src/thread/SDL_thread_c.h | 2 +- .../lib/sdl/src/thread/generic/SDL_syscond.c | 2 +- .../lib/sdl/src/thread/generic/SDL_sysmutex.c | 2 +- .../sdl/src/thread/generic/SDL_sysmutex_c.h | 2 +- .../lib/sdl/src/thread/generic/SDL_syssem.c | 2 +- .../sdl/src/thread/generic/SDL_systhread.c | 2 +- .../sdl/src/thread/generic/SDL_systhread_c.h | 2 +- .../lib/sdl/src/thread/generic/SDL_systls.c | 2 +- Engine/lib/sdl/src/thread/psp/SDL_syscond.c | 6 +- Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c | 6 +- .../lib/sdl/src/thread/psp/SDL_sysmutex_c.h | 2 +- Engine/lib/sdl/src/thread/psp/SDL_syssem.c | 9 +- Engine/lib/sdl/src/thread/psp/SDL_systhread.c | 6 +- .../lib/sdl/src/thread/psp/SDL_systhread_c.h | 2 +- .../lib/sdl/src/thread/pthread/SDL_syscond.c | 12 +- .../lib/sdl/src/thread/pthread/SDL_sysmutex.c | 6 +- .../sdl/src/thread/pthread/SDL_sysmutex_c.h | 2 +- .../lib/sdl/src/thread/pthread/SDL_syssem.c | 32 +- .../sdl/src/thread/pthread/SDL_systhread.c | 29 +- .../sdl/src/thread/pthread/SDL_systhread_c.h | 2 +- .../lib/sdl/src/thread/pthread/SDL_systls.c | 2 +- .../lib/sdl/src/thread/stdcpp/SDL_syscond.cpp | 4 +- .../sdl/src/thread/stdcpp/SDL_sysmutex.cpp | 2 +- .../sdl/src/thread/stdcpp/SDL_sysmutex_c.h | 2 +- .../sdl/src/thread/stdcpp/SDL_systhread.cpp | 2 +- .../sdl/src/thread/stdcpp/SDL_systhread_c.h | 2 +- .../lib/sdl/src/thread/windows/SDL_sysmutex.c | 6 +- .../lib/sdl/src/thread/windows/SDL_syssem.c | 10 +- .../sdl/src/thread/windows/SDL_systhread.c | 8 +- .../sdl/src/thread/windows/SDL_systhread_c.h | 2 +- .../lib/sdl/src/thread/windows/SDL_systls.c | 2 +- Engine/lib/sdl/src/timer/SDL_timer.c | 2 +- Engine/lib/sdl/src/timer/SDL_timer_c.h | 2 +- Engine/lib/sdl/src/timer/dummy/SDL_systimer.c | 2 +- Engine/lib/sdl/src/timer/haiku/SDL_systimer.c | 2 +- Engine/lib/sdl/src/timer/psp/SDL_systimer.c | 7 +- Engine/lib/sdl/src/timer/unix/SDL_systimer.c | 30 +- .../lib/sdl/src/timer/windows/SDL_systimer.c | 86 +- Engine/lib/sdl/src/video/SDL_RLEaccel.c | 587 +- Engine/lib/sdl/src/video/SDL_RLEaccel_c.h | 2 +- Engine/lib/sdl/src/video/SDL_blit.c | 2 +- Engine/lib/sdl/src/video/SDL_blit.h | 20 +- Engine/lib/sdl/src/video/SDL_blit_0.c | 2 +- Engine/lib/sdl/src/video/SDL_blit_1.c | 2 +- Engine/lib/sdl/src/video/SDL_blit_A.c | 8 +- Engine/lib/sdl/src/video/SDL_blit_N.c | 42 +- Engine/lib/sdl/src/video/SDL_blit_auto.c | 580 +- Engine/lib/sdl/src/video/SDL_blit_auto.h | 2 +- Engine/lib/sdl/src/video/SDL_blit_copy.c | 2 +- Engine/lib/sdl/src/video/SDL_blit_copy.h | 2 +- Engine/lib/sdl/src/video/SDL_blit_slow.c | 2 +- Engine/lib/sdl/src/video/SDL_blit_slow.h | 2 +- Engine/lib/sdl/src/video/SDL_bmp.c | 155 +- Engine/lib/sdl/src/video/SDL_clipboard.c | 16 +- Engine/lib/sdl/src/video/SDL_egl.c | 227 +- Engine/lib/sdl/src/video/SDL_egl_c.h | 2 +- Engine/lib/sdl/src/video/SDL_fillrect.c | 30 +- Engine/lib/sdl/src/video/SDL_pixels.c | 8 +- Engine/lib/sdl/src/video/SDL_pixels_c.h | 2 +- Engine/lib/sdl/src/video/SDL_rect.c | 2 +- Engine/lib/sdl/src/video/SDL_rect_c.h | 2 +- Engine/lib/sdl/src/video/SDL_shape.c | 31 +- .../lib/sdl/src/video/SDL_shape_internals.h | 2 +- Engine/lib/sdl/src/video/SDL_stretch.c | 2 +- Engine/lib/sdl/src/video/SDL_surface.c | 278 +- Engine/lib/sdl/src/video/SDL_sysvideo.h | 31 +- Engine/lib/sdl/src/video/SDL_video.c | 611 +- .../src/video/android/SDL_androidclipboard.c | 2 +- .../src/video/android/SDL_androidclipboard.h | 2 +- .../sdl/src/video/android/SDL_androidevents.c | 19 +- .../sdl/src/video/android/SDL_androidevents.h | 2 +- .../lib/sdl/src/video/android/SDL_androidgl.c | 12 +- .../src/video/android/SDL_androidkeyboard.c | 59 +- .../src/video/android/SDL_androidkeyboard.h | 2 +- .../src/video/android/SDL_androidmessagebox.c | 37 + .../android/SDL_androidmessagebox.h} | 13 +- .../sdl/src/video/android/SDL_androidmouse.c | 84 + .../sdl/src/video/android/SDL_androidmouse.h | 31 + .../sdl/src/video/android/SDL_androidtouch.c | 69 +- .../sdl/src/video/android/SDL_androidtouch.h | 3 +- .../sdl/src/video/android/SDL_androidvideo.c | 21 +- .../sdl/src/video/android/SDL_androidvideo.h | 4 +- .../sdl/src/video/android/SDL_androidwindow.c | 23 +- .../sdl/src/video/android/SDL_androidwindow.h | 3 +- .../sdl/src/video/cocoa/SDL_cocoaclipboard.h | 2 +- .../sdl/src/video/cocoa/SDL_cocoaclipboard.m | 32 +- .../lib/sdl/src/video/cocoa/SDL_cocoaevents.h | 3 +- .../lib/sdl/src/video/cocoa/SDL_cocoaevents.m | 185 +- .../sdl/src/video/cocoa/SDL_cocoakeyboard.h | 2 +- .../sdl/src/video/cocoa/SDL_cocoakeyboard.m | 161 +- .../sdl/src/video/cocoa/SDL_cocoamessagebox.h | 2 +- .../sdl/src/video/cocoa/SDL_cocoamessagebox.m | 25 +- .../lib/sdl/src/video/cocoa/SDL_cocoamodes.h | 2 +- .../lib/sdl/src/video/cocoa/SDL_cocoamodes.m | 87 +- .../lib/sdl/src/video/cocoa/SDL_cocoamouse.h | 2 +- .../lib/sdl/src/video/cocoa/SDL_cocoamouse.m | 157 +- .../sdl/src/video/cocoa/SDL_cocoamousetap.h | 2 +- .../sdl/src/video/cocoa/SDL_cocoamousetap.m | 5 +- .../lib/sdl/src/video/cocoa/SDL_cocoaopengl.h | 2 +- .../lib/sdl/src/video/cocoa/SDL_cocoaopengl.m | 67 +- .../lib/sdl/src/video/cocoa/SDL_cocoashape.h | 2 +- .../lib/sdl/src/video/cocoa/SDL_cocoashape.m | 22 +- .../lib/sdl/src/video/cocoa/SDL_cocoavideo.h | 7 +- .../lib/sdl/src/video/cocoa/SDL_cocoavideo.m | 19 +- .../lib/sdl/src/video/cocoa/SDL_cocoawindow.h | 19 +- .../lib/sdl/src/video/cocoa/SDL_cocoawindow.m | 584 +- .../sdl/src/video/directfb/SDL_DirectFB_WM.c | 4 +- .../sdl/src/video/directfb/SDL_DirectFB_WM.h | 2 +- .../sdl/src/video/directfb/SDL_DirectFB_dyn.c | 2 +- .../sdl/src/video/directfb/SDL_DirectFB_dyn.h | 2 +- .../src/video/directfb/SDL_DirectFB_events.c | 2 +- .../src/video/directfb/SDL_DirectFB_events.h | 2 +- .../src/video/directfb/SDL_DirectFB_modes.c | 2 +- .../src/video/directfb/SDL_DirectFB_modes.h | 2 +- .../src/video/directfb/SDL_DirectFB_mouse.c | 2 +- .../src/video/directfb/SDL_DirectFB_mouse.h | 2 +- .../src/video/directfb/SDL_DirectFB_opengl.c | 2 +- .../src/video/directfb/SDL_DirectFB_opengl.h | 2 +- .../src/video/directfb/SDL_DirectFB_render.c | 4 +- .../src/video/directfb/SDL_DirectFB_render.h | 2 +- .../src/video/directfb/SDL_DirectFB_shape.c | 2 +- .../src/video/directfb/SDL_DirectFB_shape.h | 2 +- .../src/video/directfb/SDL_DirectFB_video.c | 6 +- .../src/video/directfb/SDL_DirectFB_video.h | 2 +- .../src/video/directfb/SDL_DirectFB_window.c | 4 +- .../src/video/directfb/SDL_DirectFB_window.h | 2 +- .../lib/sdl/src/video/dummy/SDL_nullevents.c | 2 +- .../sdl/src/video/dummy/SDL_nullevents_c.h | 2 +- .../sdl/src/video/dummy/SDL_nullframebuffer.c | 2 +- .../src/video/dummy/SDL_nullframebuffer_c.h | 2 +- .../lib/sdl/src/video/dummy/SDL_nullvideo.c | 3 +- .../lib/sdl/src/video/dummy/SDL_nullvideo.h | 2 +- .../video/emscripten/SDL_emscriptenevents.c | 644 + .../video/emscripten/SDL_emscriptenevents.h | 36 + .../emscripten/SDL_emscriptenframebuffer.c | 136 + .../emscripten/SDL_emscriptenframebuffer.h | 32 + .../video/emscripten/SDL_emscriptenmouse.c | 232 + .../video/emscripten/SDL_emscriptenmouse.h | 39 + .../video/emscripten/SDL_emscriptenopengles.c | 117 + .../video/emscripten/SDL_emscriptenopengles.h | 49 + .../video/emscripten/SDL_emscriptenvideo.c | 319 + .../video/emscripten/SDL_emscriptenvideo.h | 52 + Engine/lib/sdl/src/video/haiku/SDL_BWin.h | 2 +- .../lib/sdl/src/video/haiku/SDL_bclipboard.cc | 2 +- .../lib/sdl/src/video/haiku/SDL_bclipboard.h | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bevents.cc | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bevents.h | 2 +- .../sdl/src/video/haiku/SDL_bframebuffer.cc | 2 +- .../sdl/src/video/haiku/SDL_bframebuffer.h | 2 +- .../lib/sdl/src/video/haiku/SDL_bkeyboard.cc | 2 +- .../lib/sdl/src/video/haiku/SDL_bkeyboard.h | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bmodes.h | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bopengl.h | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bvideo.h | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc | 2 +- Engine/lib/sdl/src/video/haiku/SDL_bwindow.h | 2 +- Engine/lib/sdl/src/video/mir/SDL_mirdyn.c | 2 +- Engine/lib/sdl/src/video/mir/SDL_mirdyn.h | 2 +- Engine/lib/sdl/src/video/mir/SDL_mirevents.c | 30 +- Engine/lib/sdl/src/video/mir/SDL_mirevents.h | 2 +- .../sdl/src/video/mir/SDL_mirframebuffer.c | 4 +- .../sdl/src/video/mir/SDL_mirframebuffer.h | 2 +- Engine/lib/sdl/src/video/mir/SDL_mirmouse.c | 9 +- Engine/lib/sdl/src/video/mir/SDL_mirmouse.h | 2 +- Engine/lib/sdl/src/video/mir/SDL_miropengl.c | 2 +- Engine/lib/sdl/src/video/mir/SDL_miropengl.h | 2 +- Engine/lib/sdl/src/video/mir/SDL_mirsym.h | 7 +- Engine/lib/sdl/src/video/mir/SDL_mirvideo.c | 4 +- Engine/lib/sdl/src/video/mir/SDL_mirvideo.h | 4 +- Engine/lib/sdl/src/video/mir/SDL_mirwindow.c | 21 +- Engine/lib/sdl/src/video/mir/SDL_mirwindow.h | 4 +- .../lib/sdl/src/video/nacl/SDL_naclevents.c | 438 + .../lib/sdl/src/video/nacl/SDL_naclevents_c.h | 30 + Engine/lib/sdl/src/video/nacl/SDL_naclglue.c | 24 + .../lib/sdl/src/video/nacl/SDL_naclopengles.c | 171 + .../lib/sdl/src/video/nacl/SDL_naclopengles.h | 38 + Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c | 183 + Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h | 67 + .../lib/sdl/src/video/nacl/SDL_naclwindow.c | 79 + .../lib/sdl/src/video/nacl/SDL_naclwindow.h | 32 + .../lib/sdl/src/video/pandora/SDL_pandora.c | 2 +- .../lib/sdl/src/video/pandora/SDL_pandora.h | 2 +- .../src/video/pandora/SDL_pandora_events.c | 2 +- .../src/video/pandora/SDL_pandora_events.h | 2 +- Engine/lib/sdl/src/video/psp/SDL_pspevents.c | 12 +- .../lib/sdl/src/video/psp/SDL_pspevents_c.h | 2 +- Engine/lib/sdl/src/video/psp/SDL_pspgl.c | 8 +- Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h | 2 +- Engine/lib/sdl/src/video/psp/SDL_pspmouse.c | 8 +- Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h | 2 +- Engine/lib/sdl/src/video/psp/SDL_pspvideo.c | 6 +- Engine/lib/sdl/src/video/psp/SDL_pspvideo.h | 8 +- .../sdl/src/video/raspberry/SDL_rpievents.c | 2 +- .../sdl/src/video/raspberry/SDL_rpievents_c.h | 2 +- .../sdl/src/video/raspberry/SDL_rpimouse.c | 16 +- .../sdl/src/video/raspberry/SDL_rpimouse.h | 2 +- .../sdl/src/video/raspberry/SDL_rpiopengles.c | 2 +- .../sdl/src/video/raspberry/SDL_rpiopengles.h | 2 +- .../sdl/src/video/raspberry/SDL_rpivideo.c | 13 +- .../sdl/src/video/raspberry/SDL_rpivideo.h | 2 +- Engine/lib/sdl/src/video/sdlgenblit.pl | 79 +- .../src/video/uikit/SDL_uikitappdelegate.h | 17 +- .../src/video/uikit/SDL_uikitappdelegate.m | 379 +- .../lib/sdl/src/video/uikit/SDL_uikitevents.h | 2 +- .../lib/sdl/src/video/uikit/SDL_uikitevents.m | 5 +- .../sdl/src/video/uikit/SDL_uikitmessagebox.h | 2 +- .../sdl/src/video/uikit/SDL_uikitmessagebox.m | 200 +- .../lib/sdl/src/video/uikit/SDL_uikitmodes.h | 22 +- .../lib/sdl/src/video/uikit/SDL_uikitmodes.m | 214 +- .../sdl/src/video/uikit/SDL_uikitopengles.h | 4 +- .../sdl/src/video/uikit/SDL_uikitopengles.m | 251 +- .../sdl/src/video/uikit/SDL_uikitopenglview.h | 74 +- .../sdl/src/video/uikit/SDL_uikitopenglview.m | 402 +- .../lib/sdl/src/video/uikit/SDL_uikitvideo.h | 18 +- .../lib/sdl/src/video/uikit/SDL_uikitvideo.m | 49 +- .../lib/sdl/src/video/uikit/SDL_uikitview.h | 49 +- .../lib/sdl/src/video/uikit/SDL_uikitview.m | 475 +- .../src/video/uikit/SDL_uikitviewcontroller.h | 52 +- .../src/video/uikit/SDL_uikitviewcontroller.m | 392 +- .../lib/sdl/src/video/uikit/SDL_uikitwindow.h | 25 +- .../lib/sdl/src/video/uikit/SDL_uikitwindow.m | 478 +- Engine/lib/sdl/src/video/uikit/keyinfotable.h | 4 +- .../src/video/vivante/SDL_vivanteopengles.c | 47 + .../src/video/vivante/SDL_vivanteopengles.h | 48 + .../src/video/vivante/SDL_vivanteplatform.c | 44 + .../src/video/vivante/SDL_vivanteplatform.h | 45 + .../sdl/src/video/vivante/SDL_vivantevideo.c | 399 + .../sdl/src/video/vivante/SDL_vivantevideo.h | 91 + .../sdl/src/video/wayland/SDL_waylanddyn.c | 2 +- .../sdl/src/video/wayland/SDL_waylanddyn.h | 2 +- .../sdl/src/video/wayland/SDL_waylandevents.c | 67 +- .../src/video/wayland/SDL_waylandevents_c.h | 2 +- .../sdl/src/video/wayland/SDL_waylandmouse.c | 67 +- .../sdl/src/video/wayland/SDL_waylandmouse.h | 2 +- .../src/video/wayland/SDL_waylandopengles.c | 2 +- .../src/video/wayland/SDL_waylandopengles.h | 2 +- .../sdl/src/video/wayland/SDL_waylandsym.h | 2 +- .../sdl/src/video/wayland/SDL_waylandtouch.c | 23 +- .../sdl/src/video/wayland/SDL_waylandtouch.h | 2 +- .../sdl/src/video/wayland/SDL_waylandvideo.c | 208 +- .../sdl/src/video/wayland/SDL_waylandvideo.h | 17 +- .../sdl/src/video/wayland/SDL_waylandwindow.c | 35 +- .../sdl/src/video/wayland/SDL_waylandwindow.h | 3 +- Engine/lib/sdl/src/video/windows/SDL_msctf.h | 2 +- Engine/lib/sdl/src/video/windows/SDL_vkeys.h | 2 +- .../src/video/windows/SDL_windowsclipboard.c | 2 +- .../src/video/windows/SDL_windowsclipboard.h | 2 +- .../sdl/src/video/windows/SDL_windowsevents.c | 415 +- .../sdl/src/video/windows/SDL_windowsevents.h | 2 +- .../video/windows/SDL_windowsframebuffer.c | 5 +- .../video/windows/SDL_windowsframebuffer.h | 2 +- .../src/video/windows/SDL_windowskeyboard.c | 48 +- .../src/video/windows/SDL_windowskeyboard.h | 2 +- .../src/video/windows/SDL_windowsmessagebox.c | 11 +- .../src/video/windows/SDL_windowsmessagebox.h | 2 +- .../sdl/src/video/windows/SDL_windowsmodes.c | 133 +- .../sdl/src/video/windows/SDL_windowsmodes.h | 10 +- .../sdl/src/video/windows/SDL_windowsmouse.c | 107 +- .../sdl/src/video/windows/SDL_windowsmouse.h | 2 +- .../sdl/src/video/windows/SDL_windowsopengl.c | 54 +- .../sdl/src/video/windows/SDL_windowsopengl.h | 3 +- .../src/video/windows/SDL_windowsopengles.c | 5 +- .../src/video/windows/SDL_windowsopengles.h | 2 +- .../sdl/src/video/windows/SDL_windowsshape.c | 2 +- .../sdl/src/video/windows/SDL_windowsshape.h | 2 +- .../sdl/src/video/windows/SDL_windowsvideo.c | 327 +- .../sdl/src/video/windows/SDL_windowsvideo.h | 23 +- .../sdl/src/video/windows/SDL_windowswindow.c | 103 +- .../sdl/src/video/windows/SDL_windowswindow.h | 11 +- Engine/lib/sdl/src/video/windows/wmmsg.h | 12 +- .../sdl/src/video/winrt/SDL_winrtevents.cpp | 2 +- .../sdl/src/video/winrt/SDL_winrtevents_c.h | 5 +- .../sdl/src/video/winrt/SDL_winrtkeyboard.cpp | 471 +- .../src/video/winrt/SDL_winrtmessagebox.cpp | 112 + .../sdl/src/video/winrt/SDL_winrtmessagebox.h | 29 + .../sdl/src/video/winrt/SDL_winrtmouse.cpp | 2 +- .../sdl/src/video/winrt/SDL_winrtmouse_c.h | 4 +- .../sdl/src/video/winrt/SDL_winrtopengles.cpp | 164 +- .../sdl/src/video/winrt/SDL_winrtopengles.h | 26 +- .../src/video/winrt/SDL_winrtpointerinput.cpp | 40 +- .../sdl/src/video/winrt/SDL_winrtvideo.cpp | 623 +- .../sdl/src/video/winrt/SDL_winrtvideo_cpp.h | 56 +- .../lib/sdl/src/video/x11/SDL_x11clipboard.c | 19 +- .../lib/sdl/src/video/x11/SDL_x11clipboard.h | 3 +- Engine/lib/sdl/src/video/x11/SDL_x11dyn.c | 4 +- Engine/lib/sdl/src/video/x11/SDL_x11dyn.h | 5 +- Engine/lib/sdl/src/video/x11/SDL_x11events.c | 621 +- Engine/lib/sdl/src/video/x11/SDL_x11events.h | 2 +- .../sdl/src/video/x11/SDL_x11framebuffer.c | 2 +- .../sdl/src/video/x11/SDL_x11framebuffer.h | 2 +- .../lib/sdl/src/video/x11/SDL_x11keyboard.c | 125 +- .../lib/sdl/src/video/x11/SDL_x11keyboard.h | 5 +- .../lib/sdl/src/video/x11/SDL_x11messagebox.c | 91 +- .../lib/sdl/src/video/x11/SDL_x11messagebox.h | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11modes.c | 439 +- Engine/lib/sdl/src/video/x11/SDL_x11modes.h | 6 +- Engine/lib/sdl/src/video/x11/SDL_x11mouse.c | 77 +- Engine/lib/sdl/src/video/x11/SDL_x11mouse.h | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11opengl.c | 241 +- Engine/lib/sdl/src/video/x11/SDL_x11opengl.h | 5 +- .../lib/sdl/src/video/x11/SDL_x11opengles.c | 6 +- .../lib/sdl/src/video/x11/SDL_x11opengles.h | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11shape.c | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11shape.h | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11sym.h | 23 +- Engine/lib/sdl/src/video/x11/SDL_x11touch.c | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11touch.h | 2 +- Engine/lib/sdl/src/video/x11/SDL_x11video.c | 228 +- Engine/lib/sdl/src/video/x11/SDL_x11video.h | 19 +- Engine/lib/sdl/src/video/x11/SDL_x11window.c | 127 +- Engine/lib/sdl/src/video/x11/SDL_x11window.h | 6 +- Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c | 24 +- Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h | 2 +- Engine/lib/sdl/src/video/x11/edid-parse.c | 2 +- Engine/lib/sdl/test/COPYING | 8 + Engine/lib/sdl/test/Makefile.in | 283 + Engine/lib/sdl/test/README | 23 +- Engine/lib/sdl/test/acinclude.m4 | 359 + Engine/lib/sdl/test/aclocal.m4 | 359 + Engine/lib/sdl/test/autogen.sh | 12 + Engine/lib/sdl/test/axis.bmp | Bin 0 -> 3746 bytes Engine/lib/sdl/test/button.bmp | Bin 0 -> 3746 bytes Engine/lib/sdl/test/checkkeys.c | 236 + Engine/lib/sdl/test/configure | 5124 ++++++ Engine/lib/sdl/test/configure.in | 191 + Engine/lib/sdl/test/controllermap.bmp | Bin 0 -> 163450 bytes Engine/lib/sdl/test/controllermap.c | 440 + .../lib/sdl/test/emscripten/joystick-pre.js | 25 + Engine/lib/sdl/test/gcc-fat.sh | 110 + .../{Xcode-iOS/Demos/data => test}/icon.bmp | Bin Engine/lib/sdl/test/loopwave.c | 161 + Engine/lib/sdl/test/loopwavequeue.c | 150 + Engine/lib/sdl/test/moose.dat | Bin 0 -> 56320 bytes Engine/lib/sdl/test/nacl/Makefile | 63 + Engine/lib/sdl/test/nacl/background.js | 40 + Engine/lib/sdl/test/nacl/common.js | 469 + Engine/lib/sdl/test/nacl/index.html | 21 + Engine/lib/sdl/test/nacl/manifest.json | 22 + Engine/lib/sdl/test/picture.xbm | 14 + Engine/lib/sdl/test/relative_mode.markdown | 58 + Engine/lib/sdl/test/sample.bmp | Bin 0 -> 69202 bytes Engine/lib/sdl/test/sample.wav | Bin 0 -> 121946 bytes Engine/lib/sdl/test/shapes/p01_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p01_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p01_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p02_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p02_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p02_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p03_shape24.bmp | Bin 0 -> 1228938 bytes Engine/lib/sdl/test/shapes/p03_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p04_shape1.bmp | Bin 0 -> 51346 bytes Engine/lib/sdl/test/shapes/p04_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p04_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p04_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p05_shape8.bmp | Bin 0 -> 410678 bytes .../lib/sdl/test/shapes/p06_shape1alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p06_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p06_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p06_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p07_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p07_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p07_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p08_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p08_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p08_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p09_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p09_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p09_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p10_shape1.bmp | Bin 0 -> 51346 bytes Engine/lib/sdl/test/shapes/p10_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p10_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p10_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p11_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p11_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p11_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p12_shape24.bmp | Bin 0 -> 1228938 bytes Engine/lib/sdl/test/shapes/p12_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p13_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p13_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p13_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p14_shape24.bmp | Bin 0 -> 1228938 bytes Engine/lib/sdl/test/shapes/p14_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p15_shape24.bmp | Bin 0 -> 1228938 bytes .../lib/sdl/test/shapes/p15_shape32alpha.bmp | Bin 0 -> 1638538 bytes Engine/lib/sdl/test/shapes/p15_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/p16_shape1.bmp | Bin 0 -> 51346 bytes Engine/lib/sdl/test/shapes/p16_shape24.bmp | Bin 0 -> 1228938 bytes Engine/lib/sdl/test/shapes/p16_shape8.bmp | Bin 0 -> 410678 bytes Engine/lib/sdl/test/shapes/trollface_24.bmp | Bin 0 -> 196662 bytes .../lib/sdl/test/shapes/trollface_32alpha.bmp | Bin 0 -> 262198 bytes Engine/lib/sdl/test/testatomic.c | 724 + Engine/lib/sdl/test/testaudiohotplug.c | 183 + Engine/lib/sdl/test/testaudioinfo.c | 70 + Engine/lib/sdl/test/testautomation.c | 124 + Engine/lib/sdl/test/testautomation_audio.c | 1038 ++ .../lib/sdl/test/testautomation_clipboard.c | 184 + Engine/lib/sdl/test/testautomation_events.c | 201 + Engine/lib/sdl/test/testautomation_hints.c | 168 + Engine/lib/sdl/test/testautomation_keyboard.c | 713 + Engine/lib/sdl/test/testautomation_main.c | 157 + Engine/lib/sdl/test/testautomation_mouse.c | 594 + Engine/lib/sdl/test/testautomation_pixels.c | 529 + Engine/lib/sdl/test/testautomation_platform.c | 584 + Engine/lib/sdl/test/testautomation_rect.c | 1696 ++ Engine/lib/sdl/test/testautomation_render.c | 1099 ++ Engine/lib/sdl/test/testautomation_rwops.c | 748 + Engine/lib/sdl/test/testautomation_sdltest.c | 1315 ++ Engine/lib/sdl/test/testautomation_stdlib.c | 279 + Engine/lib/sdl/test/testautomation_suites.h | 54 + Engine/lib/sdl/test/testautomation_surface.c | 647 + Engine/lib/sdl/test/testautomation_syswm.c | 61 + Engine/lib/sdl/test/testautomation_timer.c | 201 + Engine/lib/sdl/test/testautomation_video.c | 1811 +++ Engine/lib/sdl/test/testdisplayinfo.c | 89 + Engine/lib/sdl/test/testdraw2.c | 305 + Engine/lib/sdl/test/testdrawchessboard.c | 135 + Engine/lib/sdl/test/testdropfile.c | 93 + Engine/lib/sdl/test/testerror.c | 77 + Engine/lib/sdl/test/testfile.c | 283 + Engine/lib/sdl/test/testfilesystem.c | 52 + Engine/lib/sdl/test/testgamecontroller.c | 348 + Engine/lib/sdl/test/testgesture.c | 310 + Engine/lib/sdl/test/testgl2.c | 416 + Engine/lib/sdl/test/testgles.c | 355 + Engine/lib/sdl/test/testgles2.c | 731 + Engine/lib/sdl/test/testhaptic.c | 369 + Engine/lib/sdl/test/testhittesting.c | 134 + Engine/lib/sdl/test/testhotplug.c | 162 + Engine/lib/sdl/test/testiconv.c | 88 + Engine/lib/sdl/test/testime.c | 373 + Engine/lib/sdl/test/testintersections.c | 363 + Engine/lib/sdl/test/testjoystick.c | 346 + Engine/lib/sdl/test/testkeys.c | 40 + Engine/lib/sdl/test/testloadso.c | 82 + Engine/lib/sdl/test/testlock.c | 126 + Engine/lib/sdl/test/testmessage.c | 193 + Engine/lib/sdl/test/testmultiaudio.c | 200 + Engine/lib/sdl/test/testnative.c | 237 + Engine/lib/sdl/test/testnative.h | 46 + Engine/lib/sdl/test/testnativecocoa.m | 51 + Engine/lib/sdl/test/testnativew32.c | 86 + Engine/lib/sdl/test/testnativex11.c | 53 + Engine/lib/sdl/test/testoverlay2.c | 511 + Engine/lib/sdl/test/testplatform.c | 204 + Engine/lib/sdl/test/testpower.c | 80 + Engine/lib/sdl/test/testrelative.c | 126 + Engine/lib/sdl/test/testrendercopyex.c | 233 + Engine/lib/sdl/test/testrendertarget.c | 335 + Engine/lib/sdl/test/testresample.c | 118 + Engine/lib/sdl/test/testrumble.c | 152 + Engine/lib/sdl/test/testscale.c | 224 + Engine/lib/sdl/test/testsem.c | 130 + Engine/lib/sdl/test/testshader.c | 500 + Engine/lib/sdl/test/testshape.c | 201 + Engine/lib/sdl/test/testsprite2.c | 401 + Engine/lib/sdl/test/testspriteminimal.c | 194 + Engine/lib/sdl/test/teststreaming.c | 190 + Engine/lib/sdl/test/testthread.c | 98 + Engine/lib/sdl/test/testtimer.c | 122 + Engine/lib/sdl/test/testver.c | 47 + Engine/lib/sdl/test/testviewport.c | 217 + Engine/lib/sdl/test/testwm2.c | 159 + Engine/lib/sdl/test/torturethread.c | 113 + Engine/lib/sdl/test/utf8.txt | 287 + 924 files changed, 79241 insertions(+), 39934 deletions(-) delete mode 100644 Engine/lib/sdl/README-android.txt delete mode 100644 Engine/lib/sdl/README-cmake.txt delete mode 100644 Engine/lib/sdl/README-directfb.txt delete mode 100644 Engine/lib/sdl/README-dynapi.txt delete mode 100644 Engine/lib/sdl/README-gesture.txt delete mode 100644 Engine/lib/sdl/README-hg.txt delete mode 100644 Engine/lib/sdl/README-ios.txt delete mode 100644 Engine/lib/sdl/README-linux.txt delete mode 100644 Engine/lib/sdl/README-macosx.txt delete mode 100644 Engine/lib/sdl/README-pandora.txt delete mode 100644 Engine/lib/sdl/README-platforms.txt delete mode 100644 Engine/lib/sdl/README-porting.txt delete mode 100644 Engine/lib/sdl/README-psp.txt delete mode 100644 Engine/lib/sdl/README-raspberrypi.txt delete mode 100644 Engine/lib/sdl/README-touch.txt delete mode 100644 Engine/lib/sdl/README-wince.txt delete mode 100644 Engine/lib/sdl/README-windows.txt delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/Default.png delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/Demos.xcodeproj/project.pbxproj delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/Icon.png delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/Info.plist delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/README delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/kromasky_16x16.bmp delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/license.txt delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_brush_snare.wav delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_china.wav delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_kick_big_amb.wav delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_loose_skin_mute.wav delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/ship.bmp delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/space.bmp delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/data/stroke.bmp delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/accelerometer.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/common.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/common.h delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/fireworks.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/happy.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/keyboard.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/rectangles.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/SDL/SDL.xcodeproj/project.pbxproj delete mode 100644 Engine/lib/sdl/Xcode-iOS/SDLtest/SDL2test.xcodeproj/project.pbxproj delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default.png delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Icon.png delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Info.plist delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateIcon.icns delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateInfo.plist delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/project.pbxproj delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/main.c delete mode 100644 Engine/lib/sdl/Xcode-iOS/Test/Info.plist delete mode 100644 Engine/lib/sdl/Xcode-iOS/Test/README delete mode 100644 Engine/lib/sdl/Xcode-iOS/Test/TestiPhoneOS.xcodeproj/project.pbxproj delete mode 100644 Engine/lib/sdl/Xcode/SDL/pkg-support/codesign-frameworks.sh delete mode 100644 Engine/lib/sdl/android-project/AndroidManifest.xml delete mode 100644 Engine/lib/sdl/android-project/ant.properties delete mode 100644 Engine/lib/sdl/android-project/build.properties delete mode 100644 Engine/lib/sdl/android-project/build.xml delete mode 100644 Engine/lib/sdl/android-project/default.properties delete mode 100644 Engine/lib/sdl/android-project/jni/Android.mk delete mode 100644 Engine/lib/sdl/android-project/jni/Application.mk delete mode 100644 Engine/lib/sdl/android-project/jni/src/Android.mk delete mode 100644 Engine/lib/sdl/android-project/jni/src/Android_static.mk delete mode 100644 Engine/lib/sdl/android-project/proguard-project.txt delete mode 100644 Engine/lib/sdl/android-project/project.properties delete mode 100644 Engine/lib/sdl/android-project/res/drawable-hdpi/ic_launcher.png delete mode 100644 Engine/lib/sdl/android-project/res/drawable-mdpi/ic_launcher.png delete mode 100644 Engine/lib/sdl/android-project/res/drawable-xhdpi/ic_launcher.png delete mode 100644 Engine/lib/sdl/android-project/res/drawable-xxhdpi/ic_launcher.png delete mode 100644 Engine/lib/sdl/android-project/res/layout/main.xml delete mode 100644 Engine/lib/sdl/android-project/res/values/strings.xml delete mode 100644 Engine/lib/sdl/android-project/src/org/libsdl/app/SDLActivity.java create mode 100644 Engine/lib/sdl/build-scripts/checker-buildbot.sh create mode 100644 Engine/lib/sdl/build-scripts/emscripten-buildbot.sh create mode 100644 Engine/lib/sdl/build-scripts/nacl-buildbot.sh create mode 100644 Engine/lib/sdl/build-scripts/naclbuild.sh create mode 100644 Engine/lib/sdl/build-scripts/update-copyright.sh create mode 100644 Engine/lib/sdl/build-scripts/windows-buildbot-zipper.bat create mode 100644 Engine/lib/sdl/build-scripts/winrtbuild.bat create mode 100644 Engine/lib/sdl/build-scripts/winrtbuild.ps1 create mode 100644 Engine/lib/sdl/cmake_uninstall.cmake.in create mode 100644 Engine/lib/sdl/include/SDL_opengl_glext.h create mode 100644 Engine/lib/sdl/include/SDL_opengles2_gl2.h create mode 100644 Engine/lib/sdl/include/SDL_opengles2_gl2ext.h create mode 100644 Engine/lib/sdl/include/SDL_opengles2_gl2platform.h create mode 100644 Engine/lib/sdl/include/SDL_opengles2_khrplatform.h delete mode 100644 Engine/lib/sdl/include/doxyfile create mode 100644 Engine/lib/sdl/sdl2-config.cmake.in create mode 100644 Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c create mode 100644 Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.h create mode 100644 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c create mode 100644 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h create mode 100644 Engine/lib/sdl/src/audio/xaudio2/SDL_xaudio2.h create mode 100644 Engine/lib/sdl/src/core/linux/SDL_dbus.c create mode 100644 Engine/lib/sdl/src/core/linux/SDL_dbus.h create mode 100644 Engine/lib/sdl/src/core/linux/SDL_ibus.c create mode 100644 Engine/lib/sdl/src/core/linux/SDL_ibus.h rename Engine/lib/sdl/src/{audio/directsound/directx.h => core/windows/SDL_directx.h} (84%) create mode 100644 Engine/lib/sdl/src/core/windows/SDL_xinput.c rename Engine/lib/sdl/src/{joystick/windows/SDL_dxjoystick_c.h => core/windows/SDL_xinput.h} (55%) create mode 100644 Engine/lib/sdl/src/filesystem/android/SDL_sysfilesystem.c create mode 100644 Engine/lib/sdl/src/filesystem/emscripten/SDL_sysfilesystem.c rename Engine/lib/sdl/src/{joystick/iphoneos/SDLUIAccelerationDelegate.h => filesystem/nacl/SDL_sysfilesystem.c} (60%) rename Engine/lib/sdl/src/haptic/windows/{SDL_syshaptic.c => SDL_dinputhaptic.c} (52%) create mode 100644 Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic_c.h create mode 100644 Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic.c create mode 100644 Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic_c.h create mode 100644 Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic.c create mode 100644 Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic_c.h create mode 100644 Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c create mode 100644 Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick_c.h delete mode 100644 Engine/lib/sdl/src/joystick/iphoneos/SDLUIAccelerationDelegate.m create mode 100644 Engine/lib/sdl/src/joystick/iphoneos/SDL_sysjoystick_c.h create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick_c.h delete mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_dxjoystick.c create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c create mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick_c.h delete mode 100644 Engine/lib/sdl/src/joystick/winrt/SDL_xinputjoystick.c create mode 100644 Engine/lib/sdl/src/libm/k_tan.c create mode 100644 Engine/lib/sdl/src/libm/s_tan.c create mode 100644 Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c create mode 100644 Engine/lib/sdl/src/power/emscripten/SDL_syspower.c create mode 100644 Engine/lib/sdl/src/video/android/SDL_androidmessagebox.c rename Engine/lib/sdl/src/{haptic/windows/SDL_syshaptic_c.h => video/android/SDL_androidmessagebox.h} (72%) create mode 100644 Engine/lib/sdl/src/video/android/SDL_androidmouse.c create mode 100644 Engine/lib/sdl/src/video/android/SDL_androidmouse.h create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.c create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.h create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.h create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.h create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.c create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.h create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c create mode 100644 Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.h create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclevents.c create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclevents_c.h create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclglue.c create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclopengles.c create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclopengles.h create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclwindow.c create mode 100644 Engine/lib/sdl/src/video/nacl/SDL_naclwindow.h create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.c create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.h create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.c create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.h create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.c create mode 100644 Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.h create mode 100644 Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.cpp create mode 100644 Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.h create mode 100644 Engine/lib/sdl/test/COPYING create mode 100644 Engine/lib/sdl/test/Makefile.in create mode 100644 Engine/lib/sdl/test/acinclude.m4 create mode 100644 Engine/lib/sdl/test/aclocal.m4 create mode 100644 Engine/lib/sdl/test/autogen.sh create mode 100644 Engine/lib/sdl/test/axis.bmp create mode 100644 Engine/lib/sdl/test/button.bmp create mode 100644 Engine/lib/sdl/test/checkkeys.c create mode 100644 Engine/lib/sdl/test/configure create mode 100644 Engine/lib/sdl/test/configure.in create mode 100644 Engine/lib/sdl/test/controllermap.bmp create mode 100644 Engine/lib/sdl/test/controllermap.c create mode 100644 Engine/lib/sdl/test/emscripten/joystick-pre.js create mode 100644 Engine/lib/sdl/test/gcc-fat.sh rename Engine/lib/sdl/{Xcode-iOS/Demos/data => test}/icon.bmp (100%) create mode 100644 Engine/lib/sdl/test/loopwave.c create mode 100644 Engine/lib/sdl/test/loopwavequeue.c create mode 100644 Engine/lib/sdl/test/moose.dat create mode 100644 Engine/lib/sdl/test/nacl/Makefile create mode 100644 Engine/lib/sdl/test/nacl/background.js create mode 100644 Engine/lib/sdl/test/nacl/common.js create mode 100644 Engine/lib/sdl/test/nacl/index.html create mode 100644 Engine/lib/sdl/test/nacl/manifest.json create mode 100644 Engine/lib/sdl/test/picture.xbm create mode 100644 Engine/lib/sdl/test/relative_mode.markdown create mode 100644 Engine/lib/sdl/test/sample.bmp create mode 100644 Engine/lib/sdl/test/sample.wav create mode 100644 Engine/lib/sdl/test/shapes/p01_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p01_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p01_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p02_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p02_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p02_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p03_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p03_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p04_shape1.bmp create mode 100644 Engine/lib/sdl/test/shapes/p04_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p04_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p04_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p05_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p06_shape1alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p06_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p06_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p06_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p07_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p07_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p07_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p08_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p08_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p08_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p09_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p09_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p09_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p10_shape1.bmp create mode 100644 Engine/lib/sdl/test/shapes/p10_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p10_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p10_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p11_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p11_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p11_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p12_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p12_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p13_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p13_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p13_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p14_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p14_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p15_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p15_shape32alpha.bmp create mode 100644 Engine/lib/sdl/test/shapes/p15_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/p16_shape1.bmp create mode 100644 Engine/lib/sdl/test/shapes/p16_shape24.bmp create mode 100644 Engine/lib/sdl/test/shapes/p16_shape8.bmp create mode 100644 Engine/lib/sdl/test/shapes/trollface_24.bmp create mode 100644 Engine/lib/sdl/test/shapes/trollface_32alpha.bmp create mode 100644 Engine/lib/sdl/test/testatomic.c create mode 100644 Engine/lib/sdl/test/testaudiohotplug.c create mode 100644 Engine/lib/sdl/test/testaudioinfo.c create mode 100644 Engine/lib/sdl/test/testautomation.c create mode 100644 Engine/lib/sdl/test/testautomation_audio.c create mode 100644 Engine/lib/sdl/test/testautomation_clipboard.c create mode 100644 Engine/lib/sdl/test/testautomation_events.c create mode 100644 Engine/lib/sdl/test/testautomation_hints.c create mode 100644 Engine/lib/sdl/test/testautomation_keyboard.c create mode 100644 Engine/lib/sdl/test/testautomation_main.c create mode 100644 Engine/lib/sdl/test/testautomation_mouse.c create mode 100644 Engine/lib/sdl/test/testautomation_pixels.c create mode 100644 Engine/lib/sdl/test/testautomation_platform.c create mode 100644 Engine/lib/sdl/test/testautomation_rect.c create mode 100644 Engine/lib/sdl/test/testautomation_render.c create mode 100644 Engine/lib/sdl/test/testautomation_rwops.c create mode 100644 Engine/lib/sdl/test/testautomation_sdltest.c create mode 100644 Engine/lib/sdl/test/testautomation_stdlib.c create mode 100644 Engine/lib/sdl/test/testautomation_suites.h create mode 100644 Engine/lib/sdl/test/testautomation_surface.c create mode 100644 Engine/lib/sdl/test/testautomation_syswm.c create mode 100644 Engine/lib/sdl/test/testautomation_timer.c create mode 100644 Engine/lib/sdl/test/testautomation_video.c create mode 100644 Engine/lib/sdl/test/testdisplayinfo.c create mode 100644 Engine/lib/sdl/test/testdraw2.c create mode 100644 Engine/lib/sdl/test/testdrawchessboard.c create mode 100644 Engine/lib/sdl/test/testdropfile.c create mode 100644 Engine/lib/sdl/test/testerror.c create mode 100644 Engine/lib/sdl/test/testfile.c create mode 100644 Engine/lib/sdl/test/testfilesystem.c create mode 100644 Engine/lib/sdl/test/testgamecontroller.c create mode 100644 Engine/lib/sdl/test/testgesture.c create mode 100644 Engine/lib/sdl/test/testgl2.c create mode 100644 Engine/lib/sdl/test/testgles.c create mode 100644 Engine/lib/sdl/test/testgles2.c create mode 100644 Engine/lib/sdl/test/testhaptic.c create mode 100644 Engine/lib/sdl/test/testhittesting.c create mode 100644 Engine/lib/sdl/test/testhotplug.c create mode 100644 Engine/lib/sdl/test/testiconv.c create mode 100644 Engine/lib/sdl/test/testime.c create mode 100644 Engine/lib/sdl/test/testintersections.c create mode 100644 Engine/lib/sdl/test/testjoystick.c create mode 100644 Engine/lib/sdl/test/testkeys.c create mode 100644 Engine/lib/sdl/test/testloadso.c create mode 100644 Engine/lib/sdl/test/testlock.c create mode 100644 Engine/lib/sdl/test/testmessage.c create mode 100644 Engine/lib/sdl/test/testmultiaudio.c create mode 100644 Engine/lib/sdl/test/testnative.c create mode 100644 Engine/lib/sdl/test/testnative.h create mode 100644 Engine/lib/sdl/test/testnativecocoa.m create mode 100644 Engine/lib/sdl/test/testnativew32.c create mode 100644 Engine/lib/sdl/test/testnativex11.c create mode 100644 Engine/lib/sdl/test/testoverlay2.c create mode 100644 Engine/lib/sdl/test/testplatform.c create mode 100644 Engine/lib/sdl/test/testpower.c create mode 100644 Engine/lib/sdl/test/testrelative.c create mode 100644 Engine/lib/sdl/test/testrendercopyex.c create mode 100644 Engine/lib/sdl/test/testrendertarget.c create mode 100644 Engine/lib/sdl/test/testresample.c create mode 100644 Engine/lib/sdl/test/testrumble.c create mode 100644 Engine/lib/sdl/test/testscale.c create mode 100644 Engine/lib/sdl/test/testsem.c create mode 100644 Engine/lib/sdl/test/testshader.c create mode 100644 Engine/lib/sdl/test/testshape.c create mode 100644 Engine/lib/sdl/test/testsprite2.c create mode 100644 Engine/lib/sdl/test/testspriteminimal.c create mode 100644 Engine/lib/sdl/test/teststreaming.c create mode 100644 Engine/lib/sdl/test/testthread.c create mode 100644 Engine/lib/sdl/test/testtimer.c create mode 100644 Engine/lib/sdl/test/testver.c create mode 100644 Engine/lib/sdl/test/testviewport.c create mode 100644 Engine/lib/sdl/test/testwm2.c create mode 100644 Engine/lib/sdl/test/torturethread.c create mode 100644 Engine/lib/sdl/test/utf8.txt diff --git a/Engine/lib/sdl/Android.mk b/Engine/lib/sdl/Android.mk index 4f9408204..13d765f57 100644 --- a/Engine/lib/sdl/Android.mk +++ b/Engine/lib/sdl/Android.mk @@ -34,7 +34,7 @@ LOCAL_SRC_FILES := \ $(wildcard $(LOCAL_PATH)/src/loadso/dlopen/*.c) \ $(wildcard $(LOCAL_PATH)/src/power/*.c) \ $(wildcard $(LOCAL_PATH)/src/power/android/*.c) \ - $(wildcard $(LOCAL_PATH)/src/filesystem/dummy/*.c) \ + $(wildcard $(LOCAL_PATH)/src/filesystem/android/*.c) \ $(wildcard $(LOCAL_PATH)/src/render/*.c) \ $(wildcard $(LOCAL_PATH)/src/render/*/*.c) \ $(wildcard $(LOCAL_PATH)/src/stdlib/*.c) \ @@ -44,7 +44,7 @@ LOCAL_SRC_FILES := \ $(wildcard $(LOCAL_PATH)/src/timer/unix/*.c) \ $(wildcard $(LOCAL_PATH)/src/video/*.c) \ $(wildcard $(LOCAL_PATH)/src/video/android/*.c) \ - $(wildcard $(LOCAL_PATH)/src/test/*.c)) + $(wildcard $(LOCAL_PATH)/src/test/*.c)) LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES LOCAL_LDLIBS := -ldl -lGLESv1_CM -lGLESv2 -llog -landroid @@ -61,7 +61,7 @@ LOCAL_MODULE := SDL2_static LOCAL_MODULE_FILENAME := libSDL2 -LOCAL_SRC_FILES += $(LOCAL_PATH)/src/main/android/SDL_android_main.c +LOCAL_SRC_FILES += $(subst $(LOCAL_PATH)/,,$(LOCAL_PATH)/src/main/android/SDL_android_main.c) LOCAL_LDLIBS := LOCAL_EXPORT_LDLIBS := -Wl,--undefined=Java_org_libsdl_app_SDLActivity_nativeInit -ldl -lGLESv1_CM -lGLESv2 -llog -landroid diff --git a/Engine/lib/sdl/CMakeLists.txt b/Engine/lib/sdl/CMakeLists.txt index 75a89378b..74356b60f 100644 --- a/Engine/lib/sdl/CMakeLists.txt +++ b/Engine/lib/sdl/CMakeLists.txt @@ -2,7 +2,7 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR}) message(FATAL_ERROR "Prevented in-tree built. Please create a build directory outside of the SDL source code and call cmake from there") endif() -cmake_minimum_required(VERSION 2.6) +cmake_minimum_required(VERSION 2.8) project(SDL2 C) include(CheckFunctionExists) include(CheckLibraryExists) @@ -29,9 +29,9 @@ include(${SDL2_SOURCE_DIR}/cmake/sdlchecks.cmake) # set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0. set(SDL_MAJOR_VERSION 2) set(SDL_MINOR_VERSION 0) -set(SDL_MICRO_VERSION 3) -set(SDL_INTERFACE_AGE 1) -set(SDL_BINARY_AGE 3) +set(SDL_MICRO_VERSION 4) +set(SDL_INTERFACE_AGE 0) +set(SDL_BINARY_AGE 4) set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}") # Calculate a libtool-like version number @@ -117,6 +117,12 @@ else() set(UNIX_OR_MAC_SYS OFF) endif() +if (UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN) # JavaScript does not yet have threading support, so disable pthreads when building for Emscripten. + set(SDL_PTHREADS_ENABLED_BY_DEFAULT ON) +else() + set(SDL_PTHREADS_ENABLED_BY_DEFAULT OFF) +endif() + # Default option knobs if(APPLE OR ARCH_64) set(OPT_DEF_SSEMATH ON) @@ -144,7 +150,7 @@ if("$ENV{CFLAGS}" STREQUAL "") if(USE_GCC OR USE_CLANG) set(CMAKE_C_FLAGS "-g -O3") endif() -else("$ENV{CFLAGS}" STREQUAL "") +else() set(CMAKE_C_FLAGS "$ENV{CFLAGS}") list(APPEND EXTRA_CFLAGS "$ENV{CFLAGS}") endif() @@ -161,8 +167,15 @@ if(MSVC) if(${flag_var} MATCHES "/MD") string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") endif() - endforeach(flag_var) + endforeach() endif() + + # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT + foreach(flag_var + CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE + CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO) + string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}") + endforeach(flag_var) endif() # Those are used for pkg-config and friends, so that the SDL2.pc, sdl2-config, @@ -170,13 +183,19 @@ endif() set(SDL_LIBS "-lSDL2") set(SDL_CFLAGS "") +# Emscripten toolchain has a nonempty default value for this, and the checks +# in this file need to change that, so remember the original value, and +# restore back to that afterwards. For check_function_exists() to work in +# Emscripten, this value must be at its default value. +set(ORIG_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) + if(CYGWIN) # We build SDL on cygwin without the UNIX emulation layer include_directories("-I/usr/include/mingw") set(CMAKE_REQUIRED_FLAGS "-mno-cygwin") check_c_source_compiles("int main(int argc, char **argv) {}" HAVE_GCC_NO_CYGWIN) - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) if(HAVE_GCC_NO_CYGWIN) list(APPEND EXTRA_LDFLAGS "-mno-cygwin") list(APPEND SDL_LIBS "-mno-cygwin") @@ -188,12 +207,35 @@ add_definitions(-DUSING_GENERATED_CONFIG_H) # General includes include_directories(${SDL2_BINARY_DIR}/include ${SDL2_SOURCE_DIR}/include) +# All these ENABLED_BY_DEFAULT vars will default to ON if not specified, so +# you only need to have a platform override them if they are disabling. +set(OPT_DEF_ASM TRUE) +if(EMSCRIPTEN) + # Set up default values for the currently supported set of subsystems: + # Emscripten/Javascript does not have assembly support, a dynamic library + # loading architecture, low-level CPU inspection or multithreading. + set(OPT_DEF_ASM FALSE) + set(SDL_SHARED_ENABLED_BY_DEFAULT OFF) + set(SDL_ATOMIC_ENABLED_BY_DEFAULT OFF) + set(SDL_THREADS_ENABLED_BY_DEFAULT OFF) + set(SDL_LOADSO_ENABLED_BY_DEFAULT OFF) + set(SDL_CPUINFO_ENABLED_BY_DEFAULT OFF) + set(SDL_DLOPEN_ENABLED_BY_DEFAULT OFF) +endif() + +if (NOT DEFINED SDL_SHARED_ENABLED_BY_DEFAULT) + set(SDL_SHARED_ENABLED_BY_DEFAULT ON) +endif() + set(SDL_SUBSYSTEMS Atomic Audio Video Render Events Joystick Haptic Power Threads Timers - File Loadso CPUinfo Filesystem) + File Loadso CPUinfo Filesystem Dlopen) foreach(_SUB ${SDL_SUBSYSTEMS}) string(TOUPPER ${_SUB} _OPT) - option(SDL_${_OPT} "Enable the ${_SUB} subsystem" ON) + if (NOT DEFINED SDL_${_OPT}_ENABLED_BY_DEFAULT) + set(SDL_${_OPT}_ENABLED_BY_DEFAULT ON) + endif() + option(SDL_${_OPT} "Enable the ${_SUB} subsystem" ${SDL_${_OPT}_ENABLED_BY_DEFAULT}) endforeach() option_string(ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto") @@ -212,13 +254,13 @@ set_option(DUMMYAUDIO "Support the dummy audio driver" ON) set_option(VIDEO_DIRECTFB "Use DirectFB video driver" OFF) dep_option(DIRECTFB_SHARED "Dynamically load directfb support" ON "VIDEO_DIRECTFB" OFF) set_option(FUSIONSOUND "Use FusionSound audio driver" OFF) -dep_option(FUSIONSOUND_SHARED "Dynamically load fusionsound audio support" ON "FUSIONSOUND_SHARED" OFF) +dep_option(FUSIONSOUND_SHARED "Dynamically load fusionsound audio support" ON "FUSIONSOUND" OFF) set_option(VIDEO_DUMMY "Use dummy video driver" ON) set_option(VIDEO_OPENGL "Include OpenGL support" ON) set_option(VIDEO_OPENGLES "Include OpenGL ES support" ON) -set_option(PTHREADS "Use POSIX threads for multi-threading" ${UNIX_OR_MAC_SYS}) +set_option(PTHREADS "Use POSIX threads for multi-threading" ${SDL_PTHREADS_ENABLED_BY_DEFAULT}) dep_option(PTHREADS_SEM "Use pthread semaphores" ON "PTHREADS" OFF) -set_option(SDL_DLOPEN "Use dlopen for shared object loading" ON) +set_option(SDL_DLOPEN "Use dlopen for shared object loading" ${SDL_DLOPEN_ENABLED_BY_DEFAULT}) set_option(OSS "Support the OSS audio API" ${UNIX_SYS}) set_option(ALSA "Support the ALSA audio API" ${UNIX_SYS}) dep_option(ALSA_SHARED "Dynamically load ALSA audio support" ON "ALSA" OFF) @@ -235,8 +277,12 @@ set_option(RPATH "Use an rpath when linking SDL" ${UNIX_SYS}) set_option(CLOCK_GETTIME "Use clock_gettime() instead of gettimeofday()" OFF) set_option(INPUT_TSLIB "Use the Touchscreen library for input" ${UNIX_SYS}) set_option(VIDEO_X11 "Use X11 video driver" ${UNIX_SYS}) -set_option(VIDEO_WAYLAND "Use Wayland video driver" OFF) #${UNIX_SYS}) -set_option(VIDEO_MIR "Use Mir video driver" OFF) #${UNIX_SYS}) +set_option(VIDEO_WAYLAND "Use Wayland video driver" ${UNIX_SYS}) +dep_option(WAYLAND_SHARED "Dynamically load Wayland support" ON "VIDEO_WAYLAND" OFF) +dep_option(VIDEO_WAYLAND_QT_TOUCH "QtWayland server support for Wayland video driver" ON "VIDEO_WAYLAND" OFF) +set_option(VIDEO_MIR "Use Mir video driver" ${UNIX_SYS}) +dep_option(MIR_SHARED "Dynamically load Mir support" ON "VIDEO_MIR" OFF) +set_option(VIDEO_RPI "Use Raspberry Pi video driver" ${UNIX_SYS}) dep_option(X11_SHARED "Dynamically load X11 support" ON "VIDEO_X11" OFF) set(SDL_X11_OPTIONS Xcursor Xinerama XInput Xrandr Xscrnsaver XShape Xvm) foreach(_SUB ${SDL_X11_OPTIONS}) @@ -246,10 +292,11 @@ endforeach() set_option(VIDEO_COCOA "Use Cocoa video driver" ${APPLE}) set_option(DIRECTX "Use DirectX for Windows audio/video" ${WINDOWS}) set_option(RENDER_D3D "Enable the Direct3D render driver" ${WINDOWS}) +set_option(VIDEO_VIVANTE "Use Vivante EGL video driver" ${UNIX_SYS}) # TODO: We should (should we?) respect cmake's ${BUILD_SHARED_LIBS} flag here # The options below are for compatibility to configure's default behaviour. -set(SDL_SHARED ON CACHE BOOL "Build a shared version of the library") +set(SDL_SHARED ${SDL_SHARED_ENABLED_BY_DEFAULT} CACHE BOOL "Build a shared version of the library") set(SDL_STATIC ON CACHE BOOL "Build a static version of the library") # General source files @@ -315,7 +362,7 @@ if(USE_GCC OR USE_CLANG) set(CMAKE_REQUIRED_FLAGS "-mpreferred-stack-boundary=2") check_c_source_compiles("int x = 0; int main(int argc, char **argv) {}" HAVE_GCC_PREFERRED_STACK_BOUNDARY) - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) set(CMAKE_REQUIRED_FLAGS "-fvisibility=hidden -Werror") check_c_source_compiles(" @@ -326,14 +373,26 @@ if(USE_GCC OR USE_CLANG) if(HAVE_GCC_FVISIBILITY) list(APPEND EXTRA_CFLAGS "-fvisibility=hidden") endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) check_c_compiler_flag(-Wall HAVE_GCC_WALL) if(HAVE_GCC_WALL) + list(APPEND EXTRA_CFLAGS "-Wall") if(HAIKU) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-multichar") endif() endif() + check_c_compiler_flag(-Wshadow HAVE_GCC_WSHADOW) + if(HAVE_GCC_WSHADOW) + list(APPEND EXTRA_CFLAGS "-Wshadow") + endif() + + set(CMAKE_REQUIRED_FLAGS "-Wl,--no-undefined") + check_c_compiler_flag("" HAVE_NO_UNDEFINED) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) + if(HAVE_NO_UNDEFINED) + list(APPEND EXTRA_LDFLAGS "-Wl,--no-undefined") + endif() endif() if(ASSEMBLY) @@ -362,7 +421,7 @@ if(ASSEMBLY) if(HAVE_MMX) list(APPEND EXTRA_CFLAGS "-mmmx") endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) endif() if(3DNOW) @@ -379,7 +438,7 @@ if(ASSEMBLY) if(HAVE_3DNOW) list(APPEND EXTRA_CFLAGS "-m3dnow") endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) endif() if(SSE) @@ -402,7 +461,7 @@ if(ASSEMBLY) if(HAVE_SSE) list(APPEND EXTRA_CFLAGS "-msse") endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) endif() if(SSE2) @@ -425,7 +484,7 @@ if(ASSEMBLY) if(HAVE_SSE2) list(APPEND EXTRA_CFLAGS "-msse2") endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) endif() if(SSEMATH) @@ -450,7 +509,7 @@ if(ASSEMBLY) return vec_splat_u32(0); } int main(int argc, char **argv) { }" HAVE_ALTIVEC) - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) if(HAVE_ALTIVEC OR HAVE_ALTIVEC_H_HDR) set(HAVE_ALTIVEC TRUE) # if only HAVE_ALTIVEC_H_HDR is set list(APPEND EXTRA_CFLAGS "-maltivec") @@ -472,7 +531,7 @@ if(ASSEMBLY) set(SDL_ASSEMBLY_ROUTINES 1) endif() # TODO: -#else(ASSEMBLY) +#else() # if(USE_GCC OR USE_CLANG) # list(APPEND EXTRA_CFLAGS "-mno-sse" "-mno-sse2" "-mno-mmx") # endif() @@ -494,7 +553,7 @@ if(LIBC) strlen _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa _ultoa strtol strtoul strtoll strtod atoi atof strcmp strncmp _stricmp _strnicmp sscanf atan atan2 acos asin ceil copysign cos - cosf fabs floor log pow scalbn sin sinf sqrt) + cosf fabs floor log pow scalbn sin sinf sqrt sqrtf tan tanf) string(TOUPPER ${_FN} _UPPER) set(HAVE_${_UPPER} 1) endforeach() @@ -504,7 +563,7 @@ if(LIBC) set(HAVE_M_PI 1) add_definitions(-D_USE_MATH_DEFINES) # needed for M_PI set(STDC_HEADERS 1) - else(WINDOWS AND NOT MINGW) + else() set(HAVE_LIBC TRUE) check_include_file(sys/types.h HAVE_SYS_TYPES_H) foreach(_HEADER @@ -541,7 +600,7 @@ if(LIBC) set(CMAKE_REQUIRED_LIBRARIES m) foreach(_FN atan atan2 ceil copysign cos cosf fabs floor log pow scalbn sin - sinf sqrt) + sinf sqrt sqrtf tan tanf acos asin) string(TOUPPER ${_FN} _UPPER) set(_HAVEVAR "HAVE_${_UPPER}") check_function_exists("${_FN}" ${_HAVEVAR}) @@ -553,11 +612,20 @@ if(LIBC) check_library_exists(iconv iconv_open "" HAVE_LIBICONV) if(HAVE_LIBICONV) list(APPEND EXTRA_LIBS iconv) + set(HAVE_ICONV 1) + endif() + + if(NOT APPLE) + check_include_file(alloca.h HAVE_ALLOCA_H) + check_function_exists(alloca HAVE_ALLOCA) + else() + set(HAVE_ALLOCA_H 1) + set(HAVE_ALLOCA 1) endif() check_struct_has_member("struct sigaction" "sa_sigaction" "signal.h" HAVE_SA_SIGACTION) endif() -else(LIBC) +else() if(WINDOWS) set(HAVE_STDARG_H 1) set(HAVE_STDDEF_H 1) @@ -627,8 +695,96 @@ if(SDL_VIDEO) endif() endif() +if(ANDROID) + file(GLOB ANDROID_CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_CORE_SOURCES}) + file(GLOB ANDROID_MAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_MAIN_SOURCES}) + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_ANDROID 1) + file(GLOB ANDROID_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_AUDIO_SOURCES}) + set(HAVE_SDL_AUDIO TRUE) + endif() + if(SDL_FILESYSTEM) + set(SDL_FILESYSTEM_ANDROID 1) + file(GLOB ANDROID_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_FILESYSTEM_SOURCES}) + set(HAVE_SDL_FILESYSTEM TRUE) + endif() + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_ANDROID 1) + file(GLOB ANDROID_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_JOYSTICK_SOURCES}) + set(HAVE_SDL_JOYSTICK TRUE) + endif() + if(SDL_POWER) + set(SDL_POWER_ANDROID 1) + file(GLOB ANDROID_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_POWER_SOURCES}) + set(HAVE_SDL_POWER TRUE) + endif() + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_ANDROID 1) + file(GLOB ANDROID_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/android/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_VIDEO_SOURCES}) + set(HAVE_SDL_VIDEO TRUE) + + #enable gles + if(VIDEO_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(HAVE_VIDEO_OPENGLES TRUE) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + endif() + endif() + list(APPEND EXTRA_LDFLAGS "-Wl,--undefined=Java_org_libsdl_app_SDLActivity_nativeInit") +endif() + # Platform-specific options and settings -if(UNIX AND NOT APPLE) +if(EMSCRIPTEN) + # Hide noisy warnings that intend to aid mostly during initial stages of porting a new + # project. Uncomment at will for verbose cross-compiling -I/../ path info. + add_definitions(-Wno-warn-absolute-paths) + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_EMSCRIPTEN 1) + file(GLOB EM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/emscripten/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${EM_AUDIO_SOURCES}) + set(HAVE_SDL_AUDIO TRUE) + endif() + if(SDL_FILESYSTEM) + set(SDL_FILESYSTEM_EMSCRIPTEN 1) + file(GLOB EM_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/emscripten/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${EM_FILESYSTEM_SOURCES}) + set(HAVE_SDL_FILESYSTEM TRUE) + endif() + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_EMSCRIPTEN 1) + file(GLOB EM_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/emscripten/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${EM_JOYSTICK_SOURCES}) + set(HAVE_SDL_JOYSTICK TRUE) + endif() + if(SDL_POWER) + set(SDL_POWER_EMSCRIPTEN 1) + file(GLOB EM_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/emscripten/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${EM_POWER_SOURCES}) + set(HAVE_SDL_POWER TRUE) + endif() + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_EMSCRIPTEN 1) + file(GLOB EM_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/emscripten/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${EM_VIDEO_SOURCES}) + set(HAVE_SDL_VIDEO TRUE) + + #enable gles + if(VIDEO_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(HAVE_VIDEO_OPENGLES TRUE) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + endif() + endif() +elseif(UNIX AND NOT APPLE) if(SDL_AUDIO) if(SYSV5 OR SOLARIS OR HPUX) set(SDL_AUDIO_DRIVER_SUNAUDIO 1) @@ -657,12 +813,15 @@ if(UNIX AND NOT APPLE) endif() if(SDL_VIDEO) + # Need to check for Raspberry PI first and add platform specific compiler flags, otherwise the test for GLES fails! + CheckRPI() CheckX11() CheckMir() CheckDirectFB() CheckOpenGLX11() CheckOpenGLESX11() CheckWayland() + CheckVivante() endif() if(LINUX) @@ -720,7 +879,7 @@ if(UNIX AND NOT APPLE) if(SDL_JOYSTICK) CheckUSBHID() # seems to be BSD specific - limit the test to BSD only? - if(LINUX) + if(LINUX AND NOT ANDROID) set(SDL_JOYSTICK_LINUX 1) file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/linux/*.c) set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES}) @@ -735,7 +894,7 @@ if(UNIX AND NOT APPLE) if(FOUND_CLOCK_GETTIME) list(APPEND EXTRA_LIBS rt) set(HAVE_CLOCK_GETTIME 1) - else(FOUND_CLOCK_GETTIME) + else() check_library_exists(c clock_gettime "" FOUND_CLOCK_GETTIME) if(FOUND_CLOCK_GETTIME) set(HAVE_CLOCK_GETTIME 1) @@ -792,25 +951,52 @@ elseif(WINDOWS) file(GLOB CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/windows/*.c) set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES}) + if(MSVC) + # Prevent codegen that would use the VC runtime libraries. + add_definitions(/GS-) + if(NOT ARCH_64) + add_definitions(/arch:SSE) + endif() + endif() + # Check for DirectX if(DIRECTX) - if("$ENV{DXSDK_DIR}" STREQUAL "") - message_error("DIRECTX requires the \$DXSDK_DIR environment variable to be set") + if(DEFINED MSVC_VERSION AND NOT ${MSVC_VERSION} LESS 1700) + set(USE_WINSDK_DIRECTX TRUE) endif() - set(CMAKE_REQUIRED_FLAGS "/I\"$ENV{DXSDK_DIR}\\Include\"") + if(NOT CMAKE_COMPILER_IS_MINGW AND NOT USE_WINSDK_DIRECTX) + if("$ENV{DXSDK_DIR}" STREQUAL "") + message_error("DIRECTX requires the \$DXSDK_DIR environment variable to be set") + endif() + set(CMAKE_REQUIRED_FLAGS "/I\"$ENV{DXSDK_DIR}\\Include\"") + endif() + + if(HAVE_WIN32_CC) + # xinput.h may need windows.h, but doesn't include it itself. + check_c_source_compiles(" + #include + #include + int main(int argc, char **argv) { }" HAVE_XINPUT_H) + else() + check_include_file(xinput.h HAVE_XINPUT_H) + endif() + check_include_file(d3d9.h HAVE_D3D_H) check_include_file(d3d11_1.h HAVE_D3D11_H) check_include_file(ddraw.h HAVE_DDRAW_H) check_include_file(dsound.h HAVE_DSOUND_H) check_include_file(dinput.h HAVE_DINPUT_H) check_include_file(xaudio2.h HAVE_XAUDIO2_H) + check_include_file(dxgi.h HAVE_DXGI_H) if(HAVE_D3D_H OR HAVE_D3D11_H OR HAVE_DDRAW_H OR HAVE_DSOUND_H OR HAVE_DINPUT_H OR HAVE_XAUDIO2_H) set(HAVE_DIRECTX TRUE) + if(NOT CMAKE_COMPILER_IS_MINGW AND NOT USE_WINSDK_DIRECTX) # TODO: change $ENV{DXSDL_DIR} to get the path from the include checks - link_directories($ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH}) - include_directories($ENV{DXSDK_DIR}\\Include) + link_directories($ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH}) + include_directories($ENV{DXSDK_DIR}\\Include) + endif() endif() - set(CMAKE_REQUIRED_FLAGS) + set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS}) endif() if(SDL_AUDIO) @@ -905,24 +1091,51 @@ elseif(WINDOWS) set(SDL_VIDEO_RENDER_OGL 1) set(HAVE_VIDEO_OPENGL TRUE) endif() + + if(VIDEO_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + set(HAVE_VIDEO_OPENGLES TRUE) + endif() endif() if(SDL_JOYSTICK) + file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/windows/*.c) + set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES}) if(HAVE_DINPUT_H) set(SDL_JOYSTICK_DINPUT 1) - set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/joystick/windows/SDL_dxjoystick.c) - list(APPEND EXTRA_LIBS dinput8 dxguid dxerr) - else() + list(APPEND EXTRA_LIBS dinput8 dxguid) + if(CMAKE_COMPILER_IS_MINGW) + list(APPEND EXTRA_LIBS dxerr8) + elseif (NOT USE_WINSDK_DIRECTX) + list(APPEND EXTRA_LIBS dxerr) + endif() + endif() + if(HAVE_XINPUT_H) + set(SDL_JOYSTICK_XINPUT 1) + endif() + if(NOT HAVE_DINPUT_H AND NOT HAVE_XINPUT_H) set(SDL_JOYSTICK_WINMM 1) - set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/joystick/windows/SDL_mmjoystick.c) endif() set(HAVE_SDL_JOYSTICK TRUE) - endif() - if(SDL_HAPTIC AND HAVE_DINPUT_H) - set(SDL_HAPTIC_DINPUT 1) - set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/haptic/windows/SDL_syshaptic.c) - set(HAVE_SDL_HAPTIC TRUE) + if(SDL_HAPTIC) + if(HAVE_DINPUT_H OR HAVE_XINPUT_H) + file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/windows/*.c) + if(HAVE_DINPUT_H) + set(SDL_HAPTIC_DINPUT 1) + endif() + if(HAVE_XINPUT_H) + set(SDL_HAPTIC_XINPUT 1) + endif() + else() + file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/dummy/*.c) + set(SDL_HAPTIC_DUMMY 1) + endif() + set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES}) + set(HAVE_SDL_HAPTIC TRUE) + endif() endif() file(GLOB VERSION_SOURCES ${SDL2_SOURCE_DIR}/src/main/windows/*.rc) @@ -938,17 +1151,18 @@ elseif(APPLE) # Requires the darwin file implementation if(SDL_FILE) - file(GLOB EXTRA_SOURCES ${PROJECT_SOURCE_DIR}/src/file/cocoa/*.m) + file(GLOB EXTRA_SOURCES ${SDL2_SOURCE_DIR}/src/file/cocoa/*.m) set(SOURCE_FILES ${EXTRA_SOURCES} ${SOURCE_FILES}) set_source_files_properties(${EXTRA_SOURCES} PROPERTIES LANGUAGE C) set(HAVE_SDL_FILE TRUE) set(SDL_FRAMEWORK_COCOA 1) + set(SDL_FRAMEWORK_COREVIDEO 1) else() message_error("SDL_FILE must be enabled to build on MacOS X") endif() if(SDL_AUDIO) - set(MACOSX_COREAUDIO 1) + set(SDL_AUDIO_DRIVER_COREAUDIO 1) file(GLOB AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/coreaudio/*.c) set(SOURCE_FILES ${SOURCE_FILES} ${AUDIO_SOURCES}) set(HAVE_SDL_AUDIO TRUE) @@ -1002,6 +1216,10 @@ elseif(APPLE) endif() # Actually load the frameworks at the end so we don't duplicate include. + if(SDL_FRAMEWORK_COREVIDEO) + find_library(COREVIDEO CoreVideo) + list(APPEND EXTRA_LIBS ${COREVIDEO}) + endif() if(SDL_FRAMEWORK_COCOA) find_library(COCOA_LIBRARY Cocoa) list(APPEND EXTRA_LIBS ${COCOA_LIBRARY}) @@ -1034,10 +1252,6 @@ elseif(APPLE) set(SDL_VIDEO_OPENGL 1) set(SDL_VIDEO_OPENGL_CGL 1) set(SDL_VIDEO_RENDER_OGL 1) - if(DARWIN) - find_library(OpenGL_LIBRARY OpenGL) - list(APPEND EXTRA_LIBRARIES ${OpenGL_LIBRARY}) - endif() set(HAVE_VIDEO_OPENGL TRUE) endif() endif() @@ -1159,14 +1373,14 @@ if(NOT WINDOWS OR CYGWIN) if(SDL_STATIC) set(ENABLE_STATIC_TRUE "") set(ENABLE_STATIC_FALSE "#") - else(SDL_STATIC) + else() set(ENABLE_STATIC_TRUE "#") set(ENABLE_STATIC_FALSE "") endif() if(SDL_SHARED) set(ENABLE_SHARED_TRUE "") set(ENABLE_SHARED_FALSE "#") - else(SDL_SHARED) + else() set(ENABLE_SHARED_TRUE "#") set(ENABLE_SHARED_FALSE "") endif() @@ -1247,14 +1461,20 @@ if(SDL_SHARED) VERSION ${LT_VERSION} SOVERSION ${LT_REVISION} OUTPUT_NAME "SDL2-${LT_RELEASE}") - else(UNIX) + else() set_target_properties(SDL2 PROPERTIES VERSION ${SDL_VERSION} SOVERSION ${LT_REVISION} OUTPUT_NAME "SDL2") endif() - set(_INSTALL_LIBS "SDL2" ${_INSTALL_LIBS}) - target_link_libraries(SDL2 ${EXTRA_LIBS} ${EXTRA_LDFLAGS}) + if(MSVC) + # Don't try to link with the default set of libraries. + set_target_properties(SDL2 PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB") + set_target_properties(SDL2 PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB") + set_target_properties(SDL2 PROPERTIES STATIC_LIBRARY_FLAGS "/NODEFAULTLIB") + endif() + set(_INSTALL_LIBS "SDL2" ${_INSTALL_LIBS}) + target_link_libraries(SDL2 ${EXTRA_LIBS} ${EXTRA_LDFLAGS}) endif() if(SDL_STATIC) @@ -1275,7 +1495,8 @@ endif() ##### Installation targets ##### install(TARGETS ${_INSTALL_LIBS} LIBRARY DESTINATION "lib${LIB_SUFFIX}" - ARCHIVE DESTINATION "lib${LIB_SUFFIX}") + ARCHIVE DESTINATION "lib${LIB_SUFFIX}" + RUNTIME DESTINATION bin) file(GLOB INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/*.h) file(GLOB BIN_INCLUDE_FILES ${SDL2_BINARY_DIR}/include/*.h) @@ -1296,14 +1517,21 @@ if(NOT WINDOWS OR CYGWIN) if(FREEBSD) # FreeBSD uses ${PREFIX}/libdata/pkgconfig install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "libdata/pkgconfig") - else(FREEBSD) + else() install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "lib${LIB_SUFFIX}/pkgconfig") endif() install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION bin) # TODO: what about the .spec file? Is it only needed for RPM creation? install(FILES "${SDL2_SOURCE_DIR}/sdl2.m4" DESTINATION "share/aclocal") -else() - install(TARGETS SDL2 RUNTIME DESTINATION bin) endif() +##### Uninstall target ##### + +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + +add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) diff --git a/Engine/lib/sdl/COPYING.txt b/Engine/lib/sdl/COPYING.txt index a17cd0dcf..dd9574e06 100644 --- a/Engine/lib/sdl/COPYING.txt +++ b/Engine/lib/sdl/COPYING.txt @@ -1,6 +1,6 @@ Simple DirectMedia Layer -Copyright (C) 1997-2014 Sam Lantinga +Copyright (C) 1997-2016 Sam Lantinga This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages diff --git a/Engine/lib/sdl/INSTALL.txt b/Engine/lib/sdl/INSTALL.txt index 5bd27c51f..66e5706f7 100644 --- a/Engine/lib/sdl/INSTALL.txt +++ b/Engine/lib/sdl/INSTALL.txt @@ -9,7 +9,7 @@ To compile and install SDL: * Run './configure; make; make install' Mac OS X with Xcode: - * Read README-macosx.txt + * Read docs/README-macosx.md Mac OS X from the command line: * Run './configure; make; make install' @@ -18,13 +18,13 @@ To compile and install SDL: * Run './configure; make; make install' Android: - * Read README-android.txt + * Read docs/README-android.md iOS: - * Read README-ios.txt + * Read docs/README-ios.md Using Cmake: - * Read README-cmake.txt + * Read docs/README-cmake.md 2. Look at the example programs in ./test, and check out the online documentation at http://wiki.libsdl.org/ diff --git a/Engine/lib/sdl/Makefile.in b/Engine/lib/sdl/Makefile.in index da42661c5..b66e0f5e2 100644 --- a/Engine/lib/sdl/Makefile.in +++ b/Engine/lib/sdl/Makefile.in @@ -39,18 +39,28 @@ SDLMAIN_OBJECTS = @SDLMAIN_OBJECTS@ SDLTEST_TARGET = libSDL2_test.a SDLTEST_OBJECTS = @SDLTEST_OBJECTS@ -SRC_DIST = *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake configure configure.in debian include Makefile.* sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in src test VisualC.html VisualC Xcode Xcode-iOS +SRC_DIST = *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake cmake_uninstall.cmake.in configure configure.in debian docs include Makefile.* sdl2-config.cmake.in sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in src test VisualC.html VisualC VisualC-WinRT Xcode Xcode-iOS GEN_DIST = SDL2.spec +ifneq ($V,1) +RUN_CMD_AR = @echo " AR " $@; +RUN_CMD_CC = @echo " CC " $@; +RUN_CMD_CXX = @echo " CXX " $@; +RUN_CMD_LTLINK = @echo " LTLINK" $@; +RUN_CMD_RANLIB = @echo " RANLIB" $@; +LIBTOOL += --quiet +endif + HDRS = \ SDL.h \ SDL_assert.h \ SDL_atomic.h \ SDL_audio.h \ - SDL_bits.h \ + SDL_bits.h \ SDL_blendmode.h \ SDL_clipboard.h \ SDL_cpuinfo.h \ + SDL_egl.h \ SDL_endian.h \ SDL_error.h \ SDL_events.h \ @@ -70,8 +80,13 @@ HDRS = \ SDL_mutex.h \ SDL_name.h \ SDL_opengl.h \ + SDL_opengl_glext.h \ SDL_opengles.h \ + SDL_opengles2_gl2ext.h \ + SDL_opengles2_gl2.h \ + SDL_opengles2_gl2platform.h \ SDL_opengles2.h \ + SDL_opengles2_khrplatform.h \ SDL_pixels.h \ SDL_platform.h \ SDL_power.h \ @@ -123,15 +138,15 @@ update-revision: .PHONY: all update-revision install install-bin install-hdrs install-lib install-data uninstall uninstall-bin uninstall-hdrs uninstall-lib uninstall-data clean distclean dist $(OBJECTS:.lo=.d) $(objects)/$(TARGET): $(OBJECTS) $(VERSION_OBJECTS) - $(LIBTOOL) --mode=link $(CC) -o $@ $(OBJECTS) $(VERSION_OBJECTS) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LT_LDFLAGS) + $(RUN_CMD_LTLINK)$(LIBTOOL) --tag=CC --mode=link $(CC) -o $@ $(OBJECTS) $(VERSION_OBJECTS) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LT_LDFLAGS) $(objects)/$(SDLMAIN_TARGET): $(SDLMAIN_OBJECTS) - $(AR) cru $@ $(SDLMAIN_OBJECTS) - $(RANLIB) $@ + $(RUN_CMD_AR)$(AR) cru $@ $(SDLMAIN_OBJECTS) + $(RUN_CMD_RANLIB)$(RANLIB) $@ $(objects)/$(SDLTEST_TARGET): $(SDLTEST_OBJECTS) - $(AR) cru $@ $(SDLTEST_OBJECTS) - $(RANLIB) $@ + $(RUN_CMD_AR)$(AR) cru $@ $(SDLTEST_OBJECTS) + $(RUN_CMD_RANLIB)$(RANLIB) $@ install: all install-bin install-hdrs install-lib install-data install-bin: @@ -161,6 +176,8 @@ install-data: $(INSTALL) -m 644 $(srcdir)/sdl2.m4 $(DESTDIR)$(datadir)/aclocal/sdl2.m4 $(SHELL) $(auxdir)/mkinstalldirs $(DESTDIR)$(libdir)/pkgconfig $(INSTALL) -m 644 sdl2.pc $(DESTDIR)$(libdir)/pkgconfig + $(SHELL) $(auxdir)/mkinstalldirs $(DESTDIR)$(libdir)/cmake/SDL2 + $(INSTALL) -m 644 sdl2-config.cmake $(DESTDIR)$(libdir)/cmake/SDL2 uninstall: uninstall-bin uninstall-hdrs uninstall-lib uninstall-data uninstall-bin: @@ -179,6 +196,7 @@ uninstall-lib: uninstall-data: rm -f $(DESTDIR)$(datadir)/aclocal/sdl2.m4 rm -f $(DESTDIR)$(libdir)/pkgconfig/sdl2.pc + rm -f $(DESTDIR)$(libdir)/cmake/SDL2/sdl2-config.cmake clean: rm -rf $(objects) diff --git a/Engine/lib/sdl/Makefile.wiz b/Engine/lib/sdl/Makefile.wiz index 82619f076..bb7705789 100644 --- a/Engine/lib/sdl/Makefile.wiz +++ b/Engine/lib/sdl/Makefile.wiz @@ -12,13 +12,13 @@ CFLAGS = -Wall -fPIC -I./include -I$(WIZSDK)/include -DWIZ_GLES_LITE TARGET_STATIC = libSDL13.a TARGET_SHARED = libSDL13.so -SOURCES = ./src/*.c ./src/audio/*.c ./src/cdrom/*.c ./src/cpuinfo/*.c ./src/events/*.c \ +SOURCES = ./src/*.c ./src/audio/*.c ./src/cpuinfo/*.c ./src/events/*.c \ ./src/file/*.c ./src/stdlib/*.c ./src/thread/*.c ./src/timer/*.c ./src/video/*.c \ ./src/joystick/*.c ./src/haptic/*.c ./src/video/dummy/*.c ./src/audio/disk/*.c \ ./src/audio/dummy/*.c ./src/loadso/dlopen/*.c ./src/audio/dsp/*.c \ ./src/thread/pthread/SDL_systhread.c ./src/thread/pthread/SDL_syssem.c \ ./src/thread/pthread/SDL_sysmutex.c ./src/thread/pthread/SDL_syscond.c \ - ./src/joystick/linux/*.c ./src/haptic/linux/*.c ./src/timer/unix/*.c ./src/cdrom/dummy/*.c \ + ./src/joystick/linux/*.c ./src/haptic/linux/*.c ./src/timer/unix/*.c \ ./src/video/pandora/SDL_pandora.o ./src/video/pandora/SDL_pandora_events.o diff --git a/Engine/lib/sdl/README-android.txt b/Engine/lib/sdl/README-android.txt deleted file mode 100644 index 08a2592d4..000000000 --- a/Engine/lib/sdl/README-android.txt +++ /dev/null @@ -1,438 +0,0 @@ -================================================================================ -Simple DirectMedia Layer for Android -================================================================================ - -Requirements: - -Android SDK (version 12 or later) -http://developer.android.com/sdk/index.html - -Android NDK r7 or later -http://developer.android.com/tools/sdk/ndk/index.html - -Minimum API level supported by SDL: 10 (Android 2.3.3) -Joystick support is available for API level >=12 devices. - -================================================================================ - How the port works -================================================================================ - -- Android applications are Java-based, optionally with parts written in C -- As SDL apps are C-based, we use a small Java shim that uses JNI to talk to -the SDL library -- This means that your application C code must be placed inside an Android -Java project, along with some C support code that communicates with Java -- This eventually produces a standard Android .apk package - -The Android Java code implements an "Activity" and can be found in: -android-project/src/org/libsdl/app/SDLActivity.java - -The Java code loads your game code, the SDL shared library, and -dispatches to native functions implemented in the SDL library: -src/core/android/SDL_android.c - -Your project must include some glue code that starts your main() routine: -src/main/android/SDL_android_main.c - - -================================================================================ - Building an app -================================================================================ - -For simple projects you can use the script located at build-scripts/androidbuild.sh - -There's two ways of using it: - -androidbuild.sh com.yourcompany.yourapp < sources.list -androidbuild.sh com.yourcompany.yourapp source1.c source2.c ...sourceN.c - -sources.list should be a text file with a source file name in each line -Filenames should be specified relative to the current directory, for example if -you are in the build-scripts directory and want to create the testgles.c test, you'll -run: - -./androidbuild.sh org.libsdl.testgles ../test/testgles.c - -One limitation of this script is that all sources provided will be aggregated into -a single directory, thus all your source files should have a unique name. - -Once the project is complete the script will tell you where the debug APK is located. -If you want to create a signed release APK, you can use the project created by this -utility to generate it. - -Finally, a word of caution: re running androidbuild.sh wipes any changes you may have -done in the build directory for the app! - - -For more complex projects, follow these instructions: - -1. Copy the android-project directory wherever you want to keep your projects - and rename it to the name of your project. -2. Move or symlink this SDL directory into the /jni directory -3. Edit /jni/src/Android.mk to include your source files -4. Run 'ndk-build' (a script provided by the NDK). This compiles the C source - -If you want to use the Eclipse IDE, skip to the Eclipse section below. - -5. Create /local.properties and use that to point to the Android SDK directory, by writing a line with the following form: -sdk.dir=PATH_TO_ANDROID_SDK -6. Run 'ant debug' in android/project. This compiles the .java and eventually - creates a .apk with the native code embedded -7. 'ant debug install' will push the apk to the device or emulator (if connected) - -Here's an explanation of the files in the Android project, so you can customize them: - -android-project/ - AndroidManifest.xml - package manifest. Among others, it contains the class name - of the main Activity and the package name of the application. - build.properties - empty - build.xml - build description file, used by ant. The actual application name - is specified here. - default.properties - holds the target ABI for the application, android-10 and up - project.properties - holds the target ABI for the application, android-10 and up - local.properties - holds the SDK path, you should change this to the path to your SDK - jni/ - directory holding native code - jni/Android.mk - Android makefile that can call recursively the Android.mk files - in all subdirectories - jni/SDL/ - (symlink to) directory holding the SDL library files - jni/SDL/Android.mk - Android makefile for creating the SDL shared library - jni/src/ - directory holding your C/C++ source - jni/src/Android.mk - Android makefile that you should customize to include your - source code and any library references - res/ - directory holding resources for your application - res/drawable-* - directories holding icons for different phone hardware. Could be - one dir called "drawable". - res/layout/main.xml - Usually contains a file main.xml, which declares the screen layout. - We don't need it because we use the SDL video output. - res/values/strings.xml - strings used in your application, including the application name - shown on the phone. - src/org/libsdl/app/SDLActivity.java - the Java class handling the initialization and binding - to SDL. Be very careful changing this, as the SDL library relies - on this implementation. - - -================================================================================ - Build an app with static linking of libSDL -================================================================================ - -This build uses the Android NDK module system. - -Instructions: -1. Copy the android-project directory wherever you want to keep your projects - and rename it to the name of your project. -2. Rename /jni/src/Android_static.mk to /jni/src/Android.mk - (overwrite the existing one) -3. Edit /jni/src/Android.mk to include your source files -4. create and export an environment variable named NDK_MODULE_PATH that points - to the parent directory of this SDL directory. e.g.: - - export NDK_MODULE_PATH="$PWD"/.. - -5. Edit /src/org/libsdl/app/SDLActivity.java and remove the call to - System.loadLibrary("SDL2") line 42. -6. Run 'ndk-build' (a script provided by the NDK). This compiles the C source - - -================================================================================ - Customizing your application name -================================================================================ - -To customize your application name, edit AndroidManifest.xml and replace -"org.libsdl.app" with an identifier for your product package. - -Then create a Java class extending SDLActivity and place it in a directory -under src matching your package, e.g. - src/com/gamemaker/game/MyGame.java - -Here's an example of a minimal class file: ---- MyGame.java -------------------------- -package com.gamemaker.game; - -import org.libsdl.app.SDLActivity; - -/* - * A sample wrapper class that just calls SDLActivity - */ - -public class MyGame extends SDLActivity { } - ------------------------------------------- - -Then replace "SDLActivity" in AndroidManifest.xml with the name of your -class, .e.g. "MyGame" - -================================================================================ - Customizing your application icon -================================================================================ - -Conceptually changing your icon is just replacing the "ic_launcher.png" files in -the drawable directories under the res directory. There are four directories for -different screen sizes. These can be replaced with one dir called "drawable", -containing an icon file "ic_launcher.png" with dimensions 48x48 or 72x72. - -You may need to change the name of your icon in AndroidManifest.xml to match -this icon filename. - -================================================================================ - Loading assets -================================================================================ - -Any files you put in the "assets" directory of your android-project directory -will get bundled into the application package and you can load them using the -standard functions in SDL_rwops.h. - -There are also a few Android specific functions that allow you to get other -useful paths for saving and loading data: -SDL_AndroidGetInternalStoragePath() -SDL_AndroidGetExternalStorageState() -SDL_AndroidGetExternalStoragePath() - -See SDL_system.h for more details on these functions. - -The asset packaging system will, by default, compress certain file extensions. -SDL includes two asset file access mechanisms, the preferred one is the so -called "File Descriptor" method, which is faster and doesn't involve the Dalvik -GC, but given this method does not work on compressed assets, there is also the -"Input Stream" method, which is automatically used as a fall back by SDL. You -may want to keep this fact in mind when building your APK, specially when large -files are involved. -For more information on which extensions get compressed by default and how to -disable this behaviour, see for example: - -http://ponystyle.com/blog/2010/03/26/dealing-with-asset-compression-in-android-apps/ - -================================================================================ - Pause / Resume behaviour -================================================================================ - -If SDL is compiled with SDL_ANDROID_BLOCK_ON_PAUSE defined (the default), -the event loop will block itself when the app is paused (ie, when the user -returns to the main Android dashboard). Blocking is better in terms of battery -use, and it allows your app to spring back to life instantaneously after resume -(versus polling for a resume message). - -Upon resume, SDL will attempt to restore the GL context automatically. -In modern devices (Android 3.0 and up) this will most likely succeed and your -app can continue to operate as it was. - -However, there's a chance (on older hardware, or on systems under heavy load), -where the GL context can not be restored. In that case you have to listen for -a specific message, (which is not yet implemented!) and restore your textures -manually or quit the app (which is actually the kind of behaviour you'll see -under iOS, if the OS can not restore your GL context it will just kill your app) - -================================================================================ - Threads and the Java VM -================================================================================ - -For a quick tour on how Linux native threads interoperate with the Java VM, take -a look here: http://developer.android.com/guide/practices/jni.html -If you want to use threads in your SDL app, it's strongly recommended that you -do so by creating them using SDL functions. This way, the required attach/detach -handling is managed by SDL automagically. If you have threads created by other -means and they make calls to SDL functions, make sure that you call -Android_JNI_SetupThread before doing anything else otherwise SDL will attach -your thread automatically anyway (when you make an SDL call), but it'll never -detach it. - -================================================================================ - Using STL -================================================================================ - -You can use STL in your project by creating an Application.mk file in the jni -folder and adding the following line: -APP_STL := stlport_static - -For more information check out CPLUSPLUS-SUPPORT.html in the NDK documentation. - -================================================================================ - Additional documentation -================================================================================ - -The documentation in the NDK docs directory is very helpful in understanding the -build process and how to work with native code on the Android platform. - -The best place to start is with docs/OVERVIEW.TXT - - -================================================================================ - Using Eclipse -================================================================================ - -First make sure that you've installed Eclipse and the Android extensions as described here: - http://developer.android.com/tools/sdk/eclipse-adt.html - -Once you've copied the SDL android project and customized it, you can create an Eclipse project from it: - * File -> New -> Other - * Select the Android -> Android Project wizard and click Next - * Enter the name you'd like your project to have - * Select "Create project from existing source" and browse for your project directory - * Make sure the Build Target is set to Android 2.0 - * Click Finish - - -================================================================================ - Using the emulator -================================================================================ - -There are some good tips and tricks for getting the most out of the -emulator here: http://developer.android.com/tools/devices/emulator.html - -Especially useful is the info on setting up OpenGL ES 2.0 emulation. - -Notice that this software emulator is incredibly slow and needs a lot of disk space. -Using a real device works better. - -================================================================================ - Troubleshooting -================================================================================ - -You can create and run an emulator from the Eclipse IDE: - * Window -> Android SDK and AVD Manager - -You can see if adb can see any devices with the following command: - adb devices - -You can see the output of log messages on the default device with: - adb logcat - -You can push files to the device with: - adb push local_file remote_path_and_file - -You can push files to the SD Card at /sdcard, for example: - adb push moose.dat /sdcard/moose.dat - -You can see the files on the SD card with a shell command: - adb shell ls /sdcard/ - -You can start a command shell on the default device with: - adb shell - -You can remove the library files of your project (and not the SDL lib files) with: - ndk-build clean - -You can do a build with the following command: - ndk-build - -You can see the complete command line that ndk-build is using by passing V=1 on the command line: - ndk-build V=1 - -If your application crashes in native code, you can use addr2line to convert the -addresses in the stack trace to lines in your code. - -For example, if your crash looks like this: -I/DEBUG ( 31): signal 11 (SIGSEGV), code 2 (SEGV_ACCERR), fault addr 400085d0 -I/DEBUG ( 31): r0 00000000 r1 00001000 r2 00000003 r3 400085d4 -I/DEBUG ( 31): r4 400085d0 r5 40008000 r6 afd41504 r7 436c6a7c -I/DEBUG ( 31): r8 436c6b30 r9 435c6fb0 10 435c6f9c fp 4168d82c -I/DEBUG ( 31): ip 8346aff0 sp 436c6a60 lr afd1c8ff pc afd1c902 cpsr 60000030 -I/DEBUG ( 31): #00 pc 0001c902 /system/lib/libc.so -I/DEBUG ( 31): #01 pc 0001ccf6 /system/lib/libc.so -I/DEBUG ( 31): #02 pc 000014bc /data/data/org.libsdl.app/lib/libmain.so -I/DEBUG ( 31): #03 pc 00001506 /data/data/org.libsdl.app/lib/libmain.so - -You can see that there's a crash in the C library being called from the main code. -I run addr2line with the debug version of my code: - arm-eabi-addr2line -C -f -e obj/local/armeabi/libmain.so -and then paste in the number after "pc" in the call stack, from the line that I care about: -000014bc - -I get output from addr2line showing that it's in the quit function, in testspriteminimal.c, on line 23. - -You can add logging to your code to help show what's happening: - -#include - - __android_log_print(ANDROID_LOG_INFO, "foo", "Something happened! x = %d", x); - -If you need to build without optimization turned on, you can create a file called -"Application.mk" in the jni directory, with the following line in it: -APP_OPTIM := debug - - -================================================================================ - Memory debugging -================================================================================ - -The best (and slowest) way to debug memory issues on Android is valgrind. -Valgrind has support for Android out of the box, just grab code using: - svn co svn://svn.valgrind.org/valgrind/trunk valgrind -... and follow the instructions in the file README.android to build it. - -One thing I needed to do on Mac OS X was change the path to the toolchain, -and add ranlib to the environment variables: -export RANLIB=$NDKROOT/toolchains/arm-linux-androideabi-4.4.3/prebuilt/darwin-x86/bin/arm-linux-androideabi-ranlib - -Once valgrind is built, you can create a wrapper script to launch your -application with it, changing org.libsdl.app to your package identifier: ---- start_valgrind_app ------------------- -#!/system/bin/sh -export TMPDIR=/data/data/org.libsdl.app -exec /data/local/Inst/bin/valgrind --log-file=/sdcard/valgrind.log --error-limit=no $* ------------------------------------------- - -Then push it to the device: - adb push start_valgrind_app /data/local - -and make it executable: - adb shell chmod 755 /data/local/start_valgrind_app - -and tell Android to use the script to launch your application: - adb shell setprop wrap.org.libsdl.app "logwrapper /data/local/start_valgrind_app" - -If the setprop command says "could not set property", it's likely that -your package name is too long and you should make it shorter by changing -AndroidManifest.xml and the path to your class file in android-project/src - -You can then launch your application normally and waaaaaaaiiittt for it. -You can monitor the startup process with the logcat command above, and -when it's done (or even while it's running) you can grab the valgrind -output file: - adb pull /sdcard/valgrind.log - -When you're done instrumenting with valgrind, you can disable the wrapper: - adb shell setprop wrap.org.libsdl.app "" - -================================================================================ - Why is API level 10 the minimum required? -================================================================================ - -API level 10 is the minimum required level at runtime (that is, on the device) -because SDL requires some functionality for running not -available on older devices. Since the incorporation of joystick support into SDL, -the minimum SDK required to *build* SDL is version 12. Devices running API levels -10-11 are still supported, only with the joystick functionality disabled. - -Support for native OpenGL ES and ES2 applications was introduced in the NDK for -API level 4 and 8. EGL was made a stable API in the NDK for API level 9, which -has since then been obsoleted, with the recommendation to developers to bump the -required API level to 10. -As of this writing, according to http://developer.android.com/about/dashboards/index.html -about 90% of the Android devices accessing Google Play support API level 10 or -higher (March 2013). - -================================================================================ - A note regarding the use of the "dirty rectangles" rendering technique -================================================================================ - -If your app uses a variation of the "dirty rectangles" rendering technique, -where you only update a portion of the screen on each frame, you may notice a -variety of visual glitches on Android, that are not present on other platforms. -This is caused by SDL's use of EGL as the support system to handle OpenGL ES/ES2 -contexts, in particular the use of the eglSwapBuffers function. As stated in the -documentation for the function "The contents of ancillary buffers are always -undefined after calling eglSwapBuffers". -Setting the EGL_SWAP_BEHAVIOR attribute of the surface to EGL_BUFFER_PRESERVED -is not possible for SDL as it requires EGL 1.4, available only on the API level -17+, so the only workaround available on this platform is to redraw the entire -screen each frame. - -Reference: http://www.khronos.org/registry/egl/specs/EGLTechNote0001.html - -================================================================================ - Known issues -================================================================================ - -- The number of buttons reported for each joystick is hardcoded to be 36, which -is the current maximum number of buttons Android can report. - diff --git a/Engine/lib/sdl/README-cmake.txt b/Engine/lib/sdl/README-cmake.txt deleted file mode 100644 index 7f5ac80dd..000000000 --- a/Engine/lib/sdl/README-cmake.txt +++ /dev/null @@ -1,31 +0,0 @@ -================================================================================ -CMake build system for SDL (www.cmake.org) -================================================================================ - -SDL's build system was traditionally based on autotools. Over time, this -approach has suffered from several issues across the different supported -platforms. -To solve these problems, a new build system based on CMake is under development. -It works in parallel to the legacy system, so users can experiment with it -without complication. -While still experimental, the build system should be usable on the following -platforms: - - * FreeBSD - * Linux - * VS.NET 2010 - * MinGW and Msys - * OS X with support for XCode - -================================================================================ -Usage -================================================================================ - -Assuming the source for SDL is located at ~/sdl - -cd ~ -mkdir build -cd build -cmake ../sdl - -This will build the static and dynamic versions of SDL in the ~/build directory. diff --git a/Engine/lib/sdl/README-directfb.txt b/Engine/lib/sdl/README-directfb.txt deleted file mode 100644 index 9c16a7b67..000000000 --- a/Engine/lib/sdl/README-directfb.txt +++ /dev/null @@ -1,106 +0,0 @@ -SDL on DirectFB - -Supports: - -- Hardware YUV overlays -- OpenGL - software only -- 2D/3D accelerations (depends on directfb driver) -- multiple displays -- windows - -What you need: - -DirectFB 1.0.1, 1.2.x, 1.3.0 -Kernel-Framebuffer support: required: vesafb, radeonfb .... -Mesa 7.0.x - optional for OpenGL - -/etc/directfbrc - -This file should contain the following lines to make -your joystick work and avoid crashes: ------------------------- -disable-module=joystick -disable-module=cle266 -disable-module=cyber5k -no-linux-input-grab ------------------------- - -To disable to use x11 backend when DISPLAY variable is found use - -export SDL_DIRECTFB_X11_CHECK=0 - -To disable the use of linux input devices, i.e. multimice/multikeyboard support, -use - -export SDL_DIRECTFB_LINUX_INPUT=0 - -To use hardware accelerated YUV-overlays for YUV-textures, use: - -export SDL_DIRECTFB_YUV_DIRECT=1 - -This is disabled by default. It will only support one -YUV texture, namely the first. Every other YUV texture will be -rendered in software. - -In addition, you may use (directfb-1.2.x) - -export SDL_DIRECTFB_YUV_UNDERLAY=1 - -to make the YUV texture an underlay. This will make the cursor to -be shown. - -Simple Window Manager -===================== - -The driver has support for a very, very basic window manager you may -want to use when running with "wm=default". Use - -export SDL_DIRECTFB_WM=1 - -to enable basic window borders. In order to have the window title rendered, -you need to have the following font installed: - -/usr/share/fonts/truetype/freefont/FreeSans.ttf - -OpenGL Support -============== - -The following instructions will give you *software* OpenGL. However this -works at least on all directfb supported platforms. - -As of this writing 20100802 you need to pull Mesa from git and do the following: - ------------------------- -git clone git://anongit.freedesktop.org/git/mesa/mesa -cd mesa -git checkout 2c9fdaf7292423c157fc79b5ce43f0f199dd753a ------------------------- - -Edit configs/linux-directfb so that the Directories-section looks like ------------------------- -# Directories -SRC_DIRS = mesa glu -GLU_DIRS = sgi -DRIVER_DIRS = directfb -PROGRAM_DIRS = ------------------------- - -make linux-directfb -make - -echo Installing - please enter sudo pw. - -sudo make install INSTALL_DIR=/usr/local/dfb_GL -cd src/mesa/drivers/directfb -make -sudo make install INSTALL_DIR=/usr/local/dfb_GL ------------------------- - -To run the SDL - testprograms: - -export SDL_VIDEODRIVER=directfb -export LD_LIBRARY_PATH=/usr/local/dfb_GL/lib -export LD_PRELOAD=/usr/local/dfb_GL/libGL.so.7 - -./testgl - diff --git a/Engine/lib/sdl/README-dynapi.txt b/Engine/lib/sdl/README-dynapi.txt deleted file mode 100644 index da52f3a32..000000000 --- a/Engine/lib/sdl/README-dynapi.txt +++ /dev/null @@ -1,130 +0,0 @@ -================================================================================ -Dynamic API -================================================================================ -Originally posted by Ryan at https://plus.google.com/103391075724026391227/posts/TB8UfnDYu4U - -Background: - -- The Steam Runtime has (at least in theory) a really kick-ass build of SDL2, - but developers are shipping their own SDL2 with individual Steam games. - These games might stop getting updates, but a newer SDL2 might be needed later. - Certainly we'll always be fixing bugs in SDL, even if a new video target isn't - ever needed, and these fixes won't make it to a game shipping its own SDL. -- Even if we replace the SDL2 in those games with a compatible one, that is to - say, edit a developer's Steam depot (yuck!), there are developers that are - statically linking SDL2 that we can't do this for. We can't even force the - dynamic loader to ignore their SDL2 in this case, of course. -- If you don't ship an SDL2 with the game in some form, people that disabled the - Steam Runtime, or just tried to run the game from the command line instead of - Steam might find themselves unable to run the game, due to a missing dependency. -- If you want to ship on non-Steam platforms like GOG or Humble Bundle, or target - generic Linux boxes that may or may not have SDL2 installed, you have to ship - the library or risk a total failure to launch. So now, you might have to have - a non-Steam build plus a Steam build (that is, one with and one without SDL2 - included), which is inconvenient if you could have had one universal build - that works everywhere. -- We like the zlib license, but the biggest complaint from the open source - community about the license change is the static linking. The LGPL forced this - as a legal, not technical issue, but zlib doesn't care. Even those that aren't - concerned about the GNU freedoms found themselves solving the same problems: - swapping in a newer SDL to an older game often times can save the day. - Static linking stops this dead. - -So here's what we did: - -SDL now has, internally, a table of function pointers. So, this is what SDL_Init -now looks like: - - UInt32 SDL_Init(Uint32 flags) - { - return jump_table.SDL_Init(flags); - } - -Except that is all done with a bunch of macro magic so we don't have to maintain -every one of these. - -What is jump_table.SDL_init()? Eventually, that's a function pointer of the real -SDL_Init() that you've been calling all this time. But at startup, it looks more -like this: - - Uint32 SDL_Init_DEFAULT(Uint32 flags) - { - SDL_InitDynamicAPI(); - return jump_table.SDL_Init(flags); - } - -SDL_InitDynamicAPI() fills in jump_table with all the actual SDL function -pointers, which means that this _DEFAULT function never gets called again. -First call to any SDL function sets the whole thing up. - -So you might be asking, what was the value in that? Isn't this what the operating -system's dynamic loader was supposed to do for us? Yes, but now we've got this -level of indirection, we can do things like this: - - export SDL_DYNAMIC_API=/my/actual/libSDL-2.0.so.0 - ./MyGameThatIsStaticallyLinkedToSDL2 - -And now, this game that is staticallly linked to SDL, can still be overridden -with a newer, or better, SDL. The statically linked one will only be used as -far as calling into the jump table in this case. But in cases where no override -is desired, the statically linked version will provide its own jump table, -and everyone is happy. - -So now: -- Developers can statically link SDL, and users can still replace it. - (We'd still rather you ship a shared library, though!) -- Developers can ship an SDL with their game, Valve can override it for, say, - new features on SteamOS, or distros can override it for their own needs, - but it'll also just work in the default case. -- Developers can ship the same package to everyone (Humble Bundle, GOG, etc), - and it'll do the right thing. -- End users (and Valve) can update a game's SDL in almost any case, - to keep abandoned games running on newer platforms. -- Everyone develops with SDL exactly as they have been doing all along. - Same headers, same ABI. Just get the latest version to enable this magic. - - -A little more about SDL_InitDynamicAPI(): - -Internally, InitAPI does some locking to make sure everything waits until a -single thread initializes everything (although even SDL_CreateThread() goes -through here before spinning a thread, too), and then decides if it should use -an external SDL library. If not, it sets up the jump table using the current -SDL's function pointers (which might be statically linked into a program, or in -a shared library of its own). If so, it loads that library and looks for and -calls a single function: - - SInt32 SDL_DYNAPI_entry(Uint32 version, void *table, Uint32 tablesize); - -That function takes a version number (more on that in a moment), the address of -the jump table, and the size, in bytes, of the table. -Now, we've got policy here: this table's layout never changes; new stuff gets -added to the end. Therefore SDL_DYNAPI_entry() knows that it can provide all -the needed functions if tablesize <= sizeof its own jump table. If tablesize is -bigger (say, SDL 2.0.4 is trying to load SDL 2.0.3), then we know to abort, but -if it's smaller, we know we can provide the entire API that the caller needs. - -The version variable is a failsafe switch. -Right now it's always 1. This number changes when there are major API changes -(so we know if the tablesize might be smaller, or entries in it have changed). -Right now SDL_DYNAPI_entry gives up if the version doesn't match, but it's not -inconceivable to have a small dispatch library that only supplies this one -function and loads different, otherwise-incompatible SDL libraries and has the -right one initialize the jump table based on the version. For something that -must generically catch lots of different versions of SDL over time, like the -Steam Client, this isn't a bad option. - -Finally, I'm sure some people are reading this and thinking -"I don't want that overhead in my project!" -To which I would point out that the extra function call through the jump table -probably wouldn't even show up in a profile, but lucky you: this can all be -disabled. You can build SDL without this if you absolutely must, but we would -encourage you not to do that. However, on heavily locked down platforms like -iOS, or maybe when debugging, it makes sense to disable it. The way this is -designed in SDL, you just have to change one #define, and the entire system -vaporizes out, and SDL functions exactly like it always did. Most of it is -macro magic, so the system is contained to one C file and a few headers. -However, this is on by default and you have to edit a header file to turn it -off. Our hopes is that if we make it easy to disable, but not too easy, -everyone will ultimately be able to get what they want, but we've gently -nudged everyone towards what we think is the best solution. diff --git a/Engine/lib/sdl/README-gesture.txt b/Engine/lib/sdl/README-gesture.txt deleted file mode 100644 index 205fb97d3..000000000 --- a/Engine/lib/sdl/README-gesture.txt +++ /dev/null @@ -1,72 +0,0 @@ -=========================================================================== -Dollar Gestures -=========================================================================== -SDL Provides an implementation of the $1 gesture recognition system. This allows for recording, saving, loading, and performing single stroke gestures. - -Gestures can be performed with any number of fingers (the centroid of the fingers must follow the path of the gesture), but the number of fingers must be constant (a finger cannot go down in the middle of a gesture). The path of a gesture is considered the path from the time when the final finger went down, to the first time any finger comes up. - -Dollar gestures are assigned an Id based on a hash function. This is guaranteed to remain constant for a given gesture. There is a (small) chance that two different gestures will be assigned the same ID. In this case, simply re-recording one of the gestures should result in a different ID. - -Recording: ----------- -To begin recording on a touch device call: -SDL_RecordGesture(SDL_TouchID touchId), where touchId is the id of the touch device you wish to record on, or -1 to record on all connected devices. - -Recording terminates as soon as a finger comes up. Recording is acknowledged by an SDL_DOLLARRECORD event. -A SDL_DOLLARRECORD event is a dgesture with the following fields: - -event.dgesture.touchId - the Id of the touch used to record the gesture. -event.dgesture.gestureId - the unique id of the recorded gesture. - - -Performing: ------------ -As long as there is a dollar gesture assigned to a touch, every finger-up event will also cause an SDL_DOLLARGESTURE event with the following fields: - -event.dgesture.touchId - the Id of the touch which performed the gesture. -event.dgesture.gestureId - the unique id of the closest gesture to the performed stroke. -event.dgesture.error - the difference between the gesture template and the actual performed gesture. Lower error is a better match. -event.dgesture.numFingers - the number of fingers used to draw the stroke. - -Most programs will want to define an appropriate error threshold and check to be sure that the error of a gesture is not abnormally high (an indicator that no gesture was performed). - - - -Saving: -------- -To save a template, call SDL_SaveDollarTemplate(gestureId, dst) where gestureId is the id of the gesture you want to save, and dst is an SDL_RWops pointer to the file where the gesture will be stored. - -To save all currently loaded templates, call SDL_SaveAllDollarTemplates(dst) where dst is an SDL_RWops pointer to the file where the gesture will be stored. - -Both functions return the number of gestures successfully saved. - - -Loading: --------- -To load templates from a file, call SDL_LoadDollarTemplates(touchId,src) where touchId is the id of the touch to load to (or -1 to load to all touch devices), and src is an SDL_RWops pointer to a gesture save file. - -SDL_LoadDollarTemplates returns the number of templates successfully loaded. - - - -=========================================================================== -Multi Gestures -=========================================================================== -SDL provides simple support for pinch/rotate/swipe gestures. -Every time a finger is moved an SDL_MULTIGESTURE event is sent with the following fields: - -event.mgesture.touchId - the Id of the touch on which the gesture was performed. -event.mgesture.x - the normalized x coordinate of the gesture. (0..1) -event.mgesture.y - the normalized y coordinate of the gesture. (0..1) -event.mgesture.dTheta - the amount that the fingers rotated during this motion. -event.mgesture.dDist - the amount that the fingers pinched during this motion. -event.mgesture.numFingers - the number of fingers used in the gesture. - - -=========================================================================== -Notes -=========================================================================== -For a complete example see test/testgesture.c - -Please direct questions/comments to: - jim.tla+sdl_touch@gmail.com diff --git a/Engine/lib/sdl/README-hg.txt b/Engine/lib/sdl/README-hg.txt deleted file mode 100644 index 616307c6c..000000000 --- a/Engine/lib/sdl/README-hg.txt +++ /dev/null @@ -1,23 +0,0 @@ -The latest development version of SDL is available via Mercurial. -Mercurial allows you to get up-to-the-minute fixes and enhancements; -as a developer works on a source tree, you can use "hg" to mirror that -source tree instead of waiting for an official release. Please look -at the Mercurial website ( http://mercurial.selenic.com/ ) for more -information on using hg, where you can also download software for -Mac OS X, Windows, and Unix systems. - - hg clone http://hg.libsdl.org/SDL - -If you are building SDL with an IDE, you will need to copy the file -include/SDL_config.h.default to include/SDL_config.h before building. - -If you are building SDL via configure, you will need to run autogen.sh -before running configure. - -There is a web interface to the subversion repository at: - - http://hg.libsdl.org/SDL/ - -There is an RSS feed available at that URL, for those that want to -track commits in real time. - diff --git a/Engine/lib/sdl/README-ios.txt b/Engine/lib/sdl/README-ios.txt deleted file mode 100644 index 60f3391dc..000000000 --- a/Engine/lib/sdl/README-ios.txt +++ /dev/null @@ -1,222 +0,0 @@ -============================================================================== -Building the Simple DirectMedia Layer for iPhone OS 2.0 -============================================================================== - -Requirements: Mac OS X v10.5 or later and the iPhone SDK. - -Instructions: -1. Open SDL.xcodeproj (located in Xcode-iOS/SDL) in XCode. -2. Select your desired target, and hit build. - -There are three build targets: -- libSDL.a: - Build SDL as a statically linked library -- testsdl - Build a test program (there are known test failures which are fine) -- Template: - Package a project template together with the SDL for iPhone static libraries and copies of the SDL headers. The template includes proper references to the SDL library and headers, skeleton code for a basic SDL program, and placeholder graphics for the application icon and startup screen. - -============================================================================== -Build SDL for iOS from the command line -============================================================================== - -1. cd (PATH WHERE THE SDL CODE IS)/build-scripts -2. ./iosbuild.sh - -If everything goes fine, you should see a build/ios directory, inside there's -two directories "lib" and "include". -"include" contains a copy of the SDL headers that you'll need for your project, -make sure to configure XCode to look for headers there. -"lib" contains find two files, libSDL2.a and libSDL2main.a, you have to add both -to your XCode project. These libraries contain three architectures in them, -armv6 for legacy devices, armv7, and i386 (for the simulator). -By default, iosbuild.sh will autodetect the SDK version you have installed using -xcodebuild -showsdks, and build for iOS >= 3.0, you can override this behaviour -by setting the MIN_OS_VERSION variable, ie: - -MIN_OS_VERSION=4.2 ./iosbuild.sh - -============================================================================== -Using the Simple DirectMedia Layer for iOS -============================================================================== - -FIXME: This needs to be updated for the latest methods - -Here is the easiest method: -1. Build the SDL libraries (libSDL.a and libSDLSimulator.a) and the iPhone SDL Application template. -1. Install the iPhone SDL Application template by copying it to one of XCode's template directories. I recommend creating a directory called "SDL" in "/Developer/Platforms/iOS.platform/Developer/Library/XCode/Project Templates/" and placing it there. -2. Start a new project using the template. The project should be immediately ready for use with SDL. - -Here is a more manual method: -1. Create a new iPhone view based application. -2. Build the SDL static libraries (libSDL.a and libSDLSimulator.a) for iPhone and include them in your project. XCode will ignore the library that is not currently of the correct architecture, hence your app will work both on iPhone and in the iPhone Simulator. -3. Include the SDL header files in your project. -4. Remove the ApplicationDelegate.h and ApplicationDelegate.m files -- SDL for iPhone provides its own UIApplicationDelegate. Remove MainWindow.xib -- SDL for iPhone produces its user interface programmatically. -5. Delete the contents of main.m and program your app as a regular SDL program instead. You may replace main.m with your own main.c, but you must tell XCode not to use the project prefix file, as it includes Objective-C code. - -============================================================================== -Notes -- Application events -============================================================================== - -On iOS the application goes through a fixed life cycle and you will get -notifications of state changes via application events. When these events -are delivered you must handle them in an event callback because the OS may -not give you any processing time after the events are delivered. - -e.g. - -int HandleAppEvents(void *userdata, SDL_Event *event) -{ - switch (event->type) - { - case SDL_APP_TERMINATING: - /* Terminate the app. - Shut everything down before returning from this function. - */ - return 0; - case SDL_APP_LOWMEMORY: - /* You will get this when your app is paused and iOS wants more memory. - Release as much memory as possible. - */ - return 0; - case SDL_APP_WILLENTERBACKGROUND: - /* Prepare your app to go into the background. Stop loops, etc. - This gets called when the user hits the home button, or gets a call. - */ - return 0; - case SDL_APP_DIDENTERBACKGROUND: - /* This will get called if the user accepted whatever sent your app to the background. - If the user got a phone call and canceled it, you'll instead get an SDL_APP_DIDENTERFOREGROUND event and restart your loops. - When you get this, you have 5 seconds to save all your state or the app will be terminated. - Your app is NOT active at this point. - */ - return 0; - case SDL_APP_WILLENTERFOREGROUND: - /* This call happens when your app is coming back to the foreground. - Restore all your state here. - */ - return 0; - case SDL_APP_DIDENTERFOREGROUND: - /* Restart your loops here. - Your app is interactive and getting CPU again. - */ - return 0; - default: - /* No special processing, add it to the event queue */ - return 1; - } -} - -int main(int argc, char *argv[]) -{ - SDL_SetEventFilter(HandleAppEvents, NULL); - - ... run your main loop - - return 0; -} - - -============================================================================== -Notes -- Accelerometer as Joystick -============================================================================== - -SDL for iPhone supports polling the built in accelerometer as a joystick device. For an example on how to do this, see the accelerometer.c in the demos directory. - -The main thing to note when using the accelerometer with SDL is that while the iPhone natively reports accelerometer as floating point values in units of g-force, SDL_JoystickGetAxis reports joystick values as signed integers. Hence, in order to convert between the two, some clamping and scaling is necessary on the part of the iPhone SDL joystick driver. To convert SDL_JoystickGetAxis reported values BACK to units of g-force, simply multiply the values by SDL_IPHONE_MAX_GFORCE / 0x7FFF. - -============================================================================== -Notes -- OpenGL ES -============================================================================== - -Your SDL application for iPhone uses OpenGL ES for video by default. - -OpenGL ES for iPhone supports several display pixel formats, such as RGBA8 and RGB565, which provide a 32 bit and 16 bit color buffer respectively. By default, the implementation uses RGB565, but you may use RGBA8 by setting each color component to 8 bits in SDL_GL_SetAttribute. - -If your application doesn't use OpenGL's depth buffer, you may find significant performance improvement by setting SDL_GL_DEPTH_SIZE to 0. - -Finally, if your application completely redraws the screen each frame, you may find significant performance improvement by setting the attribute SDL_GL_RETAINED_BACKING to 1. - -============================================================================== -Notes -- Keyboard -============================================================================== - -The SDL keyboard API has been extended to support on-screen keyboards: - -void SDL_StartTextInput() - -- enables text events and reveals the onscreen keyboard. -void SDL_StopTextInput() - -- disables text events and hides the onscreen keyboard. -SDL_bool SDL_IsTextInputActive() - -- returns whether or not text events are enabled (and the onscreen keyboard is visible) - -============================================================================== -Notes -- Reading and Writing files -============================================================================== - -Each application installed on iPhone resides in a sandbox which includes its own Application Home directory. Your application may not access files outside this directory. - -Once your application is installed its directory tree looks like: - -MySDLApp Home/ - MySDLApp.app - Documents/ - Library/ - Preferences/ - tmp/ - -When your SDL based iPhone application starts up, it sets the working directory to the main bundle (MySDLApp Home/MySDLApp.app), where your application resources are stored. You cannot write to this directory. Instead, I advise you to write document files to "../Documents/" and preferences to "../Library/Preferences". - -More information on this subject is available here: -http://developer.apple.com/library/ios/#documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Introduction/Introduction.html - -============================================================================== -Notes -- iPhone SDL limitations -============================================================================== - -Windows: - Full-size, single window applications only. You cannot create multi-window SDL applications for iPhone OS. The application window will fill the display, though you have the option of turning on or off the menu-bar (pass SDL_CreateWindow the flag SDL_WINDOW_BORDERLESS). - -Textures: - The optimal texture formats on iOS are SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, and SDL_PIXELFORMAT_RGB24 pixel formats. - -Loading Shared Objects: - This is disabled by default since it seems to break the terms of the iPhone SDK agreement. It can be re-enabled in SDL_config_iphoneos.h. - -============================================================================== -Game Center -============================================================================== - -Game Center integration requires that you break up your main loop in order to yield control back to the system. In other words, instead of running an endless main loop, you run each frame in a callback function, using: - -int SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (*callback)(void*), void *callbackParam); - -This will set up the given function to be called back on the animation callback, and then you have to return from main() to let the Cocoa event loop run. - -e.g. - -extern "C" -void ShowFrame(void*) -{ - ... do event handling, frame logic and rendering -} - -int main(int argc, char *argv[]) -{ - ... initialize game ... - -#if __IPHONEOS__ - // Initialize the Game Center for scoring and matchmaking - InitGameCenter(); - - // Set up the game to run in the window animation callback on iOS - // so that Game Center and so forth works correctly. - SDL_iPhoneSetAnimationCallback(window, 1, ShowFrame, NULL); -#else - while ( running ) { - ShowFrame(0); - DelayFrame(); - } -#endif - return 0; -} diff --git a/Engine/lib/sdl/README-linux.txt b/Engine/lib/sdl/README-linux.txt deleted file mode 100644 index e0f029d81..000000000 --- a/Engine/lib/sdl/README-linux.txt +++ /dev/null @@ -1,80 +0,0 @@ -================================================================================ -Simple DirectMedia Layer for Linux -================================================================================ - -By default SDL will only link against glibc, the rest of the features will be -enabled dynamically at runtime depending on the available features on the target -system. So, for example if you built SDL with Xinerama support and the target -system does not have the Xinerama libraries installed, it will be disabled -at runtime, and you won't get a missing library error, at least with the -default configuration parameters. - - -================================================================================ -Build Dependencies -================================================================================ - -Ubuntu 13.04, all available features enabled: - -sudo apt-get install build-essential mercurial make cmake autoconf automake \ -libtool libasound2-dev libpulse-dev libaudio-dev libx11-dev libxext-dev \ -libxrandr-dev libxcursor-dev libxi-dev libxinerama-dev libxxf86vm-dev \ -libxss-dev libgl1-mesa-dev libesd0-dev libdbus-1-dev libudev-dev \ -libgles1-mesa-dev libgles2-mesa-dev libegl1-mesa-dev - -NOTES: -- This includes all the audio targets except arts, because Ubuntu pulled the - artsc0-dev package, but in theory SDL still supports it. -- DirectFB isn't included because the configure script (currently) fails to find - it at all. You can do "sudo apt-get install libdirectfb-dev" and fix the - configure script to include DirectFB support. Send patches. :) - - -================================================================================ -Joystick does not work -================================================================================ - -If you compiled or are using a version of SDL with udev support (and you should!) -there's a few issues that may cause SDL to fail to detect your joystick. To -debug this, start by installing the evtest utility. On Ubuntu/Debian: - - sudo apt-get install evtest - -Then run: - - sudo evtest - -You'll hopefully see your joystick listed along with a name like "/dev/input/eventXX" -Now run: - - cat /dev/input/event/XX - -If you get a permission error, you need to set a udev rule to change the mode of -your device (see below) - -Also, try: - - sudo udevadm info --query=all --name=input/eventXX - -If you see a line stating ID_INPUT_JOYSTICK=1, great, if you don't see it, -you need to set up an udev rule to force this variable. - -A combined rule for the Saitek Pro Flight Rudder Pedals to fix both issues looks -like: - - SUBSYSTEM=="input", ATTRS{idProduct}=="0763", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1" - SUBSYSTEM=="input", ATTRS{idProduct}=="0764", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1" - -You can set up similar rules for your device by changing the values listed in -idProduct and idVendor. To obtain these values, try: - - sudo udevadm info -a --name=input/eventXX | grep idVendor - sudo udevadm info -a --name=input/eventXX | grep idProduct - -If multiple values come up for each of these, the one you want is the first one of each. - -On other systems which ship with an older udev (such as CentOS), you may need -to set up a rule such as: - - SUBSYSTEM=="input", ENV{ID_CLASS}=="joystick", ENV{ID_INPUT_JOYSTICK}="1" - diff --git a/Engine/lib/sdl/README-macosx.txt b/Engine/lib/sdl/README-macosx.txt deleted file mode 100644 index 35d70b759..000000000 --- a/Engine/lib/sdl/README-macosx.txt +++ /dev/null @@ -1,226 +0,0 @@ -============================================================================== -Using the Simple DirectMedia Layer with Mac OS X -============================================================================== - -These instructions are for people using Apple's Mac OS X (pronounced -"ten"). - -From the developer's point of view, OS X is a sort of hybrid Mac and -Unix system, and you have the option of using either traditional -command line tools or Apple's IDE Xcode. - -To build SDL using the command line, use the standard configure and make -process: - - ./configure - make - sudo make install - -You can also build SDL as a Universal library (a single binary for both -32-bit and 64-bit Intel architectures), on Mac OS X 10.7 and newer, by using -the fatbuild.sh script in build-scripts: - sh build-scripts/fatbuild.sh - sudo build-scripts/fatbuild.sh install -This script builds SDL with 10.5 ABI compatibility on i386 and 10.6 -ABI compatibility on x86_64 architectures. For best compatibility you -should compile your application the same way. A script which wraps -gcc to make this easy is provided in test/gcc-fat.sh - -Please note that building SDL requires at least Xcode 4.6 and the 10.7 SDK -(even if you target back to 10.5 systems). PowerPC support for Mac OS X has -been officially dropped as of SDL 2.0.2. - -To use the library once it's built, you essential have two possibilities: -use the traditional autoconf/automake/make method, or use Xcode. - -============================================================================== -Caveats for using SDL with Mac OS X -============================================================================== - -Some things you have to be aware of when using SDL on Mac OS X: - -- If you register your own NSApplicationDelegate (using [NSApp setDelegate:]), - SDL will not register its own. This means that SDL will not terminate using - SDL_Quit if it receives a termination request, it will terminate like a - normal app, and it will not send a SDL_DROPFILE when you request to open a - file with the app. To solve these issues, put the following code in your - NSApplicationDelegate implementation: - - - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender - { - if (SDL_GetEventState(SDL_QUIT) == SDL_ENABLE) { - SDL_Event event; - event.type = SDL_QUIT; - SDL_PushEvent(&event); - } - - return NSTerminateCancel; - } - - - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename - { - if (SDL_GetEventState(SDL_DROPFILE) == SDL_ENABLE) { - SDL_Event event; - event.type = SDL_DROPFILE; - event.drop.file = SDL_strdup([filename UTF8String]); - return (SDL_PushEvent(&event) > 0); - } - - return NO; - } - -============================================================================== -Using the Simple DirectMedia Layer with a traditional Makefile -============================================================================== - -An existing autoconf/automake build system for your SDL app has good chances -to work almost unchanged on OS X. However, to produce a "real" Mac OS X binary -that you can distribute to users, you need to put the generated binary into a -so called "bundle", which basically is a fancy folder with a name like -"MyCoolGame.app". - -To get this build automatically, add something like the following rule to -your Makefile.am: - -bundle_contents = APP_NAME.app/Contents -APP_NAME_bundle: EXE_NAME - mkdir -p $(bundle_contents)/MacOS - mkdir -p $(bundle_contents)/Resources - echo "APPL????" > $(bundle_contents)/PkgInfo - $(INSTALL_PROGRAM) $< $(bundle_contents)/MacOS/ - -You should replace EXE_NAME with the name of the executable. APP_NAME is what -will be visible to the user in the Finder. Usually it will be the same -as EXE_NAME but capitalized. E.g. if EXE_NAME is "testgame" then APP_NAME -usually is "TestGame". You might also want to use @PACKAGE@ to use the package -name as specified in your configure.in file. - -If your project builds more than one application, you will have to do a bit -more. For each of your target applications, you need a separate rule. - -If you want the created bundles to be installed, you may want to add this -rule to your Makefile.am: - -install-exec-hook: APP_NAME_bundle - rm -rf $(DESTDIR)$(prefix)/Applications/APP_NAME.app - mkdir -p $(DESTDIR)$(prefix)/Applications/ - cp -r $< /$(DESTDIR)$(prefix)Applications/ - -This rule takes the Bundle created by the rule from step 3 and installs them -into $(DESTDIR)$(prefix)/Applications/. - -Again, if you want to install multiple applications, you will have to augment -the make rule accordingly. - - -But beware! That is only part of the story! With the above, you end up with -a bare bone .app bundle, which is double clickable from the Finder. But -there are some more things you should do before shipping your product... - -1) The bundle right now probably is dynamically linked against SDL. That - means that when you copy it to another computer, *it will not run*, - unless you also install SDL on that other computer. A good solution - for this dilemma is to static link against SDL. On OS X, you can - achieve that by linking against the libraries listed by - sdl-config --static-libs - instead of those listed by - sdl-config --libs - Depending on how exactly SDL is integrated into your build systems, the - way to achieve that varies, so I won't describe it here in detail -2) Add an 'Info.plist' to your application. That is a special XML file which - contains some meta-information about your application (like some copyright - information, the version of your app, the name of an optional icon file, - and other things). Part of that information is displayed by the Finder - when you click on the .app, or if you look at the "Get Info" window. - More information about Info.plist files can be found on Apple's homepage. - - -As a final remark, let me add that I use some of the techniques (and some -variations of them) in Exult and ScummVM; both are available in source on -the net, so feel free to take a peek at them for inspiration! - - -============================================================================== -Using the Simple DirectMedia Layer with Xcode -============================================================================== - -These instructions are for using Apple's Xcode IDE to build SDL applications. - -- First steps - -The first thing to do is to unpack the Xcode.tar.gz archive in the -top level SDL directory (where the Xcode.tar.gz archive resides). -Because Stuffit Expander will unpack the archive into a subdirectory, -you should unpack the archive manually from the command line: - cd [path_to_SDL_source] - tar zxf Xcode.tar.gz -This will create a new folder called Xcode, which you can browse -normally from the Finder. - -- Building the Framework - -The SDL Library is packaged as a framework bundle, an organized -relocatable folder hierarchy of executable code, interface headers, -and additional resources. For practical purposes, you can think of a -framework as a more user and system-friendly shared library, whose library -file behaves more or less like a standard UNIX shared library. - -To build the framework, simply open the framework project and build it. -By default, the framework bundle "SDL.framework" is installed in -/Library/Frameworks. Therefore, the testers and project stationary expect -it to be located there. However, it will function the same in any of the -following locations: - - ~/Library/Frameworks - /Local/Library/Frameworks - /System/Library/Frameworks - -- Build Options - There are two "Build Styles" (See the "Targets" tab) for SDL. - "Deployment" should be used if you aren't tweaking the SDL library. - "Development" should be used to debug SDL apps or the library itself. - -- Building the Testers - Open the SDLTest project and build away! - -- Using the Project Stationary - Copy the stationary to the indicated folders to access it from - the "New Project" and "Add target" menus. What could be easier? - -- Setting up a new project by hand - Some of you won't want to use the Stationary so I'll give some tips: - * Create a new "Cocoa Application" - * Add src/main/macosx/SDLMain.m , .h and .nib to your project - * Remove "main.c" from your project - * Remove "MainMenu.nib" from your project - * Add "$(HOME)/Library/Frameworks/SDL.framework/Headers" to include path - * Add "$(HOME)/Library/Frameworks" to the frameworks search path - * Add "-framework SDL -framework Foundation -framework AppKit" to "OTHER_LDFLAGS" - * Set the "Main Nib File" under "Application Settings" to "SDLMain.nib" - * Add your files - * Clean and build - -- Building from command line - Use pbxbuild in the same directory as your .pbproj file - -- Running your app - You can send command line args to your app by either invoking it from - the command line (in *.app/Contents/MacOS) or by entering them in the - "Executables" panel of the target settings. - -- Implementation Notes - Some things that may be of interest about how it all works... - * Working directory - As defined in the SDL_main.m file, the working directory of your SDL app - is by default set to its parent. You may wish to change this to better - suit your needs. - * You have a Cocoa App! - Your SDL app is essentially a Cocoa application. When your app - starts up and the libraries finish loading, a Cocoa procedure is called, - which sets up the working directory and calls your main() method. - You are free to modify your Cocoa app with generally no consequence - to SDL. You cannot, however, easily change the SDL window itself. - Functionality may be added in the future to help this. - - -Known bugs are listed in the file "BUGS" diff --git a/Engine/lib/sdl/README-pandora.txt b/Engine/lib/sdl/README-pandora.txt deleted file mode 100644 index d522bc77a..000000000 --- a/Engine/lib/sdl/README-pandora.txt +++ /dev/null @@ -1,16 +0,0 @@ -SDL 2.0 with open pandora console support ( http://openpandora.org/ ) -===================================================================== - -- A pandora specific video driver was written to allow SDL 2.0 with OpenGL ES -support to work on the pandora under the framebuffer. This driver do not have -input support for now, so if you use it you will have to add your own control code. -The video driver name is "pandora" so if you have problem running it from -the framebuffer, try to set the following variable before starting your application : -"export SDL_VIDEODRIVER=pandora" - -- OpenGL ES support was added to the x11 driver, so it's working like the normal -x11 driver one with OpenGLX support, with SDL input event's etc.. - - -David Carré (Cpasjuste) -cpasjuste@gmail.com diff --git a/Engine/lib/sdl/README-platforms.txt b/Engine/lib/sdl/README-platforms.txt deleted file mode 100644 index 2a099cd4b..000000000 --- a/Engine/lib/sdl/README-platforms.txt +++ /dev/null @@ -1,30 +0,0 @@ - -This is a list of the platforms SDL supports, and who maintains them. - -Officially supported platforms -============================== -(code compiles, and thoroughly tested for release) -============================== -Windows XP/Vista/7/8 -Mac OS X 10.5+ -Linux 2.6+ -iOS 5.1.1+ -Android 2.3.3+ - -Unofficially supported platforms -================================ -(code compiles, but not thoroughly tested) -================================ -FreeBSD -NetBSD -OpenBSD -Solaris - -Platforms supported by volunteers -================================= -Haiku - maintained by Axel Dörfler -PSP - maintained by 527721088@qq.com -Pandora - maintained by Scott Smith - -Platforms that need maintainers -=============================== diff --git a/Engine/lib/sdl/README-porting.txt b/Engine/lib/sdl/README-porting.txt deleted file mode 100644 index f8540b600..000000000 --- a/Engine/lib/sdl/README-porting.txt +++ /dev/null @@ -1,61 +0,0 @@ - -* Porting To A New Platform - - The first thing you have to do when porting to a new platform, is look at -include/SDL_platform.h and create an entry there for your operating system. -The standard format is __PLATFORM__, where PLATFORM is the name of the OS. -Ideally SDL_platform.h will be able to auto-detect the system it's building -on based on C preprocessor symbols. - -There are two basic ways of building SDL at the moment: - -1. The "UNIX" way: ./configure; make; make install - - If you have a GNUish system, then you might try this. Edit configure.in, - take a look at the large section labelled: - "Set up the configuration based on the target platform!" - Add a section for your platform, and then re-run autogen.sh and build! - -2. Using an IDE: - - If you're using an IDE or other non-configure build system, you'll probably - want to create a custom SDL_config.h for your platform. Edit SDL_config.h, - add a section for your platform, and create a custom SDL_config_{platform}.h, - based on SDL_config.h.minimal and SDL_config.h.in - - Add the top level include directory to the header search path, and then add - the following sources to the project: - src/*.c - src/atomic/*.c - src/audio/*.c - src/cpuinfo/*.c - src/events/*.c - src/file/*.c - src/haptic/*.c - src/joystick/*.c - src/power/*.c - src/render/*.c - src/stdlib/*.c - src/thread/*.c - src/timer/*.c - src/video/*.c - src/audio/disk/*.c - src/audio/dummy/*.c - src/video/dummy/*.c - src/haptic/dummy/*.c - src/joystick/dummy/*.c - src/main/dummy/*.c - src/thread/generic/*.c - src/timer/dummy/*.c - src/loadso/dummy/*.c - - -Once you have a working library without any drivers, you can go back to each -of the major subsystems and start implementing drivers for your platform. - -If you have any questions, don't hesitate to ask on the SDL mailing list: - http://www.libsdl.org/mailing-list.php - -Enjoy! - Sam Lantinga (slouken@libsdl.org) - diff --git a/Engine/lib/sdl/README-psp.txt b/Engine/lib/sdl/README-psp.txt deleted file mode 100644 index d30842057..000000000 --- a/Engine/lib/sdl/README-psp.txt +++ /dev/null @@ -1,17 +0,0 @@ -SDL port for the Sony PSP contributed by - Captian Lex - -Credit to - Marcus R.Brown,Jim Paris,Matthew H for the original SDL 1.2 for PSP - Geecko for his PSP GU lib "Glib2d" - -Building --------- -To build for the PSP, make sure psp-config is in the path and run: - make -f Makefile.psp - - - -To Do ------- -PSP Screen Keyboard diff --git a/Engine/lib/sdl/README-raspberrypi.txt b/Engine/lib/sdl/README-raspberrypi.txt deleted file mode 100644 index bfc3f8b8c..000000000 --- a/Engine/lib/sdl/README-raspberrypi.txt +++ /dev/null @@ -1,161 +0,0 @@ -================================================================================ -SDL2 for Raspberry Pi -================================================================================ - -Requirements: - -Raspbian (other Linux distros may work as well). - -================================================================================ - Features -================================================================================ - -* Works without X11 -* Hardware accelerated OpenGL ES 2.x -* Sound via ALSA -* Input (mouse/keyboard/joystick) via EVDEV -* Hotplugging of input devices via UDEV - -================================================================================ - Raspbian Build Dependencies -================================================================================ - -sudo apt-get install libudev-dev libasound2-dev libdbus-1-dev - -You also need the VideoCore binary stuff that ships in /opt/vc for EGL and -OpenGL ES 2.x, it usually comes pre installed, but in any case: - -sudo apt-get install libraspberrypi0 libraspberrypi-bin libraspberrypi-dev - -================================================================================ - Cross compiling from x86 Linux -================================================================================ - -To cross compile SDL for Raspbian from your desktop machine, you'll need a -Raspbian system root and the cross compilation tools. We'll assume these tools -will be placed in /opt/rpi-tools - - sudo git clone --depth 1 https://github.com/raspberrypi/tools /opt/rpi-tools - -You'll also need a Rasbian binary image. -Get it from: http://downloads.raspberrypi.org/raspbian_latest -After unzipping, you'll get file with a name like: -wheezy-raspbian.img -Let's assume the sysroot will be built in /opt/rpi-sysroot. - - export SYSROOT=/opt/rpi-sysroot - sudo kpartx -a -v .img - sudo mount -o loop /dev/mapper/loop0p2 /mnt - sudo cp -r /mnt $SYSROOT - sudo apt-get install qemu binfmt-support qemu-user-static - sudo cp /usr/bin/qemu-arm-static $SYSROOT/usr/bin - sudo mount --bind /dev $SYSROOT/dev - sudo mount --bind /proc $SYSROOT/proc - sudo mount --bind /sys $SYSROOT/sys - -Now, before chrooting into the ARM sysroot, you'll need to apply a workaround, -edit $SYSROOT/etc/ld.so.preload and comment out all lines in it. - - sudo chroot $SYSROOT - apt-get install libudev-dev libasound2-dev libdbus-1-dev libraspberrypi0 libraspberrypi-bin libraspberrypi-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxinerama-dev libxxf86vm-dev libxss-dev - exit - sudo umount $SYSROOT/dev - sudo umount $SYSROOT/proc - sudo umount $SYSROOT/sys - sudo umount /mnt - -There's one more fix required, as the libdl.so symlink uses an absolute path -which doesn't quite work in our setup. - - sudo rm -rf $SYSROOT/usr/lib/arm-linux-gnueabihf/libdl.so - sudo ln -s ../../../lib/arm-linux-gnueabihf/libdl.so.2 $SYSROOT/usr/lib/arm-linux-gnueabihf/libdl.so - -The final step is compiling SDL itself. - - export CC="/opt/rpi-tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-gcc --sysroot=$SYSROOT -I$SYSROOT/opt/vc/include -I$SYSROOT/usr/include -I$SYSROOT/opt/vc/include/interface/vcos/pthreads -I$SYSROOT/opt/vc/include/interface/vmcs_host/linux" - cd - mkdir -p build;cd build - ../configure --with-sysroot=$SYSROOT --host=arm-raspberry-linux-gnueabihf --prefix=$PWD/rpi-sdl2-installed --disable-pulseaudio --disable-esd - make - make install - -To be able to deploy this to /usr/local in the Raspbian system you need to fix up a few paths: - - perl -w -pi -e "s#$PWD/rpi-sdl2-installed#/usr/local#g;" ./rpi-sdl2-installed/lib/libSDL2.la ./rpi-sdl2-installed/lib/pkgconfig/sdl2.pc ./rpi-sdl2-installed/bin/sdl2-config - -================================================================================ - Apps don't work or poor video/audio performance -================================================================================ - -If you get sound problems, buffer underruns, etc, run "sudo rpi-update" to -update the RPi's firmware. Note that doing so will fix these problems, but it -will also render the CMA - Dynamic Memory Split functionality useless. - -Also, by default the Raspbian distro configures the GPU RAM at 64MB, this is too -low in general, specially if a 1080p TV is hooked up. - -See here how to configure this setting: http://elinux.org/RPiconfig - -Using a fixed gpu_mem=128 is the best option (specially if you updated the -firmware, using CMA probably won't work, at least it's the current case). - -================================================================================ - No input -================================================================================ - -Make sure you belong to the "input" group. - - sudo usermod -aG input `whoami` - -================================================================================ - No HDMI Audio -================================================================================ - -If you notice that ALSA works but there's no audio over HDMI, try adding: - - hdmi_drive=2 - -to your config.txt file and reboot. - -Reference: http://www.raspberrypi.org/phpBB3/viewtopic.php?t=5062 - -================================================================================ - Text Input API support -================================================================================ - -The Text Input API is supported, with translation of scan codes done via the -kernel symbol tables. For this to work, SDL needs access to a valid console. -If you notice there's no SDL_TEXTINPUT message being emitted, double check that -your app has read access to one of the following: - -* /proc/self/fd/0 -* /dev/tty -* /dev/tty[0...6] -* /dev/vc/0 -* /dev/console - -This is usually not a problem if you run from the physical terminal (as opposed -to running from a pseudo terminal, such as via SSH). If running from a PTS, a -quick workaround is to run your app as root or add yourself to the tty group, -then re login to the system. - - sudo usermod -aG tty `whoami` - -The keyboard layout used by SDL is the same as the one the kernel uses. -To configure the layout on Raspbian: - - sudo dpkg-reconfigure keyboard-configuration - -To configure the locale, which controls which keys are interpreted as letters, -this determining the CAPS LOCK behavior: - - sudo dpkg-reconfigure locales - -================================================================================ - Notes -================================================================================ - -* When launching apps remotely (via SSH), SDL can prevent local keystrokes from - leaking into the console only if it has root privileges. Launching apps locally - does not suffer from this issue. - - diff --git a/Engine/lib/sdl/README-touch.txt b/Engine/lib/sdl/README-touch.txt deleted file mode 100644 index 6b41707ed..000000000 --- a/Engine/lib/sdl/README-touch.txt +++ /dev/null @@ -1,84 +0,0 @@ -=========================================================================== -System Specific Notes -=========================================================================== -Linux: -The linux touch system is currently based off event streams, and proc/bus/devices. The active user must be given permissions to read /dev/input/TOUCHDEVICE, where TOUCHDEVICE is the event stream for your device. Currently only Wacom tablets are supported. If you have an unsupported tablet contact me at jim.tla+sdl_touch@gmail.com and I will help you get support for it. - -Mac: -The Mac and iPhone APIs are pretty. If your touch device supports them then you'll be fine. If it doesn't, then there isn't much we can do. - -iPhone: -Works out of box. - -Windows: -Unfortunately there is no windows support as of yet. Support for Windows 7 is planned, but we currently have no way to test. If you have a Windows 7 WM_TOUCH supported device, and are willing to help test please contact me at jim.tla+sdl_touch@gmail.com - -=========================================================================== -Events -=========================================================================== -SDL_FINGERDOWN: -Sent when a finger (or stylus) is placed on a touch device. -Fields: -event.tfinger.touchId - the Id of the touch device. -event.tfinger.fingerId - the Id of the finger which just went down. -event.tfinger.x - the x coordinate of the touch (0..1) -event.tfinger.y - the y coordinate of the touch (0..1) -event.tfinger.pressure - the pressure of the touch (0..1) - -SDL_FINGERMOTION: -Sent when a finger (or stylus) is moved on the touch device. -Fields: -Same as SDL_FINGERDOWN but with additional: -event.tfinger.dx - change in x coordinate during this motion event. -event.tfinger.dy - change in y coordinate during this motion event. - -SDL_FINGERUP: -Sent when a finger (or stylus) is lifted from the touch device. -Fields: -Same as SDL_FINGERDOWN. - - -=========================================================================== -Functions -=========================================================================== -SDL provides the ability to access the underlying Finger structures. -These structures should _never_ be modified. - -The following functions are included from SDL_touch.h - -To get a SDL_TouchID call SDL_GetTouchDevice(index). -This returns a SDL_TouchID. -IMPORTANT: If the touch has been removed, or there is no touch with the given ID, SDL_GetTouchID will return 0. Be sure to check for this! - -The number of touch devices can be queried with SDL_GetNumTouchDevices(). - -A SDL_TouchID may be used to get pointers to SDL_Finger. - -SDL_GetNumTouchFingers(touchID) may be used to get the number of fingers currently down on the device. - -The most common reason to access SDL_Finger is to query the fingers outside the event. In most cases accessing the fingers is using the event. This would be accomplished by code like the following: - - float x = event.tfinger.x; - float y = event.tfinger.y; - - - -To get a SDL_Finger, call SDL_GetTouchFinger(touchID,index), where touchID is a SDL_TouchID, and index is the requested finger. -This returns a SDL_Finger*, or NULL if the finger does not exist, or has been removed. -A SDL_Finger is guaranteed to be persistent for the duration of a touch, but it will be de-allocated as soon as the finger is removed. This occurs when the SDL_FINGERUP event is _added_ to the event queue, and thus _before_ the SDL_FINGERUP event is polled. -As a result, be very careful to check for NULL return values. - -A SDL_Finger has the following fields: ->x,y,pressure: - The current coordinates of the touch. ->pressure: - The pressure of the touch. - -=========================================================================== -Notes -=========================================================================== -For a complete example see test/testgesture.c - -Please direct questions/comments to: - jim.tla+sdl_touch@gmail.com - (original author, API was changed since) diff --git a/Engine/lib/sdl/README-wince.txt b/Engine/lib/sdl/README-wince.txt deleted file mode 100644 index 9ebc695a7..000000000 --- a/Engine/lib/sdl/README-wince.txt +++ /dev/null @@ -1,8 +0,0 @@ - -Windows CE is no longer supported by SDL. - -We have left the CE support in SDL 1.2 for those that must have it, and we -have support for Windows Phone 8 and WinRT in SDL2, as of SDL 2.0.3. - ---ryan. - diff --git a/Engine/lib/sdl/README-windows.txt b/Engine/lib/sdl/README-windows.txt deleted file mode 100644 index 7f9c4a35f..000000000 --- a/Engine/lib/sdl/README-windows.txt +++ /dev/null @@ -1,42 +0,0 @@ -================================================================================ -Simple DirectMedia Layer for Windows -================================================================================ - -================================================================================ -OpenGL ES 2.x support -================================================================================ - -SDL has support for OpenGL ES 2.x under Windows via two alternative -implementations. -The most straightforward method consists in running your app in a system with -a graphic card paired with a relatively recent (as of November of 2013) driver -which supports the WGL_EXT_create_context_es2_profile extension. Vendors known -to ship said extension on Windows currently include nVidia and Intel. - -The other method involves using the ANGLE library (https://code.google.com/p/angleproject/) -If an OpenGL ES 2.x context is requested and no WGL_EXT_create_context_es2_profile -extension is found, SDL will try to load the libEGL.dll library provided by -ANGLE. -To obtain the ANGLE binaries, you can either compile from source from -https://chromium.googlesource.com/angle/angle or copy the relevant binaries from -a recent Chrome/Chromium install for Windows. The files you need are: - - * libEGL.dll - * libGLESv2.dll - * d3dcompiler_46.dll (supports Windows Vista or later, better shader compiler) - or... - * d3dcompiler_43.dll (supports Windows XP or later) - -If you compile ANGLE from source, you can configure it so it does not need the -d3dcompiler_* DLL at all (for details on this, see their documentation). -However, by default SDL will try to preload the d3dcompiler_46.dll to -comply with ANGLE's requirements. If you wish SDL to preload d3dcompiler_43.dll (to -support Windows XP) or to skip this step at all, you can use the -SDL_HINT_VIDEO_WIN_D3DCOMPILER hint (see SDL_hints.h for more details). - -Known Bugs: - - * SDL_GL_SetSwapInterval is currently a no op when using ANGLE. It appears - that there's a bug in the library which prevents the window contents from - refreshing if this is set to anything other than the default value. - diff --git a/Engine/lib/sdl/README.txt b/Engine/lib/sdl/README.txt index b9f80ee73..f76a633ba 100644 --- a/Engine/lib/sdl/README.txt +++ b/Engine/lib/sdl/README.txt @@ -14,29 +14,8 @@ hardware via OpenGL and Direct3D. It is used by video playback software, emulators, and popular games including Valve's award winning catalog and many Humble Bundle games. -SDL officially supports Windows, Mac OS X, Linux, iOS, and Android. -Support for other platforms may be found in the source code. - -SDL is written in C, works natively with C++, and there are bindings -available for several other languages, including C# and Python. - -This library is distributed under the zlib license, which can be found -in the file "COPYING.txt". - -The best way to learn how to use SDL is to check out the header files in -the "include" subdirectory and the programs in the "test" subdirectory. -The header files and test programs are well commented and always up to date. -More documentation and FAQs are available online at: - http://wiki.libsdl.org/ - -If you need help with the library, or just want to discuss SDL related -issues, you can join the developers mailing list: - http://www.libsdl.org/mailing-list.php - -If you want to report bugs or contribute patches, please submit them to -bugzilla: - http://bugzilla.libsdl.org/ +More extensive documentation is available in the docs directory, starting +with README.md Enjoy! Sam Lantinga (slouken@libsdl.org) - diff --git a/Engine/lib/sdl/SDL2.spec b/Engine/lib/sdl/SDL2.spec index e8220c170..0fe57540f 100644 --- a/Engine/lib/sdl/SDL2.spec +++ b/Engine/lib/sdl/SDL2.spec @@ -1,7 +1,7 @@ Summary: Simple DirectMedia Layer Name: SDL2 -Version: 2.0.3 -Release: 1 +Version: 2.0.4 +Release: 2 Source: http://www.libsdl.org/release/%{name}-%{version}.tar.gz URL: http://www.libsdl.org/ License: zlib @@ -63,12 +63,12 @@ rm -rf $RPM_BUILD_ROOT %files %{__defattr} -%doc README-SDL.txt COPYING.txt CREDITS.txt BUGS.txt +%doc README*.txt COPYING.txt CREDITS.txt BUGS.txt %{_libdir}/lib*.%{__soext}.* %files devel %{__defattr} -%doc README README-SDL.txt COPYING CREDITS BUGS WhatsNew +%doc docs/README*.md %{_bindir}/*-config %{_libdir}/lib*.a %{_libdir}/lib*.la @@ -78,13 +78,19 @@ rm -rf $RPM_BUILD_ROOT %{_datadir}/aclocal/* %changelog +* Thu Jun 04 2015 Ryan C. Gordon +- Fixed README paths. + +* Sun Dec 07 2014 Simone Contini +- Fixed changelog date issue and docs filenames + * Sun Jan 22 2012 Sam Lantinga - Updated for SDL 2.0 * Tue May 16 2006 Sam Lantinga - Removed support for Darwin, due to build problems on ps2linux -* Mon Jan 03 2004 Anders Bjorklund +* Sat Jan 03 2004 Anders Bjorklund - Added support for Darwin, updated spec file * Wed Jan 19 2000 Sam Lantinga diff --git a/Engine/lib/sdl/SDL2.spec.in b/Engine/lib/sdl/SDL2.spec.in index 2a5c47924..dba240037 100644 --- a/Engine/lib/sdl/SDL2.spec.in +++ b/Engine/lib/sdl/SDL2.spec.in @@ -1,7 +1,7 @@ Summary: Simple DirectMedia Layer Name: SDL2 Version: @SDL_VERSION@ -Release: 1 +Release: 2 Source: http://www.libsdl.org/release/%{name}-%{version}.tar.gz URL: http://www.libsdl.org/ License: zlib @@ -63,12 +63,12 @@ rm -rf $RPM_BUILD_ROOT %files %{__defattr} -%doc README-SDL.txt COPYING.txt CREDITS.txt BUGS.txt +%doc README*.txt COPYING.txt CREDITS.txt BUGS.txt %{_libdir}/lib*.%{__soext}.* %files devel %{__defattr} -%doc README README-SDL.txt COPYING CREDITS BUGS WhatsNew +%doc docs/README*.md %{_bindir}/*-config %{_libdir}/lib*.a %{_libdir}/lib*.la @@ -78,13 +78,19 @@ rm -rf $RPM_BUILD_ROOT %{_datadir}/aclocal/* %changelog +* Thu Jun 04 2015 Ryan C. Gordon +- Fixed README paths. + +* Sun Dec 07 2014 Simone Contini +- Fixed changelog date issue and docs filenames + * Sun Jan 22 2012 Sam Lantinga - Updated for SDL 2.0 * Tue May 16 2006 Sam Lantinga - Removed support for Darwin, due to build problems on ps2linux -* Mon Jan 03 2004 Anders Bjorklund +* Sat Jan 03 2004 Anders Bjorklund - Added support for Darwin, updated spec file * Wed Jan 19 2000 Sam Lantinga diff --git a/Engine/lib/sdl/VisualC.html b/Engine/lib/sdl/VisualC.html index a25907bd9..89035d677 100644 --- a/Engine/lib/sdl/VisualC.html +++ b/Engine/lib/sdl/VisualC.html @@ -22,8 +22,7 @@

There are different solution files for the various versions of the IDE. Please use the appropiate version - 2008, 2010 or 2012; the 2010EE and 2012EE files - should be used with the "Express Edition" releases. + 2008, 2010, 2012 or 2013.

Build the .dll and .lib files. @@ -111,8 +110,8 @@

Now create the basic body of your project. The body of your program should take - the following form: - 

+			the following form:
+			

 #include "SDL.h"
 
 int main( int argc, char* argv[] )
@@ -120,8 +119,7 @@ int main( int argc, char* argv[] )
   // Body of the program goes here.
   return 0;
 }
-

-			
+

That's it! diff --git a/Engine/lib/sdl/VisualC/clean.sh b/Engine/lib/sdl/VisualC/clean.sh index f90a11e97..fd16f9a12 100644 --- a/Engine/lib/sdl/VisualC/clean.sh +++ b/Engine/lib/sdl/VisualC/clean.sh @@ -1,5 +1,4 @@ -find . -type d -name 'Debug' -exec rm -rv {} \; -find . -type d -name 'Release' -exec rm -rv {} \; -find . -type f -name '*.user' -exec rm -v {} \; -find . -type f -name '*.ncb' -exec rm -v {} \; -find . -type f -name '*.suo' -exec rm -v {} \; +#!/bin/sh +find . -type f \( -name '*.user' -o -name '*.sdf' -o -name '*.ncb' -o -name '*.suo' \) -print -delete +find . -type f \( -name '*.bmp' -o -name '*.wav' -o -name '*.dat' \) -print -delete +find . -depth -type d \( -name Win32 -o -name x64 \) -exec rm -rv {} \; diff --git a/Engine/lib/sdl/WhatsNew.txt b/Engine/lib/sdl/WhatsNew.txt index d0e5f6d38..9b7139f5d 100644 --- a/Engine/lib/sdl/WhatsNew.txt +++ b/Engine/lib/sdl/WhatsNew.txt @@ -1,6 +1,97 @@ This is a list of major changes in SDL's version history. +--------------------------------------------------------------------------- +2.0.4: +--------------------------------------------------------------------------- + +General: +* Added support for web applications using Emscripten, see docs/README-emscripten.md for more information +* Added support for web applications using Native Client (NaCl), see docs/README-nacl.md for more information +* Added an API to queue audio instead of using the audio callback: + SDL_QueueAudio(), SDL_GetQueuedAudioSize(), SDL_ClearQueuedAudio() +* Added events for audio device hot plug support: + SDL_AUDIODEVICEADDED, SDL_AUDIODEVICEREMOVED +* Added SDL_PointInRect() +* Added SDL_HasAVX2() to detect CPUs with AVX2 support +* Added SDL_SetWindowHitTest() to let apps treat parts of their SDL window like traditional window decorations (drag areas, resize areas) +* Added SDL_GetGrabbedWindow() to get the window that currently has input grab, if any +* Added SDL_RenderIsClipEnabled() to tell whether clipping is currently enabled in a renderer +* Added SDL_CaptureMouse() to capture the mouse to get events while the mouse is not in your window +* Added SDL_WarpMouseGlobal() to warp the mouse cursor in global screen space +* Added SDL_GetGlobalMouseState() to get the current mouse state outside of an SDL window +* Added a direction field to mouse wheel events to tell whether they are flipped (natural) or not +* Added GL_CONTEXT_RELEASE_BEHAVIOR GL attribute (maps to [WGL|GLX]_ARB_context_flush_control extension) +* Added EGL_KHR_create_context support to allow OpenGL ES version selection on some platforms +* Added NV12 and NV21 YUV texture support for OpenGL and OpenGL ES 2.0 renderers +* Added a Vivante video driver that is used on various SoC platforms +* Added an event SDL_RENDER_DEVICE_RESET that is sent from the D3D renderers when the D3D device is lost, and from Android's event loop when the GLES context had to be recreated +* Added a hint SDL_HINT_NO_SIGNAL_HANDLERS to disable SDL's built in signal handling +* Added a hint SDL_HINT_THREAD_STACK_SIZE to set the stack size of SDL's threads +* Added SDL_sqrtf(), SDL_tan(), and SDL_tanf() to the stdlib routines +* Improved support for WAV and BMP files with unusual chunks in them +* Renamed SDL_assert_data to SDL_AssertData and SDL_assert_state to SDL_AssertState +* Added a hint SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN to prevent window interaction while cursor is hidden +* Added SDL_GetDisplayDPI() to get the DPI information for a display +* Added SDL_JoystickCurrentPowerLevel() to get the battery level of a joystick +* Added SDL_JoystickFromInstanceID(), as a helper function, to get the SDL_Joystick* that an event is referring to. +* Added SDL_GameControllerFromInstanceID(), as a helper function, to get the SDL_GameController* that an event is referring to. + +Windows: +* Added support for Windows Phone 8.1 and Windows 10/UWP (Universal Windows Platform) +* Timer resolution is now 1 ms by default, adjustable with the SDL_HINT_TIMER_RESOLUTION hint +* SDLmain no longer depends on the C runtime, so you can use the same .lib in both Debug and Release builds +* Added SDL_SetWindowsMessageHook() to set a function to be called for every windows message before TranslateMessage() +* Added a hint SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP to control whether SDL_PumpEvents() processes the Windows message loop +* You can distinguish between real mouse and touch events by looking for SDL_TOUCH_MOUSEID in the mouse event "which" field +* SDL_SysWMinfo now contains the window HDC +* Added support for Unicode command line options +* Prevent beeping when Alt-key combos are pressed +* SDL_SetTextInputRect() re-positions the OS-rendered IME +* Added a hint SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 to prevent generating SDL_WINDOWEVENT_CLOSE events when Alt-F4 is pressed +* Added a hint SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING to use the old axis and button mapping for XInput devices (deprecated) + +Mac OS X: +* Implemented drag-and-drop support +* Improved joystick hot-plug detection +* The SDL_WINDOWEVENT_EXPOSED window event is triggered in the appropriate situations +* Fixed relative mouse mode when the application loses/regains focus +* Fixed bugs related to transitioning to and from Spaces-aware fullscreen-desktop mode +* Fixed the refresh rate of display modes +* SDL_SysWMInfo is now ARC-compatible +* Added a hint SDL_HINT_MAC_BACKGROUND_APP to prevent forcing the application to become a foreground process + +Linux: +* Enabled building with Mir and Wayland support by default. +* Added IBus IME support +* Added a hint SDL_HINT_IME_INTERNAL_EDITING to control whether IBus should handle text editing internally instead of sending SDL_TEXTEDITING events +* Added a hint SDL_HINT_VIDEO_X11_NET_WM_PING to allow disabling _NET_WM_PING protocol handling in SDL_CreateWindow() +* Added support for multiple audio devices when using Pulseaudio +* Fixed duplicate mouse events when using relative mouse motion + +iOS: +* Added support for iOS 8 +* The SDL_WINDOW_ALLOW_HIGHDPI window flag now enables high-dpi support, and SDL_GL_GetDrawableSize() or SDL_GetRendererOutputSize() gets the window resolution in pixels +* SDL_GetWindowSize() and display mode sizes are in the "DPI-independent points" / "screen coordinates" coordinate space rather than pixels (matches OS X behavior) +* Added native resolution support for the iPhone 6 Plus +* Added support for MFi game controllers +* Added support for the hint SDL_HINT_ACCELEROMETER_AS_JOYSTICK +* Added sRGB OpenGL ES context support on iOS 7+ +* Added support for SDL_DisableScreenSaver(), SDL_EnableScreenSaver() and the hint SDL_HINT_VIDEO_ALLOW_SCREENSAVER +* SDL_SysWMinfo now contains the OpenGL ES framebuffer and color renderbuffer objects used by the window's active GLES view +* Fixed various rotation and orientation issues +* Fixed memory leaks + +Android: +* Added a hint SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH to prevent mouse events from being registered as touch events +* Added hints SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION and SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION +* Added support for SDL_DisableScreenSaver(), SDL_EnableScreenSaver() and the hint SDL_HINT_VIDEO_ALLOW_SCREENSAVER +* Added support for SDL_ShowMessageBox() and SDL_ShowSimpleMessageBox() + +Raspberry Pi: +* Added support for the Raspberry Pi 2 + + --------------------------------------------------------------------------- 2.0.3: --------------------------------------------------------------------------- diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/Default.png b/Engine/lib/sdl/Xcode-iOS/Demos/Default.png deleted file mode 100644 index f91282875ae2654ee5ff9f347921620f358fd85e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 18383 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 diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist b/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist deleted file mode 100644 index 0398f008b..000000000 --- a/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist +++ /dev/null @@ -1,30 +0,0 @@ - - - - - CFBundleDevelopmentRegion - en - CFBundleDisplayName - ${PRODUCT_NAME} - CFBundleExecutable - ${EXECUTABLE_NAME} - CFBundleIconFile - - CFBundleIdentifier - com.yourcompany.${PRODUCT_NAME:identifier} - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - ${PRODUCT_NAME} - CFBundlePackageType - APPL - CFBundleSignature - ???? - CFBundleVersion - 1.0 - NSMainNibFile - - UISupportedInterfaceOrientations - - - diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/README b/Engine/lib/sdl/Xcode-iOS/Demos/README deleted file mode 100644 index 55f8066d6..000000000 --- a/Engine/lib/sdl/Xcode-iOS/Demos/README +++ /dev/null @@ -1,43 +0,0 @@ -============================================================================== -About the iPhone OS Demo Applications -============================================================================== - -Demos.xcodeproj contains several targets for iPhone oriented SDL demos. These demos are written strictly using SDL 1.3 calls. All the demos except for Fireworks (which requires OpenGL ES) should work on platforms other than iPhone OS, though you'll need to write your own compile script. To run them on your favorite platform, you may wish to set the macros SCREEN_WIDTH and SCREEN_HEIGHT, located in common.h. - -Common files: - - common.c and common.h contain code common to all demo applications. This includes macros about the screen dimensions (in pixels), simple error handling, and functions for generating random numbers. - -Rectangles (rectangles.c): - - Draws randomly sized and colored rectangles all over the screen by using SDL_RenderFill. This is the simplest of all the demos. - -Happy (happy.c): - - Loads the classic happy-face bitmap and draws a large number of happy faces bouncing around the screen. Shows how you can load a bitmap into an SDL_Texture. - -Accelerometer (accelerometer.c): - - Uses the iPhone's accelerometer as a joystick device to move a spaceship around the screen. Note the use of the macro SDL_IPHONE_MAX_GFORCE (normally defined in SDL_config_iphoneos.h) which converts between the Sint16 number returned by SDL_JoystickGetAxis, and the floating point units of g-force reported natively by the iPhone. - -Touch (touch.c): - - Acts as a finger-paint type program. Demonstrates how you can use SDL mouse input to accept touch input from the iPhone. If SDL for iPhone is compiled with multitouch as multiple mouse emulation (SDL_IPHONE_MULTIPLE_MICE in SDL_config_iphoneos.h) then the program will accept multiple finger inputs simultaneously. - -Mixer (mixer.c): - - Displays several rectangular buttons which can be used as a virtual drumkit. Demonstrates how you can play .wav sounds in SDL and how you can use SDL_MixAudioFormat to build a software mixer that can play multiple sounds at once. - -Keyboard (keyboard.c): - - Loads a bitmap font and let's the user type words, numbers, and symbols using the iPhone's virtual keyboard. The iPhone's onscreen keyboard visibility is toggled when the user taps the screen. If the user types ':)' a happy face is displayed. Demonstrates how to use functions added to the iPhone implementation of SDL to toggle keyboard onscreen visibility. - -Fireworks (fireworks.c): - - Displays a fireworks show. When you tap the iPhone's screen, fireworks fly from the bottom of the screen and explode at the point that you tapped. Demonstrates how you can use SDL on iPhone to build an OpenGL ES based application. Shows you how you can use SDL_LoadBMP to load a bmp image and convert it to an OpenGL ES texture. Of lesser importance, shows how you can use OpenGL ES point sprites to build an efficient particle system. - -============================================================================== -Building and Running the demos -============================================================================== - -Before building the demos you must first build SDL as a static library for BOTH the iPhone Simulator and the iPhone itself. See the iPhone SDL main README file for directions on how to do this. Once this is done, simply launch XCode, select the target you'd like to build, select the active SDK (simulator or device), and then build and go. diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/kromasky_16x16.bmp b/Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/kromasky_16x16.bmp deleted file mode 100644 index c0b6fb964fd176d5770cf7000088fe1c87b220bf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 45368 zcmeHPF{`CX6&y7%FcCK~G8Qut)Nm0L4EzVi`xD$Bp_$Qwk*f;^D{7`-WV$SDCJ2h4 z*{Wb5h{Chpt9@n7sXqO6fA`**eY(TlZ>mq%sZ)LWd*AK3duP7(t*`$4*~70dQc8Et4vTyOxTdFfapyc~ z>DW`cxN{skzr!7WH@>UC%fGcB*C(b!kGtpHxaT@v(Q%Gr*CFPt$2yw~!BiG`0I$eC%4|P&4BlC52{7d|}x9jSst8@D9 zu+yA#GK-P*taYZ>VwOj|Zi%Zzi4TV&0}Khnpl6-H)cnRbzy97Yzl#?DBPXPkBA=3_ zxL;KWWF z*02`pGSRPYCUGgmVbT;K;iaF4wLo@8L-{O#gq7z5nYw?}=f!yL6eFF^RrnD9(pSC+ zhgfy-xvMXqrGXk=OTXx-F5|d%&KVa?V9qc47?Qsm@2VW?uz_@&OL$p+w5S5NnDhI80hblsJ^__*#fS zR%GPG`8FnS0q$%wzD3Ry7k8vsCCKuqS`+X^R@i#|nsbtOeVTrku5 zFa3c6naSUc7c&^H_{l8R^?vSRD*WNyxAnT6=3=b}+FP%^cK5~`cf%ub>cG4jsD%Jr zzLwp7-iVKd=&cQJaQp@E(4RYgV$3(eG~n$zY>1QD$-|VaIEk$2C&%|U#fN;q4TQ^D zIK)*100mWu5$AMRxkYo%S0RC{$Os8JJJ;Xk%LYK^x|4H$*0WY>C1=;a^MNVo=V3$& z$A{!EeqVxQTwUMQ9E&XAvyMUF^8t?n;Ge$zi|@StI-U{$7?$S))%>1eWIgV=jyoOa zIDT1t*7XKD&OW$j$DRLq9JQPP+-YJ;Wao6)Wu3Dd_gu#-I^-~Gg}6#)&1E~Z12#>4Z^ zzx}m5?CLn5no#4*n*gjh0H-1s9}DB8cZVbKJMRpR#LR+Kmjb5wTuU)t449B1x| zez(7<<$}Ph?wXEyV>3dgr)Ta8$MuDI`!OBY^iSs8553J@adurl)#Mpq?k97#OtmpN zEBf6kcKuLCW(r7eb3W2Z;Cc1OKl%xWejS#WoQFM^7_wJ94^xxR2Vk6m(LWX`78cQt0kWP-CkE~&XG7k>Zc}Xut$fB zd@muq(g%?NoWI^5W_5h&gFvSD>I8O^R}_5zkMH6oaSqG1lzSL{a2VE+c=#zX6VZVp zsGg`U8X~+1vWHB}_$0DetI±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 a>CgMt_2-hf@6IJUzMH!`p6mG0+kXHiqKaAo diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/license.txt b/Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/license.txt deleted file mode 100644 index 6949ec444..000000000 --- a/Engine/lib/sdl/Xcode-iOS/Demos/data/bitmapfont/license.txt +++ /dev/null @@ -1,258 +0,0 @@ - __ _ _ - / _| | | | | -| |_ ___ _ __ | |_ _ __ __ _ ___| | __ -| _/ _ \| '_ \| __| '_ \ / _` |/ __| |/ / -| || (_) | | | | |_| |_) | (_| | (__| < -|_| \___/|_| |_|\__| .__/ \__,_|\___|_|\_\ - | | - |_| ----------------------------------------------------------------------- -Product : font-pack.zip -Website : http://www.spicypixel.net -Author : Marc Russell -Released: 16th January 2008 ----------------------------------------------------------------------- - -What is this? -------------- -font-pack is a package of free art assets to be used under the terms of this document. It is available to game developers and hobbyists alike. - -Contents --------- -The contents of the font-pack ZIP file include 20 bitmap fonts - -Usage License & Restrictions ----------------------------- -font-pack is distributed under the "Common Public License Version 1.0." -The terms of which are given below. If you do not understand the terms of the license please refer to a solicitor. It should however, be relatively clear how this package can be used. - -THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON -PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF -THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. - -1. DEFINITIONS - -"Contribution" means: - - a) in the case of the initial Contributor, the initial code and - documentation distributed under this Agreement, and - - b) in the case of each subsequent Contributor: - - i) changes to the Program, and - - ii) additions to the Program; - - where such changes and/or additions to the Program originate from - and are distributed by that particular Contributor. A Contribution - 'originates' from a Contributor if it was added to the Program by - such Contributor itself or anyone acting on such Contributor's - behalf. Contributions do not include additions to the Program which: - (i) are separate modules of software distributed in conjunction with - the Program under their own license agreement, and (ii) are not - derivative works of the Program. - -"Contributor" means any person or entity that distributes the Program. - -"Licensed Patents " mean patent claims licensable by a Contributor which -are necessarily infringed by the use or sale of its Contribution alone -or when combined with the Program. - -"Program" means the Contributions distributed in accordance with this -Agreement. - -"Recipient" means anyone who receives the Program under this Agreement, -including all Contributors. - -2. GRANT OF RIGHTS - - a) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free copyright - license to reproduce, prepare derivative works of, publicly display, - publicly perform, distribute and sublicense the Contribution of such - Contributor, if any, and such derivative works, in source code and - object code form. - - b) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free patent - license under Licensed Patents to make, use, sell, offer to sell, - import and otherwise transfer the Contribution of such Contributor, - if any, in source code and object code form. This patent license - shall apply to the combination of the Contribution and the Program - if, at the time the Contribution is added by the Contributor, such - addition of the Contribution causes such combination to be covered - by the Licensed Patents. The patent license shall not apply to any - other combinations which include the Contribution. No hardware per - se is licensed hereunder. - - c) Recipient understands that although each Contributor grants the - licenses to its Contributions set forth herein, no assurances are - provided by any Contributor that the Program does not infringe the - patent or other intellectual property rights of any other entity. - Each Contributor disclaims any liability to Recipient for claims - brought by any other entity based on infringement of intellectual - property rights or otherwise. As a condition to exercising the - rights and licenses granted hereunder, each Recipient hereby assumes - sole responsibility to secure any other intellectual property rights - needed, if any. For example, if a third party patent license is - required to allow Recipient to distribute the Program, it is - Recipient's responsibility to acquire that license before - distributing the Program. - - d) Each Contributor represents that to its knowledge it has - sufficient copyright rights in its Contribution, if any, to grant - the copyright license set forth in this Agreement. - -3. REQUIREMENTS - -A Contributor may choose to distribute the Program in object code form -under its own license agreement, provided that: - - a) it complies with the terms and conditions of this Agreement; and - - b) its license agreement: - - i) effectively disclaims on behalf of all Contributors all - warranties and conditions, express and implied, including warranties - or conditions of title and non-infringement, and implied warranties - or conditions of merchantability and fitness for a particular - purpose; - - ii) effectively excludes on behalf of all Contributors all liability - for damages, including direct, indirect, special, incidental and - consequential damages, such as lost profits; - - iii) states that any provisions which differ from this Agreement are - offered by that Contributor alone and not by any other party; and - - iv) states that source code for the Program is available from such - Contributor, and informs licensees how to obtain it in a reasonable - manner on or through a medium customarily used for software - exchange. - -When the Program is made available in source code form: - - a) it must be made available under this Agreement; and - - b) a copy of this Agreement must be included with each copy of the - Program. - -Contributors may not remove or alter any copyright notices contained -within the Program. - -Each Contributor must identify itself as the originator of its -Contribution, if any, in a manner that reasonably allows subsequent -Recipients to identify the originator of the Contribution. - -4. COMMERCIAL DISTRIBUTION - -Commercial distributors of software may accept certain responsibilities -with respect to end users, business partners and the like. While this -license is intended to facilitate the commercial use of the Program, the -Contributor who includes the Program in a commercial product offering -should do so in a manner which does not create potential liability for -other Contributors. Therefore, if a Contributor includes the Program in -a commercial product offering, such Contributor ("Commercial -Contributor") hereby agrees to defend and indemnify every other -Contributor ("Indemnified Contributor") against any losses, damages and -costs (collectively "Losses") arising from claims, lawsuits and other -legal actions brought by a third party against the Indemnified -Contributor to the extent caused by the acts or omissions of such -Commercial Contributor in connection with its distribution of the -Program in a commercial product offering. The obligations in this -section do not apply to any claims or Losses relating to any actual or -alleged intellectual property infringement. In order to qualify, an -Indemnified Contributor must: a) promptly notify the Commercial -Contributor in writing of such claim, and b) allow the Commercial -Contributor to control, and cooperate with the Commercial Contributor -in, the defense and any related settlement negotiations. The Indemnified -Contributor may participate in any such claim at its own expense. - -For example, a Contributor might include the Program in a commercial -product offering, Product X. That Contributor is then a Commercial -Contributor. If that Commercial Contributor then makes performance -claims, or offers warranties related to Product X, those performance -claims and warranties are such Commercial Contributor's responsibility -alone. Under this section, the Commercial Contributor would have to -defend claims against the other Contributors related to those -performance claims and warranties, and if a court requires any other -Contributor to pay any damages as a result, the Commercial Contributor -must pay those damages. - -5. NO WARRANTY - -EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED -ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, -EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES -OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR -A PARTICULAR PURPOSE. Each Recipient is solely responsible for -determining the appropriateness of using and distributing the Program -and assumes all risks associated with its exercise of rights under this -Agreement, including but not limited to the risks and costs of program -errors, compliance with applicable laws, damage to or loss of data, -programs or equipment, and unavailability or interruption of operations. - -6. DISCLAIMER OF LIABILITY - -EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR -ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING -WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR -DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED -HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - -7. GENERAL - -If any provision of this Agreement is invalid or unenforceable under -applicable law, it shall not affect the validity or enforceability of -the remainder of the terms of this Agreement, and without further action -by the parties hereto, such provision shall be reformed to the minimum -extent necessary to make such provision valid and enforceable. - -If Recipient institutes patent litigation against a Contributor with -respect to a patent applicable to software (including a cross-claim or -counterclaim in a lawsuit), then any patent licenses granted by that -Contributor to such Recipient under this Agreement shall terminate as of -the date such litigation is filed. In addition, if Recipient institutes -patent litigation against any entity (including a cross-claim or -counterclaim in a lawsuit) alleging that the Program itself (excluding -combinations of the Program with other software or hardware) infringes -such Recipient's patent(s), then such Recipient's rights granted under -Section 2(b) shall terminate as of the date such litigation is filed. - -All Recipient's rights under this Agreement shall terminate if it fails -to comply with any of the material terms or conditions of this Agreement -and does not cure such failure in a reasonable period of time after -becoming aware of such noncompliance. If all Recipient's rights under -this Agreement terminate, Recipient agrees to cease use and distribution -of the Program as soon as reasonably practicable. However, Recipient's -obligations under this Agreement and any licenses granted by Recipient -relating to the Program shall continue and survive. - -Everyone is permitted to copy and distribute copies of this Agreement, -but in order to avoid inconsistency the Agreement is copyrighted and may -only be modified in the following manner. The Agreement Steward reserves -the right to publish new versions (including revisions) of this -Agreement from time to time. No one other than the Agreement Steward has -the right to modify this Agreement. IBM is the initial Agreement -Steward. IBM may assign the responsibility to serve as the Agreement -Steward to a suitable separate entity. Each new version of the Agreement -will be given a distinguishing version number. The Program (including -Contributions) may always be distributed subject to the version of the -Agreement under which it was received. In addition, after a new version -of the Agreement is published, Contributor may elect to distribute the -Program (including its Contributions) under the new version. Except as -expressly stated in Sections 2(a) and 2(b) above, Recipient receives no -rights or licenses to the intellectual property of any Contributor under -this Agreement, whether expressly, by implication, estoppel or -otherwise. All rights in the Program not expressly granted under this -Agreement are reserved. - -This Agreement is governed by the laws of the State of New York and the -intellectual property laws of the United States of America. No party to -this Agreement will bring a legal action under this Agreement more than -one year after the cause of action arose. Each party waives its rights -to a jury trial in any resulting litigation. - diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_brush_snare.wav b/Engine/lib/sdl/Xcode-iOS/Demos/data/drums/ds_brush_snare.wav deleted file mode 100644 index fa752637a0e32359a2339d235d0c069d61f4494d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 194604 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 z%0D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