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