michael@0: #include "precompiled.h"
michael@0: //
michael@0: // Copyright (c) 2012-2013 The ANGLE Project Authors. All rights reserved.
michael@0: // Use of this source code is governed by a BSD-style license that can be
michael@0: // found in the LICENSE file.
michael@0: //
michael@0: 
michael@0: // RenderStateCache.cpp: Defines rx::RenderStateCache, a cache of Direct3D render
michael@0: // state objects.
michael@0: 
michael@0: #include "libGLESv2/renderer/RenderStateCache.h"
michael@0: #include "libGLESv2/renderer/renderer11_utils.h"
michael@0: 
michael@0: #include "common/debug.h"
michael@0: #include "third_party/murmurhash/MurmurHash3.h"
michael@0: 
michael@0: namespace rx
michael@0: {
michael@0: 
michael@0: // MSDN's documentation of ID3D11Device::CreateBlendState, ID3D11Device::CreateRasterizerState,
michael@0: // ID3D11Device::CreateDepthStencilState and ID3D11Device::CreateSamplerState claims the maximum
michael@0: // number of unique states of each type an application can create is 4096
michael@0: const unsigned int RenderStateCache::kMaxBlendStates = 4096;
michael@0: const unsigned int RenderStateCache::kMaxRasterizerStates = 4096;
michael@0: const unsigned int RenderStateCache::kMaxDepthStencilStates = 4096;
michael@0: const unsigned int RenderStateCache::kMaxSamplerStates = 4096;
michael@0: 
michael@0: RenderStateCache::RenderStateCache() : mDevice(NULL), mCounter(0),
michael@0:                                        mBlendStateCache(kMaxBlendStates, hashBlendState, compareBlendStates),
michael@0:                                        mRasterizerStateCache(kMaxRasterizerStates, hashRasterizerState, compareRasterizerStates),
michael@0:                                        mDepthStencilStateCache(kMaxDepthStencilStates, hashDepthStencilState, compareDepthStencilStates),
michael@0:                                        mSamplerStateCache(kMaxSamplerStates, hashSamplerState, compareSamplerStates)
michael@0: {
michael@0: }
michael@0: 
michael@0: RenderStateCache::~RenderStateCache()
michael@0: {
michael@0:     clear();
michael@0: }
michael@0: 
michael@0: void RenderStateCache::initialize(ID3D11Device *device)
michael@0: {
michael@0:     clear();
michael@0:     mDevice = device;
michael@0: }
michael@0: 
michael@0: void RenderStateCache::clear()
michael@0: {
michael@0:     for (BlendStateMap::iterator i = mBlendStateCache.begin(); i != mBlendStateCache.end(); i++)
michael@0:     {
michael@0:         i->second.first->Release();
michael@0:     }
michael@0:     mBlendStateCache.clear();
michael@0: 
michael@0:     for (RasterizerStateMap::iterator i = mRasterizerStateCache.begin(); i != mRasterizerStateCache.end(); i++)
michael@0:     {
michael@0:         i->second.first->Release();
michael@0:     }
michael@0:     mRasterizerStateCache.clear();
michael@0: 
michael@0:     for (DepthStencilStateMap::iterator i = mDepthStencilStateCache.begin(); i != mDepthStencilStateCache.end(); i++)
michael@0:     {
michael@0:         i->second.first->Release();
michael@0:     }
michael@0:     mDepthStencilStateCache.clear();
michael@0: 
michael@0:     for (SamplerStateMap::iterator i = mSamplerStateCache.begin(); i != mSamplerStateCache.end(); i++)
michael@0:     {
michael@0:         i->second.first->Release();
michael@0:     }
michael@0:     mSamplerStateCache.clear();
michael@0: }
michael@0: 
michael@0: std::size_t RenderStateCache::hashBlendState(const gl::BlendState &blendState)
michael@0: {
michael@0:     static const unsigned int seed = 0xABCDEF98;
michael@0: 
michael@0:     std::size_t hash = 0;
michael@0:     MurmurHash3_x86_32(&blendState, sizeof(gl::BlendState), seed, &hash);
michael@0:     return hash;
michael@0: }
michael@0: 
michael@0: bool RenderStateCache::compareBlendStates(const gl::BlendState &a, const gl::BlendState &b)
michael@0: {
michael@0:     return memcmp(&a, &b, sizeof(gl::BlendState)) == 0;
michael@0: }
michael@0: 
michael@0: ID3D11BlendState *RenderStateCache::getBlendState(const gl::BlendState &blendState)
michael@0: {
michael@0:     if (!mDevice)
michael@0:     {
michael@0:         ERR("RenderStateCache is not initialized.");
michael@0:         return NULL;
michael@0:     }
michael@0: 
michael@0:     BlendStateMap::iterator i = mBlendStateCache.find(blendState);
michael@0:     if (i != mBlendStateCache.end())
michael@0:     {
michael@0:         BlendStateCounterPair &state = i->second;
michael@0:         state.second = mCounter++;
michael@0:         return state.first;
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         if (mBlendStateCache.size() >= kMaxBlendStates)
michael@0:         {
michael@0:             TRACE("Overflowed the limit of %u blend states, removing the least recently used "
michael@0:                   "to make room.", kMaxBlendStates);
michael@0: 
michael@0:             BlendStateMap::iterator leastRecentlyUsed = mBlendStateCache.begin();
michael@0:             for (BlendStateMap::iterator i = mBlendStateCache.begin(); i != mBlendStateCache.end(); i++)
michael@0:             {
michael@0:                 if (i->second.second < leastRecentlyUsed->second.second)
michael@0:                 {
michael@0:                     leastRecentlyUsed = i;
michael@0:                 }
michael@0:             }
michael@0:             leastRecentlyUsed->second.first->Release();
michael@0:             mBlendStateCache.erase(leastRecentlyUsed);
michael@0:         }
michael@0: 
michael@0:         // Create a new blend state and insert it into the cache
michael@0:         D3D11_BLEND_DESC blendDesc = { 0 };
michael@0:         blendDesc.AlphaToCoverageEnable = blendState.sampleAlphaToCoverage;
michael@0:         blendDesc.IndependentBlendEnable = FALSE;
michael@0: 
michael@0:         for (unsigned int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
michael@0:         {
michael@0:             D3D11_RENDER_TARGET_BLEND_DESC &rtBlend = blendDesc.RenderTarget[i];
michael@0: 
michael@0:             rtBlend.BlendEnable = blendState.blend;
michael@0:             if (blendState.blend)
michael@0:             {
michael@0:                 rtBlend.SrcBlend = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendRGB, false);
michael@0:                 rtBlend.DestBlend = gl_d3d11::ConvertBlendFunc(blendState.destBlendRGB, false);
michael@0:                 rtBlend.BlendOp = gl_d3d11::ConvertBlendOp(blendState.blendEquationRGB);
michael@0: 
michael@0:                 rtBlend.SrcBlendAlpha = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendAlpha, true);
michael@0:                 rtBlend.DestBlendAlpha = gl_d3d11::ConvertBlendFunc(blendState.destBlendAlpha, true);
michael@0:                 rtBlend.BlendOpAlpha = gl_d3d11::ConvertBlendOp(blendState.blendEquationAlpha);
michael@0:             }
michael@0: 
michael@0:             rtBlend.RenderTargetWriteMask = gl_d3d11::ConvertColorMask(blendState.colorMaskRed,
michael@0:                                                                        blendState.colorMaskGreen,
michael@0:                                                                        blendState.colorMaskBlue,
michael@0:                                                                        blendState.colorMaskAlpha);
michael@0:         }
michael@0: 
michael@0:         ID3D11BlendState *dx11BlendState = NULL;
michael@0:         HRESULT result = mDevice->CreateBlendState(&blendDesc, &dx11BlendState);
michael@0:         if (FAILED(result) || !dx11BlendState)
michael@0:         {
michael@0:             ERR("Unable to create a ID3D11BlendState, HRESULT: 0x%X.", result);
michael@0:             return NULL;
michael@0:         }
michael@0: 
michael@0:         mBlendStateCache.insert(std::make_pair(blendState, std::make_pair(dx11BlendState, mCounter++)));
michael@0: 
michael@0:         return dx11BlendState;
michael@0:     }
michael@0: }
michael@0: 
michael@0: std::size_t RenderStateCache::hashRasterizerState(const RasterizerStateKey &rasterState)
michael@0: {
michael@0:     static const unsigned int seed = 0xABCDEF98;
michael@0: 
michael@0:     std::size_t hash = 0;
michael@0:     MurmurHash3_x86_32(&rasterState, sizeof(RasterizerStateKey), seed, &hash);
michael@0:     return hash;
michael@0: }
michael@0: 
michael@0: bool RenderStateCache::compareRasterizerStates(const RasterizerStateKey &a, const RasterizerStateKey &b)
michael@0: {
michael@0:     return memcmp(&a, &b, sizeof(RasterizerStateKey)) == 0;
michael@0: }
michael@0: 
michael@0: ID3D11RasterizerState *RenderStateCache::getRasterizerState(const gl::RasterizerState &rasterState,
michael@0:                                                             bool scissorEnabled, unsigned int depthSize)
michael@0: {
michael@0:     if (!mDevice)
michael@0:     {
michael@0:         ERR("RenderStateCache is not initialized.");
michael@0:         return NULL;
michael@0:     }
michael@0: 
michael@0:     RasterizerStateKey key;
michael@0:     key.rasterizerState = rasterState;
michael@0:     key.scissorEnabled = scissorEnabled;
michael@0:     key.depthSize = depthSize;
michael@0: 
michael@0:     RasterizerStateMap::iterator i = mRasterizerStateCache.find(key);
michael@0:     if (i != mRasterizerStateCache.end())
michael@0:     {
michael@0:         RasterizerStateCounterPair &state = i->second;
michael@0:         state.second = mCounter++;
michael@0:         return state.first;
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         if (mRasterizerStateCache.size() >= kMaxRasterizerStates)
michael@0:         {
michael@0:             TRACE("Overflowed the limit of %u rasterizer states, removing the least recently used "
michael@0:                   "to make room.", kMaxRasterizerStates);
michael@0: 
michael@0:             RasterizerStateMap::iterator leastRecentlyUsed = mRasterizerStateCache.begin();
michael@0:             for (RasterizerStateMap::iterator i = mRasterizerStateCache.begin(); i != mRasterizerStateCache.end(); i++)
michael@0:             {
michael@0:                 if (i->second.second < leastRecentlyUsed->second.second)
michael@0:                 {
michael@0:                     leastRecentlyUsed = i;
michael@0:                 }
michael@0:             }
michael@0:             leastRecentlyUsed->second.first->Release();
michael@0:             mRasterizerStateCache.erase(leastRecentlyUsed);
michael@0:         }
michael@0: 
michael@0:         D3D11_CULL_MODE cullMode = gl_d3d11::ConvertCullMode(rasterState.cullFace, rasterState.cullMode);
michael@0: 
michael@0:         // Disable culling if drawing points
michael@0:         if (rasterState.pointDrawMode)
michael@0:         {
michael@0:             cullMode = D3D11_CULL_NONE;
michael@0:         }
michael@0: 
michael@0:         D3D11_RASTERIZER_DESC rasterDesc;
michael@0:         rasterDesc.FillMode = D3D11_FILL_SOLID;
michael@0:         rasterDesc.CullMode = cullMode;
michael@0:         rasterDesc.FrontCounterClockwise = (rasterState.frontFace == GL_CCW) ? FALSE: TRUE;
michael@0:         rasterDesc.DepthBias = ldexp(rasterState.polygonOffsetUnits, -static_cast<int>(depthSize));
michael@0:         rasterDesc.DepthBiasClamp = 0.0f; // MSDN documentation of DepthBiasClamp implies a value of zero will preform no clamping, must be tested though.
michael@0:         rasterDesc.SlopeScaledDepthBias = rasterState.polygonOffsetFactor;
michael@0:         rasterDesc.DepthClipEnable = TRUE;
michael@0:         rasterDesc.ScissorEnable = scissorEnabled ? TRUE : FALSE;
michael@0:         rasterDesc.MultisampleEnable = rasterState.multiSample;
michael@0:         rasterDesc.AntialiasedLineEnable = FALSE;
michael@0: 
michael@0:         ID3D11RasterizerState *dx11RasterizerState = NULL;
michael@0:         HRESULT result = mDevice->CreateRasterizerState(&rasterDesc, &dx11RasterizerState);
michael@0:         if (FAILED(result) || !dx11RasterizerState)
michael@0:         {
michael@0:             ERR("Unable to create a ID3D11RasterizerState, HRESULT: 0x%X.", result);
michael@0:             return NULL;
michael@0:         }
michael@0: 
michael@0:         mRasterizerStateCache.insert(std::make_pair(key, std::make_pair(dx11RasterizerState, mCounter++)));
michael@0: 
michael@0:         return dx11RasterizerState;
michael@0:     }
michael@0: }
michael@0: 
michael@0: std::size_t RenderStateCache::hashDepthStencilState(const gl::DepthStencilState &dsState)
michael@0: {
michael@0:     static const unsigned int seed = 0xABCDEF98;
michael@0: 
michael@0:     std::size_t hash = 0;
michael@0:     MurmurHash3_x86_32(&dsState, sizeof(gl::DepthStencilState), seed, &hash);
michael@0:     return hash;
michael@0: }
michael@0: 
michael@0: bool RenderStateCache::compareDepthStencilStates(const gl::DepthStencilState &a, const gl::DepthStencilState &b)
michael@0: {
michael@0:     return memcmp(&a, &b, sizeof(gl::DepthStencilState)) == 0;
michael@0: }
michael@0: 
michael@0: ID3D11DepthStencilState *RenderStateCache::getDepthStencilState(const gl::DepthStencilState &dsState)
michael@0: {
michael@0:     if (!mDevice)
michael@0:     {
michael@0:         ERR("RenderStateCache is not initialized.");
michael@0:         return NULL;
michael@0:     }
michael@0: 
michael@0:     DepthStencilStateMap::iterator i = mDepthStencilStateCache.find(dsState);
michael@0:     if (i != mDepthStencilStateCache.end())
michael@0:     {
michael@0:         DepthStencilStateCounterPair &state = i->second;
michael@0:         state.second = mCounter++;
michael@0:         return state.first;
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         if (mDepthStencilStateCache.size() >= kMaxDepthStencilStates)
michael@0:         {
michael@0:             TRACE("Overflowed the limit of %u depth stencil states, removing the least recently used "
michael@0:                   "to make room.", kMaxDepthStencilStates);
michael@0: 
michael@0:             DepthStencilStateMap::iterator leastRecentlyUsed = mDepthStencilStateCache.begin();
michael@0:             for (DepthStencilStateMap::iterator i = mDepthStencilStateCache.begin(); i != mDepthStencilStateCache.end(); i++)
michael@0:             {
michael@0:                 if (i->second.second < leastRecentlyUsed->second.second)
michael@0:                 {
michael@0:                     leastRecentlyUsed = i;
michael@0:                 }
michael@0:             }
michael@0:             leastRecentlyUsed->second.first->Release();
michael@0:             mDepthStencilStateCache.erase(leastRecentlyUsed);
michael@0:         }
michael@0: 
michael@0:         D3D11_DEPTH_STENCIL_DESC dsDesc = { 0 };
michael@0:         dsDesc.DepthEnable = dsState.depthTest ? TRUE : FALSE;
michael@0:         dsDesc.DepthWriteMask = gl_d3d11::ConvertDepthMask(dsState.depthMask);
michael@0:         dsDesc.DepthFunc = gl_d3d11::ConvertComparison(dsState.depthFunc);
michael@0:         dsDesc.StencilEnable = dsState.stencilTest ? TRUE : FALSE;
michael@0:         dsDesc.StencilReadMask = gl_d3d11::ConvertStencilMask(dsState.stencilMask);
michael@0:         dsDesc.StencilWriteMask = gl_d3d11::ConvertStencilMask(dsState.stencilWritemask);
michael@0:         dsDesc.FrontFace.StencilFailOp = gl_d3d11::ConvertStencilOp(dsState.stencilFail);
michael@0:         dsDesc.FrontFace.StencilDepthFailOp = gl_d3d11::ConvertStencilOp(dsState.stencilPassDepthFail);
michael@0:         dsDesc.FrontFace.StencilPassOp = gl_d3d11::ConvertStencilOp(dsState.stencilPassDepthPass);
michael@0:         dsDesc.FrontFace.StencilFunc = gl_d3d11::ConvertComparison(dsState.stencilFunc);
michael@0:         dsDesc.BackFace.StencilFailOp = gl_d3d11::ConvertStencilOp(dsState.stencilBackFail);
michael@0:         dsDesc.BackFace.StencilDepthFailOp = gl_d3d11::ConvertStencilOp(dsState.stencilBackPassDepthFail);
michael@0:         dsDesc.BackFace.StencilPassOp = gl_d3d11::ConvertStencilOp(dsState.stencilBackPassDepthPass);
michael@0:         dsDesc.BackFace.StencilFunc = gl_d3d11::ConvertComparison(dsState.stencilBackFunc);
michael@0: 
michael@0:         ID3D11DepthStencilState *dx11DepthStencilState = NULL;
michael@0:         HRESULT result = mDevice->CreateDepthStencilState(&dsDesc, &dx11DepthStencilState);
michael@0:         if (FAILED(result) || !dx11DepthStencilState)
michael@0:         {
michael@0:             ERR("Unable to create a ID3D11DepthStencilState, HRESULT: 0x%X.", result);
michael@0:             return NULL;
michael@0:         }
michael@0: 
michael@0:         mDepthStencilStateCache.insert(std::make_pair(dsState, std::make_pair(dx11DepthStencilState, mCounter++)));
michael@0: 
michael@0:         return dx11DepthStencilState;
michael@0:     }
michael@0: }
michael@0: 
michael@0: std::size_t RenderStateCache::hashSamplerState(const gl::SamplerState &samplerState)
michael@0: {
michael@0:     static const unsigned int seed = 0xABCDEF98;
michael@0: 
michael@0:     std::size_t hash = 0;
michael@0:     MurmurHash3_x86_32(&samplerState, sizeof(gl::SamplerState), seed, &hash);
michael@0:     return hash;
michael@0: }
michael@0: 
michael@0: bool RenderStateCache::compareSamplerStates(const gl::SamplerState &a, const gl::SamplerState &b)
michael@0: {
michael@0:     return memcmp(&a, &b, sizeof(gl::SamplerState)) == 0;
michael@0: }
michael@0: 
michael@0: ID3D11SamplerState *RenderStateCache::getSamplerState(const gl::SamplerState &samplerState)
michael@0: {
michael@0:     if (!mDevice)
michael@0:     {
michael@0:         ERR("RenderStateCache is not initialized.");
michael@0:         return NULL;
michael@0:     }
michael@0: 
michael@0:     SamplerStateMap::iterator i = mSamplerStateCache.find(samplerState);
michael@0:     if (i != mSamplerStateCache.end())
michael@0:     {
michael@0:         SamplerStateCounterPair &state = i->second;
michael@0:         state.second = mCounter++;
michael@0:         return state.first;
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         if (mSamplerStateCache.size() >= kMaxSamplerStates)
michael@0:         {
michael@0:             TRACE("Overflowed the limit of %u sampler states, removing the least recently used "
michael@0:                   "to make room.", kMaxSamplerStates);
michael@0: 
michael@0:             SamplerStateMap::iterator leastRecentlyUsed = mSamplerStateCache.begin();
michael@0:             for (SamplerStateMap::iterator i = mSamplerStateCache.begin(); i != mSamplerStateCache.end(); i++)
michael@0:             {
michael@0:                 if (i->second.second < leastRecentlyUsed->second.second)
michael@0:                 {
michael@0:                     leastRecentlyUsed = i;
michael@0:                 }
michael@0:             }
michael@0:             leastRecentlyUsed->second.first->Release();
michael@0:             mSamplerStateCache.erase(leastRecentlyUsed);
michael@0:         }
michael@0: 
michael@0:         D3D11_SAMPLER_DESC samplerDesc;
michael@0:         samplerDesc.Filter = gl_d3d11::ConvertFilter(samplerState.minFilter, samplerState.magFilter, samplerState.maxAnisotropy);
michael@0:         samplerDesc.AddressU = gl_d3d11::ConvertTextureWrap(samplerState.wrapS);
michael@0:         samplerDesc.AddressV = gl_d3d11::ConvertTextureWrap(samplerState.wrapT);
michael@0:         samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
michael@0:         samplerDesc.MipLODBias = static_cast<float>(samplerState.lodOffset);
michael@0:         samplerDesc.MaxAnisotropy = samplerState.maxAnisotropy;
michael@0:         samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
michael@0:         samplerDesc.BorderColor[0] = 0.0f;
michael@0:         samplerDesc.BorderColor[1] = 0.0f;
michael@0:         samplerDesc.BorderColor[2] = 0.0f;
michael@0:         samplerDesc.BorderColor[3] = 0.0f;
michael@0:         samplerDesc.MinLOD = gl_d3d11::ConvertMinLOD(samplerState.minFilter, samplerState.lodOffset);
michael@0:         samplerDesc.MaxLOD = gl_d3d11::ConvertMaxLOD(samplerState.minFilter, samplerState.lodOffset);
michael@0: 
michael@0:         ID3D11SamplerState *dx11SamplerState = NULL;
michael@0:         HRESULT result = mDevice->CreateSamplerState(&samplerDesc, &dx11SamplerState);
michael@0:         if (FAILED(result) || !dx11SamplerState)
michael@0:         {
michael@0:             ERR("Unable to create a ID3D11DepthStencilState, HRESULT: 0x%X.", result);
michael@0:             return NULL;
michael@0:         }
michael@0: 
michael@0:         mSamplerStateCache.insert(std::make_pair(samplerState, std::make_pair(dx11SamplerState, mCounter++)));
michael@0: 
michael@0:         return dx11SamplerState;
michael@0:     }
michael@0: }
michael@0: 
michael@0: }