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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GPU_COMMAND_BUFFER_SERVICE_SHADER_MANAGER_H_
#define GPU_COMMAND_BUFFER_SERVICE_SHADER_MANAGER_H_
#include <string>
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "gpu/command_buffer/service/gl_utils.h"
#include "gpu/command_buffer/service/shader_translator.h"
#include "gpu/gpu_export.h"
namespace gpu {
namespace gles2 {
// This is used to keep the source code for a shader. This is because in order
// to emluate GLES2 the shaders will have to be re-written before passed to
// the underlying OpenGL. But, when the user calls glGetShaderSource they
// should get the source they passed in, not the re-written source.
class GPU_EXPORT Shader : public base::RefCounted<Shader> {
public:
enum TranslatedShaderSourceType {
kANGLE,
kGL, // GL or GLES
};
void DoCompile(ShaderTranslatorInterface* translator,
TranslatedShaderSourceType type);
GLuint service_id() const {
return service_id_;
}
GLenum shader_type() const {
return shader_type_;
}
const std::string& source() const {
return source_;
}
void set_source(const std::string& source) {
source_ = source;
}
const std::string& translated_source() const {
return translated_source_;
}
const std::string& signature_source() const {
return signature_source_;
}
const sh::Attribute* GetAttribInfo(const std::string& name) const;
const sh::Uniform* GetUniformInfo(const std::string& name) const;
const sh::Varying* GetVaryingInfo(const std::string& name) const;
// If the original_name is not found, return NULL.
const std::string* GetAttribMappedName(
const std::string& original_name) const;
// If the hashed_name is not found, return NULL.
const std::string* GetOriginalNameFromHashedName(
const std::string& hashed_name) const;
const std::string& log_info() const {
return log_info_;
}
bool valid() const {
return valid_;
}
bool IsDeleted() const {
return service_id_ == 0;
}
bool InUse() const {
DCHECK_GE(use_count_, 0);
return use_count_ != 0;
}
// Used by program cache.
const AttributeMap& attrib_map() const {
return attrib_map_;
}
// Used by program cache.
const UniformMap& uniform_map() const {
return uniform_map_;
}
// Used by program cache.
const VaryingMap& varying_map() const {
return varying_map_;
}
// Used by program cache.
void set_attrib_map(const AttributeMap& attrib_map) {
// copied because cache might be cleared
attrib_map_ = AttributeMap(attrib_map);
}
// Used by program cache.
void set_uniform_map(const UniformMap& uniform_map) {
// copied because cache might be cleared
uniform_map_ = UniformMap(uniform_map);
}
// Used by program cache.
void set_varying_map(const VaryingMap& varying_map) {
// copied because cache might be cleared
varying_map_ = VaryingMap(varying_map);
}
private:
friend class base::RefCounted<Shader>;
friend class ShaderManager;
Shader(GLuint service_id, GLenum shader_type);
~Shader();
void IncUseCount();
void DecUseCount();
void MarkAsDeleted();
int use_count_;
// The shader this Shader is tracking.
GLuint service_id_;
// Type of shader - GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.
GLenum shader_type_;
// True if compilation succeeded.
bool valid_;
// The shader source as passed to glShaderSource.
std::string source_;
// The source the last compile used.
std::string signature_source_;
// The translated shader source.
std::string translated_source_;
// The shader translation log.
std::string log_info_;
// The type info when the shader was last compiled.
AttributeMap attrib_map_;
UniformMap uniform_map_;
VaryingMap varying_map_;
// The name hashing info when the shader was last compiled.
NameMap name_map_;
};
// Tracks the Shaders.
//
// NOTE: To support shared resources an instance of this class will
// need to be shared by multiple GLES2Decoders.
class GPU_EXPORT ShaderManager {
public:
ShaderManager();
~ShaderManager();
// Must call before destruction.
void Destroy(bool have_context);
// Creates a shader for the given shader ID.
Shader* CreateShader(
GLuint client_id,
GLuint service_id,
GLenum shader_type);
// Gets an existing shader info for the given shader ID. Returns NULL if none
// exists.
Shader* GetShader(GLuint client_id);
// Gets a client id for a given service id.
bool GetClientId(GLuint service_id, GLuint* client_id) const;
void MarkAsDeleted(Shader* shader);
// Mark a shader as used
void UseShader(Shader* shader);
// Unmark a shader as used. If it has been deleted and is not used
// then we free the shader.
void UnuseShader(Shader* shader);
// Check if a Shader is owned by this ShaderManager.
bool IsOwned(Shader* shader);
private:
friend class Shader;
// Info for each shader by service side shader Id.
typedef base::hash_map<GLuint, scoped_refptr<Shader> > ShaderMap;
ShaderMap shaders_;
void RemoveShader(Shader* shader);
DISALLOW_COPY_AND_ASSIGN(ShaderManager);
};
} // namespace gles2
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_SHADER_MANAGER_H_
|
