gles2_cmd_format.h revision cedac228d2dd51db4b79ea1e72c7f249408ee061 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// This file defines the GLES2 command buffer commands.
6
7#ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
8#define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
9
10
11#include <KHR/khrplatform.h>
12
13#include <stdint.h>
14#include <string.h>
15
16#include "base/atomicops.h"
17#include "base/logging.h"
18#include "base/macros.h"
19#include "gpu/command_buffer/common/bitfield_helpers.h"
20#include "gpu/command_buffer/common/cmd_buffer_common.h"
21#include "gpu/command_buffer/common/gles2_cmd_ids.h"
22
23// GL types are forward declared to avoid including the GL headers. The problem
24// is determining which GL headers to include from code that is common to the
25// client and service sides (GLES2 or one of several GL implementations).
26typedef unsigned int GLenum;
27typedef unsigned int GLbitfield;
28typedef unsigned int GLuint;
29typedef int GLint;
30typedef int GLsizei;
31typedef unsigned char GLboolean;
32typedef signed char GLbyte;
33typedef short GLshort;
34typedef unsigned char GLubyte;
35typedef unsigned short GLushort;
36typedef unsigned long GLulong;
37typedef float GLfloat;
38typedef float GLclampf;
39typedef double GLdouble;
40typedef double GLclampd;
41typedef void GLvoid;
42typedef khronos_intptr_t GLintptr;
43typedef khronos_ssize_t  GLsizeiptr;
44
45namespace gpu {
46namespace gles2 {
47
48// Command buffer is GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT byte aligned.
49#pragma pack(push, GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT)
50
51namespace id_namespaces {
52
53// These are used when contexts share resources.
54enum IdNamespaces {
55  kBuffers,
56  kFramebuffers,
57  kProgramsAndShaders,
58  kRenderbuffers,
59  kTextures,
60  kQueries,
61  kVertexArrays,
62  kNumIdNamespaces
63};
64
65// These numbers must not change
66COMPILE_ASSERT(kBuffers == 0, kBuffers_is_not_0);
67COMPILE_ASSERT(kFramebuffers == 1, kFramebuffers_is_not_1);
68COMPILE_ASSERT(kProgramsAndShaders == 2, kProgramsAndShaders_is_not_2);
69COMPILE_ASSERT(kRenderbuffers == 3, kRenderbuffers_is_not_3);
70COMPILE_ASSERT(kTextures == 4, kTextures_is_not_4);
71
72}  // namespace id_namespaces
73
74// Used for some glGetXXX commands that return a result through a pointer. We
75// need to know if the command succeeded or not and the size of the result. If
76// the command failed its result size will 0.
77template <typename T>
78struct SizedResult {
79  typedef T Type;
80
81  T* GetData() {
82    return static_cast<T*>(static_cast<void*>(&data));
83  }
84
85  // Returns the total size in bytes of the SizedResult for a given number of
86  // results including the size field.
87  static size_t ComputeSize(size_t num_results) {
88    return sizeof(T) * num_results + sizeof(uint32_t);  // NOLINT
89  }
90
91  // Returns the total size in bytes of the SizedResult for a given size of
92  // results.
93  static size_t ComputeSizeFromBytes(size_t size_of_result_in_bytes) {
94    return size_of_result_in_bytes + sizeof(uint32_t);  // NOLINT
95  }
96
97  // Returns the maximum number of results for a given buffer size.
98  static uint32_t ComputeMaxResults(size_t size_of_buffer) {
99    return (size_of_buffer >= sizeof(uint32_t)) ?
100        ((size_of_buffer - sizeof(uint32_t)) / sizeof(T)) : 0;  // NOLINT
101  }
102
103  // Set the size for a given number of results.
104  void SetNumResults(size_t num_results) {
105    size = sizeof(T) * num_results;  // NOLINT
106  }
107
108  // Get the number of elements in the result
109  int32_t GetNumResults() const {
110    return size / sizeof(T);  // NOLINT
111  }
112
113  // Copy the result.
114  void CopyResult(void* dst) const {
115    memcpy(dst, &data, size);
116  }
117
118  uint32_t size;  // in bytes.
119  int32_t data;  // this is just here to get an offset.
120};
121
122COMPILE_ASSERT(sizeof(SizedResult<int8_t>) == 8, SizedResult_size_not_8);
123COMPILE_ASSERT(offsetof(SizedResult<int8_t>, size) == 0,
124               OffsetOf_SizedResult_size_not_0);
125COMPILE_ASSERT(offsetof(SizedResult<int8_t>, data) == 4,
126               OffsetOf_SizedResult_data_not_4);
127
128// The data for one attrib or uniform from GetProgramInfoCHROMIUM.
129struct ProgramInput {
130  uint32_t type;             // The type (GL_VEC3, GL_MAT3, GL_SAMPLER_2D, etc.
131  int32_t size;              // The size (how big the array is for uniforms)
132  uint32_t location_offset;  // offset from ProgramInfoHeader to 'size'
133                             // locations for uniforms, 1 for attribs.
134  uint32_t name_offset;      // offset from ProgrmaInfoHeader to start of name.
135  uint32_t name_length;      // length of the name.
136};
137
138// The format of the bucket filled out by GetProgramInfoCHROMIUM
139struct ProgramInfoHeader {
140  uint32_t link_status;
141  uint32_t num_attribs;
142  uint32_t num_uniforms;
143  // ProgramInput inputs[num_attribs + num_uniforms];
144};
145
146// The format of QuerySync used by EXT_occlusion_query_boolean
147struct QuerySync {
148  void Reset() {
149    process_count = 0;
150    result = 0;
151  }
152
153  base::subtle::Atomic32 process_count;
154  uint64_t result;
155};
156
157struct AsyncUploadSync {
158  void Reset() {
159    base::subtle::Release_Store(&async_upload_token, 0);
160  }
161
162  void SetAsyncUploadToken(uint32_t token) {
163    DCHECK_NE(token, 0u);
164    base::subtle::Release_Store(&async_upload_token, token);
165  }
166
167  bool HasAsyncUploadTokenPassed(uint32_t token) {
168    DCHECK_NE(token, 0u);
169    uint32_t current_token = base::subtle::Acquire_Load(&async_upload_token);
170    return (current_token - token < 0x80000000);
171  }
172
173  base::subtle::Atomic32 async_upload_token;
174};
175
176COMPILE_ASSERT(sizeof(ProgramInput) == 20, ProgramInput_size_not_20);
177COMPILE_ASSERT(offsetof(ProgramInput, type) == 0,
178               OffsetOf_ProgramInput_type_not_0);
179COMPILE_ASSERT(offsetof(ProgramInput, size) == 4,
180               OffsetOf_ProgramInput_size_not_4);
181COMPILE_ASSERT(offsetof(ProgramInput, location_offset) == 8,
182               OffsetOf_ProgramInput_location_offset_not_8);
183COMPILE_ASSERT(offsetof(ProgramInput, name_offset) == 12,
184               OffsetOf_ProgramInput_name_offset_not_12);
185COMPILE_ASSERT(offsetof(ProgramInput, name_length) == 16,
186               OffsetOf_ProgramInput_name_length_not_16);
187
188COMPILE_ASSERT(sizeof(ProgramInfoHeader) == 12, ProgramInfoHeader_size_not_12);
189COMPILE_ASSERT(offsetof(ProgramInfoHeader, link_status) == 0,
190               OffsetOf_ProgramInfoHeader_link_status_not_0);
191COMPILE_ASSERT(offsetof(ProgramInfoHeader, num_attribs) == 4,
192               OffsetOf_ProgramInfoHeader_num_attribs_not_4);
193COMPILE_ASSERT(offsetof(ProgramInfoHeader, num_uniforms) == 8,
194               OffsetOf_ProgramInfoHeader_num_uniforms_not_8);
195
196namespace cmds {
197
198#include "../common/gles2_cmd_format_autogen.h"
199
200// These are hand written commands.
201// TODO(gman): Attempt to make these auto-generated.
202
203struct GetAttribLocation {
204  typedef GetAttribLocation ValueType;
205  static const CommandId kCmdId = kGetAttribLocation;
206  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
207  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
208
209  typedef GLint Result;
210
211  static uint32 ComputeSize() {
212    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
213  }
214
215  void SetHeader() {
216    header.SetCmd<ValueType>();
217  }
218
219  void Init(
220      GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
221      uint32 _location_shm_id, uint32 _location_shm_offset,
222      uint32 _data_size) {
223    SetHeader();
224    program = _program;
225    name_shm_id = _name_shm_id;
226    name_shm_offset = _name_shm_offset;
227    location_shm_id = _location_shm_id;
228    location_shm_offset = _location_shm_offset;
229    data_size = _data_size;
230  }
231
232  void* Set(
233      void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
234      uint32 _location_shm_id, uint32 _location_shm_offset,
235      uint32 _data_size) {
236    static_cast<ValueType*>(
237        cmd)->Init(
238            _program, _name_shm_id, _name_shm_offset, _location_shm_id,
239            _location_shm_offset, _data_size);
240    return NextCmdAddress<ValueType>(cmd);
241  }
242
243  CommandHeader header;
244  uint32 program;
245  uint32 name_shm_id;
246  uint32 name_shm_offset;
247  uint32 location_shm_id;
248  uint32 location_shm_offset;
249  uint32 data_size;
250};
251
252COMPILE_ASSERT(sizeof(GetAttribLocation) == 28,
253               Sizeof_GetAttribLocation_is_not_28);
254COMPILE_ASSERT(offsetof(GetAttribLocation, header) == 0,
255               OffsetOf_GetAttribLocation_header_not_0);
256COMPILE_ASSERT(offsetof(GetAttribLocation, program) == 4,
257               OffsetOf_GetAttribLocation_program_not_4);
258COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_id) == 8,
259               OffsetOf_GetAttribLocation_name_shm_id_not_8);
260COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_offset) == 12,
261               OffsetOf_GetAttribLocation_name_shm_offset_not_12);
262COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_id) == 16,
263               OffsetOf_GetAttribLocation_location_shm_id_not_16);
264COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_offset) == 20,
265               OffsetOf_GetAttribLocation_location_shm_offset_not_20);
266COMPILE_ASSERT(offsetof(GetAttribLocation, data_size) == 24,
267               OffsetOf_GetAttribLocation_data_size_not_24);
268
269
270struct GetAttribLocationBucket {
271  typedef GetAttribLocationBucket ValueType;
272  static const CommandId kCmdId = kGetAttribLocationBucket;
273  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
274  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
275
276  typedef GLint Result;
277
278  static uint32 ComputeSize() {
279    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
280  }
281
282  void SetHeader() {
283    header.SetCmd<ValueType>();
284  }
285
286  void Init(
287      GLuint _program, uint32 _name_bucket_id,
288      uint32 _location_shm_id, uint32 _location_shm_offset) {
289    SetHeader();
290    program = _program;
291    name_bucket_id = _name_bucket_id;
292    location_shm_id = _location_shm_id;
293    location_shm_offset = _location_shm_offset;
294  }
295
296  void* Set(
297      void* cmd, GLuint _program, uint32 _name_bucket_id,
298      uint32 _location_shm_id, uint32 _location_shm_offset) {
299    static_cast<ValueType*>(
300        cmd)->Init(
301            _program, _name_bucket_id, _location_shm_id,
302            _location_shm_offset);
303    return NextCmdAddress<ValueType>(cmd);
304  }
305
306  CommandHeader header;
307  uint32 program;
308  uint32 name_bucket_id;
309  uint32 location_shm_id;
310  uint32 location_shm_offset;
311};
312
313COMPILE_ASSERT(sizeof(GetAttribLocationBucket) == 20,
314               Sizeof_GetAttribLocationBucket_is_not_24);
315COMPILE_ASSERT(offsetof(GetAttribLocationBucket, header) == 0,
316               OffsetOf_GetAttribLocationBucket_header_not_0);
317COMPILE_ASSERT(offsetof(GetAttribLocationBucket, program) == 4,
318               OffsetOf_GetAttribLocationBucket_program_not_4);
319COMPILE_ASSERT(offsetof(GetAttribLocationBucket, name_bucket_id) == 8,
320               OffsetOf_GetAttribLocationBucket_name_bucket_id_not_8);
321COMPILE_ASSERT(offsetof(GetAttribLocationBucket, location_shm_id) == 12,
322               OffsetOf_GetAttribLocationBucket_location_shm_id_not_12);
323COMPILE_ASSERT(offsetof(GetAttribLocationBucket, location_shm_offset) == 16,
324               OffsetOf_GetAttribLocationBucket_location_shm_offset_not_16);
325
326struct GetUniformLocation {
327  typedef GetUniformLocation ValueType;
328  static const CommandId kCmdId = kGetUniformLocation;
329  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
330  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
331
332  typedef GLint Result;
333
334  static uint32 ComputeSize() {
335    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
336  }
337
338  void SetHeader() {
339    header.SetCmd<ValueType>();
340  }
341
342  void Init(
343      GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
344      uint32 _location_shm_id, uint32 _location_shm_offset,
345      uint32 _data_size) {
346    SetHeader();
347    program = _program;
348    name_shm_id = _name_shm_id;
349    name_shm_offset = _name_shm_offset;
350    location_shm_id = _location_shm_id;
351    location_shm_offset = _location_shm_offset;
352    data_size = _data_size;
353  }
354
355  void* Set(
356      void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
357      uint32 _location_shm_id, uint32 _location_shm_offset,
358      uint32 _data_size) {
359    static_cast<ValueType*>(
360        cmd)->Init(
361            _program, _name_shm_id, _name_shm_offset, _location_shm_id,
362            _location_shm_offset, _data_size);
363    return NextCmdAddress<ValueType>(cmd);
364  }
365
366  CommandHeader header;
367  uint32 program;
368  uint32 name_shm_id;
369  uint32 name_shm_offset;
370  uint32 location_shm_id;
371  uint32 location_shm_offset;
372  uint32 data_size;
373};
374
375COMPILE_ASSERT(sizeof(GetUniformLocation) == 28,
376               Sizeof_GetUniformLocation_is_not_28);
377COMPILE_ASSERT(offsetof(GetUniformLocation, header) == 0,
378               OffsetOf_GetUniformLocation_header_not_0);
379COMPILE_ASSERT(offsetof(GetUniformLocation, program) == 4,
380               OffsetOf_GetUniformLocation_program_not_4);
381COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_id) == 8,
382               OffsetOf_GetUniformLocation_name_shm_id_not_8);
383COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_offset) == 12,
384               OffsetOf_GetUniformLocation_name_shm_offset_not_12);
385COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_id) == 16,
386               OffsetOf_GetUniformLocation_location_shm_id_not_16);
387COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_offset) == 20,
388               OffsetOf_GetUniformLocation_location_shm_offset_not_20);
389COMPILE_ASSERT(offsetof(GetUniformLocation, data_size) == 24,
390               OffsetOf_GetUniformLocation_data_size_not_24);
391
392struct GetUniformLocationBucket {
393  typedef GetUniformLocationBucket ValueType;
394  static const CommandId kCmdId = kGetUniformLocationBucket;
395  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
396  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
397
398  typedef GLint Result;
399
400  static uint32 ComputeSize() {
401    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
402  }
403
404  void SetHeader() {
405    header.SetCmd<ValueType>();
406  }
407
408  void Init(
409      GLuint _program, uint32 _name_bucket_id,
410      uint32 _location_shm_id, uint32 _location_shm_offset) {
411    SetHeader();
412    program = _program;
413    name_bucket_id = _name_bucket_id;
414    location_shm_id = _location_shm_id;
415    location_shm_offset = _location_shm_offset;
416  }
417
418  void* Set(
419      void* cmd, GLuint _program, uint32 _name_bucket_id,
420      uint32 _location_shm_id, uint32 _location_shm_offset) {
421    static_cast<ValueType*>(
422        cmd)->Init(
423            _program, _name_bucket_id, _location_shm_id,
424            _location_shm_offset);
425    return NextCmdAddress<ValueType>(cmd);
426  }
427
428  CommandHeader header;
429  uint32 program;
430  uint32 name_bucket_id;
431  uint32 location_shm_id;
432  uint32 location_shm_offset;
433};
434
435COMPILE_ASSERT(sizeof(GetUniformLocationBucket) == 20,
436               Sizeof_GetUniformLocationBucket_is_not_24);
437COMPILE_ASSERT(offsetof(GetUniformLocationBucket, header) == 0,
438               OffsetOf_GetUniformLocationBucket_header_not_0);
439COMPILE_ASSERT(offsetof(GetUniformLocationBucket, program) == 4,
440               OffsetOf_GetUniformLocationBucket_program_not_4);
441COMPILE_ASSERT(offsetof(GetUniformLocationBucket, name_bucket_id) == 8,
442               OffsetOf_GetUniformLocationBucket_name_bucket_id_not_8);
443COMPILE_ASSERT(offsetof(GetUniformLocationBucket, location_shm_id) == 12,
444               OffsetOf_GetUniformLocationBucket_location_shm_id_not_12);
445COMPILE_ASSERT(offsetof(GetUniformLocationBucket, location_shm_offset) == 16,
446               OffsetOf_GetUniformLocationBucket_location_shm_offset_not_16);
447
448struct GenMailboxCHROMIUM {
449  typedef GenMailboxCHROMIUM ValueType;
450  static const CommandId kCmdId = kGenMailboxCHROMIUM;
451  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
452  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
453  CommandHeader header;
454};
455
456struct InsertSyncPointCHROMIUM {
457  typedef InsertSyncPointCHROMIUM ValueType;
458  static const CommandId kCmdId = kInsertSyncPointCHROMIUM;
459  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
460  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
461  CommandHeader header;
462};
463
464#pragma pack(pop)
465
466}  // namespace cmd
467}  // namespace gles2
468}  // namespace gpu
469
470#endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
471