blob: 487e8b799dfa0ed9a30227caf7dd55490a2ca3d2 [file] [log] [blame]
// Copyright 2014 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
// It's formatted by clang-format using chromium coding style:
// clang-format -i -style=chromium filename
// 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _texture) {
SetHeader();
texture = _texture;
}
void* Set(void* cmd, GLenum _texture) {
static_cast<ValueType*>(cmd)->Init(_texture);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program, GLuint _shader) {
SetHeader();
program = _program;
shader = _shader;
}
void* Set(void* cmd, GLuint _program, GLuint _shader) {
static_cast<ValueType*>(cmd)->Init(_program, _shader);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t program;
uint32_t 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 BindAttribLocationBucket {
typedef BindAttribLocationBucket ValueType;
static const CommandId kCmdId = kBindAttribLocationBucket;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program, GLuint _index, uint32_t _name_bucket_id) {
SetHeader();
program = _program;
index = _index;
name_bucket_id = _name_bucket_id;
}
void* Set(void* cmd,
GLuint _program,
GLuint _index,
uint32_t _name_bucket_id) {
static_cast<ValueType*>(cmd)->Init(_program, _index, _name_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t program;
uint32_t index;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target, GLuint _buffer) {
SetHeader();
target = _target;
buffer = _buffer;
}
void* Set(void* cmd, GLenum _target, GLuint _buffer) {
static_cast<ValueType*>(cmd)->Init(_target, _buffer);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target, GLuint _framebuffer) {
SetHeader();
target = _target;
framebuffer = _framebuffer;
}
void* Set(void* cmd, GLenum _target, GLuint _framebuffer) {
static_cast<ValueType*>(cmd)->Init(_target, _framebuffer);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target, GLuint _renderbuffer) {
SetHeader();
target = _target;
renderbuffer = _renderbuffer;
}
void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) {
static_cast<ValueType*>(cmd)->Init(_target, _renderbuffer);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target, GLuint _texture) {
SetHeader();
target = _target;
texture = _texture;
}
void* Set(void* cmd, GLenum _target, GLuint _texture) {
static_cast<ValueType*>(cmd)->Init(_target, _texture);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _mode) {
SetHeader();
mode = _mode;
}
void* Set(void* cmd, GLenum _mode) {
static_cast<ValueType*>(cmd)->Init(_mode);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _modeRGB, GLenum _modeAlpha) {
SetHeader();
modeRGB = _modeRGB;
modeAlpha = _modeAlpha;
}
void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) {
static_cast<ValueType*>(cmd)->Init(_modeRGB, _modeAlpha);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t modeRGB;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _sfactor, GLenum _dfactor) {
SetHeader();
sfactor = _sfactor;
dfactor = _dfactor;
}
void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) {
static_cast<ValueType*>(cmd)->Init(_sfactor, _dfactor);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t sfactor;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t srcRGB;
uint32_t dstRGB;
uint32_t srcAlpha;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLsizeiptr _size,
uint32_t _data_shm_id,
uint32_t _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_t _data_shm_id,
uint32_t _data_shm_offset,
GLenum _usage) {
static_cast<ValueType*>(cmd)
->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t size;
uint32_t data_shm_id;
uint32_t data_shm_offset;
uint32_t 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 BufferSubData {
typedef BufferSubData ValueType;
static const CommandId kCmdId = kBufferSubData;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLintptr _offset,
GLsizeiptr _size,
uint32_t _data_shm_id,
uint32_t _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_t _data_shm_id,
uint32_t _data_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t offset;
int32_t size;
uint32_t data_shm_id;
uint32_t 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 CheckFramebufferStatus {
typedef CheckFramebufferStatus ValueType;
static const CommandId kCmdId = kCheckFramebufferStatus;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
typedef GLenum Result;
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
uint32_t _result_shm_id,
uint32_t _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_t _result_shm_id,
uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t result_shm_id;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLbitfield _mask) {
SetHeader();
mask = _mask;
}
void* Set(void* cmd, GLbitfield _mask) {
static_cast<ValueType*>(cmd)->Init(_mask);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLclampf _depth) {
SetHeader();
depth = _depth;
}
void* Set(void* cmd, GLclampf _depth) {
static_cast<ValueType*>(cmd)->Init(_depth);
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLint _s) {
SetHeader();
s = _s;
}
void* Set(void* cmd, GLint _s) {
static_cast<ValueType*>(cmd)->Init(_s);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t red;
uint32_t green;
uint32_t blue;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _shader) {
SetHeader();
shader = _shader;
}
void* Set(void* cmd, GLuint _shader) {
static_cast<ValueType*>(cmd)->Init(_shader);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 CompressedTexImage2DBucket {
typedef CompressedTexImage2DBucket ValueType;
static const CommandId kCmdId = kCompressedTexImage2DBucket;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLint _level,
GLenum _internalformat,
GLsizei _width,
GLsizei _height,
GLuint _bucket_id) {
SetHeader();
target = _target;
level = _level;
internalformat = _internalformat;
width = _width;
height = _height;
bucket_id = _bucket_id;
}
void* Set(void* cmd,
GLenum _target,
GLint _level,
GLenum _internalformat,
GLsizei _width,
GLsizei _height,
GLuint _bucket_id) {
static_cast<ValueType*>(cmd)
->Init(_target, _level, _internalformat, _width, _height, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
uint32_t internalformat;
int32_t width;
int32_t height;
uint32_t bucket_id;
static const int32_t border = 0;
};
COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 28,
Sizeof_CompressedTexImage2DBucket_is_not_28);
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, bucket_id) == 24,
OffsetOf_CompressedTexImage2DBucket_bucket_id_not_24);
struct CompressedTexImage2D {
typedef CompressedTexImage2D ValueType;
static const CommandId kCmdId = kCompressedTexImage2D;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLint _level,
GLenum _internalformat,
GLsizei _width,
GLsizei _height,
GLsizei _imageSize,
uint32_t _data_shm_id,
uint32_t _data_shm_offset) {
SetHeader();
target = _target;
level = _level;
internalformat = _internalformat;
width = _width;
height = _height;
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,
GLsizei _imageSize,
uint32_t _data_shm_id,
uint32_t _data_shm_offset) {
static_cast<ValueType*>(cmd)->Init(_target,
_level,
_internalformat,
_width,
_height,
_imageSize,
_data_shm_id,
_data_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
uint32_t internalformat;
int32_t width;
int32_t height;
int32_t imageSize;
uint32_t data_shm_id;
uint32_t data_shm_offset;
static const int32_t border = 0;
};
COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 36,
Sizeof_CompressedTexImage2D_is_not_36);
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, imageSize) == 24,
OffsetOf_CompressedTexImage2D_imageSize_not_24);
COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 28,
OffsetOf_CompressedTexImage2D_data_shm_id_not_28);
COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 32,
OffsetOf_CompressedTexImage2D_data_shm_offset_not_32);
struct CompressedTexSubImage2DBucket {
typedef CompressedTexSubImage2DBucket ValueType;
static const CommandId kCmdId = kCompressedTexSubImage2DBucket;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_target,
_level,
_xoffset,
_yoffset,
_width,
_height,
_format,
_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
int32_t xoffset;
int32_t yoffset;
int32_t width;
int32_t height;
uint32_t format;
uint32_t 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 CompressedTexSubImage2D {
typedef CompressedTexSubImage2D ValueType;
static const CommandId kCmdId = kCompressedTexSubImage2D;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLint _level,
GLint _xoffset,
GLint _yoffset,
GLsizei _width,
GLsizei _height,
GLenum _format,
GLsizei _imageSize,
uint32_t _data_shm_id,
uint32_t _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_t _data_shm_id,
uint32_t _data_shm_offset) {
static_cast<ValueType*>(cmd)->Init(_target,
_level,
_xoffset,
_yoffset,
_width,
_height,
_format,
_imageSize,
_data_shm_id,
_data_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
int32_t xoffset;
int32_t yoffset;
int32_t width;
int32_t height;
uint32_t format;
int32_t imageSize;
uint32_t data_shm_id;
uint32_t 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 CopyTexImage2D {
typedef CopyTexImage2D ValueType;
static const CommandId kCmdId = kCopyTexImage2D;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLint _level,
GLenum _internalformat,
GLint _x,
GLint _y,
GLsizei _width,
GLsizei _height) {
SetHeader();
target = _target;
level = _level;
internalformat = _internalformat;
x = _x;
y = _y;
width = _width;
height = _height;
}
void* Set(void* cmd,
GLenum _target,
GLint _level,
GLenum _internalformat,
GLint _x,
GLint _y,
GLsizei _width,
GLsizei _height) {
static_cast<ValueType*>(cmd)
->Init(_target, _level, _internalformat, _x, _y, _width, _height);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
uint32_t internalformat;
int32_t x;
int32_t y;
int32_t width;
int32_t height;
static const int32_t border = 0;
};
COMPILE_ASSERT(sizeof(CopyTexImage2D) == 32, Sizeof_CopyTexImage2D_is_not_32);
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);
struct CopyTexSubImage2D {
typedef CopyTexSubImage2D ValueType;
static const CommandId kCmdId = kCopyTexSubImage2D;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)
->Init(_target, _level, _xoffset, _yoffset, _x, _y, _width, _height);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
int32_t level;
int32_t xoffset;
int32_t yoffset;
int32_t x;
int32_t y;
int32_t width;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(uint32_t _client_id) {
SetHeader();
client_id = _client_id;
}
void* Set(void* cmd, uint32_t _client_id) {
static_cast<ValueType*>(cmd)->Init(_client_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _type, uint32_t _client_id) {
SetHeader();
type = _type;
client_id = _client_id;
}
void* Set(void* cmd, GLenum _type, uint32_t _client_id) {
static_cast<ValueType*>(cmd)->Init(_type, _client_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t type;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _mode) {
SetHeader();
mode = _mode;
}
void* Set(void* cmd, GLenum _mode) {
static_cast<ValueType*>(cmd)->Init(_mode);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 DeleteBuffersImmediate {
typedef DeleteBuffersImmediate ValueType;
static const CommandId kCmdId = kDeleteBuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _buffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 DeleteFramebuffersImmediate {
typedef DeleteFramebuffersImmediate ValueType;
static const CommandId kCmdId = kDeleteFramebuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _framebuffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program) {
SetHeader();
program = _program;
}
void* Set(void* cmd, GLuint _program) {
static_cast<ValueType*>(cmd)->Init(_program);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 DeleteRenderbuffersImmediate {
typedef DeleteRenderbuffersImmediate ValueType;
static const CommandId kCmdId = kDeleteRenderbuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _renderbuffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _shader) {
SetHeader();
shader = _shader;
}
void* Set(void* cmd, GLuint _shader) {
static_cast<ValueType*>(cmd)->Init(_shader);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 DeleteTexturesImmediate {
typedef DeleteTexturesImmediate ValueType;
static const CommandId kCmdId = kDeleteTexturesImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _textures);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _func) {
SetHeader();
func = _func;
}
void* Set(void* cmd, GLenum _func) {
static_cast<ValueType*>(cmd)->Init(_func);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLboolean _flag) {
SetHeader();
flag = _flag;
}
void* Set(void* cmd, GLboolean _flag) {
static_cast<ValueType*>(cmd)->Init(_flag);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLclampf _zNear, GLclampf _zFar) {
SetHeader();
zNear = _zNear;
zFar = _zFar;
}
void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) {
static_cast<ValueType*>(cmd)->Init(_zNear, _zFar);
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program, GLuint _shader) {
SetHeader();
program = _program;
shader = _shader;
}
void* Set(void* cmd, GLuint _program, GLuint _shader) {
static_cast<ValueType*>(cmd)->Init(_program, _shader);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t program;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _cap) {
SetHeader();
cap = _cap;
}
void* Set(void* cmd, GLenum _cap) {
static_cast<ValueType*>(cmd)->Init(_cap);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _index) {
SetHeader();
index = _index;
}
void* Set(void* cmd, GLuint _index) {
static_cast<ValueType*>(cmd)->Init(_index);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_mode, _first, _count);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t mode;
int32_t first;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t mode;
int32_t count;
uint32_t type;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _cap) {
SetHeader();
cap = _cap;
}
void* Set(void* cmd, GLenum _cap) {
static_cast<ValueType*>(cmd)->Init(_cap);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _index) {
SetHeader();
index = _index;
}
void* Set(void* cmd, GLuint _index) {
static_cast<ValueType*>(cmd)->Init(_index);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init() { SetHeader(); }
void* Set(void* cmd) {
static_cast<ValueType*>(cmd)->Init();
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init() { SetHeader(); }
void* Set(void* cmd) {
static_cast<ValueType*>(cmd)->Init();
return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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<ValueType*>(cmd)
->Init(_target, _attachment, _renderbuffertarget, _renderbuffer);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t attachment;
uint32_t renderbuffertarget;
uint32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _attachment,
GLenum _textarget,
GLuint _texture) {
SetHeader();
target = _target;
attachment = _attachment;
textarget = _textarget;
texture = _texture;
}
void* Set(void* cmd,
GLenum _target,
GLenum _attachment,
GLenum _textarget,
GLuint _texture) {
static_cast<ValueType*>(cmd)
->Init(_target, _attachment, _textarget, _texture);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t target;
uint32_t attachment;
uint32_t textarget;
uint32_t texture;
static const int32_t level = 0;
};
COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 20,
Sizeof_FramebufferTexture2D_is_not_20);
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);
struct FrontFace {
typedef FrontFace ValueType;
static const CommandId kCmdId = kFrontFace;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _mode) {
SetHeader();
mode = _mode;
}
void* Set(void* cmd, GLenum _mode) {
static_cast<ValueType*>(cmd)->Init(_mode);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 GenBuffersImmediate {
typedef GenBuffersImmediate ValueType;
static const CommandId kCmdId = kGenBuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _buffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target) {
SetHeader();
target = _target;
}
void* Set(void* cmd, GLenum _target) {
static_cast<ValueType*>(cmd)->Init(_target);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t 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 GenFramebuffersImmediate {
typedef GenFramebuffersImmediate ValueType;
static const CommandId kCmdId = kGenFramebuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _framebuffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 GenRenderbuffersImmediate {
typedef GenRenderbuffersImmediate ValueType;
static const CommandId kCmdId = kGenRenderbuffersImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _renderbuffers);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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 GenTexturesImmediate {
typedef GenTexturesImmediate ValueType;
static const CommandId kCmdId = kGenTexturesImmediate;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
static uint32_t ComputeSize(GLsizei n) {
return static_cast<uint32_t>(sizeof(ValueType) +
ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
header.SetCmdByTotalSize<ValueType>(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<ValueType*>(cmd)->Init(_n, _textures);
const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
int32_t 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;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
int32_t success;
int32_t size;
uint32_t type;
};
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLuint _index,
uint32_t _name_bucket_id,
uint32_t _result_shm_id,
uint32_t _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_t _name_bucket_id,
uint32_t _result_shm_id,
uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)->Init(
_program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t program;
uint32_t index;
uint32_t name_bucket_id;
uint32_t result_shm_id;
uint32_t 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;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
int32_t success;
int32_t size;
uint32_t type;
};
static uint32_t ComputeSize() {
return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLuint _index,
uint32_t _name_bucket_id,
uint32_t _result_shm_id,
uint32_t _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_t _name_bucket_id,
uint32_t _result_shm_id,
uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)->Init(
_program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
uint32_t program;
uint32_t index;
uint32_t name_bucket_id;
uint32_t result_shm_id;
uint32_t 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;
static const