1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
//
// 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 "common/angleutils.h"
#include "libANGLE/Error.h"
#include "libANGLE/SizedMRUCache.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
#include <unordered_map>
namespace gl
{
class Framebuffer;
}
namespace std
{
template <>
struct hash<rx::d3d11::BlendStateKey>
{
size_t operator()(const rx::d3d11::BlendStateKey &key) const
{
return angle::ComputeGenericHash(key);
}
};
template <>
struct hash<rx::d3d11::RasterizerStateKey>
{
size_t operator()(const rx::d3d11::RasterizerStateKey &key) const
{
return angle::ComputeGenericHash(key);
}
};
template <>
struct hash<gl::DepthStencilState>
{
size_t operator()(const gl::DepthStencilState &key) const
{
return angle::ComputeGenericHash(key);
}
};
template <>
struct hash<gl::SamplerState>
{
size_t operator()(const gl::SamplerState &key) const { return angle::ComputeGenericHash(key); }
};
} // namespace std
namespace rx
{
class Renderer11;
class RenderStateCache : angle::NonCopyable
{
public:
RenderStateCache();
virtual ~RenderStateCache();
void clear();
static d3d11::BlendStateKey GetBlendStateKey(const gl::Context *context,
const gl::Framebuffer *framebuffer,
const gl::BlendState &blendState);
gl::Error getBlendState(Renderer11 *renderer,
const d3d11::BlendStateKey &key,
const d3d11::BlendState **outBlendState);
gl::Error getRasterizerState(Renderer11 *renderer,
const gl::RasterizerState &rasterState,
bool scissorEnabled,
ID3D11RasterizerState **outRasterizerState);
gl::Error getDepthStencilState(Renderer11 *renderer,
const gl::DepthStencilState &dsState,
const d3d11::DepthStencilState **outDSState);
gl::Error getSamplerState(Renderer11 *renderer,
const gl::SamplerState &samplerState,
ID3D11SamplerState **outSamplerState);
private:
// MSDN's documentation of ID3D11Device::CreateBlendState, ID3D11Device::CreateRasterizerState,
// ID3D11Device::CreateDepthStencilState and ID3D11Device::CreateSamplerState claims the maximum
// number of unique states of each type an application can create is 4096
// TODO(ShahmeerEsmail): Revisit the cache sizes to make sure they are appropriate for most
// scenarios.
static constexpr unsigned int kMaxStates = 4096;
// The cache tries to clean up this many states at once.
static constexpr unsigned int kGCLimit = 128;
// Blend state cache
using BlendStateMap = angle::base::HashingMRUCache<d3d11::BlendStateKey, d3d11::BlendState>;
BlendStateMap mBlendStateCache;
// Rasterizer state cache
using RasterizerStateMap =
angle::base::HashingMRUCache<d3d11::RasterizerStateKey, d3d11::RasterizerState>;
RasterizerStateMap mRasterizerStateCache;
// Depth stencil state cache
using DepthStencilStateMap =
angle::base::HashingMRUCache<gl::DepthStencilState, d3d11::DepthStencilState>;
DepthStencilStateMap mDepthStencilStateCache;
// Sample state cache
using SamplerStateMap = angle::base::HashingMRUCache<gl::SamplerState, d3d11::SamplerState>;
SamplerStateMap mSamplerStateCache;
};
} // namespace rx
#endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
|
