kc3-lang/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h

• Show log

  Commit

• Hash : 15ede106
  Author :
  Date : 2015-11-26T15:20:34
  

  D3D11: Disable stencil buffer when not attached.
  
  Similarly to the D24S8 attachment getting confused when we use only
  the stencil portion, ANGLE could write to the stencil portion when
  we were only using the depth. Fix this by internally disabling stencil
  test and writes when using this type of configuration.
  
  BUG=angleproject:1237
  
  Change-Id: Ib7868d5e9f8aea73304a132005541dab947aa619
  Reviewed-on: https://chromium-review.googlesource.com/314032
  Tryjob-Request: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h

• //
  // Copyright (c) 2012-2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // RenderStateCache.h: Defines rx::RenderStateCache, a cache of Direct3D render
  // state objects.
  
  #ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
  #define LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
  
  #include "libANGLE/angletypes.h"
  #include "libANGLE/Error.h"
  #include "common/angleutils.h"
  
  #include <unordered_map>
  
  namespace gl
  {
  class Framebuffer;
  }
  
  namespace rx
  {
  class Renderer11;
  
  class RenderStateCache : angle::NonCopyable
  {
    public:
      RenderStateCache(Renderer11 *renderer);
      virtual ~RenderStateCache();
  
      void initialize(ID3D11Device *device);
      void clear();
  
      gl::Error getBlendState(const gl::Framebuffer *framebuffer, const gl::BlendState &blendState, ID3D11BlendState **outBlendState);
      gl::Error getRasterizerState(const gl::RasterizerState &rasterState, bool scissorEnabled, ID3D11RasterizerState **outRasterizerState);
      gl::Error getDepthStencilState(const gl::DepthStencilState &dsState,
                                     bool disableDepth,
                                     bool disableStencil,
                                     ID3D11DepthStencilState **outDSState);
      gl::Error getSamplerState(const gl::SamplerState &samplerState, ID3D11SamplerState **outSamplerState);
  
    private:
      Renderer11 *mRenderer;
      unsigned long long mCounter;
  
      // Blend state cache
      struct BlendStateKey
      {
          gl::BlendState blendState;
          bool rtChannels[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT][4];
      };
      static std::size_t hashBlendState(const BlendStateKey &blendState);
      static bool compareBlendStates(const BlendStateKey &a, const BlendStateKey &b);
      static const unsigned int kMaxBlendStates;
  
      typedef std::size_t (*BlendStateHashFunction)(const BlendStateKey &);
      typedef bool (*BlendStateEqualityFunction)(const BlendStateKey &, const BlendStateKey &);
      typedef std::pair<ID3D11BlendState*, unsigned long long> BlendStateCounterPair;
      typedef std::unordered_map<BlendStateKey, BlendStateCounterPair, BlendStateHashFunction, BlendStateEqualityFunction> BlendStateMap;
      BlendStateMap mBlendStateCache;
  
      // Rasterizer state cache
      struct RasterizerStateKey
      {
          gl::RasterizerState rasterizerState;
          bool scissorEnabled;
      };
      static std::size_t hashRasterizerState(const RasterizerStateKey &rasterState);
      static bool compareRasterizerStates(const RasterizerStateKey &a, const RasterizerStateKey &b);
      static const unsigned int kMaxRasterizerStates;
  
      typedef std::size_t (*RasterizerStateHashFunction)(const RasterizerStateKey &);
      typedef bool (*RasterizerStateEqualityFunction)(const RasterizerStateKey &, const RasterizerStateKey &);
      typedef std::pair<ID3D11RasterizerState*, unsigned long long> RasterizerStateCounterPair;
      typedef std::unordered_map<RasterizerStateKey, RasterizerStateCounterPair, RasterizerStateHashFunction, RasterizerStateEqualityFunction> RasterizerStateMap;
      RasterizerStateMap mRasterizerStateCache;
  
      // Depth stencil state cache
      static std::size_t hashDepthStencilState(const gl::DepthStencilState &dsState);
      static bool compareDepthStencilStates(const gl::DepthStencilState &a, const gl::DepthStencilState &b);
      static const unsigned int kMaxDepthStencilStates;
  
      typedef std::size_t (*DepthStencilStateHashFunction)(const gl::DepthStencilState &);
      typedef bool (*DepthStencilStateEqualityFunction)(const gl::DepthStencilState &, const gl::DepthStencilState &);
      typedef std::pair<ID3D11DepthStencilState*, unsigned long long> DepthStencilStateCounterPair;
      typedef std::unordered_map<gl::DepthStencilState,
                                 DepthStencilStateCounterPair,
                                 DepthStencilStateHashFunction,
                                 DepthStencilStateEqualityFunction> DepthStencilStateMap;
      DepthStencilStateMap mDepthStencilStateCache;
  
      // Sample state cache
      static std::size_t hashSamplerState(const gl::SamplerState &samplerState);
      static bool compareSamplerStates(const gl::SamplerState &a, const gl::SamplerState &b);
      static const unsigned int kMaxSamplerStates;
  
      typedef std::size_t (*SamplerStateHashFunction)(const gl::SamplerState &);
      typedef bool (*SamplerStateEqualityFunction)(const gl::SamplerState &, const gl::SamplerState &);
      typedef std::pair<ID3D11SamplerState*, unsigned long long> SamplerStateCounterPair;
      typedef std::unordered_map<gl::SamplerState,
                                 SamplerStateCounterPair,
                                 SamplerStateHashFunction,
                                 SamplerStateEqualityFunction> SamplerStateMap;
      SamplerStateMap mSamplerStateCache;
  
      ID3D11Device *mDevice;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
  

Download