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
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
|
// 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.
// This file defines the GLES2 command buffer commands.
#ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
#define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
#include <KHR/khrplatform.h>
#include <stdint.h>
#include <string.h>
#include "base/atomicops.h"
#include "base/logging.h"
#include "base/macros.h"
#include "gpu/command_buffer/common/bitfield_helpers.h"
#include "gpu/command_buffer/common/cmd_buffer_common.h"
#include "gpu/command_buffer/common/gles2_cmd_ids.h"
#include "gpu/command_buffer/common/gles2_cmd_utils.h"
// GL types are forward declared to avoid including the GL headers. The problem
// is determining which GL headers to include from code that is common to the
// client and service sides (GLES2 or one of several GL implementations).
typedef unsigned int GLenum;
typedef unsigned int GLbitfield;
typedef unsigned int GLuint;
typedef int GLint;
typedef int GLsizei;
typedef unsigned char GLboolean;
typedef signed char GLbyte;
typedef short GLshort;
typedef unsigned char GLubyte;
typedef unsigned short GLushort;
typedef unsigned long GLulong;
typedef float GLfloat;
typedef float GLclampf;
typedef double GLdouble;
typedef double GLclampd;
typedef void GLvoid;
typedef khronos_intptr_t GLintptr;
typedef khronos_ssize_t GLsizeiptr;
typedef struct __GLsync *GLsync;
typedef int64_t GLint64;
typedef uint64_t GLuint64;
namespace gpu {
namespace gles2 {
// Command buffer is GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT byte aligned.
#pragma pack(push, GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT)
namespace id_namespaces {
// These are used when contexts share resources.
enum IdNamespaces {
kBuffers,
kFramebuffers,
kProgramsAndShaders,
kRenderbuffers,
kTextures,
kQueries,
kVertexArrays,
kValuebuffers,
kSamplers,
kTransformFeedbacks,
kSyncs,
kNumIdNamespaces
};
enum RangeIdNamespaces { kPaths, kNumRangeIdNamespaces };
// These numbers must not change
static_assert(kBuffers == 0, "kBuffers should equal 0");
static_assert(kFramebuffers == 1, "kFramebuffers should equal 1");
static_assert(kProgramsAndShaders == 2, "kProgramsAndShaders should equal 2");
static_assert(kRenderbuffers == 3, "kRenderbuffers should equal 3");
static_assert(kTextures == 4, "kTextures should equal 4");
static_assert(kPaths == 0, "kPaths should equal 0");
} // namespace id_namespaces
// Used for some glGetXXX commands that return a result through a pointer. We
// need to know if the command succeeded or not and the size of the result. If
// the command failed its result size will 0.
template <typename T>
struct SizedResult {
typedef T Type;
T* GetData() {
return static_cast<T*>(static_cast<void*>(&data));
}
// Returns the total size in bytes of the SizedResult for a given number of
// results including the size field.
static size_t ComputeSize(size_t num_results) {
return sizeof(T) * num_results + sizeof(uint32_t); // NOLINT
}
// Returns the maximum number of results for a given buffer size.
static uint32_t ComputeMaxResults(size_t size_of_buffer) {
return (size_of_buffer >= sizeof(uint32_t)) ?
((size_of_buffer - sizeof(uint32_t)) / sizeof(T)) : 0; // NOLINT
}
// Set the size for a given number of results.
void SetNumResults(size_t num_results) {
size = sizeof(T) * num_results; // NOLINT
}
// Get the number of elements in the result
int32_t GetNumResults() const {
return size / sizeof(T); // NOLINT
}
// Copy the result.
void CopyResult(void* dst) const {
memcpy(dst, &data, size);
}
uint32_t size; // in bytes.
int32_t data; // this is just here to get an offset.
};
static_assert(sizeof(SizedResult<int8_t>) == 8,
"size of SizedResult<int8_t> should be 8");
static_assert(offsetof(SizedResult<int8_t>, size) == 0,
"offset of SizedResult<int8_t>.size should be 0");
static_assert(offsetof(SizedResult<int8_t>, data) == 4,
"offset of SizedResult<int8_t>.data should be 4");
// The data for one attrib or uniform from GetProgramInfoCHROMIUM.
struct ProgramInput {
uint32_t type; // The type (GL_VEC3, GL_MAT3, GL_SAMPLER_2D, etc.
int32_t size; // The size (how big the array is for uniforms)
uint32_t location_offset; // offset from ProgramInfoHeader to 'size'
// locations for uniforms, 1 for attribs.
uint32_t name_offset; // offset from ProgrmaInfoHeader to start of name.
uint32_t name_length; // length of the name.
};
// The format of the bucket filled out by GetProgramInfoCHROMIUM
struct ProgramInfoHeader {
uint32_t link_status;
uint32_t num_attribs;
uint32_t num_uniforms;
// ProgramInput inputs[num_attribs + num_uniforms];
};
// The data for one UniformBlock from GetProgramInfoCHROMIUM
struct UniformBlockInfo {
uint32_t binding; // UNIFORM_BLOCK_BINDING
uint32_t data_size; // UNIFORM_BLOCK_DATA_SIZE
uint32_t name_offset; // offset from UniformBlocksHeader to start of name.
uint32_t name_length; // UNIFORM_BLOCK_NAME_LENGTH
uint32_t active_uniforms; // UNIFORM_BLOCK_ACTIVE_UNIFORMS
// offset from UniformBlocksHeader to |active_uniforms| indices.
uint32_t active_uniform_offset;
// UNIFORM_BLOCK_REFERENDED_BY_VERTEX_SHADER
uint32_t referenced_by_vertex_shader;
// UNIFORM_BLOCK_REFERENDED_BY_FRAGMENT_SHADER
uint32_t referenced_by_fragment_shader;
};
// The format of the bucket filled out by GetUniformBlocksCHROMIUM
struct UniformBlocksHeader {
uint32_t num_uniform_blocks;
// UniformBlockInfo uniform_blocks[num_uniform_blocks];
};
// The data for one TransformFeedbackVarying from
// GetTransformFeedbackVaringCHROMIUM.
struct TransformFeedbackVaryingInfo {
uint32_t size;
uint32_t type;
uint32_t name_offset; // offset from Header to start of name.
uint32_t name_length; // including the null terminator.
};
// The format of the bucket filled out by GetTransformFeedbackVaryingsCHROMIUM
struct TransformFeedbackVaryingsHeader {
uint32_t num_transform_feedback_varyings;
// TransformFeedbackVaryingInfo varyings[num_transform_feedback_varyings];
};
// Parameters of a uniform that can be queried through glGetActiveUniformsiv,
// but not through glGetActiveUniform.
struct UniformES3Info {
int32_t block_index;
int32_t offset;
int32_t array_stride;
int32_t matrix_stride;
int32_t is_row_major;
};
// The format of the bucket filled out by GetUniformsivES3CHROMIUM
struct UniformsES3Header {
uint32_t num_uniforms;
// UniformES3Info uniforms[num_uniforms];
};
// The format of QuerySync used by EXT_occlusion_query_boolean
struct QuerySync {
void Reset() {
process_count = 0;
result = 0;
}
base::subtle::Atomic32 process_count;
uint64_t result;
};
struct AsyncUploadSync {
void Reset() {
base::subtle::Release_Store(&async_upload_token, 0);
}
void SetAsyncUploadToken(uint32_t token) {
DCHECK_NE(token, 0u);
base::subtle::Release_Store(&async_upload_token, token);
}
bool HasAsyncUploadTokenPassed(uint32_t token) {
DCHECK_NE(token, 0u);
uint32_t current_token = base::subtle::Acquire_Load(&async_upload_token);
return (current_token - token < 0x80000000);
}
base::subtle::Atomic32 async_upload_token;
};
static_assert(sizeof(ProgramInput) == 20, "size of ProgramInput should be 20");
static_assert(offsetof(ProgramInput, type) == 0,
"offset of ProgramInput.type should be 0");
static_assert(offsetof(ProgramInput, size) == 4,
"offset of ProgramInput.size should be 4");
static_assert(offsetof(ProgramInput, location_offset) == 8,
"offset of ProgramInput.location_offset should be 8");
static_assert(offsetof(ProgramInput, name_offset) == 12,
"offset of ProgramInput.name_offset should be 12");
static_assert(offsetof(ProgramInput, name_length) == 16,
"offset of ProgramInput.name_length should be 16");
static_assert(sizeof(ProgramInfoHeader) == 12,
"size of ProgramInfoHeader should be 12");
static_assert(offsetof(ProgramInfoHeader, link_status) == 0,
"offset of ProgramInfoHeader.link_status should be 0");
static_assert(offsetof(ProgramInfoHeader, num_attribs) == 4,
"offset of ProgramInfoHeader.num_attribs should be 4");
static_assert(offsetof(ProgramInfoHeader, num_uniforms) == 8,
"offset of ProgramInfoHeader.num_uniforms should be 8");
static_assert(sizeof(UniformBlockInfo) == 32,
"size of UniformBlockInfo should be 32");
static_assert(offsetof(UniformBlockInfo, binding) == 0,
"offset of UniformBlockInfo.binding should be 0");
static_assert(offsetof(UniformBlockInfo, data_size) == 4,
"offset of UniformBlockInfo.data_size should be 4");
static_assert(offsetof(UniformBlockInfo, name_offset) == 8,
"offset of UniformBlockInfo.name_offset should be 8");
static_assert(offsetof(UniformBlockInfo, name_length) == 12,
"offset of UniformBlockInfo.name_length should be 12");
static_assert(offsetof(UniformBlockInfo, active_uniforms) == 16,
"offset of UniformBlockInfo.active_uniforms should be 16");
static_assert(offsetof(UniformBlockInfo, active_uniform_offset) == 20,
"offset of UniformBlockInfo.active_uniform_offset should be 20");
static_assert(offsetof(UniformBlockInfo, referenced_by_vertex_shader) == 24,
"offset of UniformBlockInfo.referenced_by_vertex_shader "
"should be 24");
static_assert(offsetof(UniformBlockInfo, referenced_by_fragment_shader) == 28,
"offset of UniformBlockInfo.referenced_by_fragment_shader "
"should be 28");
static_assert(sizeof(UniformBlocksHeader) == 4,
"size of UniformBlocksHeader should be 4");
static_assert(offsetof(UniformBlocksHeader, num_uniform_blocks) == 0,
"offset of UniformBlocksHeader.num_uniform_blocks should be 0");
namespace cmds {
#include "../common/gles2_cmd_format_autogen.h"
// These are hand written commands.
// TODO(gman): Attempt to make these auto-generated.
struct GenMailboxCHROMIUM {
typedef GenMailboxCHROMIUM ValueType;
static const CommandId kCmdId = kGenMailboxCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
CommandHeader header;
};
struct InsertSyncPointCHROMIUM {
typedef InsertSyncPointCHROMIUM ValueType;
static const CommandId kCmdId = kInsertSyncPointCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
CommandHeader header;
};
struct CreateAndConsumeTextureCHROMIUMImmediate {
typedef CreateAndConsumeTextureCHROMIUMImmediate ValueType;
static const CommandId kCmdId = kCreateAndConsumeTextureCHROMIUMImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeDataSize() {
return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
}
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize()); // NOLINT
}
void SetHeader(uint32_t size_in_bytes) {
header.SetCmdByTotalSize<ValueType>(size_in_bytes);
}
void Init(GLenum _target, uint32_t _client_id, const GLbyte* _mailbox) {
SetHeader(ComputeSize());
target = _target;
client_id = _client_id;
memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize());
}
void* Set(void* cmd,
GLenum _target,
uint32_t _client_id,
const GLbyte* _mailbox) {
static_cast<ValueType*>(cmd)->Init(_target, _client_id, _mailbox);
const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t client_id;
};
static_assert(sizeof(CreateAndConsumeTextureCHROMIUMImmediate) == 12,
"size of CreateAndConsumeTextureCHROMIUMImmediate should be 12");
static_assert(offsetof(CreateAndConsumeTextureCHROMIUMImmediate, header) == 0,
"offset of CreateAndConsumeTextureCHROMIUMImmediate.header "
"should be 0");
static_assert(offsetof(CreateAndConsumeTextureCHROMIUMImmediate, target) == 4,
"offset of CreateAndConsumeTextureCHROMIUMImmediate.target "
"should be 4");
static_assert(
offsetof(CreateAndConsumeTextureCHROMIUMImmediate, client_id) == 8,
"offset of CreateAndConsumeTextureCHROMIUMImmediate.client_id should be 8");
#pragma pack(pop)
} // namespace cmd
} // namespace gles2
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
|