// 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 is auto-generated from // gpu/command_buffer/build_gles2_cmd_buffer.py // DO NOT EDIT! #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ struct ActiveTexture { typedef ActiveTexture ValueType; static const CommandId kCmdId = kActiveTexture; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _texture) { SetHeader(); texture = _texture; } void* Set(void* cmd, GLenum _texture) { static_cast(cmd)->Init(_texture); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 texture; }; COMPILE_ASSERT(sizeof(ActiveTexture) == 8, Sizeof_ActiveTexture_is_not_8); COMPILE_ASSERT(offsetof(ActiveTexture, header) == 0, OffsetOf_ActiveTexture_header_not_0); COMPILE_ASSERT(offsetof(ActiveTexture, texture) == 4, OffsetOf_ActiveTexture_texture_not_4); struct AttachShader { typedef AttachShader ValueType; static const CommandId kCmdId = kAttachShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, GLuint _shader) { SetHeader(); program = _program; shader = _shader; } void* Set(void* cmd, GLuint _program, GLuint _shader) { static_cast(cmd)->Init(_program, _shader); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 shader; }; COMPILE_ASSERT(sizeof(AttachShader) == 12, Sizeof_AttachShader_is_not_12); COMPILE_ASSERT(offsetof(AttachShader, header) == 0, OffsetOf_AttachShader_header_not_0); COMPILE_ASSERT(offsetof(AttachShader, program) == 4, OffsetOf_AttachShader_program_not_4); COMPILE_ASSERT(offsetof(AttachShader, shader) == 8, OffsetOf_AttachShader_shader_not_8); struct BindAttribLocation { typedef BindAttribLocation ValueType; static const CommandId kCmdId = kBindAttribLocation; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLuint _index, uint32 _name_shm_id, uint32 _name_shm_offset, uint32 _data_size) { SetHeader(); program = _program; index = _index; name_shm_id = _name_shm_id; name_shm_offset = _name_shm_offset; data_size = _data_size; } void* Set( void* cmd, GLuint _program, GLuint _index, uint32 _name_shm_id, uint32 _name_shm_offset, uint32 _data_size) { static_cast( cmd)->Init( _program, _index, _name_shm_id, _name_shm_offset, _data_size); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 index; uint32 name_shm_id; uint32 name_shm_offset; uint32 data_size; }; COMPILE_ASSERT(sizeof(BindAttribLocation) == 24, Sizeof_BindAttribLocation_is_not_24); COMPILE_ASSERT(offsetof(BindAttribLocation, header) == 0, OffsetOf_BindAttribLocation_header_not_0); COMPILE_ASSERT(offsetof(BindAttribLocation, program) == 4, OffsetOf_BindAttribLocation_program_not_4); COMPILE_ASSERT(offsetof(BindAttribLocation, index) == 8, OffsetOf_BindAttribLocation_index_not_8); COMPILE_ASSERT(offsetof(BindAttribLocation, name_shm_id) == 12, OffsetOf_BindAttribLocation_name_shm_id_not_12); COMPILE_ASSERT(offsetof(BindAttribLocation, name_shm_offset) == 16, OffsetOf_BindAttribLocation_name_shm_offset_not_16); COMPILE_ASSERT(offsetof(BindAttribLocation, data_size) == 20, OffsetOf_BindAttribLocation_data_size_not_20); struct BindAttribLocationImmediate { typedef BindAttribLocationImmediate ValueType; static const CommandId kCmdId = kBindAttribLocationImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 data_size) { return static_cast( sizeof(ValueType) + data_size); // NOLINT } void SetHeader(uint32 data_size) { header.SetCmdBySize(data_size); } void Init( GLuint _program, GLuint _index, const char* _name, uint32 _data_size) { SetHeader(_data_size); program = _program; index = _index; data_size = _data_size; memcpy(ImmediateDataAddress(this), _name, _data_size); } void* Set( void* cmd, GLuint _program, GLuint _index, const char* _name, uint32 _data_size) { static_cast(cmd)->Init(_program, _index, _name, _data_size); return NextImmediateCmdAddress(cmd, _data_size); } gpu::CommandHeader header; uint32 program; uint32 index; uint32 data_size; }; COMPILE_ASSERT(sizeof(BindAttribLocationImmediate) == 16, Sizeof_BindAttribLocationImmediate_is_not_16); COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, header) == 0, OffsetOf_BindAttribLocationImmediate_header_not_0); COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, program) == 4, OffsetOf_BindAttribLocationImmediate_program_not_4); COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, index) == 8, OffsetOf_BindAttribLocationImmediate_index_not_8); COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, data_size) == 12, OffsetOf_BindAttribLocationImmediate_data_size_not_12); struct BindAttribLocationBucket { typedef BindAttribLocationBucket ValueType; static const CommandId kCmdId = kBindAttribLocationBucket; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, GLuint _index, uint32 _name_bucket_id) { SetHeader(); program = _program; index = _index; name_bucket_id = _name_bucket_id; } void* Set( void* cmd, GLuint _program, GLuint _index, uint32 _name_bucket_id) { static_cast(cmd)->Init(_program, _index, _name_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 index; uint32 name_bucket_id; }; COMPILE_ASSERT(sizeof(BindAttribLocationBucket) == 16, Sizeof_BindAttribLocationBucket_is_not_16); COMPILE_ASSERT(offsetof(BindAttribLocationBucket, header) == 0, OffsetOf_BindAttribLocationBucket_header_not_0); COMPILE_ASSERT(offsetof(BindAttribLocationBucket, program) == 4, OffsetOf_BindAttribLocationBucket_program_not_4); COMPILE_ASSERT(offsetof(BindAttribLocationBucket, index) == 8, OffsetOf_BindAttribLocationBucket_index_not_8); COMPILE_ASSERT(offsetof(BindAttribLocationBucket, name_bucket_id) == 12, OffsetOf_BindAttribLocationBucket_name_bucket_id_not_12); struct BindBuffer { typedef BindBuffer ValueType; static const CommandId kCmdId = kBindBuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLuint _buffer) { SetHeader(); target = _target; buffer = _buffer; } void* Set(void* cmd, GLenum _target, GLuint _buffer) { static_cast(cmd)->Init(_target, _buffer); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 buffer; }; COMPILE_ASSERT(sizeof(BindBuffer) == 12, Sizeof_BindBuffer_is_not_12); COMPILE_ASSERT(offsetof(BindBuffer, header) == 0, OffsetOf_BindBuffer_header_not_0); COMPILE_ASSERT(offsetof(BindBuffer, target) == 4, OffsetOf_BindBuffer_target_not_4); COMPILE_ASSERT(offsetof(BindBuffer, buffer) == 8, OffsetOf_BindBuffer_buffer_not_8); struct BindFramebuffer { typedef BindFramebuffer ValueType; static const CommandId kCmdId = kBindFramebuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLuint _framebuffer) { SetHeader(); target = _target; framebuffer = _framebuffer; } void* Set(void* cmd, GLenum _target, GLuint _framebuffer) { static_cast(cmd)->Init(_target, _framebuffer); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 framebuffer; }; COMPILE_ASSERT(sizeof(BindFramebuffer) == 12, Sizeof_BindFramebuffer_is_not_12); COMPILE_ASSERT(offsetof(BindFramebuffer, header) == 0, OffsetOf_BindFramebuffer_header_not_0); COMPILE_ASSERT(offsetof(BindFramebuffer, target) == 4, OffsetOf_BindFramebuffer_target_not_4); COMPILE_ASSERT(offsetof(BindFramebuffer, framebuffer) == 8, OffsetOf_BindFramebuffer_framebuffer_not_8); struct BindRenderbuffer { typedef BindRenderbuffer ValueType; static const CommandId kCmdId = kBindRenderbuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLuint _renderbuffer) { SetHeader(); target = _target; renderbuffer = _renderbuffer; } void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) { static_cast(cmd)->Init(_target, _renderbuffer); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 renderbuffer; }; COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12, Sizeof_BindRenderbuffer_is_not_12); COMPILE_ASSERT(offsetof(BindRenderbuffer, header) == 0, OffsetOf_BindRenderbuffer_header_not_0); COMPILE_ASSERT(offsetof(BindRenderbuffer, target) == 4, OffsetOf_BindRenderbuffer_target_not_4); COMPILE_ASSERT(offsetof(BindRenderbuffer, renderbuffer) == 8, OffsetOf_BindRenderbuffer_renderbuffer_not_8); struct BindTexture { typedef BindTexture ValueType; static const CommandId kCmdId = kBindTexture; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLuint _texture) { SetHeader(); target = _target; texture = _texture; } void* Set(void* cmd, GLenum _target, GLuint _texture) { static_cast(cmd)->Init(_target, _texture); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 texture; }; COMPILE_ASSERT(sizeof(BindTexture) == 12, Sizeof_BindTexture_is_not_12); COMPILE_ASSERT(offsetof(BindTexture, header) == 0, OffsetOf_BindTexture_header_not_0); COMPILE_ASSERT(offsetof(BindTexture, target) == 4, OffsetOf_BindTexture_target_not_4); COMPILE_ASSERT(offsetof(BindTexture, texture) == 8, OffsetOf_BindTexture_texture_not_8); struct BlendColor { typedef BlendColor ValueType; static const CommandId kCmdId = kBlendColor; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { SetHeader(); red = _red; green = _green; blue = _blue; alpha = _alpha; } void* Set( void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { static_cast(cmd)->Init(_red, _green, _blue, _alpha); return NextCmdAddress(cmd); } gpu::CommandHeader header; float red; float green; float blue; float alpha; }; COMPILE_ASSERT(sizeof(BlendColor) == 20, Sizeof_BlendColor_is_not_20); COMPILE_ASSERT(offsetof(BlendColor, header) == 0, OffsetOf_BlendColor_header_not_0); COMPILE_ASSERT(offsetof(BlendColor, red) == 4, OffsetOf_BlendColor_red_not_4); COMPILE_ASSERT(offsetof(BlendColor, green) == 8, OffsetOf_BlendColor_green_not_8); COMPILE_ASSERT(offsetof(BlendColor, blue) == 12, OffsetOf_BlendColor_blue_not_12); COMPILE_ASSERT(offsetof(BlendColor, alpha) == 16, OffsetOf_BlendColor_alpha_not_16); struct BlendEquation { typedef BlendEquation ValueType; static const CommandId kCmdId = kBlendEquation; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode) { SetHeader(); mode = _mode; } void* Set(void* cmd, GLenum _mode) { static_cast(cmd)->Init(_mode); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; }; COMPILE_ASSERT(sizeof(BlendEquation) == 8, Sizeof_BlendEquation_is_not_8); COMPILE_ASSERT(offsetof(BlendEquation, header) == 0, OffsetOf_BlendEquation_header_not_0); COMPILE_ASSERT(offsetof(BlendEquation, mode) == 4, OffsetOf_BlendEquation_mode_not_4); struct BlendEquationSeparate { typedef BlendEquationSeparate ValueType; static const CommandId kCmdId = kBlendEquationSeparate; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _modeRGB, GLenum _modeAlpha) { SetHeader(); modeRGB = _modeRGB; modeAlpha = _modeAlpha; } void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) { static_cast(cmd)->Init(_modeRGB, _modeAlpha); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 modeRGB; uint32 modeAlpha; }; COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12, Sizeof_BlendEquationSeparate_is_not_12); COMPILE_ASSERT(offsetof(BlendEquationSeparate, header) == 0, OffsetOf_BlendEquationSeparate_header_not_0); COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeRGB) == 4, OffsetOf_BlendEquationSeparate_modeRGB_not_4); COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeAlpha) == 8, OffsetOf_BlendEquationSeparate_modeAlpha_not_8); struct BlendFunc { typedef BlendFunc ValueType; static const CommandId kCmdId = kBlendFunc; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _sfactor, GLenum _dfactor) { SetHeader(); sfactor = _sfactor; dfactor = _dfactor; } void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) { static_cast(cmd)->Init(_sfactor, _dfactor); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 sfactor; uint32 dfactor; }; COMPILE_ASSERT(sizeof(BlendFunc) == 12, Sizeof_BlendFunc_is_not_12); COMPILE_ASSERT(offsetof(BlendFunc, header) == 0, OffsetOf_BlendFunc_header_not_0); COMPILE_ASSERT(offsetof(BlendFunc, sfactor) == 4, OffsetOf_BlendFunc_sfactor_not_4); COMPILE_ASSERT(offsetof(BlendFunc, dfactor) == 8, OffsetOf_BlendFunc_dfactor_not_8); struct BlendFuncSeparate { typedef BlendFuncSeparate ValueType; static const CommandId kCmdId = kBlendFuncSeparate; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha, GLenum _dstAlpha) { SetHeader(); srcRGB = _srcRGB; dstRGB = _dstRGB; srcAlpha = _srcAlpha; dstAlpha = _dstAlpha; } void* Set( void* cmd, GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha, GLenum _dstAlpha) { static_cast(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 srcRGB; uint32 dstRGB; uint32 srcAlpha; uint32 dstAlpha; }; COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20, Sizeof_BlendFuncSeparate_is_not_20); COMPILE_ASSERT(offsetof(BlendFuncSeparate, header) == 0, OffsetOf_BlendFuncSeparate_header_not_0); COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcRGB) == 4, OffsetOf_BlendFuncSeparate_srcRGB_not_4); COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstRGB) == 8, OffsetOf_BlendFuncSeparate_dstRGB_not_8); COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcAlpha) == 12, OffsetOf_BlendFuncSeparate_srcAlpha_not_12); COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstAlpha) == 16, OffsetOf_BlendFuncSeparate_dstAlpha_not_16); struct BufferData { typedef BufferData ValueType; static const CommandId kCmdId = kBufferData; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLsizeiptr _size, uint32 _data_shm_id, uint32 _data_shm_offset, GLenum _usage) { SetHeader(); target = _target; size = _size; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; usage = _usage; } void* Set( void* cmd, GLenum _target, GLsizeiptr _size, uint32 _data_shm_id, uint32 _data_shm_offset, GLenum _usage) { static_cast( cmd)->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 size; uint32 data_shm_id; uint32 data_shm_offset; uint32 usage; }; COMPILE_ASSERT(sizeof(BufferData) == 24, Sizeof_BufferData_is_not_24); COMPILE_ASSERT(offsetof(BufferData, header) == 0, OffsetOf_BufferData_header_not_0); COMPILE_ASSERT(offsetof(BufferData, target) == 4, OffsetOf_BufferData_target_not_4); COMPILE_ASSERT(offsetof(BufferData, size) == 8, OffsetOf_BufferData_size_not_8); COMPILE_ASSERT(offsetof(BufferData, data_shm_id) == 12, OffsetOf_BufferData_data_shm_id_not_12); COMPILE_ASSERT(offsetof(BufferData, data_shm_offset) == 16, OffsetOf_BufferData_data_shm_offset_not_16); COMPILE_ASSERT(offsetof(BufferData, usage) == 20, OffsetOf_BufferData_usage_not_20); struct BufferDataImmediate { typedef BufferDataImmediate ValueType; static const CommandId kCmdId = kBufferDataImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init(GLenum _target, GLsizeiptr _size, GLenum _usage) { uint32 total_size = 0; // TODO(gman): get correct size. SetHeader(total_size); target = _target; size = _size; usage = _usage; } void* Set(void* cmd, GLenum _target, GLsizeiptr _size, GLenum _usage) { uint32 total_size = 0; // TODO(gman): get correct size. static_cast(cmd)->Init(_target, _size, _usage); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 size; uint32 usage; }; COMPILE_ASSERT(sizeof(BufferDataImmediate) == 16, Sizeof_BufferDataImmediate_is_not_16); COMPILE_ASSERT(offsetof(BufferDataImmediate, header) == 0, OffsetOf_BufferDataImmediate_header_not_0); COMPILE_ASSERT(offsetof(BufferDataImmediate, target) == 4, OffsetOf_BufferDataImmediate_target_not_4); COMPILE_ASSERT(offsetof(BufferDataImmediate, size) == 8, OffsetOf_BufferDataImmediate_size_not_8); COMPILE_ASSERT(offsetof(BufferDataImmediate, usage) == 12, OffsetOf_BufferDataImmediate_usage_not_12); struct BufferSubData { typedef BufferSubData ValueType; static const CommandId kCmdId = kBufferSubData; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLintptr _offset, GLsizeiptr _size, uint32 _data_shm_id, uint32 _data_shm_offset) { SetHeader(); target = _target; offset = _offset; size = _size; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; } void* Set( void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size, uint32 _data_shm_id, uint32 _data_shm_offset) { static_cast( cmd)->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 offset; int32 size; uint32 data_shm_id; uint32 data_shm_offset; }; COMPILE_ASSERT(sizeof(BufferSubData) == 24, Sizeof_BufferSubData_is_not_24); COMPILE_ASSERT(offsetof(BufferSubData, header) == 0, OffsetOf_BufferSubData_header_not_0); COMPILE_ASSERT(offsetof(BufferSubData, target) == 4, OffsetOf_BufferSubData_target_not_4); COMPILE_ASSERT(offsetof(BufferSubData, offset) == 8, OffsetOf_BufferSubData_offset_not_8); COMPILE_ASSERT(offsetof(BufferSubData, size) == 12, OffsetOf_BufferSubData_size_not_12); COMPILE_ASSERT(offsetof(BufferSubData, data_shm_id) == 16, OffsetOf_BufferSubData_data_shm_id_not_16); COMPILE_ASSERT(offsetof(BufferSubData, data_shm_offset) == 20, OffsetOf_BufferSubData_data_shm_offset_not_20); struct BufferSubDataImmediate { typedef BufferSubDataImmediate ValueType; static const CommandId kCmdId = kBufferSubDataImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init(GLenum _target, GLintptr _offset, GLsizeiptr _size) { uint32 total_size = ComputeSize(_size); SetHeader(total_size); target = _target; offset = _offset; size = _size; } void* Set(void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size) { uint32 total_size = ComputeSize(_size); static_cast(cmd)->Init(_target, _offset, _size); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 offset; int32 size; }; COMPILE_ASSERT(sizeof(BufferSubDataImmediate) == 16, Sizeof_BufferSubDataImmediate_is_not_16); COMPILE_ASSERT(offsetof(BufferSubDataImmediate, header) == 0, OffsetOf_BufferSubDataImmediate_header_not_0); COMPILE_ASSERT(offsetof(BufferSubDataImmediate, target) == 4, OffsetOf_BufferSubDataImmediate_target_not_4); COMPILE_ASSERT(offsetof(BufferSubDataImmediate, offset) == 8, OffsetOf_BufferSubDataImmediate_offset_not_8); COMPILE_ASSERT(offsetof(BufferSubDataImmediate, size) == 12, OffsetOf_BufferSubDataImmediate_size_not_12); struct CheckFramebufferStatus { typedef CheckFramebufferStatus ValueType; static const CommandId kCmdId = kCheckFramebufferStatus; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef GLenum Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); target = _target; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLenum _target, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_target, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 16, Sizeof_CheckFramebufferStatus_is_not_16); COMPILE_ASSERT(offsetof(CheckFramebufferStatus, header) == 0, OffsetOf_CheckFramebufferStatus_header_not_0); COMPILE_ASSERT(offsetof(CheckFramebufferStatus, target) == 4, OffsetOf_CheckFramebufferStatus_target_not_4); COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_id) == 8, OffsetOf_CheckFramebufferStatus_result_shm_id_not_8); COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_offset) == 12, OffsetOf_CheckFramebufferStatus_result_shm_offset_not_12); struct Clear { typedef Clear ValueType; static const CommandId kCmdId = kClear; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLbitfield _mask) { SetHeader(); mask = _mask; } void* Set(void* cmd, GLbitfield _mask) { static_cast(cmd)->Init(_mask); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mask; }; COMPILE_ASSERT(sizeof(Clear) == 8, Sizeof_Clear_is_not_8); COMPILE_ASSERT(offsetof(Clear, header) == 0, OffsetOf_Clear_header_not_0); COMPILE_ASSERT(offsetof(Clear, mask) == 4, OffsetOf_Clear_mask_not_4); struct ClearColor { typedef ClearColor ValueType; static const CommandId kCmdId = kClearColor; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { SetHeader(); red = _red; green = _green; blue = _blue; alpha = _alpha; } void* Set( void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { static_cast(cmd)->Init(_red, _green, _blue, _alpha); return NextCmdAddress(cmd); } gpu::CommandHeader header; float red; float green; float blue; float alpha; }; COMPILE_ASSERT(sizeof(ClearColor) == 20, Sizeof_ClearColor_is_not_20); COMPILE_ASSERT(offsetof(ClearColor, header) == 0, OffsetOf_ClearColor_header_not_0); COMPILE_ASSERT(offsetof(ClearColor, red) == 4, OffsetOf_ClearColor_red_not_4); COMPILE_ASSERT(offsetof(ClearColor, green) == 8, OffsetOf_ClearColor_green_not_8); COMPILE_ASSERT(offsetof(ClearColor, blue) == 12, OffsetOf_ClearColor_blue_not_12); COMPILE_ASSERT(offsetof(ClearColor, alpha) == 16, OffsetOf_ClearColor_alpha_not_16); struct ClearDepthf { typedef ClearDepthf ValueType; static const CommandId kCmdId = kClearDepthf; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLclampf _depth) { SetHeader(); depth = _depth; } void* Set(void* cmd, GLclampf _depth) { static_cast(cmd)->Init(_depth); return NextCmdAddress(cmd); } gpu::CommandHeader header; float depth; }; COMPILE_ASSERT(sizeof(ClearDepthf) == 8, Sizeof_ClearDepthf_is_not_8); COMPILE_ASSERT(offsetof(ClearDepthf, header) == 0, OffsetOf_ClearDepthf_header_not_0); COMPILE_ASSERT(offsetof(ClearDepthf, depth) == 4, OffsetOf_ClearDepthf_depth_not_4); struct ClearStencil { typedef ClearStencil ValueType; static const CommandId kCmdId = kClearStencil; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _s) { SetHeader(); s = _s; } void* Set(void* cmd, GLint _s) { static_cast(cmd)->Init(_s); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 s; }; COMPILE_ASSERT(sizeof(ClearStencil) == 8, Sizeof_ClearStencil_is_not_8); COMPILE_ASSERT(offsetof(ClearStencil, header) == 0, OffsetOf_ClearStencil_header_not_0); COMPILE_ASSERT(offsetof(ClearStencil, s) == 4, OffsetOf_ClearStencil_s_not_4); struct ColorMask { typedef ColorMask ValueType; static const CommandId kCmdId = kColorMask; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLboolean _red, GLboolean _green, GLboolean _blue, GLboolean _alpha) { SetHeader(); red = _red; green = _green; blue = _blue; alpha = _alpha; } void* Set( void* cmd, GLboolean _red, GLboolean _green, GLboolean _blue, GLboolean _alpha) { static_cast(cmd)->Init(_red, _green, _blue, _alpha); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 red; uint32 green; uint32 blue; uint32 alpha; }; COMPILE_ASSERT(sizeof(ColorMask) == 20, Sizeof_ColorMask_is_not_20); COMPILE_ASSERT(offsetof(ColorMask, header) == 0, OffsetOf_ColorMask_header_not_0); COMPILE_ASSERT(offsetof(ColorMask, red) == 4, OffsetOf_ColorMask_red_not_4); COMPILE_ASSERT(offsetof(ColorMask, green) == 8, OffsetOf_ColorMask_green_not_8); COMPILE_ASSERT(offsetof(ColorMask, blue) == 12, OffsetOf_ColorMask_blue_not_12); COMPILE_ASSERT(offsetof(ColorMask, alpha) == 16, OffsetOf_ColorMask_alpha_not_16); struct CompileShader { typedef CompileShader ValueType; static const CommandId kCmdId = kCompileShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader) { SetHeader(); shader = _shader; } void* Set(void* cmd, GLuint _shader) { static_cast(cmd)->Init(_shader); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; }; COMPILE_ASSERT(sizeof(CompileShader) == 8, Sizeof_CompileShader_is_not_8); COMPILE_ASSERT(offsetof(CompileShader, header) == 0, OffsetOf_CompileShader_header_not_0); COMPILE_ASSERT(offsetof(CompileShader, shader) == 4, OffsetOf_CompileShader_shader_not_4); struct CompressedTexImage2D { typedef CompressedTexImage2D ValueType; static const CommandId kCmdId = kCompressedTexImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize, uint32 _data_shm_id, uint32 _data_shm_offset) { SetHeader(); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; imageSize = _imageSize; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; } void* Set( void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize, uint32 _data_shm_id, uint32 _data_shm_offset) { static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _imageSize, _data_shm_id, _data_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; uint32 internalformat; int32 width; int32 height; int32 border; int32 imageSize; uint32 data_shm_id; uint32 data_shm_offset; }; COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 40, Sizeof_CompressedTexImage2D_is_not_40); COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0, OffsetOf_CompressedTexImage2D_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4, OffsetOf_CompressedTexImage2D_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexImage2D, level) == 8, OffsetOf_CompressedTexImage2D_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexImage2D, internalformat) == 12, OffsetOf_CompressedTexImage2D_internalformat_not_12); COMPILE_ASSERT(offsetof(CompressedTexImage2D, width) == 16, OffsetOf_CompressedTexImage2D_width_not_16); COMPILE_ASSERT(offsetof(CompressedTexImage2D, height) == 20, OffsetOf_CompressedTexImage2D_height_not_20); COMPILE_ASSERT(offsetof(CompressedTexImage2D, border) == 24, OffsetOf_CompressedTexImage2D_border_not_24); COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 28, OffsetOf_CompressedTexImage2D_imageSize_not_28); COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 32, OffsetOf_CompressedTexImage2D_data_shm_id_not_32); COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 36, OffsetOf_CompressedTexImage2D_data_shm_offset_not_36); struct CompressedTexImage2DImmediate { typedef CompressedTexImage2DImmediate ValueType; static const CommandId kCmdId = kCompressedTexImage2DImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init( GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize) { uint32 total_size = 0; // TODO(gman): get correct size. SetHeader(total_size); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; imageSize = _imageSize; } void* Set( void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize) { uint32 total_size = 0; // TODO(gman): get correct size. static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _imageSize); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 level; uint32 internalformat; int32 width; int32 height; int32 border; int32 imageSize; }; COMPILE_ASSERT(sizeof(CompressedTexImage2DImmediate) == 32, Sizeof_CompressedTexImage2DImmediate_is_not_32); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, header) == 0, OffsetOf_CompressedTexImage2DImmediate_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, target) == 4, OffsetOf_CompressedTexImage2DImmediate_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, level) == 8, OffsetOf_CompressedTexImage2DImmediate_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, internalformat) == 12, OffsetOf_CompressedTexImage2DImmediate_internalformat_not_12); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, width) == 16, OffsetOf_CompressedTexImage2DImmediate_width_not_16); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, height) == 20, OffsetOf_CompressedTexImage2DImmediate_height_not_20); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, border) == 24, OffsetOf_CompressedTexImage2DImmediate_border_not_24); COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, imageSize) == 28, OffsetOf_CompressedTexImage2DImmediate_imageSize_not_28); struct CompressedTexImage2DBucket { typedef CompressedTexImage2DBucket ValueType; static const CommandId kCmdId = kCompressedTexImage2DBucket; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLuint _bucket_id) { SetHeader(); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; bucket_id = _bucket_id; } void* Set( void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLuint _bucket_id) { static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; uint32 internalformat; int32 width; int32 height; int32 border; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 32, Sizeof_CompressedTexImage2DBucket_is_not_32); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, header) == 0, OffsetOf_CompressedTexImage2DBucket_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, target) == 4, OffsetOf_CompressedTexImage2DBucket_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, level) == 8, OffsetOf_CompressedTexImage2DBucket_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, internalformat) == 12, OffsetOf_CompressedTexImage2DBucket_internalformat_not_12); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, width) == 16, OffsetOf_CompressedTexImage2DBucket_width_not_16); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, height) == 20, OffsetOf_CompressedTexImage2DBucket_height_not_20); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, border) == 24, OffsetOf_CompressedTexImage2DBucket_border_not_24); COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, bucket_id) == 28, OffsetOf_CompressedTexImage2DBucket_bucket_id_not_28); struct CompressedTexSubImage2D { typedef CompressedTexSubImage2D ValueType; static const CommandId kCmdId = kCompressedTexSubImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize, uint32 _data_shm_id, uint32 _data_shm_offset) { SetHeader(); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; imageSize = _imageSize; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize, uint32 _data_shm_id, uint32 _data_shm_offset) { static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _imageSize, _data_shm_id, _data_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; int32 imageSize; uint32 data_shm_id; uint32 data_shm_offset; }; COMPILE_ASSERT(sizeof(CompressedTexSubImage2D) == 44, Sizeof_CompressedTexSubImage2D_is_not_44); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, header) == 0, OffsetOf_CompressedTexSubImage2D_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, target) == 4, OffsetOf_CompressedTexSubImage2D_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, level) == 8, OffsetOf_CompressedTexSubImage2D_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, xoffset) == 12, OffsetOf_CompressedTexSubImage2D_xoffset_not_12); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, yoffset) == 16, OffsetOf_CompressedTexSubImage2D_yoffset_not_16); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, width) == 20, OffsetOf_CompressedTexSubImage2D_width_not_20); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, height) == 24, OffsetOf_CompressedTexSubImage2D_height_not_24); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, format) == 28, OffsetOf_CompressedTexSubImage2D_format_not_28); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, imageSize) == 32, OffsetOf_CompressedTexSubImage2D_imageSize_not_32); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36, OffsetOf_CompressedTexSubImage2D_data_shm_id_not_36); COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40, OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40); struct CompressedTexSubImage2DImmediate { typedef CompressedTexSubImage2DImmediate ValueType; static const CommandId kCmdId = kCompressedTexSubImage2DImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize) { uint32 total_size = ComputeSize(_imageSize); SetHeader(total_size); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; imageSize = _imageSize; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize) { uint32 total_size = ComputeSize(_imageSize); static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _imageSize); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; int32 imageSize; }; COMPILE_ASSERT(sizeof(CompressedTexSubImage2DImmediate) == 36, Sizeof_CompressedTexSubImage2DImmediate_is_not_36); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, header) == 0, OffsetOf_CompressedTexSubImage2DImmediate_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, target) == 4, OffsetOf_CompressedTexSubImage2DImmediate_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, level) == 8, OffsetOf_CompressedTexSubImage2DImmediate_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, xoffset) == 12, OffsetOf_CompressedTexSubImage2DImmediate_xoffset_not_12); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, yoffset) == 16, OffsetOf_CompressedTexSubImage2DImmediate_yoffset_not_16); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, width) == 20, OffsetOf_CompressedTexSubImage2DImmediate_width_not_20); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, height) == 24, OffsetOf_CompressedTexSubImage2DImmediate_height_not_24); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, format) == 28, OffsetOf_CompressedTexSubImage2DImmediate_format_not_28); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, imageSize) == 32, OffsetOf_CompressedTexSubImage2DImmediate_imageSize_not_32); struct CompressedTexSubImage2DBucket { typedef CompressedTexSubImage2DBucket ValueType; static const CommandId kCmdId = kCompressedTexSubImage2DBucket; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLuint _bucket_id) { SetHeader(); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; bucket_id = _bucket_id; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLuint _bucket_id) { static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(CompressedTexSubImage2DBucket) == 36, Sizeof_CompressedTexSubImage2DBucket_is_not_36); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, header) == 0, OffsetOf_CompressedTexSubImage2DBucket_header_not_0); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, target) == 4, OffsetOf_CompressedTexSubImage2DBucket_target_not_4); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, level) == 8, OffsetOf_CompressedTexSubImage2DBucket_level_not_8); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, xoffset) == 12, OffsetOf_CompressedTexSubImage2DBucket_xoffset_not_12); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, yoffset) == 16, OffsetOf_CompressedTexSubImage2DBucket_yoffset_not_16); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, width) == 20, OffsetOf_CompressedTexSubImage2DBucket_width_not_20); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, height) == 24, OffsetOf_CompressedTexSubImage2DBucket_height_not_24); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, format) == 28, OffsetOf_CompressedTexSubImage2DBucket_format_not_28); COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, bucket_id) == 32, OffsetOf_CompressedTexSubImage2DBucket_bucket_id_not_32); struct CopyTexImage2D { typedef CopyTexImage2D ValueType; static const CommandId kCmdId = kCopyTexImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLenum _internalformat, GLint _x, GLint _y, GLsizei _width, GLsizei _height, GLint _border) { SetHeader(); target = _target; level = _level; internalformat = _internalformat; x = _x; y = _y; width = _width; height = _height; border = _border; } void* Set( void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLint _x, GLint _y, GLsizei _width, GLsizei _height, GLint _border) { static_cast( cmd)->Init( _target, _level, _internalformat, _x, _y, _width, _height, _border); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; uint32 internalformat; int32 x; int32 y; int32 width; int32 height; int32 border; }; COMPILE_ASSERT(sizeof(CopyTexImage2D) == 36, Sizeof_CopyTexImage2D_is_not_36); COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0, OffsetOf_CopyTexImage2D_header_not_0); COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4, OffsetOf_CopyTexImage2D_target_not_4); COMPILE_ASSERT(offsetof(CopyTexImage2D, level) == 8, OffsetOf_CopyTexImage2D_level_not_8); COMPILE_ASSERT(offsetof(CopyTexImage2D, internalformat) == 12, OffsetOf_CopyTexImage2D_internalformat_not_12); COMPILE_ASSERT(offsetof(CopyTexImage2D, x) == 16, OffsetOf_CopyTexImage2D_x_not_16); COMPILE_ASSERT(offsetof(CopyTexImage2D, y) == 20, OffsetOf_CopyTexImage2D_y_not_20); COMPILE_ASSERT(offsetof(CopyTexImage2D, width) == 24, OffsetOf_CopyTexImage2D_width_not_24); COMPILE_ASSERT(offsetof(CopyTexImage2D, height) == 28, OffsetOf_CopyTexImage2D_height_not_28); COMPILE_ASSERT(offsetof(CopyTexImage2D, border) == 32, OffsetOf_CopyTexImage2D_border_not_32); struct CopyTexSubImage2D { typedef CopyTexSubImage2D ValueType; static const CommandId kCmdId = kCopyTexSubImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { SetHeader(); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; x = _x; y = _y; width = _width; height = _height; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _x, _y, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 x; int32 y; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(CopyTexSubImage2D) == 36, Sizeof_CopyTexSubImage2D_is_not_36); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, header) == 0, OffsetOf_CopyTexSubImage2D_header_not_0); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, target) == 4, OffsetOf_CopyTexSubImage2D_target_not_4); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, level) == 8, OffsetOf_CopyTexSubImage2D_level_not_8); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, xoffset) == 12, OffsetOf_CopyTexSubImage2D_xoffset_not_12); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, yoffset) == 16, OffsetOf_CopyTexSubImage2D_yoffset_not_16); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, x) == 20, OffsetOf_CopyTexSubImage2D_x_not_20); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, y) == 24, OffsetOf_CopyTexSubImage2D_y_not_24); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, width) == 28, OffsetOf_CopyTexSubImage2D_width_not_28); COMPILE_ASSERT(offsetof(CopyTexSubImage2D, height) == 32, OffsetOf_CopyTexSubImage2D_height_not_32); struct CreateProgram { typedef CreateProgram ValueType; static const CommandId kCmdId = kCreateProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(uint32 _client_id) { SetHeader(); client_id = _client_id; } void* Set(void* cmd, uint32 _client_id) { static_cast(cmd)->Init(_client_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 client_id; }; COMPILE_ASSERT(sizeof(CreateProgram) == 8, Sizeof_CreateProgram_is_not_8); COMPILE_ASSERT(offsetof(CreateProgram, header) == 0, OffsetOf_CreateProgram_header_not_0); COMPILE_ASSERT(offsetof(CreateProgram, client_id) == 4, OffsetOf_CreateProgram_client_id_not_4); struct CreateShader { typedef CreateShader ValueType; static const CommandId kCmdId = kCreateShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _type, uint32 _client_id) { SetHeader(); type = _type; client_id = _client_id; } void* Set(void* cmd, GLenum _type, uint32 _client_id) { static_cast(cmd)->Init(_type, _client_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 type; uint32 client_id; }; COMPILE_ASSERT(sizeof(CreateShader) == 12, Sizeof_CreateShader_is_not_12); COMPILE_ASSERT(offsetof(CreateShader, header) == 0, OffsetOf_CreateShader_header_not_0); COMPILE_ASSERT(offsetof(CreateShader, type) == 4, OffsetOf_CreateShader_type_not_4); COMPILE_ASSERT(offsetof(CreateShader, client_id) == 8, OffsetOf_CreateShader_client_id_not_8); struct CullFace { typedef CullFace ValueType; static const CommandId kCmdId = kCullFace; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode) { SetHeader(); mode = _mode; } void* Set(void* cmd, GLenum _mode) { static_cast(cmd)->Init(_mode); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; }; COMPILE_ASSERT(sizeof(CullFace) == 8, Sizeof_CullFace_is_not_8); COMPILE_ASSERT(offsetof(CullFace, header) == 0, OffsetOf_CullFace_header_not_0); COMPILE_ASSERT(offsetof(CullFace, mode) == 4, OffsetOf_CullFace_mode_not_4); struct DeleteBuffers { typedef DeleteBuffers ValueType; static const CommandId kCmdId = kDeleteBuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { SetHeader(); n = _n; buffers_shm_id = _buffers_shm_id; buffers_shm_offset = _buffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { static_cast( cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 buffers_shm_id; uint32 buffers_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteBuffers) == 16, Sizeof_DeleteBuffers_is_not_16); COMPILE_ASSERT(offsetof(DeleteBuffers, header) == 0, OffsetOf_DeleteBuffers_header_not_0); COMPILE_ASSERT(offsetof(DeleteBuffers, n) == 4, OffsetOf_DeleteBuffers_n_not_4); COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_id) == 8, OffsetOf_DeleteBuffers_buffers_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_offset) == 12, OffsetOf_DeleteBuffers_buffers_shm_offset_not_12); struct DeleteBuffersImmediate { typedef DeleteBuffersImmediate ValueType; static const CommandId kCmdId = kDeleteBuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _buffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) { static_cast(cmd)->Init(_n, _buffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8, Sizeof_DeleteBuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0, OffsetOf_DeleteBuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4, OffsetOf_DeleteBuffersImmediate_n_not_4); struct DeleteFramebuffers { typedef DeleteFramebuffers ValueType; static const CommandId kCmdId = kDeleteFramebuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLsizei _n, uint32 _framebuffers_shm_id, uint32 _framebuffers_shm_offset) { SetHeader(); n = _n; framebuffers_shm_id = _framebuffers_shm_id; framebuffers_shm_offset = _framebuffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _framebuffers_shm_id, uint32 _framebuffers_shm_offset) { static_cast( cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 framebuffers_shm_id; uint32 framebuffers_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteFramebuffers) == 16, Sizeof_DeleteFramebuffers_is_not_16); COMPILE_ASSERT(offsetof(DeleteFramebuffers, header) == 0, OffsetOf_DeleteFramebuffers_header_not_0); COMPILE_ASSERT(offsetof(DeleteFramebuffers, n) == 4, OffsetOf_DeleteFramebuffers_n_not_4); COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_id) == 8, OffsetOf_DeleteFramebuffers_framebuffers_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_offset) == 12, OffsetOf_DeleteFramebuffers_framebuffers_shm_offset_not_12); struct DeleteFramebuffersImmediate { typedef DeleteFramebuffersImmediate ValueType; static const CommandId kCmdId = kDeleteFramebuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _framebuffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) { static_cast(cmd)->Init(_n, _framebuffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8, Sizeof_DeleteFramebuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0, OffsetOf_DeleteFramebuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4, OffsetOf_DeleteFramebuffersImmediate_n_not_4); struct DeleteProgram { typedef DeleteProgram ValueType; static const CommandId kCmdId = kDeleteProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program) { SetHeader(); program = _program; } void* Set(void* cmd, GLuint _program) { static_cast(cmd)->Init(_program); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; }; COMPILE_ASSERT(sizeof(DeleteProgram) == 8, Sizeof_DeleteProgram_is_not_8); COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0, OffsetOf_DeleteProgram_header_not_0); COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4, OffsetOf_DeleteProgram_program_not_4); struct DeleteRenderbuffers { typedef DeleteRenderbuffers ValueType; static const CommandId kCmdId = kDeleteRenderbuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLsizei _n, uint32 _renderbuffers_shm_id, uint32 _renderbuffers_shm_offset) { SetHeader(); n = _n; renderbuffers_shm_id = _renderbuffers_shm_id; renderbuffers_shm_offset = _renderbuffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id, uint32 _renderbuffers_shm_offset) { static_cast( cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 renderbuffers_shm_id; uint32 renderbuffers_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteRenderbuffers) == 16, Sizeof_DeleteRenderbuffers_is_not_16); COMPILE_ASSERT(offsetof(DeleteRenderbuffers, header) == 0, OffsetOf_DeleteRenderbuffers_header_not_0); COMPILE_ASSERT(offsetof(DeleteRenderbuffers, n) == 4, OffsetOf_DeleteRenderbuffers_n_not_4); COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_id) == 8, OffsetOf_DeleteRenderbuffers_renderbuffers_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_offset) == 12, OffsetOf_DeleteRenderbuffers_renderbuffers_shm_offset_not_12); struct DeleteRenderbuffersImmediate { typedef DeleteRenderbuffersImmediate ValueType; static const CommandId kCmdId = kDeleteRenderbuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _renderbuffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) { static_cast(cmd)->Init(_n, _renderbuffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8, Sizeof_DeleteRenderbuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0, OffsetOf_DeleteRenderbuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4, OffsetOf_DeleteRenderbuffersImmediate_n_not_4); struct DeleteShader { typedef DeleteShader ValueType; static const CommandId kCmdId = kDeleteShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader) { SetHeader(); shader = _shader; } void* Set(void* cmd, GLuint _shader) { static_cast(cmd)->Init(_shader); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; }; COMPILE_ASSERT(sizeof(DeleteShader) == 8, Sizeof_DeleteShader_is_not_8); COMPILE_ASSERT(offsetof(DeleteShader, header) == 0, OffsetOf_DeleteShader_header_not_0); COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4, OffsetOf_DeleteShader_shader_not_4); struct DeleteTextures { typedef DeleteTextures ValueType; static const CommandId kCmdId = kDeleteTextures; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { SetHeader(); n = _n; textures_shm_id = _textures_shm_id; textures_shm_offset = _textures_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { static_cast( cmd)->Init(_n, _textures_shm_id, _textures_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 textures_shm_id; uint32 textures_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteTextures) == 16, Sizeof_DeleteTextures_is_not_16); COMPILE_ASSERT(offsetof(DeleteTextures, header) == 0, OffsetOf_DeleteTextures_header_not_0); COMPILE_ASSERT(offsetof(DeleteTextures, n) == 4, OffsetOf_DeleteTextures_n_not_4); COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_id) == 8, OffsetOf_DeleteTextures_textures_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_offset) == 12, OffsetOf_DeleteTextures_textures_shm_offset_not_12); struct DeleteTexturesImmediate { typedef DeleteTexturesImmediate ValueType; static const CommandId kCmdId = kDeleteTexturesImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _textures) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _textures) { static_cast(cmd)->Init(_n, _textures); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8, Sizeof_DeleteTexturesImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0, OffsetOf_DeleteTexturesImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4, OffsetOf_DeleteTexturesImmediate_n_not_4); struct DepthFunc { typedef DepthFunc ValueType; static const CommandId kCmdId = kDepthFunc; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _func) { SetHeader(); func = _func; } void* Set(void* cmd, GLenum _func) { static_cast(cmd)->Init(_func); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 func; }; COMPILE_ASSERT(sizeof(DepthFunc) == 8, Sizeof_DepthFunc_is_not_8); COMPILE_ASSERT(offsetof(DepthFunc, header) == 0, OffsetOf_DepthFunc_header_not_0); COMPILE_ASSERT(offsetof(DepthFunc, func) == 4, OffsetOf_DepthFunc_func_not_4); struct DepthMask { typedef DepthMask ValueType; static const CommandId kCmdId = kDepthMask; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLboolean _flag) { SetHeader(); flag = _flag; } void* Set(void* cmd, GLboolean _flag) { static_cast(cmd)->Init(_flag); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 flag; }; COMPILE_ASSERT(sizeof(DepthMask) == 8, Sizeof_DepthMask_is_not_8); COMPILE_ASSERT(offsetof(DepthMask, header) == 0, OffsetOf_DepthMask_header_not_0); COMPILE_ASSERT(offsetof(DepthMask, flag) == 4, OffsetOf_DepthMask_flag_not_4); struct DepthRangef { typedef DepthRangef ValueType; static const CommandId kCmdId = kDepthRangef; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLclampf _zNear, GLclampf _zFar) { SetHeader(); zNear = _zNear; zFar = _zFar; } void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) { static_cast(cmd)->Init(_zNear, _zFar); return NextCmdAddress(cmd); } gpu::CommandHeader header; float zNear; float zFar; }; COMPILE_ASSERT(sizeof(DepthRangef) == 12, Sizeof_DepthRangef_is_not_12); COMPILE_ASSERT(offsetof(DepthRangef, header) == 0, OffsetOf_DepthRangef_header_not_0); COMPILE_ASSERT(offsetof(DepthRangef, zNear) == 4, OffsetOf_DepthRangef_zNear_not_4); COMPILE_ASSERT(offsetof(DepthRangef, zFar) == 8, OffsetOf_DepthRangef_zFar_not_8); struct DetachShader { typedef DetachShader ValueType; static const CommandId kCmdId = kDetachShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, GLuint _shader) { SetHeader(); program = _program; shader = _shader; } void* Set(void* cmd, GLuint _program, GLuint _shader) { static_cast(cmd)->Init(_program, _shader); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 shader; }; COMPILE_ASSERT(sizeof(DetachShader) == 12, Sizeof_DetachShader_is_not_12); COMPILE_ASSERT(offsetof(DetachShader, header) == 0, OffsetOf_DetachShader_header_not_0); COMPILE_ASSERT(offsetof(DetachShader, program) == 4, OffsetOf_DetachShader_program_not_4); COMPILE_ASSERT(offsetof(DetachShader, shader) == 8, OffsetOf_DetachShader_shader_not_8); struct Disable { typedef Disable ValueType; static const CommandId kCmdId = kDisable; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _cap) { SetHeader(); cap = _cap; } void* Set(void* cmd, GLenum _cap) { static_cast(cmd)->Init(_cap); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 cap; }; COMPILE_ASSERT(sizeof(Disable) == 8, Sizeof_Disable_is_not_8); COMPILE_ASSERT(offsetof(Disable, header) == 0, OffsetOf_Disable_header_not_0); COMPILE_ASSERT(offsetof(Disable, cap) == 4, OffsetOf_Disable_cap_not_4); struct DisableVertexAttribArray { typedef DisableVertexAttribArray ValueType; static const CommandId kCmdId = kDisableVertexAttribArray; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _index) { SetHeader(); index = _index; } void* Set(void* cmd, GLuint _index) { static_cast(cmd)->Init(_index); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; }; COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8, Sizeof_DisableVertexAttribArray_is_not_8); COMPILE_ASSERT(offsetof(DisableVertexAttribArray, header) == 0, OffsetOf_DisableVertexAttribArray_header_not_0); COMPILE_ASSERT(offsetof(DisableVertexAttribArray, index) == 4, OffsetOf_DisableVertexAttribArray_index_not_4); struct DrawArrays { typedef DrawArrays ValueType; static const CommandId kCmdId = kDrawArrays; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode, GLint _first, GLsizei _count) { SetHeader(); mode = _mode; first = _first; count = _count; } void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) { static_cast(cmd)->Init(_mode, _first, _count); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; int32 first; int32 count; }; COMPILE_ASSERT(sizeof(DrawArrays) == 16, Sizeof_DrawArrays_is_not_16); COMPILE_ASSERT(offsetof(DrawArrays, header) == 0, OffsetOf_DrawArrays_header_not_0); COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4, OffsetOf_DrawArrays_mode_not_4); COMPILE_ASSERT(offsetof(DrawArrays, first) == 8, OffsetOf_DrawArrays_first_not_8); COMPILE_ASSERT(offsetof(DrawArrays, count) == 12, OffsetOf_DrawArrays_count_not_12); struct DrawElements { typedef DrawElements ValueType; static const CommandId kCmdId = kDrawElements; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) { SetHeader(); mode = _mode; count = _count; type = _type; index_offset = _index_offset; } void* Set( void* cmd, GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) { static_cast(cmd)->Init(_mode, _count, _type, _index_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; int32 count; uint32 type; uint32 index_offset; }; COMPILE_ASSERT(sizeof(DrawElements) == 20, Sizeof_DrawElements_is_not_20); COMPILE_ASSERT(offsetof(DrawElements, header) == 0, OffsetOf_DrawElements_header_not_0); COMPILE_ASSERT(offsetof(DrawElements, mode) == 4, OffsetOf_DrawElements_mode_not_4); COMPILE_ASSERT(offsetof(DrawElements, count) == 8, OffsetOf_DrawElements_count_not_8); COMPILE_ASSERT(offsetof(DrawElements, type) == 12, OffsetOf_DrawElements_type_not_12); COMPILE_ASSERT(offsetof(DrawElements, index_offset) == 16, OffsetOf_DrawElements_index_offset_not_16); struct Enable { typedef Enable ValueType; static const CommandId kCmdId = kEnable; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _cap) { SetHeader(); cap = _cap; } void* Set(void* cmd, GLenum _cap) { static_cast(cmd)->Init(_cap); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 cap; }; COMPILE_ASSERT(sizeof(Enable) == 8, Sizeof_Enable_is_not_8); COMPILE_ASSERT(offsetof(Enable, header) == 0, OffsetOf_Enable_header_not_0); COMPILE_ASSERT(offsetof(Enable, cap) == 4, OffsetOf_Enable_cap_not_4); struct EnableVertexAttribArray { typedef EnableVertexAttribArray ValueType; static const CommandId kCmdId = kEnableVertexAttribArray; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _index) { SetHeader(); index = _index; } void* Set(void* cmd, GLuint _index) { static_cast(cmd)->Init(_index); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; }; COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8, Sizeof_EnableVertexAttribArray_is_not_8); COMPILE_ASSERT(offsetof(EnableVertexAttribArray, header) == 0, OffsetOf_EnableVertexAttribArray_header_not_0); COMPILE_ASSERT(offsetof(EnableVertexAttribArray, index) == 4, OffsetOf_EnableVertexAttribArray_index_not_4); struct Finish { typedef Finish ValueType; static const CommandId kCmdId = kFinish; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(Finish) == 4, Sizeof_Finish_is_not_4); COMPILE_ASSERT(offsetof(Finish, header) == 0, OffsetOf_Finish_header_not_0); struct Flush { typedef Flush ValueType; static const CommandId kCmdId = kFlush; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(Flush) == 4, Sizeof_Flush_is_not_4); COMPILE_ASSERT(offsetof(Flush, header) == 0, OffsetOf_Flush_header_not_0); struct FramebufferRenderbuffer { typedef FramebufferRenderbuffer ValueType; static const CommandId kCmdId = kFramebufferRenderbuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _attachment, GLenum _renderbuffertarget, GLuint _renderbuffer) { SetHeader(); target = _target; attachment = _attachment; renderbuffertarget = _renderbuffertarget; renderbuffer = _renderbuffer; } void* Set( void* cmd, GLenum _target, GLenum _attachment, GLenum _renderbuffertarget, GLuint _renderbuffer) { static_cast( cmd)->Init(_target, _attachment, _renderbuffertarget, _renderbuffer); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 attachment; uint32 renderbuffertarget; uint32 renderbuffer; }; COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20, Sizeof_FramebufferRenderbuffer_is_not_20); COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, header) == 0, OffsetOf_FramebufferRenderbuffer_header_not_0); COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, target) == 4, OffsetOf_FramebufferRenderbuffer_target_not_4); COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, attachment) == 8, OffsetOf_FramebufferRenderbuffer_attachment_not_8); COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffertarget) == 12, OffsetOf_FramebufferRenderbuffer_renderbuffertarget_not_12); COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffer) == 16, OffsetOf_FramebufferRenderbuffer_renderbuffer_not_16); struct FramebufferTexture2D { typedef FramebufferTexture2D ValueType; static const CommandId kCmdId = kFramebufferTexture2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _attachment, GLenum _textarget, GLuint _texture, GLint _level) { SetHeader(); target = _target; attachment = _attachment; textarget = _textarget; texture = _texture; level = _level; } void* Set( void* cmd, GLenum _target, GLenum _attachment, GLenum _textarget, GLuint _texture, GLint _level) { static_cast( cmd)->Init(_target, _attachment, _textarget, _texture, _level); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 attachment; uint32 textarget; uint32 texture; int32 level; }; COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24, Sizeof_FramebufferTexture2D_is_not_24); COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0, OffsetOf_FramebufferTexture2D_header_not_0); COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4, OffsetOf_FramebufferTexture2D_target_not_4); COMPILE_ASSERT(offsetof(FramebufferTexture2D, attachment) == 8, OffsetOf_FramebufferTexture2D_attachment_not_8); COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12, OffsetOf_FramebufferTexture2D_textarget_not_12); COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16, OffsetOf_FramebufferTexture2D_texture_not_16); COMPILE_ASSERT(offsetof(FramebufferTexture2D, level) == 20, OffsetOf_FramebufferTexture2D_level_not_20); struct FrontFace { typedef FrontFace ValueType; static const CommandId kCmdId = kFrontFace; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode) { SetHeader(); mode = _mode; } void* Set(void* cmd, GLenum _mode) { static_cast(cmd)->Init(_mode); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; }; COMPILE_ASSERT(sizeof(FrontFace) == 8, Sizeof_FrontFace_is_not_8); COMPILE_ASSERT(offsetof(FrontFace, header) == 0, OffsetOf_FrontFace_header_not_0); COMPILE_ASSERT(offsetof(FrontFace, mode) == 4, OffsetOf_FrontFace_mode_not_4); struct GenBuffers { typedef GenBuffers ValueType; static const CommandId kCmdId = kGenBuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { SetHeader(); n = _n; buffers_shm_id = _buffers_shm_id; buffers_shm_offset = _buffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { static_cast( cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 buffers_shm_id; uint32 buffers_shm_offset; }; COMPILE_ASSERT(sizeof(GenBuffers) == 16, Sizeof_GenBuffers_is_not_16); COMPILE_ASSERT(offsetof(GenBuffers, header) == 0, OffsetOf_GenBuffers_header_not_0); COMPILE_ASSERT(offsetof(GenBuffers, n) == 4, OffsetOf_GenBuffers_n_not_4); COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_id) == 8, OffsetOf_GenBuffers_buffers_shm_id_not_8); COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_offset) == 12, OffsetOf_GenBuffers_buffers_shm_offset_not_12); struct GenBuffersImmediate { typedef GenBuffersImmediate ValueType; static const CommandId kCmdId = kGenBuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _buffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _buffers) { static_cast(cmd)->Init(_n, _buffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8, Sizeof_GenBuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0, OffsetOf_GenBuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4, OffsetOf_GenBuffersImmediate_n_not_4); struct GenerateMipmap { typedef GenerateMipmap ValueType; static const CommandId kCmdId = kGenerateMipmap; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target) { SetHeader(); target = _target; } void* Set(void* cmd, GLenum _target) { static_cast(cmd)->Init(_target); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; }; COMPILE_ASSERT(sizeof(GenerateMipmap) == 8, Sizeof_GenerateMipmap_is_not_8); COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0, OffsetOf_GenerateMipmap_header_not_0); COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4, OffsetOf_GenerateMipmap_target_not_4); struct GenFramebuffers { typedef GenFramebuffers ValueType; static const CommandId kCmdId = kGenFramebuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLsizei _n, uint32 _framebuffers_shm_id, uint32 _framebuffers_shm_offset) { SetHeader(); n = _n; framebuffers_shm_id = _framebuffers_shm_id; framebuffers_shm_offset = _framebuffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _framebuffers_shm_id, uint32 _framebuffers_shm_offset) { static_cast( cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 framebuffers_shm_id; uint32 framebuffers_shm_offset; }; COMPILE_ASSERT(sizeof(GenFramebuffers) == 16, Sizeof_GenFramebuffers_is_not_16); COMPILE_ASSERT(offsetof(GenFramebuffers, header) == 0, OffsetOf_GenFramebuffers_header_not_0); COMPILE_ASSERT(offsetof(GenFramebuffers, n) == 4, OffsetOf_GenFramebuffers_n_not_4); COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_id) == 8, OffsetOf_GenFramebuffers_framebuffers_shm_id_not_8); COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_offset) == 12, OffsetOf_GenFramebuffers_framebuffers_shm_offset_not_12); struct GenFramebuffersImmediate { typedef GenFramebuffersImmediate ValueType; static const CommandId kCmdId = kGenFramebuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _framebuffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) { static_cast(cmd)->Init(_n, _framebuffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8, Sizeof_GenFramebuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0, OffsetOf_GenFramebuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4, OffsetOf_GenFramebuffersImmediate_n_not_4); struct GenRenderbuffers { typedef GenRenderbuffers ValueType; static const CommandId kCmdId = kGenRenderbuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLsizei _n, uint32 _renderbuffers_shm_id, uint32 _renderbuffers_shm_offset) { SetHeader(); n = _n; renderbuffers_shm_id = _renderbuffers_shm_id; renderbuffers_shm_offset = _renderbuffers_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id, uint32 _renderbuffers_shm_offset) { static_cast( cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 renderbuffers_shm_id; uint32 renderbuffers_shm_offset; }; COMPILE_ASSERT(sizeof(GenRenderbuffers) == 16, Sizeof_GenRenderbuffers_is_not_16); COMPILE_ASSERT(offsetof(GenRenderbuffers, header) == 0, OffsetOf_GenRenderbuffers_header_not_0); COMPILE_ASSERT(offsetof(GenRenderbuffers, n) == 4, OffsetOf_GenRenderbuffers_n_not_4); COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_id) == 8, OffsetOf_GenRenderbuffers_renderbuffers_shm_id_not_8); COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_offset) == 12, OffsetOf_GenRenderbuffers_renderbuffers_shm_offset_not_12); struct GenRenderbuffersImmediate { typedef GenRenderbuffersImmediate ValueType; static const CommandId kCmdId = kGenRenderbuffersImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _renderbuffers) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) { static_cast(cmd)->Init(_n, _renderbuffers); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8, Sizeof_GenRenderbuffersImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0, OffsetOf_GenRenderbuffersImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4, OffsetOf_GenRenderbuffersImmediate_n_not_4); struct GenTextures { typedef GenTextures ValueType; static const CommandId kCmdId = kGenTextures; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { SetHeader(); n = _n; textures_shm_id = _textures_shm_id; textures_shm_offset = _textures_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { static_cast( cmd)->Init(_n, _textures_shm_id, _textures_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 textures_shm_id; uint32 textures_shm_offset; }; COMPILE_ASSERT(sizeof(GenTextures) == 16, Sizeof_GenTextures_is_not_16); COMPILE_ASSERT(offsetof(GenTextures, header) == 0, OffsetOf_GenTextures_header_not_0); COMPILE_ASSERT(offsetof(GenTextures, n) == 4, OffsetOf_GenTextures_n_not_4); COMPILE_ASSERT(offsetof(GenTextures, textures_shm_id) == 8, OffsetOf_GenTextures_textures_shm_id_not_8); COMPILE_ASSERT(offsetof(GenTextures, textures_shm_offset) == 12, OffsetOf_GenTextures_textures_shm_offset_not_12); struct GenTexturesImmediate { typedef GenTexturesImmediate ValueType; static const CommandId kCmdId = kGenTexturesImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _textures) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _textures) { static_cast(cmd)->Init(_n, _textures); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8, Sizeof_GenTexturesImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0, OffsetOf_GenTexturesImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4, OffsetOf_GenTexturesImmediate_n_not_4); struct GetActiveAttrib { typedef GetActiveAttrib ValueType; static const CommandId kCmdId = kGetActiveAttrib; static const cmd::ArgFlags kArgFlags = cmd::kFixed; struct Result { int32 success; int32 size; uint32 type; }; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLuint _index, uint32 _name_bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); program = _program; index = _index; name_bucket_id = _name_bucket_id; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _program, GLuint _index, uint32 _name_bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init( _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 index; uint32 name_bucket_id; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(GetActiveAttrib) == 24, Sizeof_GetActiveAttrib_is_not_24); COMPILE_ASSERT(offsetof(GetActiveAttrib, header) == 0, OffsetOf_GetActiveAttrib_header_not_0); COMPILE_ASSERT(offsetof(GetActiveAttrib, program) == 4, OffsetOf_GetActiveAttrib_program_not_4); COMPILE_ASSERT(offsetof(GetActiveAttrib, index) == 8, OffsetOf_GetActiveAttrib_index_not_8); COMPILE_ASSERT(offsetof(GetActiveAttrib, name_bucket_id) == 12, OffsetOf_GetActiveAttrib_name_bucket_id_not_12); COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_id) == 16, OffsetOf_GetActiveAttrib_result_shm_id_not_16); COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_offset) == 20, OffsetOf_GetActiveAttrib_result_shm_offset_not_20); COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, success) == 0, OffsetOf_GetActiveAttrib_Result_success_not_0); COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, size) == 4, OffsetOf_GetActiveAttrib_Result_size_not_4); COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, type) == 8, OffsetOf_GetActiveAttrib_Result_type_not_8); struct GetActiveUniform { typedef GetActiveUniform ValueType; static const CommandId kCmdId = kGetActiveUniform; static const cmd::ArgFlags kArgFlags = cmd::kFixed; struct Result { int32 success; int32 size; uint32 type; }; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLuint _index, uint32 _name_bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); program = _program; index = _index; name_bucket_id = _name_bucket_id; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _program, GLuint _index, uint32 _name_bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init( _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 index; uint32 name_bucket_id; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(GetActiveUniform) == 24, Sizeof_GetActiveUniform_is_not_24); COMPILE_ASSERT(offsetof(GetActiveUniform, header) == 0, OffsetOf_GetActiveUniform_header_not_0); COMPILE_ASSERT(offsetof(GetActiveUniform, program) == 4, OffsetOf_GetActiveUniform_program_not_4); COMPILE_ASSERT(offsetof(GetActiveUniform, index) == 8, OffsetOf_GetActiveUniform_index_not_8); COMPILE_ASSERT(offsetof(GetActiveUniform, name_bucket_id) == 12, OffsetOf_GetActiveUniform_name_bucket_id_not_12); COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_id) == 16, OffsetOf_GetActiveUniform_result_shm_id_not_16); COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_offset) == 20, OffsetOf_GetActiveUniform_result_shm_offset_not_20); COMPILE_ASSERT(offsetof(GetActiveUniform::Result, success) == 0, OffsetOf_GetActiveUniform_Result_success_not_0); COMPILE_ASSERT(offsetof(GetActiveUniform::Result, size) == 4, OffsetOf_GetActiveUniform_Result_size_not_4); COMPILE_ASSERT(offsetof(GetActiveUniform::Result, type) == 8, OffsetOf_GetActiveUniform_Result_type_not_8); struct GetAttachedShaders { typedef GetAttachedShaders ValueType; static const CommandId kCmdId = kGetAttachedShaders; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset, uint32 _result_size) { SetHeader(); program = _program; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; result_size = _result_size; } void* Set( void* cmd, GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset, uint32 _result_size) { static_cast( cmd)->Init(_program, _result_shm_id, _result_shm_offset, _result_size); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 result_shm_id; uint32 result_shm_offset; uint32 result_size; }; COMPILE_ASSERT(sizeof(GetAttachedShaders) == 20, Sizeof_GetAttachedShaders_is_not_20); COMPILE_ASSERT(offsetof(GetAttachedShaders, header) == 0, OffsetOf_GetAttachedShaders_header_not_0); COMPILE_ASSERT(offsetof(GetAttachedShaders, program) == 4, OffsetOf_GetAttachedShaders_program_not_4); COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_id) == 8, OffsetOf_GetAttachedShaders_result_shm_id_not_8); COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_offset) == 12, OffsetOf_GetAttachedShaders_result_shm_offset_not_12); COMPILE_ASSERT(offsetof(GetAttachedShaders, result_size) == 16, OffsetOf_GetAttachedShaders_result_size_not_16); struct GetBooleanv { typedef GetBooleanv ValueType; static const CommandId kCmdId = kGetBooleanv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetBooleanv) == 16, Sizeof_GetBooleanv_is_not_16); COMPILE_ASSERT(offsetof(GetBooleanv, header) == 0, OffsetOf_GetBooleanv_header_not_0); COMPILE_ASSERT(offsetof(GetBooleanv, pname) == 4, OffsetOf_GetBooleanv_pname_not_4); COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_id) == 8, OffsetOf_GetBooleanv_params_shm_id_not_8); COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_offset) == 12, OffsetOf_GetBooleanv_params_shm_offset_not_12); struct GetBufferParameteriv { typedef GetBufferParameteriv ValueType; static const CommandId kCmdId = kGetBufferParameteriv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20, Sizeof_GetBufferParameteriv_is_not_20); COMPILE_ASSERT(offsetof(GetBufferParameteriv, header) == 0, OffsetOf_GetBufferParameteriv_header_not_0); COMPILE_ASSERT(offsetof(GetBufferParameteriv, target) == 4, OffsetOf_GetBufferParameteriv_target_not_4); COMPILE_ASSERT(offsetof(GetBufferParameteriv, pname) == 8, OffsetOf_GetBufferParameteriv_pname_not_8); COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_id) == 12, OffsetOf_GetBufferParameteriv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_offset) == 16, OffsetOf_GetBufferParameteriv_params_shm_offset_not_16); struct GetError { typedef GetError ValueType; static const CommandId kCmdId = kGetError; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef GLenum Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set(void* cmd, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast(cmd)->Init(_result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(GetError) == 12, Sizeof_GetError_is_not_12); COMPILE_ASSERT(offsetof(GetError, header) == 0, OffsetOf_GetError_header_not_0); COMPILE_ASSERT(offsetof(GetError, result_shm_id) == 4, OffsetOf_GetError_result_shm_id_not_4); COMPILE_ASSERT(offsetof(GetError, result_shm_offset) == 8, OffsetOf_GetError_result_shm_offset_not_8); struct GetFloatv { typedef GetFloatv ValueType; static const CommandId kCmdId = kGetFloatv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetFloatv) == 16, Sizeof_GetFloatv_is_not_16); COMPILE_ASSERT(offsetof(GetFloatv, header) == 0, OffsetOf_GetFloatv_header_not_0); COMPILE_ASSERT(offsetof(GetFloatv, pname) == 4, OffsetOf_GetFloatv_pname_not_4); COMPILE_ASSERT(offsetof(GetFloatv, params_shm_id) == 8, OffsetOf_GetFloatv_params_shm_id_not_8); COMPILE_ASSERT(offsetof(GetFloatv, params_shm_offset) == 12, OffsetOf_GetFloatv_params_shm_offset_not_12); struct GetFramebufferAttachmentParameteriv { typedef GetFramebufferAttachmentParameteriv ValueType; static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _attachment, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; attachment = _attachment; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _attachment, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init( _target, _attachment, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 attachment; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24, Sizeof_GetFramebufferAttachmentParameteriv_is_not_24); COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, header) == 0, OffsetOf_GetFramebufferAttachmentParameteriv_header_not_0); COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, target) == 4, OffsetOf_GetFramebufferAttachmentParameteriv_target_not_4); COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, attachment) == 8, OffsetOf_GetFramebufferAttachmentParameteriv_attachment_not_8); COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, pname) == 12, OffsetOf_GetFramebufferAttachmentParameteriv_pname_not_12); COMPILE_ASSERT( offsetof(GetFramebufferAttachmentParameteriv, params_shm_id) == 16, OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_id_not_16); // NOLINT COMPILE_ASSERT( offsetof(GetFramebufferAttachmentParameteriv, params_shm_offset) == 20, OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_offset_not_20); // NOLINT struct GetIntegerv { typedef GetIntegerv ValueType; static const CommandId kCmdId = kGetIntegerv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetIntegerv) == 16, Sizeof_GetIntegerv_is_not_16); COMPILE_ASSERT(offsetof(GetIntegerv, header) == 0, OffsetOf_GetIntegerv_header_not_0); COMPILE_ASSERT(offsetof(GetIntegerv, pname) == 4, OffsetOf_GetIntegerv_pname_not_4); COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8, OffsetOf_GetIntegerv_params_shm_id_not_8); COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12, OffsetOf_GetIntegerv_params_shm_offset_not_12); struct GetProgramiv { typedef GetProgramiv ValueType; static const CommandId kCmdId = kGetProgramiv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); program = _program; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _program, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_program, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetProgramiv) == 20, Sizeof_GetProgramiv_is_not_20); COMPILE_ASSERT(offsetof(GetProgramiv, header) == 0, OffsetOf_GetProgramiv_header_not_0); COMPILE_ASSERT(offsetof(GetProgramiv, program) == 4, OffsetOf_GetProgramiv_program_not_4); COMPILE_ASSERT(offsetof(GetProgramiv, pname) == 8, OffsetOf_GetProgramiv_pname_not_8); COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_id) == 12, OffsetOf_GetProgramiv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_offset) == 16, OffsetOf_GetProgramiv_params_shm_offset_not_16); struct GetProgramInfoLog { typedef GetProgramInfoLog ValueType; static const CommandId kCmdId = kGetProgramInfoLog; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, uint32 _bucket_id) { SetHeader(); program = _program; bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _program, uint32 _bucket_id) { static_cast(cmd)->Init(_program, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 12, Sizeof_GetProgramInfoLog_is_not_12); COMPILE_ASSERT(offsetof(GetProgramInfoLog, header) == 0, OffsetOf_GetProgramInfoLog_header_not_0); COMPILE_ASSERT(offsetof(GetProgramInfoLog, program) == 4, OffsetOf_GetProgramInfoLog_program_not_4); COMPILE_ASSERT(offsetof(GetProgramInfoLog, bucket_id) == 8, OffsetOf_GetProgramInfoLog_bucket_id_not_8); struct GetRenderbufferParameteriv { typedef GetRenderbufferParameteriv ValueType; static const CommandId kCmdId = kGetRenderbufferParameteriv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20, Sizeof_GetRenderbufferParameteriv_is_not_20); COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, header) == 0, OffsetOf_GetRenderbufferParameteriv_header_not_0); COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, target) == 4, OffsetOf_GetRenderbufferParameteriv_target_not_4); COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, pname) == 8, OffsetOf_GetRenderbufferParameteriv_pname_not_8); COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_id) == 12, OffsetOf_GetRenderbufferParameteriv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_offset) == 16, OffsetOf_GetRenderbufferParameteriv_params_shm_offset_not_16); struct GetShaderiv { typedef GetShaderiv ValueType; static const CommandId kCmdId = kGetShaderiv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _shader, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); shader = _shader; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _shader, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_shader, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetShaderiv) == 20, Sizeof_GetShaderiv_is_not_20); COMPILE_ASSERT(offsetof(GetShaderiv, header) == 0, OffsetOf_GetShaderiv_header_not_0); COMPILE_ASSERT(offsetof(GetShaderiv, shader) == 4, OffsetOf_GetShaderiv_shader_not_4); COMPILE_ASSERT(offsetof(GetShaderiv, pname) == 8, OffsetOf_GetShaderiv_pname_not_8); COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_id) == 12, OffsetOf_GetShaderiv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_offset) == 16, OffsetOf_GetShaderiv_params_shm_offset_not_16); struct GetShaderInfoLog { typedef GetShaderInfoLog ValueType; static const CommandId kCmdId = kGetShaderInfoLog; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader, uint32 _bucket_id) { SetHeader(); shader = _shader; bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) { static_cast(cmd)->Init(_shader, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 12, Sizeof_GetShaderInfoLog_is_not_12); COMPILE_ASSERT(offsetof(GetShaderInfoLog, header) == 0, OffsetOf_GetShaderInfoLog_header_not_0); COMPILE_ASSERT(offsetof(GetShaderInfoLog, shader) == 4, OffsetOf_GetShaderInfoLog_shader_not_4); COMPILE_ASSERT(offsetof(GetShaderInfoLog, bucket_id) == 8, OffsetOf_GetShaderInfoLog_bucket_id_not_8); struct GetShaderPrecisionFormat { typedef GetShaderPrecisionFormat ValueType; static const CommandId kCmdId = kGetShaderPrecisionFormat; static const cmd::ArgFlags kArgFlags = cmd::kFixed; struct Result { int32 success; int32 min_range; int32 max_range; int32 precision; }; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _shadertype, GLenum _precisiontype, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); shadertype = _shadertype; precisiontype = _precisiontype; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLenum _shadertype, GLenum _precisiontype, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init( _shadertype, _precisiontype, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shadertype; uint32 precisiontype; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 20, Sizeof_GetShaderPrecisionFormat_is_not_20); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, header) == 0, OffsetOf_GetShaderPrecisionFormat_header_not_0); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, shadertype) == 4, OffsetOf_GetShaderPrecisionFormat_shadertype_not_4); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precisiontype) == 8, OffsetOf_GetShaderPrecisionFormat_precisiontype_not_8); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_id) == 12, OffsetOf_GetShaderPrecisionFormat_result_shm_id_not_12); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_offset) == 16, OffsetOf_GetShaderPrecisionFormat_result_shm_offset_not_16); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, success) == 0, OffsetOf_GetShaderPrecisionFormat_Result_success_not_0); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, min_range) == 4, OffsetOf_GetShaderPrecisionFormat_Result_min_range_not_4); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, max_range) == 8, OffsetOf_GetShaderPrecisionFormat_Result_max_range_not_8); COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, precision) == 12, OffsetOf_GetShaderPrecisionFormat_Result_precision_not_12); struct GetShaderSource { typedef GetShaderSource ValueType; static const CommandId kCmdId = kGetShaderSource; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader, uint32 _bucket_id) { SetHeader(); shader = _shader; bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) { static_cast(cmd)->Init(_shader, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetShaderSource) == 12, Sizeof_GetShaderSource_is_not_12); COMPILE_ASSERT(offsetof(GetShaderSource, header) == 0, OffsetOf_GetShaderSource_header_not_0); COMPILE_ASSERT(offsetof(GetShaderSource, shader) == 4, OffsetOf_GetShaderSource_shader_not_4); COMPILE_ASSERT(offsetof(GetShaderSource, bucket_id) == 8, OffsetOf_GetShaderSource_bucket_id_not_8); struct GetString { typedef GetString ValueType; static const CommandId kCmdId = kGetString; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _name, uint32 _bucket_id) { SetHeader(); name = _name; bucket_id = _bucket_id; } void* Set(void* cmd, GLenum _name, uint32 _bucket_id) { static_cast(cmd)->Init(_name, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 name; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetString) == 12, Sizeof_GetString_is_not_12); COMPILE_ASSERT(offsetof(GetString, header) == 0, OffsetOf_GetString_header_not_0); COMPILE_ASSERT(offsetof(GetString, name) == 4, OffsetOf_GetString_name_not_4); COMPILE_ASSERT(offsetof(GetString, bucket_id) == 8, OffsetOf_GetString_bucket_id_not_8); struct GetTexParameterfv { typedef GetTexParameterfv ValueType; static const CommandId kCmdId = kGetTexParameterfv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20, Sizeof_GetTexParameterfv_is_not_20); COMPILE_ASSERT(offsetof(GetTexParameterfv, header) == 0, OffsetOf_GetTexParameterfv_header_not_0); COMPILE_ASSERT(offsetof(GetTexParameterfv, target) == 4, OffsetOf_GetTexParameterfv_target_not_4); COMPILE_ASSERT(offsetof(GetTexParameterfv, pname) == 8, OffsetOf_GetTexParameterfv_pname_not_8); COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_id) == 12, OffsetOf_GetTexParameterfv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_offset) == 16, OffsetOf_GetTexParameterfv_params_shm_offset_not_16); struct GetTexParameteriv { typedef GetTexParameteriv ValueType; static const CommandId kCmdId = kGetTexParameteriv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20, Sizeof_GetTexParameteriv_is_not_20); COMPILE_ASSERT(offsetof(GetTexParameteriv, header) == 0, OffsetOf_GetTexParameteriv_header_not_0); COMPILE_ASSERT(offsetof(GetTexParameteriv, target) == 4, OffsetOf_GetTexParameteriv_target_not_4); COMPILE_ASSERT(offsetof(GetTexParameteriv, pname) == 8, OffsetOf_GetTexParameteriv_pname_not_8); COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_id) == 12, OffsetOf_GetTexParameteriv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_offset) == 16, OffsetOf_GetTexParameteriv_params_shm_offset_not_16); struct GetUniformfv { typedef GetUniformfv ValueType; static const CommandId kCmdId = kGetUniformfv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLint _location, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); program = _program; location = _location; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; int32 location; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetUniformfv) == 20, Sizeof_GetUniformfv_is_not_20); COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0, OffsetOf_GetUniformfv_header_not_0); COMPILE_ASSERT(offsetof(GetUniformfv, program) == 4, OffsetOf_GetUniformfv_program_not_4); COMPILE_ASSERT(offsetof(GetUniformfv, location) == 8, OffsetOf_GetUniformfv_location_not_8); COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_id) == 12, OffsetOf_GetUniformfv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_offset) == 16, OffsetOf_GetUniformfv_params_shm_offset_not_16); struct GetUniformiv { typedef GetUniformiv ValueType; static const CommandId kCmdId = kGetUniformiv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLint _location, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); program = _program; location = _location; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; int32 location; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetUniformiv) == 20, Sizeof_GetUniformiv_is_not_20); COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0, OffsetOf_GetUniformiv_header_not_0); COMPILE_ASSERT(offsetof(GetUniformiv, program) == 4, OffsetOf_GetUniformiv_program_not_4); COMPILE_ASSERT(offsetof(GetUniformiv, location) == 8, OffsetOf_GetUniformiv_location_not_8); COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_id) == 12, OffsetOf_GetUniformiv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_offset) == 16, OffsetOf_GetUniformiv_params_shm_offset_not_16); struct GetVertexAttribfv { typedef GetVertexAttribfv ValueType; static const CommandId kCmdId = kGetVertexAttribfv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _index, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); index = _index; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20, Sizeof_GetVertexAttribfv_is_not_20); COMPILE_ASSERT(offsetof(GetVertexAttribfv, header) == 0, OffsetOf_GetVertexAttribfv_header_not_0); COMPILE_ASSERT(offsetof(GetVertexAttribfv, index) == 4, OffsetOf_GetVertexAttribfv_index_not_4); COMPILE_ASSERT(offsetof(GetVertexAttribfv, pname) == 8, OffsetOf_GetVertexAttribfv_pname_not_8); COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_id) == 12, OffsetOf_GetVertexAttribfv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_offset) == 16, OffsetOf_GetVertexAttribfv_params_shm_offset_not_16); struct GetVertexAttribiv { typedef GetVertexAttribiv ValueType; static const CommandId kCmdId = kGetVertexAttribiv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _index, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); index = _index; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20, Sizeof_GetVertexAttribiv_is_not_20); COMPILE_ASSERT(offsetof(GetVertexAttribiv, header) == 0, OffsetOf_GetVertexAttribiv_header_not_0); COMPILE_ASSERT(offsetof(GetVertexAttribiv, index) == 4, OffsetOf_GetVertexAttribiv_index_not_4); COMPILE_ASSERT(offsetof(GetVertexAttribiv, pname) == 8, OffsetOf_GetVertexAttribiv_pname_not_8); COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_id) == 12, OffsetOf_GetVertexAttribiv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_offset) == 16, OffsetOf_GetVertexAttribiv_params_shm_offset_not_16); struct GetVertexAttribPointerv { typedef GetVertexAttribPointerv ValueType; static const CommandId kCmdId = kGetVertexAttribPointerv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _index, GLenum _pname, uint32 _pointer_shm_id, uint32 _pointer_shm_offset) { SetHeader(); index = _index; pname = _pname; pointer_shm_id = _pointer_shm_id; pointer_shm_offset = _pointer_shm_offset; } void* Set( void* cmd, GLuint _index, GLenum _pname, uint32 _pointer_shm_id, uint32 _pointer_shm_offset) { static_cast( cmd)->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; uint32 pname; uint32 pointer_shm_id; uint32 pointer_shm_offset; }; COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20, Sizeof_GetVertexAttribPointerv_is_not_20); COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, header) == 0, OffsetOf_GetVertexAttribPointerv_header_not_0); COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, index) == 4, OffsetOf_GetVertexAttribPointerv_index_not_4); COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pname) == 8, OffsetOf_GetVertexAttribPointerv_pname_not_8); COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_id) == 12, OffsetOf_GetVertexAttribPointerv_pointer_shm_id_not_12); COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_offset) == 16, OffsetOf_GetVertexAttribPointerv_pointer_shm_offset_not_16); struct Hint { typedef Hint ValueType; static const CommandId kCmdId = kHint; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLenum _mode) { SetHeader(); target = _target; mode = _mode; } void* Set(void* cmd, GLenum _target, GLenum _mode) { static_cast(cmd)->Init(_target, _mode); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 mode; }; COMPILE_ASSERT(sizeof(Hint) == 12, Sizeof_Hint_is_not_12); COMPILE_ASSERT(offsetof(Hint, header) == 0, OffsetOf_Hint_header_not_0); COMPILE_ASSERT(offsetof(Hint, target) == 4, OffsetOf_Hint_target_not_4); COMPILE_ASSERT(offsetof(Hint, mode) == 8, OffsetOf_Hint_mode_not_8); struct IsBuffer { typedef IsBuffer ValueType; static const CommandId kCmdId = kIsBuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _buffer, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); buffer = _buffer; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _buffer, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_buffer, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 buffer; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsBuffer) == 16, Sizeof_IsBuffer_is_not_16); COMPILE_ASSERT(offsetof(IsBuffer, header) == 0, OffsetOf_IsBuffer_header_not_0); COMPILE_ASSERT(offsetof(IsBuffer, buffer) == 4, OffsetOf_IsBuffer_buffer_not_4); COMPILE_ASSERT(offsetof(IsBuffer, result_shm_id) == 8, OffsetOf_IsBuffer_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsBuffer, result_shm_offset) == 12, OffsetOf_IsBuffer_result_shm_offset_not_12); struct IsEnabled { typedef IsEnabled ValueType; static const CommandId kCmdId = kIsEnabled; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _cap, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); cap = _cap; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLenum _cap, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_cap, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 cap; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsEnabled) == 16, Sizeof_IsEnabled_is_not_16); COMPILE_ASSERT(offsetof(IsEnabled, header) == 0, OffsetOf_IsEnabled_header_not_0); COMPILE_ASSERT(offsetof(IsEnabled, cap) == 4, OffsetOf_IsEnabled_cap_not_4); COMPILE_ASSERT(offsetof(IsEnabled, result_shm_id) == 8, OffsetOf_IsEnabled_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsEnabled, result_shm_offset) == 12, OffsetOf_IsEnabled_result_shm_offset_not_12); struct IsFramebuffer { typedef IsFramebuffer ValueType; static const CommandId kCmdId = kIsFramebuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _framebuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); framebuffer = _framebuffer; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _framebuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_framebuffer, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 framebuffer; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsFramebuffer) == 16, Sizeof_IsFramebuffer_is_not_16); COMPILE_ASSERT(offsetof(IsFramebuffer, header) == 0, OffsetOf_IsFramebuffer_header_not_0); COMPILE_ASSERT(offsetof(IsFramebuffer, framebuffer) == 4, OffsetOf_IsFramebuffer_framebuffer_not_4); COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_id) == 8, OffsetOf_IsFramebuffer_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_offset) == 12, OffsetOf_IsFramebuffer_result_shm_offset_not_12); struct IsProgram { typedef IsProgram ValueType; static const CommandId kCmdId = kIsProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); program = _program; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_program, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsProgram) == 16, Sizeof_IsProgram_is_not_16); COMPILE_ASSERT(offsetof(IsProgram, header) == 0, OffsetOf_IsProgram_header_not_0); COMPILE_ASSERT(offsetof(IsProgram, program) == 4, OffsetOf_IsProgram_program_not_4); COMPILE_ASSERT(offsetof(IsProgram, result_shm_id) == 8, OffsetOf_IsProgram_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsProgram, result_shm_offset) == 12, OffsetOf_IsProgram_result_shm_offset_not_12); struct IsRenderbuffer { typedef IsRenderbuffer ValueType; static const CommandId kCmdId = kIsRenderbuffer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _renderbuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); renderbuffer = _renderbuffer; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _renderbuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_renderbuffer, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 renderbuffer; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16, Sizeof_IsRenderbuffer_is_not_16); COMPILE_ASSERT(offsetof(IsRenderbuffer, header) == 0, OffsetOf_IsRenderbuffer_header_not_0); COMPILE_ASSERT(offsetof(IsRenderbuffer, renderbuffer) == 4, OffsetOf_IsRenderbuffer_renderbuffer_not_4); COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_id) == 8, OffsetOf_IsRenderbuffer_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_offset) == 12, OffsetOf_IsRenderbuffer_result_shm_offset_not_12); struct IsShader { typedef IsShader ValueType; static const CommandId kCmdId = kIsShader; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); shader = _shader; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _shader, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_shader, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsShader) == 16, Sizeof_IsShader_is_not_16); COMPILE_ASSERT(offsetof(IsShader, header) == 0, OffsetOf_IsShader_header_not_0); COMPILE_ASSERT(offsetof(IsShader, shader) == 4, OffsetOf_IsShader_shader_not_4); COMPILE_ASSERT(offsetof(IsShader, result_shm_id) == 8, OffsetOf_IsShader_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsShader, result_shm_offset) == 12, OffsetOf_IsShader_result_shm_offset_not_12); struct IsTexture { typedef IsTexture ValueType; static const CommandId kCmdId = kIsTexture; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _texture, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); texture = _texture; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _texture, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_texture, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 texture; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsTexture) == 16, Sizeof_IsTexture_is_not_16); COMPILE_ASSERT(offsetof(IsTexture, header) == 0, OffsetOf_IsTexture_header_not_0); COMPILE_ASSERT(offsetof(IsTexture, texture) == 4, OffsetOf_IsTexture_texture_not_4); COMPILE_ASSERT(offsetof(IsTexture, result_shm_id) == 8, OffsetOf_IsTexture_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsTexture, result_shm_offset) == 12, OffsetOf_IsTexture_result_shm_offset_not_12); struct LineWidth { typedef LineWidth ValueType; static const CommandId kCmdId = kLineWidth; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLfloat _width) { SetHeader(); width = _width; } void* Set(void* cmd, GLfloat _width) { static_cast(cmd)->Init(_width); return NextCmdAddress(cmd); } gpu::CommandHeader header; float width; }; COMPILE_ASSERT(sizeof(LineWidth) == 8, Sizeof_LineWidth_is_not_8); COMPILE_ASSERT(offsetof(LineWidth, header) == 0, OffsetOf_LineWidth_header_not_0); COMPILE_ASSERT(offsetof(LineWidth, width) == 4, OffsetOf_LineWidth_width_not_4); struct LinkProgram { typedef LinkProgram ValueType; static const CommandId kCmdId = kLinkProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program) { SetHeader(); program = _program; } void* Set(void* cmd, GLuint _program) { static_cast(cmd)->Init(_program); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; }; COMPILE_ASSERT(sizeof(LinkProgram) == 8, Sizeof_LinkProgram_is_not_8); COMPILE_ASSERT(offsetof(LinkProgram, header) == 0, OffsetOf_LinkProgram_header_not_0); COMPILE_ASSERT(offsetof(LinkProgram, program) == 4, OffsetOf_LinkProgram_program_not_4); struct PixelStorei { typedef PixelStorei ValueType; static const CommandId kCmdId = kPixelStorei; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _pname, GLint _param) { SetHeader(); pname = _pname; param = _param; } void* Set(void* cmd, GLenum _pname, GLint _param) { static_cast(cmd)->Init(_pname, _param); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 pname; int32 param; }; COMPILE_ASSERT(sizeof(PixelStorei) == 12, Sizeof_PixelStorei_is_not_12); COMPILE_ASSERT(offsetof(PixelStorei, header) == 0, OffsetOf_PixelStorei_header_not_0); COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4, OffsetOf_PixelStorei_pname_not_4); COMPILE_ASSERT(offsetof(PixelStorei, param) == 8, OffsetOf_PixelStorei_param_not_8); struct PolygonOffset { typedef PolygonOffset ValueType; static const CommandId kCmdId = kPolygonOffset; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLfloat _factor, GLfloat _units) { SetHeader(); factor = _factor; units = _units; } void* Set(void* cmd, GLfloat _factor, GLfloat _units) { static_cast(cmd)->Init(_factor, _units); return NextCmdAddress(cmd); } gpu::CommandHeader header; float factor; float units; }; COMPILE_ASSERT(sizeof(PolygonOffset) == 12, Sizeof_PolygonOffset_is_not_12); COMPILE_ASSERT(offsetof(PolygonOffset, header) == 0, OffsetOf_PolygonOffset_header_not_0); COMPILE_ASSERT(offsetof(PolygonOffset, factor) == 4, OffsetOf_PolygonOffset_factor_not_4); COMPILE_ASSERT(offsetof(PolygonOffset, units) == 8, OffsetOf_PolygonOffset_units_not_8); // ReadPixels has the result separated from the pixel buffer so that // it is easier to specify the result going to some specific place // that exactly fits the rectangle of pixels. struct ReadPixels { typedef ReadPixels ValueType; static const CommandId kCmdId = kReadPixels; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _x, GLint _y, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); x = _x; y = _y; width = _width; height = _height; format = _format; type = _type; pixels_shm_id = _pixels_shm_id; pixels_shm_offset = _pixels_shm_offset; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init( _x, _y, _width, _height, _format, _type, _pixels_shm_id, _pixels_shm_offset, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 x; int32 y; int32 width; int32 height; uint32 format; uint32 type; uint32 pixels_shm_id; uint32 pixels_shm_offset; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(ReadPixels) == 44, Sizeof_ReadPixels_is_not_44); COMPILE_ASSERT(offsetof(ReadPixels, header) == 0, OffsetOf_ReadPixels_header_not_0); COMPILE_ASSERT(offsetof(ReadPixels, x) == 4, OffsetOf_ReadPixels_x_not_4); COMPILE_ASSERT(offsetof(ReadPixels, y) == 8, OffsetOf_ReadPixels_y_not_8); COMPILE_ASSERT(offsetof(ReadPixels, width) == 12, OffsetOf_ReadPixels_width_not_12); COMPILE_ASSERT(offsetof(ReadPixels, height) == 16, OffsetOf_ReadPixels_height_not_16); COMPILE_ASSERT(offsetof(ReadPixels, format) == 20, OffsetOf_ReadPixels_format_not_20); COMPILE_ASSERT(offsetof(ReadPixels, type) == 24, OffsetOf_ReadPixels_type_not_24); COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_id) == 28, OffsetOf_ReadPixels_pixels_shm_id_not_28); COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_offset) == 32, OffsetOf_ReadPixels_pixels_shm_offset_not_32); COMPILE_ASSERT(offsetof(ReadPixels, result_shm_id) == 36, OffsetOf_ReadPixels_result_shm_id_not_36); COMPILE_ASSERT(offsetof(ReadPixels, result_shm_offset) == 40, OffsetOf_ReadPixels_result_shm_offset_not_40); struct ReleaseShaderCompiler { typedef ReleaseShaderCompiler ValueType; static const CommandId kCmdId = kReleaseShaderCompiler; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(ReleaseShaderCompiler) == 4, Sizeof_ReleaseShaderCompiler_is_not_4); COMPILE_ASSERT(offsetof(ReleaseShaderCompiler, header) == 0, OffsetOf_ReleaseShaderCompiler_header_not_0); struct RenderbufferStorage { typedef RenderbufferStorage ValueType; static const CommandId kCmdId = kRenderbufferStorage; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _internalformat, GLsizei _width, GLsizei _height) { SetHeader(); target = _target; internalformat = _internalformat; width = _width; height = _height; } void* Set( void* cmd, GLenum _target, GLenum _internalformat, GLsizei _width, GLsizei _height) { static_cast( cmd)->Init(_target, _internalformat, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 internalformat; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20, Sizeof_RenderbufferStorage_is_not_20); COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0, OffsetOf_RenderbufferStorage_header_not_0); COMPILE_ASSERT(offsetof(RenderbufferStorage, target) == 4, OffsetOf_RenderbufferStorage_target_not_4); COMPILE_ASSERT(offsetof(RenderbufferStorage, internalformat) == 8, OffsetOf_RenderbufferStorage_internalformat_not_8); COMPILE_ASSERT(offsetof(RenderbufferStorage, width) == 12, OffsetOf_RenderbufferStorage_width_not_12); COMPILE_ASSERT(offsetof(RenderbufferStorage, height) == 16, OffsetOf_RenderbufferStorage_height_not_16); struct SampleCoverage { typedef SampleCoverage ValueType; static const CommandId kCmdId = kSampleCoverage; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLclampf _value, GLboolean _invert) { SetHeader(); value = _value; invert = _invert; } void* Set(void* cmd, GLclampf _value, GLboolean _invert) { static_cast(cmd)->Init(_value, _invert); return NextCmdAddress(cmd); } gpu::CommandHeader header; float value; uint32 invert; }; COMPILE_ASSERT(sizeof(SampleCoverage) == 12, Sizeof_SampleCoverage_is_not_12); COMPILE_ASSERT(offsetof(SampleCoverage, header) == 0, OffsetOf_SampleCoverage_header_not_0); COMPILE_ASSERT(offsetof(SampleCoverage, value) == 4, OffsetOf_SampleCoverage_value_not_4); COMPILE_ASSERT(offsetof(SampleCoverage, invert) == 8, OffsetOf_SampleCoverage_invert_not_8); struct Scissor { typedef Scissor ValueType; static const CommandId kCmdId = kScissor; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { SetHeader(); x = _x; y = _y; width = _width; height = _height; } void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { static_cast(cmd)->Init(_x, _y, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 x; int32 y; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(Scissor) == 20, Sizeof_Scissor_is_not_20); COMPILE_ASSERT(offsetof(Scissor, header) == 0, OffsetOf_Scissor_header_not_0); COMPILE_ASSERT(offsetof(Scissor, x) == 4, OffsetOf_Scissor_x_not_4); COMPILE_ASSERT(offsetof(Scissor, y) == 8, OffsetOf_Scissor_y_not_8); COMPILE_ASSERT(offsetof(Scissor, width) == 12, OffsetOf_Scissor_width_not_12); COMPILE_ASSERT(offsetof(Scissor, height) == 16, OffsetOf_Scissor_height_not_16); struct ShaderBinary { typedef ShaderBinary ValueType; static const CommandId kCmdId = kShaderBinary; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLsizei _n, uint32 _shaders_shm_id, uint32 _shaders_shm_offset, GLenum _binaryformat, uint32 _binary_shm_id, uint32 _binary_shm_offset, GLsizei _length) { SetHeader(); n = _n; shaders_shm_id = _shaders_shm_id; shaders_shm_offset = _shaders_shm_offset; binaryformat = _binaryformat; binary_shm_id = _binary_shm_id; binary_shm_offset = _binary_shm_offset; length = _length; } void* Set( void* cmd, GLsizei _n, uint32 _shaders_shm_id, uint32 _shaders_shm_offset, GLenum _binaryformat, uint32 _binary_shm_id, uint32 _binary_shm_offset, GLsizei _length) { static_cast( cmd)->Init( _n, _shaders_shm_id, _shaders_shm_offset, _binaryformat, _binary_shm_id, _binary_shm_offset, _length); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 shaders_shm_id; uint32 shaders_shm_offset; uint32 binaryformat; uint32 binary_shm_id; uint32 binary_shm_offset; int32 length; }; COMPILE_ASSERT(sizeof(ShaderBinary) == 32, Sizeof_ShaderBinary_is_not_32); COMPILE_ASSERT(offsetof(ShaderBinary, header) == 0, OffsetOf_ShaderBinary_header_not_0); COMPILE_ASSERT(offsetof(ShaderBinary, n) == 4, OffsetOf_ShaderBinary_n_not_4); COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_id) == 8, OffsetOf_ShaderBinary_shaders_shm_id_not_8); COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_offset) == 12, OffsetOf_ShaderBinary_shaders_shm_offset_not_12); COMPILE_ASSERT(offsetof(ShaderBinary, binaryformat) == 16, OffsetOf_ShaderBinary_binaryformat_not_16); COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_id) == 20, OffsetOf_ShaderBinary_binary_shm_id_not_20); COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_offset) == 24, OffsetOf_ShaderBinary_binary_shm_offset_not_24); COMPILE_ASSERT(offsetof(ShaderBinary, length) == 28, OffsetOf_ShaderBinary_length_not_28); struct ShaderSource { typedef ShaderSource ValueType; static const CommandId kCmdId = kShaderSource; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _shader, uint32 _data_shm_id, uint32 _data_shm_offset, uint32 _data_size) { SetHeader(); shader = _shader; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; data_size = _data_size; } void* Set( void* cmd, GLuint _shader, uint32 _data_shm_id, uint32 _data_shm_offset, uint32 _data_size) { static_cast( cmd)->Init(_shader, _data_shm_id, _data_shm_offset, _data_size); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 data_shm_id; uint32 data_shm_offset; uint32 data_size; }; COMPILE_ASSERT(sizeof(ShaderSource) == 20, Sizeof_ShaderSource_is_not_20); COMPILE_ASSERT(offsetof(ShaderSource, header) == 0, OffsetOf_ShaderSource_header_not_0); COMPILE_ASSERT(offsetof(ShaderSource, shader) == 4, OffsetOf_ShaderSource_shader_not_4); COMPILE_ASSERT(offsetof(ShaderSource, data_shm_id) == 8, OffsetOf_ShaderSource_data_shm_id_not_8); COMPILE_ASSERT(offsetof(ShaderSource, data_shm_offset) == 12, OffsetOf_ShaderSource_data_shm_offset_not_12); COMPILE_ASSERT(offsetof(ShaderSource, data_size) == 16, OffsetOf_ShaderSource_data_size_not_16); struct ShaderSourceImmediate { typedef ShaderSourceImmediate ValueType; static const CommandId kCmdId = kShaderSourceImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init(GLuint _shader, uint32 _data_size) { uint32 total_size = ComputeSize(_data_size); SetHeader(total_size); shader = _shader; data_size = _data_size; } void* Set(void* cmd, GLuint _shader, uint32 _data_size) { uint32 total_size = ComputeSize(_data_size); static_cast(cmd)->Init(_shader, _data_size); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 shader; uint32 data_size; }; COMPILE_ASSERT(sizeof(ShaderSourceImmediate) == 12, Sizeof_ShaderSourceImmediate_is_not_12); COMPILE_ASSERT(offsetof(ShaderSourceImmediate, header) == 0, OffsetOf_ShaderSourceImmediate_header_not_0); COMPILE_ASSERT(offsetof(ShaderSourceImmediate, shader) == 4, OffsetOf_ShaderSourceImmediate_shader_not_4); COMPILE_ASSERT(offsetof(ShaderSourceImmediate, data_size) == 8, OffsetOf_ShaderSourceImmediate_data_size_not_8); struct ShaderSourceBucket { typedef ShaderSourceBucket ValueType; static const CommandId kCmdId = kShaderSourceBucket; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader, uint32 _data_bucket_id) { SetHeader(); shader = _shader; data_bucket_id = _data_bucket_id; } void* Set(void* cmd, GLuint _shader, uint32 _data_bucket_id) { static_cast(cmd)->Init(_shader, _data_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 data_bucket_id; }; COMPILE_ASSERT(sizeof(ShaderSourceBucket) == 12, Sizeof_ShaderSourceBucket_is_not_12); COMPILE_ASSERT(offsetof(ShaderSourceBucket, header) == 0, OffsetOf_ShaderSourceBucket_header_not_0); COMPILE_ASSERT(offsetof(ShaderSourceBucket, shader) == 4, OffsetOf_ShaderSourceBucket_shader_not_4); COMPILE_ASSERT(offsetof(ShaderSourceBucket, data_bucket_id) == 8, OffsetOf_ShaderSourceBucket_data_bucket_id_not_8); struct StencilFunc { typedef StencilFunc ValueType; static const CommandId kCmdId = kStencilFunc; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _func, GLint _ref, GLuint _mask) { SetHeader(); func = _func; ref = _ref; mask = _mask; } void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) { static_cast(cmd)->Init(_func, _ref, _mask); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 func; int32 ref; uint32 mask; }; COMPILE_ASSERT(sizeof(StencilFunc) == 16, Sizeof_StencilFunc_is_not_16); COMPILE_ASSERT(offsetof(StencilFunc, header) == 0, OffsetOf_StencilFunc_header_not_0); COMPILE_ASSERT(offsetof(StencilFunc, func) == 4, OffsetOf_StencilFunc_func_not_4); COMPILE_ASSERT(offsetof(StencilFunc, ref) == 8, OffsetOf_StencilFunc_ref_not_8); COMPILE_ASSERT(offsetof(StencilFunc, mask) == 12, OffsetOf_StencilFunc_mask_not_12); struct StencilFuncSeparate { typedef StencilFuncSeparate ValueType; static const CommandId kCmdId = kStencilFuncSeparate; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { SetHeader(); face = _face; func = _func; ref = _ref; mask = _mask; } void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { static_cast(cmd)->Init(_face, _func, _ref, _mask); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 face; uint32 func; int32 ref; uint32 mask; }; COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20, Sizeof_StencilFuncSeparate_is_not_20); COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0, OffsetOf_StencilFuncSeparate_header_not_0); COMPILE_ASSERT(offsetof(StencilFuncSeparate, face) == 4, OffsetOf_StencilFuncSeparate_face_not_4); COMPILE_ASSERT(offsetof(StencilFuncSeparate, func) == 8, OffsetOf_StencilFuncSeparate_func_not_8); COMPILE_ASSERT(offsetof(StencilFuncSeparate, ref) == 12, OffsetOf_StencilFuncSeparate_ref_not_12); COMPILE_ASSERT(offsetof(StencilFuncSeparate, mask) == 16, OffsetOf_StencilFuncSeparate_mask_not_16); struct StencilMask { typedef StencilMask ValueType; static const CommandId kCmdId = kStencilMask; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _mask) { SetHeader(); mask = _mask; } void* Set(void* cmd, GLuint _mask) { static_cast(cmd)->Init(_mask); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mask; }; COMPILE_ASSERT(sizeof(StencilMask) == 8, Sizeof_StencilMask_is_not_8); COMPILE_ASSERT(offsetof(StencilMask, header) == 0, OffsetOf_StencilMask_header_not_0); COMPILE_ASSERT(offsetof(StencilMask, mask) == 4, OffsetOf_StencilMask_mask_not_4); struct StencilMaskSeparate { typedef StencilMaskSeparate ValueType; static const CommandId kCmdId = kStencilMaskSeparate; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _face, GLuint _mask) { SetHeader(); face = _face; mask = _mask; } void* Set(void* cmd, GLenum _face, GLuint _mask) { static_cast(cmd)->Init(_face, _mask); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 face; uint32 mask; }; COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12, Sizeof_StencilMaskSeparate_is_not_12); COMPILE_ASSERT(offsetof(StencilMaskSeparate, header) == 0, OffsetOf_StencilMaskSeparate_header_not_0); COMPILE_ASSERT(offsetof(StencilMaskSeparate, face) == 4, OffsetOf_StencilMaskSeparate_face_not_4); COMPILE_ASSERT(offsetof(StencilMaskSeparate, mask) == 8, OffsetOf_StencilMaskSeparate_mask_not_8); struct StencilOp { typedef StencilOp ValueType; static const CommandId kCmdId = kStencilOp; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _fail, GLenum _zfail, GLenum _zpass) { SetHeader(); fail = _fail; zfail = _zfail; zpass = _zpass; } void* Set(void* cmd, GLenum _fail, GLenum _zfail, GLenum _zpass) { static_cast(cmd)->Init(_fail, _zfail, _zpass); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 fail; uint32 zfail; uint32 zpass; }; COMPILE_ASSERT(sizeof(StencilOp) == 16, Sizeof_StencilOp_is_not_16); COMPILE_ASSERT(offsetof(StencilOp, header) == 0, OffsetOf_StencilOp_header_not_0); COMPILE_ASSERT(offsetof(StencilOp, fail) == 4, OffsetOf_StencilOp_fail_not_4); COMPILE_ASSERT(offsetof(StencilOp, zfail) == 8, OffsetOf_StencilOp_zfail_not_8); COMPILE_ASSERT(offsetof(StencilOp, zpass) == 12, OffsetOf_StencilOp_zpass_not_12); struct StencilOpSeparate { typedef StencilOpSeparate ValueType; static const CommandId kCmdId = kStencilOpSeparate; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) { SetHeader(); face = _face; fail = _fail; zfail = _zfail; zpass = _zpass; } void* Set( void* cmd, GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) { static_cast(cmd)->Init(_face, _fail, _zfail, _zpass); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 face; uint32 fail; uint32 zfail; uint32 zpass; }; COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20, Sizeof_StencilOpSeparate_is_not_20); COMPILE_ASSERT(offsetof(StencilOpSeparate, header) == 0, OffsetOf_StencilOpSeparate_header_not_0); COMPILE_ASSERT(offsetof(StencilOpSeparate, face) == 4, OffsetOf_StencilOpSeparate_face_not_4); COMPILE_ASSERT(offsetof(StencilOpSeparate, fail) == 8, OffsetOf_StencilOpSeparate_fail_not_8); COMPILE_ASSERT(offsetof(StencilOpSeparate, zfail) == 12, OffsetOf_StencilOpSeparate_zfail_not_12); COMPILE_ASSERT(offsetof(StencilOpSeparate, zpass) == 16, OffsetOf_StencilOpSeparate_zpass_not_16); struct TexImage2D { typedef TexImage2D ValueType; static const CommandId kCmdId = kTexImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { SetHeader(); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; format = _format; type = _type; pixels_shm_id = _pixels_shm_id; pixels_shm_offset = _pixels_shm_offset; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _format, _type, _pixels_shm_id, _pixels_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 internalformat; int32 width; int32 height; int32 border; uint32 format; uint32 type; uint32 pixels_shm_id; uint32 pixels_shm_offset; }; COMPILE_ASSERT(sizeof(TexImage2D) == 44, Sizeof_TexImage2D_is_not_44); COMPILE_ASSERT(offsetof(TexImage2D, header) == 0, OffsetOf_TexImage2D_header_not_0); COMPILE_ASSERT(offsetof(TexImage2D, target) == 4, OffsetOf_TexImage2D_target_not_4); COMPILE_ASSERT(offsetof(TexImage2D, level) == 8, OffsetOf_TexImage2D_level_not_8); COMPILE_ASSERT(offsetof(TexImage2D, internalformat) == 12, OffsetOf_TexImage2D_internalformat_not_12); COMPILE_ASSERT(offsetof(TexImage2D, width) == 16, OffsetOf_TexImage2D_width_not_16); COMPILE_ASSERT(offsetof(TexImage2D, height) == 20, OffsetOf_TexImage2D_height_not_20); COMPILE_ASSERT(offsetof(TexImage2D, border) == 24, OffsetOf_TexImage2D_border_not_24); COMPILE_ASSERT(offsetof(TexImage2D, format) == 28, OffsetOf_TexImage2D_format_not_28); COMPILE_ASSERT(offsetof(TexImage2D, type) == 32, OffsetOf_TexImage2D_type_not_32); COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 36, OffsetOf_TexImage2D_pixels_shm_id_not_36); COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 40, OffsetOf_TexImage2D_pixels_shm_offset_not_40); struct TexImage2DImmediate { typedef TexImage2DImmediate ValueType; static const CommandId kCmdId = kTexImage2DImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init( GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type) { uint32 total_size = 0; // TODO(gman): get correct size. SetHeader(total_size); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; format = _format; type = _type; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type) { uint32 total_size = 0; // TODO(gman): get correct size. static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _format, _type); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 level; int32 internalformat; int32 width; int32 height; int32 border; uint32 format; uint32 type; }; COMPILE_ASSERT(sizeof(TexImage2DImmediate) == 36, Sizeof_TexImage2DImmediate_is_not_36); COMPILE_ASSERT(offsetof(TexImage2DImmediate, header) == 0, OffsetOf_TexImage2DImmediate_header_not_0); COMPILE_ASSERT(offsetof(TexImage2DImmediate, target) == 4, OffsetOf_TexImage2DImmediate_target_not_4); COMPILE_ASSERT(offsetof(TexImage2DImmediate, level) == 8, OffsetOf_TexImage2DImmediate_level_not_8); COMPILE_ASSERT(offsetof(TexImage2DImmediate, internalformat) == 12, OffsetOf_TexImage2DImmediate_internalformat_not_12); COMPILE_ASSERT(offsetof(TexImage2DImmediate, width) == 16, OffsetOf_TexImage2DImmediate_width_not_16); COMPILE_ASSERT(offsetof(TexImage2DImmediate, height) == 20, OffsetOf_TexImage2DImmediate_height_not_20); COMPILE_ASSERT(offsetof(TexImage2DImmediate, border) == 24, OffsetOf_TexImage2DImmediate_border_not_24); COMPILE_ASSERT(offsetof(TexImage2DImmediate, format) == 28, OffsetOf_TexImage2DImmediate_format_not_28); COMPILE_ASSERT(offsetof(TexImage2DImmediate, type) == 32, OffsetOf_TexImage2DImmediate_type_not_32); struct TexParameterf { typedef TexParameterf ValueType; static const CommandId kCmdId = kTexParameterf; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLenum _pname, GLfloat _param) { SetHeader(); target = _target; pname = _pname; param = _param; } void* Set(void* cmd, GLenum _target, GLenum _pname, GLfloat _param) { static_cast(cmd)->Init(_target, _pname, _param); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; float param; }; COMPILE_ASSERT(sizeof(TexParameterf) == 16, Sizeof_TexParameterf_is_not_16); COMPILE_ASSERT(offsetof(TexParameterf, header) == 0, OffsetOf_TexParameterf_header_not_0); COMPILE_ASSERT(offsetof(TexParameterf, target) == 4, OffsetOf_TexParameterf_target_not_4); COMPILE_ASSERT(offsetof(TexParameterf, pname) == 8, OffsetOf_TexParameterf_pname_not_8); COMPILE_ASSERT(offsetof(TexParameterf, param) == 12, OffsetOf_TexParameterf_param_not_12); struct TexParameterfv { typedef TexParameterfv ValueType; static const CommandId kCmdId = kTexParameterfv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(TexParameterfv) == 20, Sizeof_TexParameterfv_is_not_20); COMPILE_ASSERT(offsetof(TexParameterfv, header) == 0, OffsetOf_TexParameterfv_header_not_0); COMPILE_ASSERT(offsetof(TexParameterfv, target) == 4, OffsetOf_TexParameterfv_target_not_4); COMPILE_ASSERT(offsetof(TexParameterfv, pname) == 8, OffsetOf_TexParameterfv_pname_not_8); COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_id) == 12, OffsetOf_TexParameterfv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_offset) == 16, OffsetOf_TexParameterfv_params_shm_offset_not_16); struct TexParameterfvImmediate { typedef TexParameterfvImmediate ValueType; static const CommandId kCmdId = kTexParameterfvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLfloat) * 1); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLenum _target, GLenum _pname, const GLfloat* _params) { SetHeader(); target = _target; pname = _pname; memcpy(ImmediateDataAddress(this), _params, ComputeDataSize()); } void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) { static_cast(cmd)->Init(_target, _pname, _params); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 target; uint32 pname; }; COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12, Sizeof_TexParameterfvImmediate_is_not_12); COMPILE_ASSERT(offsetof(TexParameterfvImmediate, header) == 0, OffsetOf_TexParameterfvImmediate_header_not_0); COMPILE_ASSERT(offsetof(TexParameterfvImmediate, target) == 4, OffsetOf_TexParameterfvImmediate_target_not_4); COMPILE_ASSERT(offsetof(TexParameterfvImmediate, pname) == 8, OffsetOf_TexParameterfvImmediate_pname_not_8); struct TexParameteri { typedef TexParameteri ValueType; static const CommandId kCmdId = kTexParameteri; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLenum _pname, GLint _param) { SetHeader(); target = _target; pname = _pname; param = _param; } void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) { static_cast(cmd)->Init(_target, _pname, _param); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; int32 param; }; COMPILE_ASSERT(sizeof(TexParameteri) == 16, Sizeof_TexParameteri_is_not_16); COMPILE_ASSERT(offsetof(TexParameteri, header) == 0, OffsetOf_TexParameteri_header_not_0); COMPILE_ASSERT(offsetof(TexParameteri, target) == 4, OffsetOf_TexParameteri_target_not_4); COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8, OffsetOf_TexParameteri_pname_not_8); COMPILE_ASSERT(offsetof(TexParameteri, param) == 12, OffsetOf_TexParameteri_param_not_12); struct TexParameteriv { typedef TexParameteriv ValueType; static const CommandId kCmdId = kTexParameteriv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { SetHeader(); target = _target; pname = _pname; params_shm_id = _params_shm_id; params_shm_offset = _params_shm_offset; } void* Set( void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { static_cast( cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 pname; uint32 params_shm_id; uint32 params_shm_offset; }; COMPILE_ASSERT(sizeof(TexParameteriv) == 20, Sizeof_TexParameteriv_is_not_20); COMPILE_ASSERT(offsetof(TexParameteriv, header) == 0, OffsetOf_TexParameteriv_header_not_0); COMPILE_ASSERT(offsetof(TexParameteriv, target) == 4, OffsetOf_TexParameteriv_target_not_4); COMPILE_ASSERT(offsetof(TexParameteriv, pname) == 8, OffsetOf_TexParameteriv_pname_not_8); COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_id) == 12, OffsetOf_TexParameteriv_params_shm_id_not_12); COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_offset) == 16, OffsetOf_TexParameteriv_params_shm_offset_not_16); struct TexParameterivImmediate { typedef TexParameterivImmediate ValueType; static const CommandId kCmdId = kTexParameterivImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLint) * 1); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLenum _target, GLenum _pname, const GLint* _params) { SetHeader(); target = _target; pname = _pname; memcpy(ImmediateDataAddress(this), _params, ComputeDataSize()); } void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) { static_cast(cmd)->Init(_target, _pname, _params); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 target; uint32 pname; }; COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12, Sizeof_TexParameterivImmediate_is_not_12); COMPILE_ASSERT(offsetof(TexParameterivImmediate, header) == 0, OffsetOf_TexParameterivImmediate_header_not_0); COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4, OffsetOf_TexParameterivImmediate_target_not_4); COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8, OffsetOf_TexParameterivImmediate_pname_not_8); struct TexSubImage2D { typedef TexSubImage2D ValueType; static const CommandId kCmdId = kTexSubImage2D; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset, GLboolean _internal) { SetHeader(); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; type = _type; pixels_shm_id = _pixels_shm_id; pixels_shm_offset = _pixels_shm_offset; internal = _internal; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset, GLboolean _internal) { static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _type, _pixels_shm_id, _pixels_shm_offset, _internal); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; uint32 type; uint32 pixels_shm_id; uint32 pixels_shm_offset; uint32 internal; }; COMPILE_ASSERT(sizeof(TexSubImage2D) == 48, Sizeof_TexSubImage2D_is_not_48); COMPILE_ASSERT(offsetof(TexSubImage2D, header) == 0, OffsetOf_TexSubImage2D_header_not_0); COMPILE_ASSERT(offsetof(TexSubImage2D, target) == 4, OffsetOf_TexSubImage2D_target_not_4); COMPILE_ASSERT(offsetof(TexSubImage2D, level) == 8, OffsetOf_TexSubImage2D_level_not_8); COMPILE_ASSERT(offsetof(TexSubImage2D, xoffset) == 12, OffsetOf_TexSubImage2D_xoffset_not_12); COMPILE_ASSERT(offsetof(TexSubImage2D, yoffset) == 16, OffsetOf_TexSubImage2D_yoffset_not_16); COMPILE_ASSERT(offsetof(TexSubImage2D, width) == 20, OffsetOf_TexSubImage2D_width_not_20); COMPILE_ASSERT(offsetof(TexSubImage2D, height) == 24, OffsetOf_TexSubImage2D_height_not_24); COMPILE_ASSERT(offsetof(TexSubImage2D, format) == 28, OffsetOf_TexSubImage2D_format_not_28); COMPILE_ASSERT(offsetof(TexSubImage2D, type) == 32, OffsetOf_TexSubImage2D_type_not_32); COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_id) == 36, OffsetOf_TexSubImage2D_pixels_shm_id_not_36); COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_offset) == 40, OffsetOf_TexSubImage2D_pixels_shm_offset_not_40); COMPILE_ASSERT(offsetof(TexSubImage2D, internal) == 44, OffsetOf_TexSubImage2D_internal_not_44); struct TexSubImage2DImmediate { typedef TexSubImage2DImmediate ValueType; static const CommandId kCmdId = kTexSubImage2DImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 size_in_bytes) { return static_cast( sizeof(ValueType) + // NOLINT RoundSizeToMultipleOfEntries(size_in_bytes)); } void SetHeader(uint32 size_in_bytes) { header.SetCmdByTotalSize(size_in_bytes); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, GLboolean _internal) { uint32 total_size = 0; // TODO(gman): get correct size. SetHeader(total_size); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; type = _type; internal = _internal; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, GLboolean _internal) { uint32 total_size = 0; // TODO(gman): get correct size. static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _type, _internal); return NextImmediateCmdAddressTotalSize(cmd, total_size); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; uint32 type; uint32 internal; }; COMPILE_ASSERT(sizeof(TexSubImage2DImmediate) == 40, Sizeof_TexSubImage2DImmediate_is_not_40); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, header) == 0, OffsetOf_TexSubImage2DImmediate_header_not_0); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, target) == 4, OffsetOf_TexSubImage2DImmediate_target_not_4); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, level) == 8, OffsetOf_TexSubImage2DImmediate_level_not_8); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, xoffset) == 12, OffsetOf_TexSubImage2DImmediate_xoffset_not_12); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, yoffset) == 16, OffsetOf_TexSubImage2DImmediate_yoffset_not_16); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, width) == 20, OffsetOf_TexSubImage2DImmediate_width_not_20); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, height) == 24, OffsetOf_TexSubImage2DImmediate_height_not_24); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, format) == 28, OffsetOf_TexSubImage2DImmediate_format_not_28); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, type) == 32, OffsetOf_TexSubImage2DImmediate_type_not_32); COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, internal) == 36, OffsetOf_TexSubImage2DImmediate_internal_not_36); struct Uniform1f { typedef Uniform1f ValueType; static const CommandId kCmdId = kUniform1f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLfloat _x) { SetHeader(); location = _location; x = _x; } void* Set(void* cmd, GLint _location, GLfloat _x) { static_cast(cmd)->Init(_location, _x); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; float x; }; COMPILE_ASSERT(sizeof(Uniform1f) == 12, Sizeof_Uniform1f_is_not_12); COMPILE_ASSERT(offsetof(Uniform1f, header) == 0, OffsetOf_Uniform1f_header_not_0); COMPILE_ASSERT(offsetof(Uniform1f, location) == 4, OffsetOf_Uniform1f_location_not_4); COMPILE_ASSERT(offsetof(Uniform1f, x) == 8, OffsetOf_Uniform1f_x_not_8); struct Uniform1fv { typedef Uniform1fv ValueType; static const CommandId kCmdId = kUniform1fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform1fv) == 20, Sizeof_Uniform1fv_is_not_20); COMPILE_ASSERT(offsetof(Uniform1fv, header) == 0, OffsetOf_Uniform1fv_header_not_0); COMPILE_ASSERT(offsetof(Uniform1fv, location) == 4, OffsetOf_Uniform1fv_location_not_4); COMPILE_ASSERT(offsetof(Uniform1fv, count) == 8, OffsetOf_Uniform1fv_count_not_8); COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_id) == 12, OffsetOf_Uniform1fv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_offset) == 16, OffsetOf_Uniform1fv_v_shm_offset_not_16); struct Uniform1fvImmediate { typedef Uniform1fvImmediate ValueType; static const CommandId kCmdId = kUniform1fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 1 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLfloat* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12, Sizeof_Uniform1fvImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0, OffsetOf_Uniform1fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4, OffsetOf_Uniform1fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform1fvImmediate, count) == 8, OffsetOf_Uniform1fvImmediate_count_not_8); struct Uniform1i { typedef Uniform1i ValueType; static const CommandId kCmdId = kUniform1i; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLint _x) { SetHeader(); location = _location; x = _x; } void* Set(void* cmd, GLint _location, GLint _x) { static_cast(cmd)->Init(_location, _x); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 x; }; COMPILE_ASSERT(sizeof(Uniform1i) == 12, Sizeof_Uniform1i_is_not_12); COMPILE_ASSERT(offsetof(Uniform1i, header) == 0, OffsetOf_Uniform1i_header_not_0); COMPILE_ASSERT(offsetof(Uniform1i, location) == 4, OffsetOf_Uniform1i_location_not_4); COMPILE_ASSERT(offsetof(Uniform1i, x) == 8, OffsetOf_Uniform1i_x_not_8); struct Uniform1iv { typedef Uniform1iv ValueType; static const CommandId kCmdId = kUniform1iv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform1iv) == 20, Sizeof_Uniform1iv_is_not_20); COMPILE_ASSERT(offsetof(Uniform1iv, header) == 0, OffsetOf_Uniform1iv_header_not_0); COMPILE_ASSERT(offsetof(Uniform1iv, location) == 4, OffsetOf_Uniform1iv_location_not_4); COMPILE_ASSERT(offsetof(Uniform1iv, count) == 8, OffsetOf_Uniform1iv_count_not_8); COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_id) == 12, OffsetOf_Uniform1iv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_offset) == 16, OffsetOf_Uniform1iv_v_shm_offset_not_16); struct Uniform1ivImmediate { typedef Uniform1ivImmediate ValueType; static const CommandId kCmdId = kUniform1ivImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLint) * 1 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLint* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12, Sizeof_Uniform1ivImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0, OffsetOf_Uniform1ivImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4, OffsetOf_Uniform1ivImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8, OffsetOf_Uniform1ivImmediate_count_not_8); struct Uniform2f { typedef Uniform2f ValueType; static const CommandId kCmdId = kUniform2f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLfloat _x, GLfloat _y) { SetHeader(); location = _location; x = _x; y = _y; } void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) { static_cast(cmd)->Init(_location, _x, _y); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; float x; float y; }; COMPILE_ASSERT(sizeof(Uniform2f) == 16, Sizeof_Uniform2f_is_not_16); COMPILE_ASSERT(offsetof(Uniform2f, header) == 0, OffsetOf_Uniform2f_header_not_0); COMPILE_ASSERT(offsetof(Uniform2f, location) == 4, OffsetOf_Uniform2f_location_not_4); COMPILE_ASSERT(offsetof(Uniform2f, x) == 8, OffsetOf_Uniform2f_x_not_8); COMPILE_ASSERT(offsetof(Uniform2f, y) == 12, OffsetOf_Uniform2f_y_not_12); struct Uniform2fv { typedef Uniform2fv ValueType; static const CommandId kCmdId = kUniform2fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform2fv) == 20, Sizeof_Uniform2fv_is_not_20); COMPILE_ASSERT(offsetof(Uniform2fv, header) == 0, OffsetOf_Uniform2fv_header_not_0); COMPILE_ASSERT(offsetof(Uniform2fv, location) == 4, OffsetOf_Uniform2fv_location_not_4); COMPILE_ASSERT(offsetof(Uniform2fv, count) == 8, OffsetOf_Uniform2fv_count_not_8); COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_id) == 12, OffsetOf_Uniform2fv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_offset) == 16, OffsetOf_Uniform2fv_v_shm_offset_not_16); struct Uniform2fvImmediate { typedef Uniform2fvImmediate ValueType; static const CommandId kCmdId = kUniform2fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 2 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLfloat* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12, Sizeof_Uniform2fvImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0, OffsetOf_Uniform2fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4, OffsetOf_Uniform2fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform2fvImmediate, count) == 8, OffsetOf_Uniform2fvImmediate_count_not_8); struct Uniform2i { typedef Uniform2i ValueType; static const CommandId kCmdId = kUniform2i; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLint _x, GLint _y) { SetHeader(); location = _location; x = _x; y = _y; } void* Set(void* cmd, GLint _location, GLint _x, GLint _y) { static_cast(cmd)->Init(_location, _x, _y); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 x; int32 y; }; COMPILE_ASSERT(sizeof(Uniform2i) == 16, Sizeof_Uniform2i_is_not_16); COMPILE_ASSERT(offsetof(Uniform2i, header) == 0, OffsetOf_Uniform2i_header_not_0); COMPILE_ASSERT(offsetof(Uniform2i, location) == 4, OffsetOf_Uniform2i_location_not_4); COMPILE_ASSERT(offsetof(Uniform2i, x) == 8, OffsetOf_Uniform2i_x_not_8); COMPILE_ASSERT(offsetof(Uniform2i, y) == 12, OffsetOf_Uniform2i_y_not_12); struct Uniform2iv { typedef Uniform2iv ValueType; static const CommandId kCmdId = kUniform2iv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform2iv) == 20, Sizeof_Uniform2iv_is_not_20); COMPILE_ASSERT(offsetof(Uniform2iv, header) == 0, OffsetOf_Uniform2iv_header_not_0); COMPILE_ASSERT(offsetof(Uniform2iv, location) == 4, OffsetOf_Uniform2iv_location_not_4); COMPILE_ASSERT(offsetof(Uniform2iv, count) == 8, OffsetOf_Uniform2iv_count_not_8); COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_id) == 12, OffsetOf_Uniform2iv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_offset) == 16, OffsetOf_Uniform2iv_v_shm_offset_not_16); struct Uniform2ivImmediate { typedef Uniform2ivImmediate ValueType; static const CommandId kCmdId = kUniform2ivImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLint) * 2 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLint* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12, Sizeof_Uniform2ivImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0, OffsetOf_Uniform2ivImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4, OffsetOf_Uniform2ivImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8, OffsetOf_Uniform2ivImmediate_count_not_8); struct Uniform3f { typedef Uniform3f ValueType; static const CommandId kCmdId = kUniform3f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { SetHeader(); location = _location; x = _x; y = _y; z = _z; } void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { static_cast(cmd)->Init(_location, _x, _y, _z); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; float x; float y; float z; }; COMPILE_ASSERT(sizeof(Uniform3f) == 20, Sizeof_Uniform3f_is_not_20); COMPILE_ASSERT(offsetof(Uniform3f, header) == 0, OffsetOf_Uniform3f_header_not_0); COMPILE_ASSERT(offsetof(Uniform3f, location) == 4, OffsetOf_Uniform3f_location_not_4); COMPILE_ASSERT(offsetof(Uniform3f, x) == 8, OffsetOf_Uniform3f_x_not_8); COMPILE_ASSERT(offsetof(Uniform3f, y) == 12, OffsetOf_Uniform3f_y_not_12); COMPILE_ASSERT(offsetof(Uniform3f, z) == 16, OffsetOf_Uniform3f_z_not_16); struct Uniform3fv { typedef Uniform3fv ValueType; static const CommandId kCmdId = kUniform3fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform3fv) == 20, Sizeof_Uniform3fv_is_not_20); COMPILE_ASSERT(offsetof(Uniform3fv, header) == 0, OffsetOf_Uniform3fv_header_not_0); COMPILE_ASSERT(offsetof(Uniform3fv, location) == 4, OffsetOf_Uniform3fv_location_not_4); COMPILE_ASSERT(offsetof(Uniform3fv, count) == 8, OffsetOf_Uniform3fv_count_not_8); COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_id) == 12, OffsetOf_Uniform3fv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_offset) == 16, OffsetOf_Uniform3fv_v_shm_offset_not_16); struct Uniform3fvImmediate { typedef Uniform3fvImmediate ValueType; static const CommandId kCmdId = kUniform3fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 3 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLfloat* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12, Sizeof_Uniform3fvImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0, OffsetOf_Uniform3fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4, OffsetOf_Uniform3fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform3fvImmediate, count) == 8, OffsetOf_Uniform3fvImmediate_count_not_8); struct Uniform3i { typedef Uniform3i ValueType; static const CommandId kCmdId = kUniform3i; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLint _x, GLint _y, GLint _z) { SetHeader(); location = _location; x = _x; y = _y; z = _z; } void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) { static_cast(cmd)->Init(_location, _x, _y, _z); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 x; int32 y; int32 z; }; COMPILE_ASSERT(sizeof(Uniform3i) == 20, Sizeof_Uniform3i_is_not_20); COMPILE_ASSERT(offsetof(Uniform3i, header) == 0, OffsetOf_Uniform3i_header_not_0); COMPILE_ASSERT(offsetof(Uniform3i, location) == 4, OffsetOf_Uniform3i_location_not_4); COMPILE_ASSERT(offsetof(Uniform3i, x) == 8, OffsetOf_Uniform3i_x_not_8); COMPILE_ASSERT(offsetof(Uniform3i, y) == 12, OffsetOf_Uniform3i_y_not_12); COMPILE_ASSERT(offsetof(Uniform3i, z) == 16, OffsetOf_Uniform3i_z_not_16); struct Uniform3iv { typedef Uniform3iv ValueType; static const CommandId kCmdId = kUniform3iv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform3iv) == 20, Sizeof_Uniform3iv_is_not_20); COMPILE_ASSERT(offsetof(Uniform3iv, header) == 0, OffsetOf_Uniform3iv_header_not_0); COMPILE_ASSERT(offsetof(Uniform3iv, location) == 4, OffsetOf_Uniform3iv_location_not_4); COMPILE_ASSERT(offsetof(Uniform3iv, count) == 8, OffsetOf_Uniform3iv_count_not_8); COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_id) == 12, OffsetOf_Uniform3iv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_offset) == 16, OffsetOf_Uniform3iv_v_shm_offset_not_16); struct Uniform3ivImmediate { typedef Uniform3ivImmediate ValueType; static const CommandId kCmdId = kUniform3ivImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLint) * 3 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLint* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12, Sizeof_Uniform3ivImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0, OffsetOf_Uniform3ivImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4, OffsetOf_Uniform3ivImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8, OffsetOf_Uniform3ivImmediate_count_not_8); struct Uniform4f { typedef Uniform4f ValueType; static const CommandId kCmdId = kUniform4f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { SetHeader(); location = _location; x = _x; y = _y; z = _z; w = _w; } void* Set( void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { static_cast(cmd)->Init(_location, _x, _y, _z, _w); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; float x; float y; float z; float w; }; COMPILE_ASSERT(sizeof(Uniform4f) == 24, Sizeof_Uniform4f_is_not_24); COMPILE_ASSERT(offsetof(Uniform4f, header) == 0, OffsetOf_Uniform4f_header_not_0); COMPILE_ASSERT(offsetof(Uniform4f, location) == 4, OffsetOf_Uniform4f_location_not_4); COMPILE_ASSERT(offsetof(Uniform4f, x) == 8, OffsetOf_Uniform4f_x_not_8); COMPILE_ASSERT(offsetof(Uniform4f, y) == 12, OffsetOf_Uniform4f_y_not_12); COMPILE_ASSERT(offsetof(Uniform4f, z) == 16, OffsetOf_Uniform4f_z_not_16); COMPILE_ASSERT(offsetof(Uniform4f, w) == 20, OffsetOf_Uniform4f_w_not_20); struct Uniform4fv { typedef Uniform4fv ValueType; static const CommandId kCmdId = kUniform4fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform4fv) == 20, Sizeof_Uniform4fv_is_not_20); COMPILE_ASSERT(offsetof(Uniform4fv, header) == 0, OffsetOf_Uniform4fv_header_not_0); COMPILE_ASSERT(offsetof(Uniform4fv, location) == 4, OffsetOf_Uniform4fv_location_not_4); COMPILE_ASSERT(offsetof(Uniform4fv, count) == 8, OffsetOf_Uniform4fv_count_not_8); COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_id) == 12, OffsetOf_Uniform4fv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_offset) == 16, OffsetOf_Uniform4fv_v_shm_offset_not_16); struct Uniform4fvImmediate { typedef Uniform4fvImmediate ValueType; static const CommandId kCmdId = kUniform4fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 4 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLfloat* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12, Sizeof_Uniform4fvImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0, OffsetOf_Uniform4fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4, OffsetOf_Uniform4fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform4fvImmediate, count) == 8, OffsetOf_Uniform4fvImmediate_count_not_8); struct Uniform4i { typedef Uniform4i ValueType; static const CommandId kCmdId = kUniform4i; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) { SetHeader(); location = _location; x = _x; y = _y; z = _z; w = _w; } void* Set( void* cmd, GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) { static_cast(cmd)->Init(_location, _x, _y, _z, _w); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 x; int32 y; int32 z; int32 w; }; COMPILE_ASSERT(sizeof(Uniform4i) == 24, Sizeof_Uniform4i_is_not_24); COMPILE_ASSERT(offsetof(Uniform4i, header) == 0, OffsetOf_Uniform4i_header_not_0); COMPILE_ASSERT(offsetof(Uniform4i, location) == 4, OffsetOf_Uniform4i_location_not_4); COMPILE_ASSERT(offsetof(Uniform4i, x) == 8, OffsetOf_Uniform4i_x_not_8); COMPILE_ASSERT(offsetof(Uniform4i, y) == 12, OffsetOf_Uniform4i_y_not_12); COMPILE_ASSERT(offsetof(Uniform4i, z) == 16, OffsetOf_Uniform4i_z_not_16); COMPILE_ASSERT(offsetof(Uniform4i, w) == 20, OffsetOf_Uniform4i_w_not_20); struct Uniform4iv { typedef Uniform4iv ValueType; static const CommandId kCmdId = kUniform4iv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { SetHeader(); location = _location; count = _count; v_shm_id = _v_shm_id; v_shm_offset = _v_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, uint32 _v_shm_offset) { static_cast( cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 v_shm_id; uint32 v_shm_offset; }; COMPILE_ASSERT(sizeof(Uniform4iv) == 20, Sizeof_Uniform4iv_is_not_20); COMPILE_ASSERT(offsetof(Uniform4iv, header) == 0, OffsetOf_Uniform4iv_header_not_0); COMPILE_ASSERT(offsetof(Uniform4iv, location) == 4, OffsetOf_Uniform4iv_location_not_4); COMPILE_ASSERT(offsetof(Uniform4iv, count) == 8, OffsetOf_Uniform4iv_count_not_8); COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_id) == 12, OffsetOf_Uniform4iv_v_shm_id_not_12); COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_offset) == 16, OffsetOf_Uniform4iv_v_shm_offset_not_16); struct Uniform4ivImmediate { typedef Uniform4ivImmediate ValueType; static const CommandId kCmdId = kUniform4ivImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLint) * 4 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLint _location, GLsizei _count, const GLint* _v) { SetHeader(_count); location = _location; count = _count; memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); } void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { static_cast(cmd)->Init(_location, _count, _v); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; }; COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12, Sizeof_Uniform4ivImmediate_is_not_12); COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0, OffsetOf_Uniform4ivImmediate_header_not_0); COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4, OffsetOf_Uniform4ivImmediate_location_not_4); COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8, OffsetOf_Uniform4ivImmediate_count_not_8); struct UniformMatrix2fv { typedef UniformMatrix2fv ValueType; static const CommandId kCmdId = kUniformMatrix2fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { SetHeader(); location = _location; count = _count; transpose = _transpose; value_shm_id = _value_shm_id; value_shm_offset = _value_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { static_cast( cmd)->Init( _location, _count, _transpose, _value_shm_id, _value_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; uint32 value_shm_id; uint32 value_shm_offset; }; COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 24, Sizeof_UniformMatrix2fv_is_not_24); COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0, OffsetOf_UniformMatrix2fv_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix2fv, location) == 4, OffsetOf_UniformMatrix2fv_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix2fv, count) == 8, OffsetOf_UniformMatrix2fv_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix2fv, transpose) == 12, OffsetOf_UniformMatrix2fv_transpose_not_12); COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_id) == 16, OffsetOf_UniformMatrix2fv_value_shm_id_not_16); COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_offset) == 20, OffsetOf_UniformMatrix2fv_value_shm_offset_not_20); struct UniformMatrix2fvImmediate { typedef UniformMatrix2fvImmediate ValueType; static const CommandId kCmdId = kUniformMatrix2fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 4 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { SetHeader(_count); location = _location; count = _count; transpose = _transpose; memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { static_cast(cmd)->Init(_location, _count, _transpose, _value); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; }; COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16, Sizeof_UniformMatrix2fvImmediate_is_not_16); COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0, OffsetOf_UniformMatrix2fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4, OffsetOf_UniformMatrix2fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8, OffsetOf_UniformMatrix2fvImmediate_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, transpose) == 12, OffsetOf_UniformMatrix2fvImmediate_transpose_not_12); struct UniformMatrix3fv { typedef UniformMatrix3fv ValueType; static const CommandId kCmdId = kUniformMatrix3fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { SetHeader(); location = _location; count = _count; transpose = _transpose; value_shm_id = _value_shm_id; value_shm_offset = _value_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { static_cast( cmd)->Init( _location, _count, _transpose, _value_shm_id, _value_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; uint32 value_shm_id; uint32 value_shm_offset; }; COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 24, Sizeof_UniformMatrix3fv_is_not_24); COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0, OffsetOf_UniformMatrix3fv_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix3fv, location) == 4, OffsetOf_UniformMatrix3fv_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix3fv, count) == 8, OffsetOf_UniformMatrix3fv_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix3fv, transpose) == 12, OffsetOf_UniformMatrix3fv_transpose_not_12); COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_id) == 16, OffsetOf_UniformMatrix3fv_value_shm_id_not_16); COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_offset) == 20, OffsetOf_UniformMatrix3fv_value_shm_offset_not_20); struct UniformMatrix3fvImmediate { typedef UniformMatrix3fvImmediate ValueType; static const CommandId kCmdId = kUniformMatrix3fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 9 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { SetHeader(_count); location = _location; count = _count; transpose = _transpose; memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { static_cast(cmd)->Init(_location, _count, _transpose, _value); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; }; COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16, Sizeof_UniformMatrix3fvImmediate_is_not_16); COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0, OffsetOf_UniformMatrix3fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4, OffsetOf_UniformMatrix3fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8, OffsetOf_UniformMatrix3fvImmediate_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, transpose) == 12, OffsetOf_UniformMatrix3fvImmediate_transpose_not_12); struct UniformMatrix4fv { typedef UniformMatrix4fv ValueType; static const CommandId kCmdId = kUniformMatrix4fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { SetHeader(); location = _location; count = _count; transpose = _transpose; value_shm_id = _value_shm_id; value_shm_offset = _value_shm_offset; } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, uint32 _value_shm_id, uint32 _value_shm_offset) { static_cast( cmd)->Init( _location, _count, _transpose, _value_shm_id, _value_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; uint32 value_shm_id; uint32 value_shm_offset; }; COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 24, Sizeof_UniformMatrix4fv_is_not_24); COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0, OffsetOf_UniformMatrix4fv_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix4fv, location) == 4, OffsetOf_UniformMatrix4fv_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix4fv, count) == 8, OffsetOf_UniformMatrix4fv_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix4fv, transpose) == 12, OffsetOf_UniformMatrix4fv_transpose_not_12); COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_id) == 16, OffsetOf_UniformMatrix4fv_value_shm_id_not_16); COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_offset) == 20, OffsetOf_UniformMatrix4fv_value_shm_offset_not_20); struct UniformMatrix4fvImmediate { typedef UniformMatrix4fvImmediate ValueType; static const CommandId kCmdId = kUniformMatrix4fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLfloat) * 16 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init( GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { SetHeader(_count); location = _location; count = _count; transpose = _transpose; memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); } void* Set( void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, const GLfloat* _value) { static_cast(cmd)->Init(_location, _count, _transpose, _value); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 location; int32 count; uint32 transpose; }; COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16, Sizeof_UniformMatrix4fvImmediate_is_not_16); COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0, OffsetOf_UniformMatrix4fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4, OffsetOf_UniformMatrix4fvImmediate_location_not_4); COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8, OffsetOf_UniformMatrix4fvImmediate_count_not_8); COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, transpose) == 12, OffsetOf_UniformMatrix4fvImmediate_transpose_not_12); struct UseProgram { typedef UseProgram ValueType; static const CommandId kCmdId = kUseProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program) { SetHeader(); program = _program; } void* Set(void* cmd, GLuint _program) { static_cast(cmd)->Init(_program); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; }; COMPILE_ASSERT(sizeof(UseProgram) == 8, Sizeof_UseProgram_is_not_8); COMPILE_ASSERT(offsetof(UseProgram, header) == 0, OffsetOf_UseProgram_header_not_0); COMPILE_ASSERT(offsetof(UseProgram, program) == 4, OffsetOf_UseProgram_program_not_4); struct ValidateProgram { typedef ValidateProgram ValueType; static const CommandId kCmdId = kValidateProgram; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program) { SetHeader(); program = _program; } void* Set(void* cmd, GLuint _program) { static_cast(cmd)->Init(_program); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; }; COMPILE_ASSERT(sizeof(ValidateProgram) == 8, Sizeof_ValidateProgram_is_not_8); COMPILE_ASSERT(offsetof(ValidateProgram, header) == 0, OffsetOf_ValidateProgram_header_not_0); COMPILE_ASSERT(offsetof(ValidateProgram, program) == 4, OffsetOf_ValidateProgram_program_not_4); struct VertexAttrib1f { typedef VertexAttrib1f ValueType; static const CommandId kCmdId = kVertexAttrib1f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, GLfloat _x) { SetHeader(); indx = _indx; x = _x; } void* Set(void* cmd, GLuint _indx, GLfloat _x) { static_cast(cmd)->Init(_indx, _x); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; float x; }; COMPILE_ASSERT(sizeof(VertexAttrib1f) == 12, Sizeof_VertexAttrib1f_is_not_12); COMPILE_ASSERT(offsetof(VertexAttrib1f, header) == 0, OffsetOf_VertexAttrib1f_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4, OffsetOf_VertexAttrib1f_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib1f, x) == 8, OffsetOf_VertexAttrib1f_x_not_8); struct VertexAttrib1fv { typedef VertexAttrib1fv ValueType; static const CommandId kCmdId = kVertexAttrib1fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { SetHeader(); indx = _indx; values_shm_id = _values_shm_id; values_shm_offset = _values_shm_offset; } void* Set( void* cmd, GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { static_cast( cmd)->Init(_indx, _values_shm_id, _values_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; uint32 values_shm_id; uint32 values_shm_offset; }; COMPILE_ASSERT(sizeof(VertexAttrib1fv) == 16, Sizeof_VertexAttrib1fv_is_not_16); COMPILE_ASSERT(offsetof(VertexAttrib1fv, header) == 0, OffsetOf_VertexAttrib1fv_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib1fv, indx) == 4, OffsetOf_VertexAttrib1fv_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_id) == 8, OffsetOf_VertexAttrib1fv_values_shm_id_not_8); COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_offset) == 12, OffsetOf_VertexAttrib1fv_values_shm_offset_not_12); struct VertexAttrib1fvImmediate { typedef VertexAttrib1fvImmediate ValueType; static const CommandId kCmdId = kVertexAttrib1fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLfloat) * 1); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLuint _indx, const GLfloat* _values) { SetHeader(); indx = _indx; memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); } void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { static_cast(cmd)->Init(_indx, _values); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 indx; }; COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8, Sizeof_VertexAttrib1fvImmediate_is_not_8); COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, header) == 0, OffsetOf_VertexAttrib1fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, indx) == 4, OffsetOf_VertexAttrib1fvImmediate_indx_not_4); struct VertexAttrib2f { typedef VertexAttrib2f ValueType; static const CommandId kCmdId = kVertexAttrib2f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, GLfloat _x, GLfloat _y) { SetHeader(); indx = _indx; x = _x; y = _y; } void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y) { static_cast(cmd)->Init(_indx, _x, _y); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; float x; float y; }; COMPILE_ASSERT(sizeof(VertexAttrib2f) == 16, Sizeof_VertexAttrib2f_is_not_16); COMPILE_ASSERT(offsetof(VertexAttrib2f, header) == 0, OffsetOf_VertexAttrib2f_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib2f, indx) == 4, OffsetOf_VertexAttrib2f_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib2f, x) == 8, OffsetOf_VertexAttrib2f_x_not_8); COMPILE_ASSERT(offsetof(VertexAttrib2f, y) == 12, OffsetOf_VertexAttrib2f_y_not_12); struct VertexAttrib2fv { typedef VertexAttrib2fv ValueType; static const CommandId kCmdId = kVertexAttrib2fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { SetHeader(); indx = _indx; values_shm_id = _values_shm_id; values_shm_offset = _values_shm_offset; } void* Set( void* cmd, GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { static_cast( cmd)->Init(_indx, _values_shm_id, _values_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; uint32 values_shm_id; uint32 values_shm_offset; }; COMPILE_ASSERT(sizeof(VertexAttrib2fv) == 16, Sizeof_VertexAttrib2fv_is_not_16); COMPILE_ASSERT(offsetof(VertexAttrib2fv, header) == 0, OffsetOf_VertexAttrib2fv_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib2fv, indx) == 4, OffsetOf_VertexAttrib2fv_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_id) == 8, OffsetOf_VertexAttrib2fv_values_shm_id_not_8); COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_offset) == 12, OffsetOf_VertexAttrib2fv_values_shm_offset_not_12); struct VertexAttrib2fvImmediate { typedef VertexAttrib2fvImmediate ValueType; static const CommandId kCmdId = kVertexAttrib2fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLfloat) * 2); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLuint _indx, const GLfloat* _values) { SetHeader(); indx = _indx; memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); } void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { static_cast(cmd)->Init(_indx, _values); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 indx; }; COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8, Sizeof_VertexAttrib2fvImmediate_is_not_8); COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, header) == 0, OffsetOf_VertexAttrib2fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, indx) == 4, OffsetOf_VertexAttrib2fvImmediate_indx_not_4); struct VertexAttrib3f { typedef VertexAttrib3f ValueType; static const CommandId kCmdId = kVertexAttrib3f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { SetHeader(); indx = _indx; x = _x; y = _y; z = _z; } void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { static_cast(cmd)->Init(_indx, _x, _y, _z); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; float x; float y; float z; }; COMPILE_ASSERT(sizeof(VertexAttrib3f) == 20, Sizeof_VertexAttrib3f_is_not_20); COMPILE_ASSERT(offsetof(VertexAttrib3f, header) == 0, OffsetOf_VertexAttrib3f_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib3f, indx) == 4, OffsetOf_VertexAttrib3f_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib3f, x) == 8, OffsetOf_VertexAttrib3f_x_not_8); COMPILE_ASSERT(offsetof(VertexAttrib3f, y) == 12, OffsetOf_VertexAttrib3f_y_not_12); COMPILE_ASSERT(offsetof(VertexAttrib3f, z) == 16, OffsetOf_VertexAttrib3f_z_not_16); struct VertexAttrib3fv { typedef VertexAttrib3fv ValueType; static const CommandId kCmdId = kVertexAttrib3fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { SetHeader(); indx = _indx; values_shm_id = _values_shm_id; values_shm_offset = _values_shm_offset; } void* Set( void* cmd, GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { static_cast( cmd)->Init(_indx, _values_shm_id, _values_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; uint32 values_shm_id; uint32 values_shm_offset; }; COMPILE_ASSERT(sizeof(VertexAttrib3fv) == 16, Sizeof_VertexAttrib3fv_is_not_16); COMPILE_ASSERT(offsetof(VertexAttrib3fv, header) == 0, OffsetOf_VertexAttrib3fv_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib3fv, indx) == 4, OffsetOf_VertexAttrib3fv_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_id) == 8, OffsetOf_VertexAttrib3fv_values_shm_id_not_8); COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_offset) == 12, OffsetOf_VertexAttrib3fv_values_shm_offset_not_12); struct VertexAttrib3fvImmediate { typedef VertexAttrib3fvImmediate ValueType; static const CommandId kCmdId = kVertexAttrib3fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLfloat) * 3); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLuint _indx, const GLfloat* _values) { SetHeader(); indx = _indx; memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); } void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { static_cast(cmd)->Init(_indx, _values); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 indx; }; COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8, Sizeof_VertexAttrib3fvImmediate_is_not_8); COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, header) == 0, OffsetOf_VertexAttrib3fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, indx) == 4, OffsetOf_VertexAttrib3fvImmediate_indx_not_4); struct VertexAttrib4f { typedef VertexAttrib4f ValueType; static const CommandId kCmdId = kVertexAttrib4f; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { SetHeader(); indx = _indx; x = _x; y = _y; z = _z; w = _w; } void* Set( void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { static_cast(cmd)->Init(_indx, _x, _y, _z, _w); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; float x; float y; float z; float w; }; COMPILE_ASSERT(sizeof(VertexAttrib4f) == 24, Sizeof_VertexAttrib4f_is_not_24); COMPILE_ASSERT(offsetof(VertexAttrib4f, header) == 0, OffsetOf_VertexAttrib4f_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib4f, indx) == 4, OffsetOf_VertexAttrib4f_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib4f, x) == 8, OffsetOf_VertexAttrib4f_x_not_8); COMPILE_ASSERT(offsetof(VertexAttrib4f, y) == 12, OffsetOf_VertexAttrib4f_y_not_12); COMPILE_ASSERT(offsetof(VertexAttrib4f, z) == 16, OffsetOf_VertexAttrib4f_z_not_16); COMPILE_ASSERT(offsetof(VertexAttrib4f, w) == 20, OffsetOf_VertexAttrib4f_w_not_20); struct VertexAttrib4fv { typedef VertexAttrib4fv ValueType; static const CommandId kCmdId = kVertexAttrib4fv; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { SetHeader(); indx = _indx; values_shm_id = _values_shm_id; values_shm_offset = _values_shm_offset; } void* Set( void* cmd, GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { static_cast( cmd)->Init(_indx, _values_shm_id, _values_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; uint32 values_shm_id; uint32 values_shm_offset; }; COMPILE_ASSERT(sizeof(VertexAttrib4fv) == 16, Sizeof_VertexAttrib4fv_is_not_16); COMPILE_ASSERT(offsetof(VertexAttrib4fv, header) == 0, OffsetOf_VertexAttrib4fv_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib4fv, indx) == 4, OffsetOf_VertexAttrib4fv_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_id) == 8, OffsetOf_VertexAttrib4fv_values_shm_id_not_8); COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_offset) == 12, OffsetOf_VertexAttrib4fv_values_shm_offset_not_12); struct VertexAttrib4fvImmediate { typedef VertexAttrib4fvImmediate ValueType; static const CommandId kCmdId = kVertexAttrib4fvImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLfloat) * 4); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLuint _indx, const GLfloat* _values) { SetHeader(); indx = _indx; memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); } void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { static_cast(cmd)->Init(_indx, _values); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 indx; }; COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8, Sizeof_VertexAttrib4fvImmediate_is_not_8); COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0, OffsetOf_VertexAttrib4fvImmediate_header_not_0); COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4, OffsetOf_VertexAttrib4fvImmediate_indx_not_4); struct VertexAttribPointer { typedef VertexAttribPointer ValueType; static const CommandId kCmdId = kVertexAttribPointer; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized, GLsizei _stride, GLuint _offset) { SetHeader(); indx = _indx; size = _size; type = _type; normalized = _normalized; stride = _stride; offset = _offset; } void* Set( void* cmd, GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized, GLsizei _stride, GLuint _offset) { static_cast( cmd)->Init(_indx, _size, _type, _normalized, _stride, _offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 indx; int32 size; uint32 type; uint32 normalized; int32 stride; uint32 offset; }; COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28, Sizeof_VertexAttribPointer_is_not_28); COMPILE_ASSERT(offsetof(VertexAttribPointer, header) == 0, OffsetOf_VertexAttribPointer_header_not_0); COMPILE_ASSERT(offsetof(VertexAttribPointer, indx) == 4, OffsetOf_VertexAttribPointer_indx_not_4); COMPILE_ASSERT(offsetof(VertexAttribPointer, size) == 8, OffsetOf_VertexAttribPointer_size_not_8); COMPILE_ASSERT(offsetof(VertexAttribPointer, type) == 12, OffsetOf_VertexAttribPointer_type_not_12); COMPILE_ASSERT(offsetof(VertexAttribPointer, normalized) == 16, OffsetOf_VertexAttribPointer_normalized_not_16); COMPILE_ASSERT(offsetof(VertexAttribPointer, stride) == 20, OffsetOf_VertexAttribPointer_stride_not_20); COMPILE_ASSERT(offsetof(VertexAttribPointer, offset) == 24, OffsetOf_VertexAttribPointer_offset_not_24); struct Viewport { typedef Viewport ValueType; static const CommandId kCmdId = kViewport; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { SetHeader(); x = _x; y = _y; width = _width; height = _height; } void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { static_cast(cmd)->Init(_x, _y, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 x; int32 y; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(Viewport) == 20, Sizeof_Viewport_is_not_20); COMPILE_ASSERT(offsetof(Viewport, header) == 0, OffsetOf_Viewport_header_not_0); COMPILE_ASSERT(offsetof(Viewport, x) == 4, OffsetOf_Viewport_x_not_4); COMPILE_ASSERT(offsetof(Viewport, y) == 8, OffsetOf_Viewport_y_not_8); COMPILE_ASSERT(offsetof(Viewport, width) == 12, OffsetOf_Viewport_width_not_12); COMPILE_ASSERT(offsetof(Viewport, height) == 16, OffsetOf_Viewport_height_not_16); struct BlitFramebufferEXT { typedef BlitFramebufferEXT ValueType; static const CommandId kCmdId = kBlitFramebufferEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLint _srcX0, GLint _srcY0, GLint _srcX1, GLint _srcY1, GLint _dstX0, GLint _dstY0, GLint _dstX1, GLint _dstY1, GLbitfield _mask, GLenum _filter) { SetHeader(); srcX0 = _srcX0; srcY0 = _srcY0; srcX1 = _srcX1; srcY1 = _srcY1; dstX0 = _dstX0; dstY0 = _dstY0; dstX1 = _dstX1; dstY1 = _dstY1; mask = _mask; filter = _filter; } void* Set( void* cmd, GLint _srcX0, GLint _srcY0, GLint _srcX1, GLint _srcY1, GLint _dstX0, GLint _dstY0, GLint _dstX1, GLint _dstY1, GLbitfield _mask, GLenum _filter) { static_cast( cmd)->Init( _srcX0, _srcY0, _srcX1, _srcY1, _dstX0, _dstY0, _dstX1, _dstY1, _mask, _filter); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 srcX0; int32 srcY0; int32 srcX1; int32 srcY1; int32 dstX0; int32 dstY0; int32 dstX1; int32 dstY1; uint32 mask; uint32 filter; }; COMPILE_ASSERT(sizeof(BlitFramebufferEXT) == 44, Sizeof_BlitFramebufferEXT_is_not_44); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, header) == 0, OffsetOf_BlitFramebufferEXT_header_not_0); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, srcX0) == 4, OffsetOf_BlitFramebufferEXT_srcX0_not_4); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, srcY0) == 8, OffsetOf_BlitFramebufferEXT_srcY0_not_8); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, srcX1) == 12, OffsetOf_BlitFramebufferEXT_srcX1_not_12); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, srcY1) == 16, OffsetOf_BlitFramebufferEXT_srcY1_not_16); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, dstX0) == 20, OffsetOf_BlitFramebufferEXT_dstX0_not_20); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, dstY0) == 24, OffsetOf_BlitFramebufferEXT_dstY0_not_24); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, dstX1) == 28, OffsetOf_BlitFramebufferEXT_dstX1_not_28); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, dstY1) == 32, OffsetOf_BlitFramebufferEXT_dstY1_not_32); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, mask) == 36, OffsetOf_BlitFramebufferEXT_mask_not_36); COMPILE_ASSERT(offsetof(BlitFramebufferEXT, filter) == 40, OffsetOf_BlitFramebufferEXT_filter_not_40); struct RenderbufferStorageMultisampleEXT { typedef RenderbufferStorageMultisampleEXT ValueType; static const CommandId kCmdId = kRenderbufferStorageMultisampleEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLsizei _samples, GLenum _internalformat, GLsizei _width, GLsizei _height) { SetHeader(); target = _target; samples = _samples; internalformat = _internalformat; width = _width; height = _height; } void* Set( void* cmd, GLenum _target, GLsizei _samples, GLenum _internalformat, GLsizei _width, GLsizei _height) { static_cast( cmd)->Init(_target, _samples, _internalformat, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 samples; uint32 internalformat; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleEXT) == 24, Sizeof_RenderbufferStorageMultisampleEXT_is_not_24); COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, header) == 0, OffsetOf_RenderbufferStorageMultisampleEXT_header_not_0); COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, target) == 4, OffsetOf_RenderbufferStorageMultisampleEXT_target_not_4); COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, samples) == 8, OffsetOf_RenderbufferStorageMultisampleEXT_samples_not_8); COMPILE_ASSERT( offsetof(RenderbufferStorageMultisampleEXT, internalformat) == 12, OffsetOf_RenderbufferStorageMultisampleEXT_internalformat_not_12); // NOLINT COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, width) == 16, OffsetOf_RenderbufferStorageMultisampleEXT_width_not_16); COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, height) == 20, OffsetOf_RenderbufferStorageMultisampleEXT_height_not_20); struct FramebufferTexture2DMultisampleEXT { typedef FramebufferTexture2DMultisampleEXT ValueType; static const CommandId kCmdId = kFramebufferTexture2DMultisampleEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _attachment, GLenum _textarget, GLuint _texture, GLint _level, GLsizei _samples) { SetHeader(); target = _target; attachment = _attachment; textarget = _textarget; texture = _texture; level = _level; samples = _samples; } void* Set( void* cmd, GLenum _target, GLenum _attachment, GLenum _textarget, GLuint _texture, GLint _level, GLsizei _samples) { static_cast( cmd)->Init( _target, _attachment, _textarget, _texture, _level, _samples); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 attachment; uint32 textarget; uint32 texture; int32 level; int32 samples; }; COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 28, Sizeof_FramebufferTexture2DMultisampleEXT_is_not_28); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, header) == 0, OffsetOf_FramebufferTexture2DMultisampleEXT_header_not_0); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, target) == 4, OffsetOf_FramebufferTexture2DMultisampleEXT_target_not_4); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, attachment) == 8, OffsetOf_FramebufferTexture2DMultisampleEXT_attachment_not_8); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, textarget) == 12, OffsetOf_FramebufferTexture2DMultisampleEXT_textarget_not_12); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, texture) == 16, OffsetOf_FramebufferTexture2DMultisampleEXT_texture_not_16); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, level) == 20, OffsetOf_FramebufferTexture2DMultisampleEXT_level_not_20); COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 24, OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_24); struct TexStorage2DEXT { typedef TexStorage2DEXT ValueType; static const CommandId kCmdId = kTexStorage2DEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLsizei _levels, GLenum _internalFormat, GLsizei _width, GLsizei _height) { SetHeader(); target = _target; levels = _levels; internalFormat = _internalFormat; width = _width; height = _height; } void* Set( void* cmd, GLenum _target, GLsizei _levels, GLenum _internalFormat, GLsizei _width, GLsizei _height) { static_cast( cmd)->Init(_target, _levels, _internalFormat, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 levels; uint32 internalFormat; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(TexStorage2DEXT) == 24, Sizeof_TexStorage2DEXT_is_not_24); COMPILE_ASSERT(offsetof(TexStorage2DEXT, header) == 0, OffsetOf_TexStorage2DEXT_header_not_0); COMPILE_ASSERT(offsetof(TexStorage2DEXT, target) == 4, OffsetOf_TexStorage2DEXT_target_not_4); COMPILE_ASSERT(offsetof(TexStorage2DEXT, levels) == 8, OffsetOf_TexStorage2DEXT_levels_not_8); COMPILE_ASSERT(offsetof(TexStorage2DEXT, internalFormat) == 12, OffsetOf_TexStorage2DEXT_internalFormat_not_12); COMPILE_ASSERT(offsetof(TexStorage2DEXT, width) == 16, OffsetOf_TexStorage2DEXT_width_not_16); COMPILE_ASSERT(offsetof(TexStorage2DEXT, height) == 20, OffsetOf_TexStorage2DEXT_height_not_20); struct GenQueriesEXT { typedef GenQueriesEXT ValueType; static const CommandId kCmdId = kGenQueriesEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _queries_shm_id, uint32 _queries_shm_offset) { SetHeader(); n = _n; queries_shm_id = _queries_shm_id; queries_shm_offset = _queries_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _queries_shm_id, uint32 _queries_shm_offset) { static_cast( cmd)->Init(_n, _queries_shm_id, _queries_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 queries_shm_id; uint32 queries_shm_offset; }; COMPILE_ASSERT(sizeof(GenQueriesEXT) == 16, Sizeof_GenQueriesEXT_is_not_16); COMPILE_ASSERT(offsetof(GenQueriesEXT, header) == 0, OffsetOf_GenQueriesEXT_header_not_0); COMPILE_ASSERT(offsetof(GenQueriesEXT, n) == 4, OffsetOf_GenQueriesEXT_n_not_4); COMPILE_ASSERT(offsetof(GenQueriesEXT, queries_shm_id) == 8, OffsetOf_GenQueriesEXT_queries_shm_id_not_8); COMPILE_ASSERT(offsetof(GenQueriesEXT, queries_shm_offset) == 12, OffsetOf_GenQueriesEXT_queries_shm_offset_not_12); struct GenQueriesEXTImmediate { typedef GenQueriesEXTImmediate ValueType; static const CommandId kCmdId = kGenQueriesEXTImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _queries) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _queries) { static_cast(cmd)->Init(_n, _queries); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenQueriesEXTImmediate) == 8, Sizeof_GenQueriesEXTImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, header) == 0, OffsetOf_GenQueriesEXTImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, n) == 4, OffsetOf_GenQueriesEXTImmediate_n_not_4); struct DeleteQueriesEXT { typedef DeleteQueriesEXT ValueType; static const CommandId kCmdId = kDeleteQueriesEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _queries_shm_id, uint32 _queries_shm_offset) { SetHeader(); n = _n; queries_shm_id = _queries_shm_id; queries_shm_offset = _queries_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _queries_shm_id, uint32 _queries_shm_offset) { static_cast( cmd)->Init(_n, _queries_shm_id, _queries_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 queries_shm_id; uint32 queries_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteQueriesEXT) == 16, Sizeof_DeleteQueriesEXT_is_not_16); COMPILE_ASSERT(offsetof(DeleteQueriesEXT, header) == 0, OffsetOf_DeleteQueriesEXT_header_not_0); COMPILE_ASSERT(offsetof(DeleteQueriesEXT, n) == 4, OffsetOf_DeleteQueriesEXT_n_not_4); COMPILE_ASSERT(offsetof(DeleteQueriesEXT, queries_shm_id) == 8, OffsetOf_DeleteQueriesEXT_queries_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteQueriesEXT, queries_shm_offset) == 12, OffsetOf_DeleteQueriesEXT_queries_shm_offset_not_12); struct DeleteQueriesEXTImmediate { typedef DeleteQueriesEXTImmediate ValueType; static const CommandId kCmdId = kDeleteQueriesEXTImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _queries) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _queries) { static_cast(cmd)->Init(_n, _queries); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteQueriesEXTImmediate) == 8, Sizeof_DeleteQueriesEXTImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, header) == 0, OffsetOf_DeleteQueriesEXTImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, n) == 4, OffsetOf_DeleteQueriesEXTImmediate_n_not_4); struct BeginQueryEXT { typedef BeginQueryEXT ValueType; static const CommandId kCmdId = kBeginQueryEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLuint _id, uint32 _sync_data_shm_id, uint32 _sync_data_shm_offset) { SetHeader(); target = _target; id = _id; sync_data_shm_id = _sync_data_shm_id; sync_data_shm_offset = _sync_data_shm_offset; } void* Set( void* cmd, GLenum _target, GLuint _id, uint32 _sync_data_shm_id, uint32 _sync_data_shm_offset) { static_cast( cmd)->Init(_target, _id, _sync_data_shm_id, _sync_data_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 id; uint32 sync_data_shm_id; uint32 sync_data_shm_offset; }; COMPILE_ASSERT(sizeof(BeginQueryEXT) == 20, Sizeof_BeginQueryEXT_is_not_20); COMPILE_ASSERT(offsetof(BeginQueryEXT, header) == 0, OffsetOf_BeginQueryEXT_header_not_0); COMPILE_ASSERT(offsetof(BeginQueryEXT, target) == 4, OffsetOf_BeginQueryEXT_target_not_4); COMPILE_ASSERT(offsetof(BeginQueryEXT, id) == 8, OffsetOf_BeginQueryEXT_id_not_8); COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_id) == 12, OffsetOf_BeginQueryEXT_sync_data_shm_id_not_12); COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_offset) == 16, OffsetOf_BeginQueryEXT_sync_data_shm_offset_not_16); struct EndQueryEXT { typedef EndQueryEXT ValueType; static const CommandId kCmdId = kEndQueryEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLuint _submit_count) { SetHeader(); target = _target; submit_count = _submit_count; } void* Set(void* cmd, GLenum _target, GLuint _submit_count) { static_cast(cmd)->Init(_target, _submit_count); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 submit_count; }; COMPILE_ASSERT(sizeof(EndQueryEXT) == 12, Sizeof_EndQueryEXT_is_not_12); COMPILE_ASSERT(offsetof(EndQueryEXT, header) == 0, OffsetOf_EndQueryEXT_header_not_0); COMPILE_ASSERT(offsetof(EndQueryEXT, target) == 4, OffsetOf_EndQueryEXT_target_not_4); COMPILE_ASSERT(offsetof(EndQueryEXT, submit_count) == 8, OffsetOf_EndQueryEXT_submit_count_not_8); struct InsertEventMarkerEXT { typedef InsertEventMarkerEXT ValueType; static const CommandId kCmdId = kInsertEventMarkerEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(InsertEventMarkerEXT) == 8, Sizeof_InsertEventMarkerEXT_is_not_8); COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, header) == 0, OffsetOf_InsertEventMarkerEXT_header_not_0); COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, bucket_id) == 4, OffsetOf_InsertEventMarkerEXT_bucket_id_not_4); struct PushGroupMarkerEXT { typedef PushGroupMarkerEXT ValueType; static const CommandId kCmdId = kPushGroupMarkerEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(PushGroupMarkerEXT) == 8, Sizeof_PushGroupMarkerEXT_is_not_8); COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, header) == 0, OffsetOf_PushGroupMarkerEXT_header_not_0); COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, bucket_id) == 4, OffsetOf_PushGroupMarkerEXT_bucket_id_not_4); struct PopGroupMarkerEXT { typedef PopGroupMarkerEXT ValueType; static const CommandId kCmdId = kPopGroupMarkerEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(PopGroupMarkerEXT) == 4, Sizeof_PopGroupMarkerEXT_is_not_4); COMPILE_ASSERT(offsetof(PopGroupMarkerEXT, header) == 0, OffsetOf_PopGroupMarkerEXT_header_not_0); struct GenVertexArraysOES { typedef GenVertexArraysOES ValueType; static const CommandId kCmdId = kGenVertexArraysOES; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _arrays_shm_id, uint32 _arrays_shm_offset) { SetHeader(); n = _n; arrays_shm_id = _arrays_shm_id; arrays_shm_offset = _arrays_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _arrays_shm_id, uint32 _arrays_shm_offset) { static_cast(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 arrays_shm_id; uint32 arrays_shm_offset; }; COMPILE_ASSERT(sizeof(GenVertexArraysOES) == 16, Sizeof_GenVertexArraysOES_is_not_16); COMPILE_ASSERT(offsetof(GenVertexArraysOES, header) == 0, OffsetOf_GenVertexArraysOES_header_not_0); COMPILE_ASSERT(offsetof(GenVertexArraysOES, n) == 4, OffsetOf_GenVertexArraysOES_n_not_4); COMPILE_ASSERT(offsetof(GenVertexArraysOES, arrays_shm_id) == 8, OffsetOf_GenVertexArraysOES_arrays_shm_id_not_8); COMPILE_ASSERT(offsetof(GenVertexArraysOES, arrays_shm_offset) == 12, OffsetOf_GenVertexArraysOES_arrays_shm_offset_not_12); struct GenVertexArraysOESImmediate { typedef GenVertexArraysOESImmediate ValueType; static const CommandId kCmdId = kGenVertexArraysOESImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, GLuint* _arrays) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, GLuint* _arrays) { static_cast(cmd)->Init(_n, _arrays); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(GenVertexArraysOESImmediate) == 8, Sizeof_GenVertexArraysOESImmediate_is_not_8); COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, header) == 0, OffsetOf_GenVertexArraysOESImmediate_header_not_0); COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, n) == 4, OffsetOf_GenVertexArraysOESImmediate_n_not_4); struct DeleteVertexArraysOES { typedef DeleteVertexArraysOES ValueType; static const CommandId kCmdId = kDeleteVertexArraysOES; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _n, uint32 _arrays_shm_id, uint32 _arrays_shm_offset) { SetHeader(); n = _n; arrays_shm_id = _arrays_shm_id; arrays_shm_offset = _arrays_shm_offset; } void* Set( void* cmd, GLsizei _n, uint32 _arrays_shm_id, uint32 _arrays_shm_offset) { static_cast(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 n; uint32 arrays_shm_id; uint32 arrays_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteVertexArraysOES) == 16, Sizeof_DeleteVertexArraysOES_is_not_16); COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, header) == 0, OffsetOf_DeleteVertexArraysOES_header_not_0); COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, n) == 4, OffsetOf_DeleteVertexArraysOES_n_not_4); COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, arrays_shm_id) == 8, OffsetOf_DeleteVertexArraysOES_arrays_shm_id_not_8); COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, arrays_shm_offset) == 12, OffsetOf_DeleteVertexArraysOES_arrays_shm_offset_not_12); struct DeleteVertexArraysOESImmediate { typedef DeleteVertexArraysOESImmediate ValueType; static const CommandId kCmdId = kDeleteVertexArraysOESImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei n) { return static_cast(sizeof(GLuint) * n); // NOLINT } static uint32 ComputeSize(GLsizei n) { return static_cast( sizeof(ValueType) + ComputeDataSize(n)); // NOLINT } void SetHeader(GLsizei n) { header.SetCmdByTotalSize(ComputeSize(n)); } void Init(GLsizei _n, const GLuint* _arrays) { SetHeader(_n); n = _n; memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n)); } void* Set(void* cmd, GLsizei _n, const GLuint* _arrays) { static_cast(cmd)->Init(_n, _arrays); const uint32 size = ComputeSize(_n); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 n; }; COMPILE_ASSERT(sizeof(DeleteVertexArraysOESImmediate) == 8, Sizeof_DeleteVertexArraysOESImmediate_is_not_8); COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, header) == 0, OffsetOf_DeleteVertexArraysOESImmediate_header_not_0); COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, n) == 4, OffsetOf_DeleteVertexArraysOESImmediate_n_not_4); struct IsVertexArrayOES { typedef IsVertexArrayOES ValueType; static const CommandId kCmdId = kIsVertexArrayOES; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef uint32 Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _array, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); array = _array; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _array, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_array, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 array; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(IsVertexArrayOES) == 16, Sizeof_IsVertexArrayOES_is_not_16); COMPILE_ASSERT(offsetof(IsVertexArrayOES, header) == 0, OffsetOf_IsVertexArrayOES_header_not_0); COMPILE_ASSERT(offsetof(IsVertexArrayOES, array) == 4, OffsetOf_IsVertexArrayOES_array_not_4); COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_id) == 8, OffsetOf_IsVertexArrayOES_result_shm_id_not_8); COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_offset) == 12, OffsetOf_IsVertexArrayOES_result_shm_offset_not_12); struct BindVertexArrayOES { typedef BindVertexArrayOES ValueType; static const CommandId kCmdId = kBindVertexArrayOES; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _array) { SetHeader(); array = _array; } void* Set(void* cmd, GLuint _array) { static_cast(cmd)->Init(_array); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 array; }; COMPILE_ASSERT(sizeof(BindVertexArrayOES) == 8, Sizeof_BindVertexArrayOES_is_not_8); COMPILE_ASSERT(offsetof(BindVertexArrayOES, header) == 0, OffsetOf_BindVertexArrayOES_header_not_0); COMPILE_ASSERT(offsetof(BindVertexArrayOES, array) == 4, OffsetOf_BindVertexArrayOES_array_not_4); struct SwapBuffers { typedef SwapBuffers ValueType; static const CommandId kCmdId = kSwapBuffers; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(SwapBuffers) == 4, Sizeof_SwapBuffers_is_not_4); COMPILE_ASSERT(offsetof(SwapBuffers, header) == 0, OffsetOf_SwapBuffers_header_not_0); struct GetMaxValueInBufferCHROMIUM { typedef GetMaxValueInBufferCHROMIUM ValueType; static const CommandId kCmdId = kGetMaxValueInBufferCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef GLuint Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _buffer_id, GLsizei _count, GLenum _type, GLuint _offset, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); buffer_id = _buffer_id; count = _count; type = _type; offset = _offset; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _buffer_id, GLsizei _count, GLenum _type, GLuint _offset, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init( _buffer_id, _count, _type, _offset, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 buffer_id; int32 count; uint32 type; uint32 offset; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(GetMaxValueInBufferCHROMIUM) == 28, Sizeof_GetMaxValueInBufferCHROMIUM_is_not_28); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, header) == 0, OffsetOf_GetMaxValueInBufferCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, buffer_id) == 4, OffsetOf_GetMaxValueInBufferCHROMIUM_buffer_id_not_4); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, count) == 8, OffsetOf_GetMaxValueInBufferCHROMIUM_count_not_8); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, type) == 12, OffsetOf_GetMaxValueInBufferCHROMIUM_type_not_12); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, offset) == 16, OffsetOf_GetMaxValueInBufferCHROMIUM_offset_not_16); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_id) == 20, OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_id_not_20); COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_offset) == 24, OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_offset_not_24); struct GenSharedIdsCHROMIUM { typedef GenSharedIdsCHROMIUM ValueType; static const CommandId kCmdId = kGenSharedIdsCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _namespace_id, GLuint _id_offset, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { SetHeader(); namespace_id = _namespace_id; id_offset = _id_offset; n = _n; ids_shm_id = _ids_shm_id; ids_shm_offset = _ids_shm_offset; } void* Set( void* cmd, GLuint _namespace_id, GLuint _id_offset, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { static_cast( cmd)->Init( _namespace_id, _id_offset, _n, _ids_shm_id, _ids_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 namespace_id; uint32 id_offset; int32 n; uint32 ids_shm_id; uint32 ids_shm_offset; }; COMPILE_ASSERT(sizeof(GenSharedIdsCHROMIUM) == 24, Sizeof_GenSharedIdsCHROMIUM_is_not_24); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, header) == 0, OffsetOf_GenSharedIdsCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, namespace_id) == 4, OffsetOf_GenSharedIdsCHROMIUM_namespace_id_not_4); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, id_offset) == 8, OffsetOf_GenSharedIdsCHROMIUM_id_offset_not_8); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, n) == 12, OffsetOf_GenSharedIdsCHROMIUM_n_not_12); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, ids_shm_id) == 16, OffsetOf_GenSharedIdsCHROMIUM_ids_shm_id_not_16); COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, ids_shm_offset) == 20, OffsetOf_GenSharedIdsCHROMIUM_ids_shm_offset_not_20); struct DeleteSharedIdsCHROMIUM { typedef DeleteSharedIdsCHROMIUM ValueType; static const CommandId kCmdId = kDeleteSharedIdsCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _namespace_id, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { SetHeader(); namespace_id = _namespace_id; n = _n; ids_shm_id = _ids_shm_id; ids_shm_offset = _ids_shm_offset; } void* Set( void* cmd, GLuint _namespace_id, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { static_cast( cmd)->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 namespace_id; int32 n; uint32 ids_shm_id; uint32 ids_shm_offset; }; COMPILE_ASSERT(sizeof(DeleteSharedIdsCHROMIUM) == 20, Sizeof_DeleteSharedIdsCHROMIUM_is_not_20); COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, header) == 0, OffsetOf_DeleteSharedIdsCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, namespace_id) == 4, OffsetOf_DeleteSharedIdsCHROMIUM_namespace_id_not_4); COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, n) == 8, OffsetOf_DeleteSharedIdsCHROMIUM_n_not_8); COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, ids_shm_id) == 12, OffsetOf_DeleteSharedIdsCHROMIUM_ids_shm_id_not_12); COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, ids_shm_offset) == 16, OffsetOf_DeleteSharedIdsCHROMIUM_ids_shm_offset_not_16); struct RegisterSharedIdsCHROMIUM { typedef RegisterSharedIdsCHROMIUM ValueType; static const CommandId kCmdId = kRegisterSharedIdsCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _namespace_id, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { SetHeader(); namespace_id = _namespace_id; n = _n; ids_shm_id = _ids_shm_id; ids_shm_offset = _ids_shm_offset; } void* Set( void* cmd, GLuint _namespace_id, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) { static_cast( cmd)->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 namespace_id; int32 n; uint32 ids_shm_id; uint32 ids_shm_offset; }; COMPILE_ASSERT(sizeof(RegisterSharedIdsCHROMIUM) == 20, Sizeof_RegisterSharedIdsCHROMIUM_is_not_20); COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, header) == 0, OffsetOf_RegisterSharedIdsCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, namespace_id) == 4, OffsetOf_RegisterSharedIdsCHROMIUM_namespace_id_not_4); COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, n) == 8, OffsetOf_RegisterSharedIdsCHROMIUM_n_not_8); COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, ids_shm_id) == 12, OffsetOf_RegisterSharedIdsCHROMIUM_ids_shm_id_not_12); COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, ids_shm_offset) == 16, OffsetOf_RegisterSharedIdsCHROMIUM_ids_shm_offset_not_16); struct EnableFeatureCHROMIUM { typedef EnableFeatureCHROMIUM ValueType; static const CommandId kCmdId = kEnableFeatureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef GLint Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); bucket_id = _bucket_id; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _bucket_id, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_bucket_id, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(EnableFeatureCHROMIUM) == 16, Sizeof_EnableFeatureCHROMIUM_is_not_16); COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, header) == 0, OffsetOf_EnableFeatureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, bucket_id) == 4, OffsetOf_EnableFeatureCHROMIUM_bucket_id_not_4); COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_id) == 8, OffsetOf_EnableFeatureCHROMIUM_result_shm_id_not_8); COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_offset) == 12, OffsetOf_EnableFeatureCHROMIUM_result_shm_offset_not_12); struct ResizeCHROMIUM { typedef ResizeCHROMIUM ValueType; static const CommandId kCmdId = kResizeCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _width, GLuint _height, GLfloat _scale_factor) { SetHeader(); width = _width; height = _height; scale_factor = _scale_factor; } void* Set(void* cmd, GLuint _width, GLuint _height, GLfloat _scale_factor) { static_cast(cmd)->Init(_width, _height, _scale_factor); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 width; uint32 height; float scale_factor; }; COMPILE_ASSERT(sizeof(ResizeCHROMIUM) == 16, Sizeof_ResizeCHROMIUM_is_not_16); COMPILE_ASSERT(offsetof(ResizeCHROMIUM, header) == 0, OffsetOf_ResizeCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(ResizeCHROMIUM, width) == 4, OffsetOf_ResizeCHROMIUM_width_not_4); COMPILE_ASSERT(offsetof(ResizeCHROMIUM, height) == 8, OffsetOf_ResizeCHROMIUM_height_not_8); COMPILE_ASSERT(offsetof(ResizeCHROMIUM, scale_factor) == 12, OffsetOf_ResizeCHROMIUM_scale_factor_not_12); struct GetRequestableExtensionsCHROMIUM { typedef GetRequestableExtensionsCHROMIUM ValueType; static const CommandId kCmdId = kGetRequestableExtensionsCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(uint32 _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, uint32 _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetRequestableExtensionsCHROMIUM) == 8, Sizeof_GetRequestableExtensionsCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, header) == 0, OffsetOf_GetRequestableExtensionsCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, bucket_id) == 4, OffsetOf_GetRequestableExtensionsCHROMIUM_bucket_id_not_4); struct RequestExtensionCHROMIUM { typedef RequestExtensionCHROMIUM ValueType; static const CommandId kCmdId = kRequestExtensionCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(uint32 _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, uint32 _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(RequestExtensionCHROMIUM) == 8, Sizeof_RequestExtensionCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, header) == 0, OffsetOf_RequestExtensionCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, bucket_id) == 4, OffsetOf_RequestExtensionCHROMIUM_bucket_id_not_4); struct GetMultipleIntegervCHROMIUM { typedef GetMultipleIntegervCHROMIUM ValueType; static const CommandId kCmdId = kGetMultipleIntegervCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( uint32 _pnames_shm_id, uint32 _pnames_shm_offset, GLuint _count, uint32 _results_shm_id, uint32 _results_shm_offset, GLsizeiptr _size) { SetHeader(); pnames_shm_id = _pnames_shm_id; pnames_shm_offset = _pnames_shm_offset; count = _count; results_shm_id = _results_shm_id; results_shm_offset = _results_shm_offset; size = _size; } void* Set( void* cmd, uint32 _pnames_shm_id, uint32 _pnames_shm_offset, GLuint _count, uint32 _results_shm_id, uint32 _results_shm_offset, GLsizeiptr _size) { static_cast( cmd)->Init( _pnames_shm_id, _pnames_shm_offset, _count, _results_shm_id, _results_shm_offset, _size); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 pnames_shm_id; uint32 pnames_shm_offset; uint32 count; uint32 results_shm_id; uint32 results_shm_offset; int32 size; }; COMPILE_ASSERT(sizeof(GetMultipleIntegervCHROMIUM) == 28, Sizeof_GetMultipleIntegervCHROMIUM_is_not_28); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, header) == 0, OffsetOf_GetMultipleIntegervCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_id) == 4, OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_id_not_4); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_offset) == 8, OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_offset_not_8); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, count) == 12, OffsetOf_GetMultipleIntegervCHROMIUM_count_not_12); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_id) == 16, OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_id_not_16); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_offset) == 20, OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_offset_not_20); COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, size) == 24, OffsetOf_GetMultipleIntegervCHROMIUM_size_not_24); struct GetProgramInfoCHROMIUM { typedef GetProgramInfoCHROMIUM ValueType; static const CommandId kCmdId = kGetProgramInfoCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; struct Result { uint32 link_status; uint32 num_attribs; uint32 num_uniforms; }; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, uint32 _bucket_id) { SetHeader(); program = _program; bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _program, uint32 _bucket_id) { static_cast(cmd)->Init(_program, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetProgramInfoCHROMIUM) == 12, Sizeof_GetProgramInfoCHROMIUM_is_not_12); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, header) == 0, OffsetOf_GetProgramInfoCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, program) == 4, OffsetOf_GetProgramInfoCHROMIUM_program_not_4); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, bucket_id) == 8, OffsetOf_GetProgramInfoCHROMIUM_bucket_id_not_8); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, link_status) == 0, OffsetOf_GetProgramInfoCHROMIUM_Result_link_status_not_0); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_attribs) == 4, OffsetOf_GetProgramInfoCHROMIUM_Result_num_attribs_not_4); COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_uniforms) == 8, OffsetOf_GetProgramInfoCHROMIUM_Result_num_uniforms_not_8); struct CreateStreamTextureCHROMIUM { typedef CreateStreamTextureCHROMIUM ValueType; static const CommandId kCmdId = kCreateStreamTextureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef GLuint Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _client_id, uint32 _result_shm_id, uint32 _result_shm_offset) { SetHeader(); client_id = _client_id; result_shm_id = _result_shm_id; result_shm_offset = _result_shm_offset; } void* Set( void* cmd, GLuint _client_id, uint32 _result_shm_id, uint32 _result_shm_offset) { static_cast( cmd)->Init(_client_id, _result_shm_id, _result_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 client_id; uint32 result_shm_id; uint32 result_shm_offset; }; COMPILE_ASSERT(sizeof(CreateStreamTextureCHROMIUM) == 16, Sizeof_CreateStreamTextureCHROMIUM_is_not_16); COMPILE_ASSERT(offsetof(CreateStreamTextureCHROMIUM, header) == 0, OffsetOf_CreateStreamTextureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(CreateStreamTextureCHROMIUM, client_id) == 4, OffsetOf_CreateStreamTextureCHROMIUM_client_id_not_4); COMPILE_ASSERT(offsetof(CreateStreamTextureCHROMIUM, result_shm_id) == 8, OffsetOf_CreateStreamTextureCHROMIUM_result_shm_id_not_8); COMPILE_ASSERT(offsetof(CreateStreamTextureCHROMIUM, result_shm_offset) == 12, OffsetOf_CreateStreamTextureCHROMIUM_result_shm_offset_not_12); struct DestroyStreamTextureCHROMIUM { typedef DestroyStreamTextureCHROMIUM ValueType; static const CommandId kCmdId = kDestroyStreamTextureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _texture) { SetHeader(); texture = _texture; } void* Set(void* cmd, GLuint _texture) { static_cast(cmd)->Init(_texture); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 texture; }; COMPILE_ASSERT(sizeof(DestroyStreamTextureCHROMIUM) == 8, Sizeof_DestroyStreamTextureCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(DestroyStreamTextureCHROMIUM, header) == 0, OffsetOf_DestroyStreamTextureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(DestroyStreamTextureCHROMIUM, texture) == 4, OffsetOf_DestroyStreamTextureCHROMIUM_texture_not_4); struct GetTranslatedShaderSourceANGLE { typedef GetTranslatedShaderSourceANGLE ValueType; static const CommandId kCmdId = kGetTranslatedShaderSourceANGLE; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _shader, uint32 _bucket_id) { SetHeader(); shader = _shader; bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) { static_cast(cmd)->Init(_shader, _bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 shader; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GetTranslatedShaderSourceANGLE) == 12, Sizeof_GetTranslatedShaderSourceANGLE_is_not_12); COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, header) == 0, OffsetOf_GetTranslatedShaderSourceANGLE_header_not_0); COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, shader) == 4, OffsetOf_GetTranslatedShaderSourceANGLE_shader_not_4); COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, bucket_id) == 8, OffsetOf_GetTranslatedShaderSourceANGLE_bucket_id_not_8); struct PostSubBufferCHROMIUM { typedef PostSubBufferCHROMIUM ValueType; static const CommandId kCmdId = kPostSubBufferCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLint _x, GLint _y, GLint _width, GLint _height) { SetHeader(); x = _x; y = _y; width = _width; height = _height; } void* Set(void* cmd, GLint _x, GLint _y, GLint _width, GLint _height) { static_cast(cmd)->Init(_x, _y, _width, _height); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 x; int32 y; int32 width; int32 height; }; COMPILE_ASSERT(sizeof(PostSubBufferCHROMIUM) == 20, Sizeof_PostSubBufferCHROMIUM_is_not_20); COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, header) == 0, OffsetOf_PostSubBufferCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, x) == 4, OffsetOf_PostSubBufferCHROMIUM_x_not_4); COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, y) == 8, OffsetOf_PostSubBufferCHROMIUM_y_not_8); COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, width) == 12, OffsetOf_PostSubBufferCHROMIUM_width_not_12); COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, height) == 16, OffsetOf_PostSubBufferCHROMIUM_height_not_16); struct TexImageIOSurface2DCHROMIUM { typedef TexImageIOSurface2DCHROMIUM ValueType; static const CommandId kCmdId = kTexImageIOSurface2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLsizei _width, GLsizei _height, GLuint _ioSurfaceId, GLuint _plane) { SetHeader(); target = _target; width = _width; height = _height; ioSurfaceId = _ioSurfaceId; plane = _plane; } void* Set( void* cmd, GLenum _target, GLsizei _width, GLsizei _height, GLuint _ioSurfaceId, GLuint _plane) { static_cast( cmd)->Init(_target, _width, _height, _ioSurfaceId, _plane); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 width; int32 height; uint32 ioSurfaceId; uint32 plane; }; COMPILE_ASSERT(sizeof(TexImageIOSurface2DCHROMIUM) == 24, Sizeof_TexImageIOSurface2DCHROMIUM_is_not_24); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, header) == 0, OffsetOf_TexImageIOSurface2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, target) == 4, OffsetOf_TexImageIOSurface2DCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, width) == 8, OffsetOf_TexImageIOSurface2DCHROMIUM_width_not_8); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, height) == 12, OffsetOf_TexImageIOSurface2DCHROMIUM_height_not_12); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, ioSurfaceId) == 16, OffsetOf_TexImageIOSurface2DCHROMIUM_ioSurfaceId_not_16); COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, plane) == 20, OffsetOf_TexImageIOSurface2DCHROMIUM_plane_not_20); struct CopyTextureCHROMIUM { typedef CopyTextureCHROMIUM ValueType; static const CommandId kCmdId = kCopyTextureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLenum _source_id, GLenum _dest_id, GLint _level, GLint _internalformat, GLenum _dest_type) { SetHeader(); target = _target; source_id = _source_id; dest_id = _dest_id; level = _level; internalformat = _internalformat; dest_type = _dest_type; } void* Set( void* cmd, GLenum _target, GLenum _source_id, GLenum _dest_id, GLint _level, GLint _internalformat, GLenum _dest_type) { static_cast( cmd)->Init( _target, _source_id, _dest_id, _level, _internalformat, _dest_type); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 source_id; uint32 dest_id; int32 level; int32 internalformat; uint32 dest_type; }; COMPILE_ASSERT(sizeof(CopyTextureCHROMIUM) == 28, Sizeof_CopyTextureCHROMIUM_is_not_28); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, header) == 0, OffsetOf_CopyTextureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, target) == 4, OffsetOf_CopyTextureCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, source_id) == 8, OffsetOf_CopyTextureCHROMIUM_source_id_not_8); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_id) == 12, OffsetOf_CopyTextureCHROMIUM_dest_id_not_12); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, level) == 16, OffsetOf_CopyTextureCHROMIUM_level_not_16); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, internalformat) == 20, OffsetOf_CopyTextureCHROMIUM_internalformat_not_20); COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_type) == 24, OffsetOf_CopyTextureCHROMIUM_dest_type_not_24); struct DrawArraysInstancedANGLE { typedef DrawArraysInstancedANGLE ValueType; static const CommandId kCmdId = kDrawArraysInstancedANGLE; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount) { SetHeader(); mode = _mode; first = _first; count = _count; primcount = _primcount; } void* Set( void* cmd, GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount) { static_cast(cmd)->Init(_mode, _first, _count, _primcount); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; int32 first; int32 count; int32 primcount; }; COMPILE_ASSERT(sizeof(DrawArraysInstancedANGLE) == 20, Sizeof_DrawArraysInstancedANGLE_is_not_20); COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, header) == 0, OffsetOf_DrawArraysInstancedANGLE_header_not_0); COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, mode) == 4, OffsetOf_DrawArraysInstancedANGLE_mode_not_4); COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, first) == 8, OffsetOf_DrawArraysInstancedANGLE_first_not_8); COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, count) == 12, OffsetOf_DrawArraysInstancedANGLE_count_not_12); COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, primcount) == 16, OffsetOf_DrawArraysInstancedANGLE_primcount_not_16); struct DrawElementsInstancedANGLE { typedef DrawElementsInstancedANGLE ValueType; static const CommandId kCmdId = kDrawElementsInstancedANGLE; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset, GLsizei _primcount) { SetHeader(); mode = _mode; count = _count; type = _type; index_offset = _index_offset; primcount = _primcount; } void* Set( void* cmd, GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset, GLsizei _primcount) { static_cast( cmd)->Init(_mode, _count, _type, _index_offset, _primcount); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 mode; int32 count; uint32 type; uint32 index_offset; int32 primcount; }; COMPILE_ASSERT(sizeof(DrawElementsInstancedANGLE) == 24, Sizeof_DrawElementsInstancedANGLE_is_not_24); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, header) == 0, OffsetOf_DrawElementsInstancedANGLE_header_not_0); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, mode) == 4, OffsetOf_DrawElementsInstancedANGLE_mode_not_4); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, count) == 8, OffsetOf_DrawElementsInstancedANGLE_count_not_8); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, type) == 12, OffsetOf_DrawElementsInstancedANGLE_type_not_12); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, index_offset) == 16, OffsetOf_DrawElementsInstancedANGLE_index_offset_not_16); COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, primcount) == 20, OffsetOf_DrawElementsInstancedANGLE_primcount_not_20); struct VertexAttribDivisorANGLE { typedef VertexAttribDivisorANGLE ValueType; static const CommandId kCmdId = kVertexAttribDivisorANGLE; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _index, GLuint _divisor) { SetHeader(); index = _index; divisor = _divisor; } void* Set(void* cmd, GLuint _index, GLuint _divisor) { static_cast(cmd)->Init(_index, _divisor); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 index; uint32 divisor; }; COMPILE_ASSERT(sizeof(VertexAttribDivisorANGLE) == 12, Sizeof_VertexAttribDivisorANGLE_is_not_12); COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, header) == 0, OffsetOf_VertexAttribDivisorANGLE_header_not_0); COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, index) == 4, OffsetOf_VertexAttribDivisorANGLE_index_not_4); COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, divisor) == 8, OffsetOf_VertexAttribDivisorANGLE_divisor_not_8); struct GenMailboxCHROMIUM { typedef GenMailboxCHROMIUM ValueType; static const CommandId kCmdId = kGenMailboxCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; typedef SizedResult Result; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(GenMailboxCHROMIUM) == 8, Sizeof_GenMailboxCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(GenMailboxCHROMIUM, header) == 0, OffsetOf_GenMailboxCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(GenMailboxCHROMIUM, bucket_id) == 4, OffsetOf_GenMailboxCHROMIUM_bucket_id_not_4); struct ProduceTextureCHROMIUM { typedef ProduceTextureCHROMIUM ValueType; static const CommandId kCmdId = kProduceTextureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, uint32 _mailbox_shm_id, uint32 _mailbox_shm_offset) { SetHeader(); target = _target; mailbox_shm_id = _mailbox_shm_id; mailbox_shm_offset = _mailbox_shm_offset; } void* Set( void* cmd, GLenum _target, uint32 _mailbox_shm_id, uint32 _mailbox_shm_offset) { static_cast( cmd)->Init(_target, _mailbox_shm_id, _mailbox_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 mailbox_shm_id; uint32 mailbox_shm_offset; }; COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUM) == 16, Sizeof_ProduceTextureCHROMIUM_is_not_16); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, header) == 0, OffsetOf_ProduceTextureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, target) == 4, OffsetOf_ProduceTextureCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, mailbox_shm_id) == 8, OffsetOf_ProduceTextureCHROMIUM_mailbox_shm_id_not_8); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, mailbox_shm_offset) == 12, OffsetOf_ProduceTextureCHROMIUM_mailbox_shm_offset_not_12); struct ProduceTextureCHROMIUMImmediate { typedef ProduceTextureCHROMIUMImmediate ValueType; static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLbyte) * 64); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLenum _target, const GLbyte* _mailbox) { SetHeader(); target = _target; memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize()); } void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) { static_cast(cmd)->Init(_target, _mailbox); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 target; }; COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUMImmediate) == 8, Sizeof_ProduceTextureCHROMIUMImmediate_is_not_8); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, header) == 0, OffsetOf_ProduceTextureCHROMIUMImmediate_header_not_0); COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, target) == 4, OffsetOf_ProduceTextureCHROMIUMImmediate_target_not_4); struct ConsumeTextureCHROMIUM { typedef ConsumeTextureCHROMIUM ValueType; static const CommandId kCmdId = kConsumeTextureCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, uint32 _mailbox_shm_id, uint32 _mailbox_shm_offset) { SetHeader(); target = _target; mailbox_shm_id = _mailbox_shm_id; mailbox_shm_offset = _mailbox_shm_offset; } void* Set( void* cmd, GLenum _target, uint32 _mailbox_shm_id, uint32 _mailbox_shm_offset) { static_cast( cmd)->Init(_target, _mailbox_shm_id, _mailbox_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; uint32 mailbox_shm_id; uint32 mailbox_shm_offset; }; COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUM) == 16, Sizeof_ConsumeTextureCHROMIUM_is_not_16); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, header) == 0, OffsetOf_ConsumeTextureCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, target) == 4, OffsetOf_ConsumeTextureCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, mailbox_shm_id) == 8, OffsetOf_ConsumeTextureCHROMIUM_mailbox_shm_id_not_8); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, mailbox_shm_offset) == 12, OffsetOf_ConsumeTextureCHROMIUM_mailbox_shm_offset_not_12); struct ConsumeTextureCHROMIUMImmediate { typedef ConsumeTextureCHROMIUMImmediate ValueType; static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize() { return static_cast( sizeof(GLbyte) * 64); // NOLINT } static uint32 ComputeSize() { return static_cast( sizeof(ValueType) + ComputeDataSize()); // NOLINT } void SetHeader() { header.SetCmdByTotalSize(ComputeSize()); } void Init(GLenum _target, const GLbyte* _mailbox) { SetHeader(); target = _target; memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize()); } void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) { static_cast(cmd)->Init(_target, _mailbox); const uint32 size = ComputeSize(); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 target; }; COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUMImmediate) == 8, Sizeof_ConsumeTextureCHROMIUMImmediate_is_not_8); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, header) == 0, OffsetOf_ConsumeTextureCHROMIUMImmediate_header_not_0); COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, target) == 4, OffsetOf_ConsumeTextureCHROMIUMImmediate_target_not_4); struct BindUniformLocationCHROMIUM { typedef BindUniformLocationCHROMIUM ValueType; static const CommandId kCmdId = kBindUniformLocationCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLuint _program, GLint _location, uint32 _name_shm_id, uint32 _name_shm_offset, uint32 _data_size) { SetHeader(); program = _program; location = _location; name_shm_id = _name_shm_id; name_shm_offset = _name_shm_offset; data_size = _data_size; } void* Set( void* cmd, GLuint _program, GLint _location, uint32 _name_shm_id, uint32 _name_shm_offset, uint32 _data_size) { static_cast( cmd)->Init( _program, _location, _name_shm_id, _name_shm_offset, _data_size); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; int32 location; uint32 name_shm_id; uint32 name_shm_offset; uint32 data_size; }; COMPILE_ASSERT(sizeof(BindUniformLocationCHROMIUM) == 24, Sizeof_BindUniformLocationCHROMIUM_is_not_24); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, header) == 0, OffsetOf_BindUniformLocationCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, program) == 4, OffsetOf_BindUniformLocationCHROMIUM_program_not_4); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, location) == 8, OffsetOf_BindUniformLocationCHROMIUM_location_not_8); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, name_shm_id) == 12, OffsetOf_BindUniformLocationCHROMIUM_name_shm_id_not_12); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, name_shm_offset) == 16, OffsetOf_BindUniformLocationCHROMIUM_name_shm_offset_not_16); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUM, data_size) == 20, OffsetOf_BindUniformLocationCHROMIUM_data_size_not_20); struct BindUniformLocationCHROMIUMImmediate { typedef BindUniformLocationCHROMIUMImmediate ValueType; static const CommandId kCmdId = kBindUniformLocationCHROMIUMImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeSize(uint32 data_size) { return static_cast( sizeof(ValueType) + data_size); // NOLINT } void SetHeader(uint32 data_size) { header.SetCmdBySize(data_size); } void Init( GLuint _program, GLint _location, const char* _name, uint32 _data_size) { SetHeader(_data_size); program = _program; location = _location; data_size = _data_size; memcpy(ImmediateDataAddress(this), _name, _data_size); } void* Set( void* cmd, GLuint _program, GLint _location, const char* _name, uint32 _data_size) { static_cast(cmd)->Init(_program, _location, _name, _data_size); return NextImmediateCmdAddress(cmd, _data_size); } gpu::CommandHeader header; uint32 program; int32 location; uint32 data_size; }; COMPILE_ASSERT(sizeof(BindUniformLocationCHROMIUMImmediate) == 16, Sizeof_BindUniformLocationCHROMIUMImmediate_is_not_16); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMImmediate, header) == 0, OffsetOf_BindUniformLocationCHROMIUMImmediate_header_not_0); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMImmediate, program) == 4, OffsetOf_BindUniformLocationCHROMIUMImmediate_program_not_4); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMImmediate, location) == 8, OffsetOf_BindUniformLocationCHROMIUMImmediate_location_not_8); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMImmediate, data_size) == 12, OffsetOf_BindUniformLocationCHROMIUMImmediate_data_size_not_12); struct BindUniformLocationCHROMIUMBucket { typedef BindUniformLocationCHROMIUMBucket ValueType; static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _program, GLint _location, uint32 _name_bucket_id) { SetHeader(); program = _program; location = _location; name_bucket_id = _name_bucket_id; } void* Set( void* cmd, GLuint _program, GLint _location, uint32 _name_bucket_id) { static_cast(cmd)->Init(_program, _location, _name_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 program; int32 location; uint32 name_bucket_id; }; COMPILE_ASSERT(sizeof(BindUniformLocationCHROMIUMBucket) == 16, Sizeof_BindUniformLocationCHROMIUMBucket_is_not_16); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, header) == 0, OffsetOf_BindUniformLocationCHROMIUMBucket_header_not_0); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, program) == 4, OffsetOf_BindUniformLocationCHROMIUMBucket_program_not_4); COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, location) == 8, OffsetOf_BindUniformLocationCHROMIUMBucket_location_not_8); COMPILE_ASSERT( offsetof(BindUniformLocationCHROMIUMBucket, name_bucket_id) == 12, OffsetOf_BindUniformLocationCHROMIUMBucket_name_bucket_id_not_12); // NOLINT struct BindTexImage2DCHROMIUM { typedef BindTexImage2DCHROMIUM ValueType; static const CommandId kCmdId = kBindTexImage2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLint _imageId) { SetHeader(); target = _target; imageId = _imageId; } void* Set(void* cmd, GLenum _target, GLint _imageId) { static_cast(cmd)->Init(_target, _imageId); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 imageId; }; COMPILE_ASSERT(sizeof(BindTexImage2DCHROMIUM) == 12, Sizeof_BindTexImage2DCHROMIUM_is_not_12); COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, header) == 0, OffsetOf_BindTexImage2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, target) == 4, OffsetOf_BindTexImage2DCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, imageId) == 8, OffsetOf_BindTexImage2DCHROMIUM_imageId_not_8); struct ReleaseTexImage2DCHROMIUM { typedef ReleaseTexImage2DCHROMIUM ValueType; static const CommandId kCmdId = kReleaseTexImage2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target, GLint _imageId) { SetHeader(); target = _target; imageId = _imageId; } void* Set(void* cmd, GLenum _target, GLint _imageId) { static_cast(cmd)->Init(_target, _imageId); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 imageId; }; COMPILE_ASSERT(sizeof(ReleaseTexImage2DCHROMIUM) == 12, Sizeof_ReleaseTexImage2DCHROMIUM_is_not_12); COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, header) == 0, OffsetOf_ReleaseTexImage2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, target) == 4, OffsetOf_ReleaseTexImage2DCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, imageId) == 8, OffsetOf_ReleaseTexImage2DCHROMIUM_imageId_not_8); struct TraceBeginCHROMIUM { typedef TraceBeginCHROMIUM ValueType; static const CommandId kCmdId = kTraceBeginCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _bucket_id) { SetHeader(); bucket_id = _bucket_id; } void* Set(void* cmd, GLuint _bucket_id) { static_cast(cmd)->Init(_bucket_id); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 bucket_id; }; COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 8, Sizeof_TraceBeginCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, header) == 0, OffsetOf_TraceBeginCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, bucket_id) == 4, OffsetOf_TraceBeginCHROMIUM_bucket_id_not_4); struct TraceEndCHROMIUM { typedef TraceEndCHROMIUM ValueType; static const CommandId kCmdId = kTraceEndCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init() { SetHeader(); } void* Set(void* cmd) { static_cast(cmd)->Init(); return NextCmdAddress(cmd); } gpu::CommandHeader header; }; COMPILE_ASSERT(sizeof(TraceEndCHROMIUM) == 4, Sizeof_TraceEndCHROMIUM_is_not_4); COMPILE_ASSERT(offsetof(TraceEndCHROMIUM, header) == 0, OffsetOf_TraceEndCHROMIUM_header_not_0); struct AsyncTexSubImage2DCHROMIUM { typedef AsyncTexSubImage2DCHROMIUM ValueType; static const CommandId kCmdId = kAsyncTexSubImage2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _data_shm_id, uint32 _data_shm_offset) { SetHeader(); target = _target; level = _level; xoffset = _xoffset; yoffset = _yoffset; width = _width; height = _height; format = _format; type = _type; data_shm_id = _data_shm_id; data_shm_offset = _data_shm_offset; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, uint32 _data_shm_id, uint32 _data_shm_offset) { static_cast( cmd)->Init( _target, _level, _xoffset, _yoffset, _width, _height, _format, _type, _data_shm_id, _data_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 xoffset; int32 yoffset; int32 width; int32 height; uint32 format; uint32 type; uint32 data_shm_id; uint32 data_shm_offset; }; COMPILE_ASSERT(sizeof(AsyncTexSubImage2DCHROMIUM) == 44, Sizeof_AsyncTexSubImage2DCHROMIUM_is_not_44); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, header) == 0, OffsetOf_AsyncTexSubImage2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, target) == 4, OffsetOf_AsyncTexSubImage2DCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, level) == 8, OffsetOf_AsyncTexSubImage2DCHROMIUM_level_not_8); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, xoffset) == 12, OffsetOf_AsyncTexSubImage2DCHROMIUM_xoffset_not_12); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, yoffset) == 16, OffsetOf_AsyncTexSubImage2DCHROMIUM_yoffset_not_16); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, width) == 20, OffsetOf_AsyncTexSubImage2DCHROMIUM_width_not_20); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, height) == 24, OffsetOf_AsyncTexSubImage2DCHROMIUM_height_not_24); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, format) == 28, OffsetOf_AsyncTexSubImage2DCHROMIUM_format_not_28); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, type) == 32, OffsetOf_AsyncTexSubImage2DCHROMIUM_type_not_32); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_id) == 36, OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_id_not_36); COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_offset) == 40, OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_offset_not_40); struct AsyncTexImage2DCHROMIUM { typedef AsyncTexImage2DCHROMIUM ValueType; static const CommandId kCmdId = kAsyncTexImage2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { SetHeader(); target = _target; level = _level; internalformat = _internalformat; width = _width; height = _height; border = _border; format = _format; type = _type; pixels_shm_id = _pixels_shm_id; pixels_shm_offset = _pixels_shm_offset; } void* Set( void* cmd, GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, GLsizei _height, GLint _border, GLenum _format, GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { static_cast( cmd)->Init( _target, _level, _internalformat, _width, _height, _border, _format, _type, _pixels_shm_id, _pixels_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 level; int32 internalformat; int32 width; int32 height; int32 border; uint32 format; uint32 type; uint32 pixels_shm_id; uint32 pixels_shm_offset; }; COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 44, Sizeof_AsyncTexImage2DCHROMIUM_is_not_44); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, header) == 0, OffsetOf_AsyncTexImage2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, target) == 4, OffsetOf_AsyncTexImage2DCHROMIUM_target_not_4); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, level) == 8, OffsetOf_AsyncTexImage2DCHROMIUM_level_not_8); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, internalformat) == 12, OffsetOf_AsyncTexImage2DCHROMIUM_internalformat_not_12); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, width) == 16, OffsetOf_AsyncTexImage2DCHROMIUM_width_not_16); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, height) == 20, OffsetOf_AsyncTexImage2DCHROMIUM_height_not_20); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, border) == 24, OffsetOf_AsyncTexImage2DCHROMIUM_border_not_24); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 28, OffsetOf_AsyncTexImage2DCHROMIUM_format_not_28); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 32, OffsetOf_AsyncTexImage2DCHROMIUM_type_not_32); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 36, OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_36); COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 40, OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_40); struct WaitAsyncTexImage2DCHROMIUM { typedef WaitAsyncTexImage2DCHROMIUM ValueType; static const CommandId kCmdId = kWaitAsyncTexImage2DCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _target) { SetHeader(); target = _target; } void* Set(void* cmd, GLenum _target) { static_cast(cmd)->Init(_target); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; }; COMPILE_ASSERT(sizeof(WaitAsyncTexImage2DCHROMIUM) == 8, Sizeof_WaitAsyncTexImage2DCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, header) == 0, OffsetOf_WaitAsyncTexImage2DCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, target) == 4, OffsetOf_WaitAsyncTexImage2DCHROMIUM_target_not_4); struct DiscardFramebufferEXT { typedef DiscardFramebufferEXT ValueType; static const CommandId kCmdId = kDiscardFramebufferEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init( GLenum _target, GLsizei _count, uint32 _attachments_shm_id, uint32 _attachments_shm_offset) { SetHeader(); target = _target; count = _count; attachments_shm_id = _attachments_shm_id; attachments_shm_offset = _attachments_shm_offset; } void* Set( void* cmd, GLenum _target, GLsizei _count, uint32 _attachments_shm_id, uint32 _attachments_shm_offset) { static_cast( cmd)->Init( _target, _count, _attachments_shm_id, _attachments_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 target; int32 count; uint32 attachments_shm_id; uint32 attachments_shm_offset; }; COMPILE_ASSERT(sizeof(DiscardFramebufferEXT) == 20, Sizeof_DiscardFramebufferEXT_is_not_20); COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, header) == 0, OffsetOf_DiscardFramebufferEXT_header_not_0); COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, target) == 4, OffsetOf_DiscardFramebufferEXT_target_not_4); COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, count) == 8, OffsetOf_DiscardFramebufferEXT_count_not_8); COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, attachments_shm_id) == 12, OffsetOf_DiscardFramebufferEXT_attachments_shm_id_not_12); COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, attachments_shm_offset) == 16, OffsetOf_DiscardFramebufferEXT_attachments_shm_offset_not_16); struct DiscardFramebufferEXTImmediate { typedef DiscardFramebufferEXTImmediate ValueType; static const CommandId kCmdId = kDiscardFramebufferEXTImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLenum) * 1 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLenum _target, GLsizei _count, const GLenum* _attachments) { SetHeader(_count); target = _target; count = _count; memcpy(ImmediateDataAddress(this), _attachments, ComputeDataSize(_count)); } void* Set( void* cmd, GLenum _target, GLsizei _count, const GLenum* _attachments) { static_cast(cmd)->Init(_target, _count, _attachments); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; uint32 target; int32 count; }; COMPILE_ASSERT(sizeof(DiscardFramebufferEXTImmediate) == 12, Sizeof_DiscardFramebufferEXTImmediate_is_not_12); COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, header) == 0, OffsetOf_DiscardFramebufferEXTImmediate_header_not_0); COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, target) == 4, OffsetOf_DiscardFramebufferEXTImmediate_target_not_4); COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, count) == 8, OffsetOf_DiscardFramebufferEXTImmediate_count_not_8); struct LoseContextCHROMIUM { typedef LoseContextCHROMIUM ValueType; static const CommandId kCmdId = kLoseContextCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLenum _current, GLenum _other) { SetHeader(); current = _current; other = _other; } void* Set(void* cmd, GLenum _current, GLenum _other) { static_cast(cmd)->Init(_current, _other); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 current; uint32 other; }; COMPILE_ASSERT(sizeof(LoseContextCHROMIUM) == 12, Sizeof_LoseContextCHROMIUM_is_not_12); COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, header) == 0, OffsetOf_LoseContextCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, current) == 4, OffsetOf_LoseContextCHROMIUM_current_not_4); COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, other) == 8, OffsetOf_LoseContextCHROMIUM_other_not_8); struct WaitSyncPointCHROMIUM { typedef WaitSyncPointCHROMIUM ValueType; static const CommandId kCmdId = kWaitSyncPointCHROMIUM; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLuint _sync_point) { SetHeader(); sync_point = _sync_point; } void* Set(void* cmd, GLuint _sync_point) { static_cast(cmd)->Init(_sync_point); return NextCmdAddress(cmd); } gpu::CommandHeader header; uint32 sync_point; }; COMPILE_ASSERT(sizeof(WaitSyncPointCHROMIUM) == 8, Sizeof_WaitSyncPointCHROMIUM_is_not_8); COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, header) == 0, OffsetOf_WaitSyncPointCHROMIUM_header_not_0); COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, sync_point) == 4, OffsetOf_WaitSyncPointCHROMIUM_sync_point_not_4); struct DrawBuffersEXT { typedef DrawBuffersEXT ValueType; static const CommandId kCmdId = kDrawBuffersEXT; static const cmd::ArgFlags kArgFlags = cmd::kFixed; static uint32 ComputeSize() { return static_cast(sizeof(ValueType)); // NOLINT } void SetHeader() { header.SetCmd(); } void Init(GLsizei _count, uint32 _bufs_shm_id, uint32 _bufs_shm_offset) { SetHeader(); count = _count; bufs_shm_id = _bufs_shm_id; bufs_shm_offset = _bufs_shm_offset; } void* Set( void* cmd, GLsizei _count, uint32 _bufs_shm_id, uint32 _bufs_shm_offset) { static_cast(cmd)->Init(_count, _bufs_shm_id, _bufs_shm_offset); return NextCmdAddress(cmd); } gpu::CommandHeader header; int32 count; uint32 bufs_shm_id; uint32 bufs_shm_offset; }; COMPILE_ASSERT(sizeof(DrawBuffersEXT) == 16, Sizeof_DrawBuffersEXT_is_not_16); COMPILE_ASSERT(offsetof(DrawBuffersEXT, header) == 0, OffsetOf_DrawBuffersEXT_header_not_0); COMPILE_ASSERT(offsetof(DrawBuffersEXT, count) == 4, OffsetOf_DrawBuffersEXT_count_not_4); COMPILE_ASSERT(offsetof(DrawBuffersEXT, bufs_shm_id) == 8, OffsetOf_DrawBuffersEXT_bufs_shm_id_not_8); COMPILE_ASSERT(offsetof(DrawBuffersEXT, bufs_shm_offset) == 12, OffsetOf_DrawBuffersEXT_bufs_shm_offset_not_12); struct DrawBuffersEXTImmediate { typedef DrawBuffersEXTImmediate ValueType; static const CommandId kCmdId = kDrawBuffersEXTImmediate; static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; static uint32 ComputeDataSize(GLsizei count) { return static_cast( sizeof(GLenum) * 1 * count); // NOLINT } static uint32 ComputeSize(GLsizei count) { return static_cast( sizeof(ValueType) + ComputeDataSize(count)); // NOLINT } void SetHeader(GLsizei count) { header.SetCmdByTotalSize(ComputeSize(count)); } void Init(GLsizei _count, const GLenum* _bufs) { SetHeader(_count); count = _count; memcpy(ImmediateDataAddress(this), _bufs, ComputeDataSize(_count)); } void* Set(void* cmd, GLsizei _count, const GLenum* _bufs) { static_cast(cmd)->Init(_count, _bufs); const uint32 size = ComputeSize(_count); return NextImmediateCmdAddressTotalSize(cmd, size); } gpu::CommandHeader header; int32 count; }; COMPILE_ASSERT(sizeof(DrawBuffersEXTImmediate) == 8, Sizeof_DrawBuffersEXTImmediate_is_not_8); COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, header) == 0, OffsetOf_DrawBuffersEXTImmediate_header_not_0); COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, count) == 4, OffsetOf_DrawBuffersEXTImmediate_count_not_4); #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_