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
124
125
126
127
128
129
130
131
132
133
134
135
|
//
// Copyright (c) 2012 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.
//
// InputLayoutCache.h: Defines InputLayoutCache, a class that builds and caches
// D3D11 input layouts.
#ifndef LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_
#define LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_
#include <GLES2/gl2.h>
#include <cstddef>
#include <array>
#include <map>
#include "common/angleutils.h"
#include "libANGLE/Constants.h"
#include "libANGLE/Error.h"
#include "libANGLE/SizedMRUCache.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/RendererD3D.h"
#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
namespace rx
{
class DrawCallVertexParams;
struct PackedAttributeLayout
{
PackedAttributeLayout();
PackedAttributeLayout(const PackedAttributeLayout &other);
void addAttributeData(GLenum glType,
UINT semanticIndex,
gl::VertexFormatType vertexFormatType,
unsigned int divisor);
bool operator==(const PackedAttributeLayout &other) const;
enum Flags
{
FLAG_USES_INSTANCED_SPRITES = 0x1,
FLAG_INSTANCED_SPRITES_ACTIVE = 0x2,
FLAG_INSTANCED_RENDERING_ACTIVE = 0x4,
};
uint32_t numAttributes;
uint32_t flags;
std::array<uint32_t, gl::MAX_VERTEX_ATTRIBS> attributeData;
};
} // namespace rx
namespace std
{
template <>
struct hash<rx::PackedAttributeLayout>
{
size_t operator()(const rx::PackedAttributeLayout &value) const
{
return angle::ComputeGenericHash(value);
}
};
} // namespace std
namespace gl
{
class Program;
} // namespace gl
namespace rx
{
struct TranslatedAttribute;
struct TranslatedIndexData;
struct SourceIndexData;
class ProgramD3D;
class Renderer11;
class InputLayoutCache : angle::NonCopyable
{
public:
InputLayoutCache();
~InputLayoutCache();
void clear();
gl::Error applyVertexBuffers(const gl::Context *context,
const std::vector<const TranslatedAttribute *> ¤tAttributes,
GLenum mode,
GLint start,
bool isIndexedRendering);
gl::Error updateVertexOffsetsForPointSpritesEmulation(
Renderer11 *renderer,
const std::vector<const TranslatedAttribute *> ¤tAttributes,
GLint startVertex,
GLsizei emulatedInstanceId);
// Useful for testing
void setCacheSize(size_t newCacheSize);
gl::Error updateInputLayout(Renderer11 *renderer,
const gl::State &state,
const std::vector<const TranslatedAttribute *> ¤tAttributes,
GLenum mode,
const AttribIndexArray &sortedSemanticIndices,
const DrawCallVertexParams &vertexParams);
private:
gl::Error createInputLayout(Renderer11 *renderer,
const AttribIndexArray &sortedSemanticIndices,
const std::vector<const TranslatedAttribute *> ¤tAttributes,
GLenum mode,
gl::Program *program,
const DrawCallVertexParams &vertexParams,
d3d11::InputLayout *inputLayoutOut);
// Starting cache size.
static constexpr size_t kDefaultCacheSize = 1024;
// The cache tries to clean up this many states at once.
static constexpr size_t kGCLimit = 128;
using LayoutCache = angle::base::HashingMRUCache<PackedAttributeLayout, d3d11::InputLayout>;
LayoutCache mLayoutCache;
d3d11::Buffer mPointSpriteVertexBuffer;
d3d11::Buffer mPointSpriteIndexBuffer;
};
} // namespace rx
#endif // LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_
|
