-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// 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.
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 texture;
+ uint32_t texture;
};
COMPILE_ASSERT(sizeof(ActiveTexture) == 8, Sizeof_ActiveTexture_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
- uint32 shader;
+ uint32_t program;
+ uint32_t shader;
};
COMPILE_ASSERT(sizeof(AttachShader) == 12, Sizeof_AttachShader_is_not_12);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_program, _index, _name_shm_id, _name_shm_offset, _data_size);
- return NextCmdAddress<ValueType>(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 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 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program, GLuint _index, uint32 _name_bucket_id) {
+ 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 _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 program;
- uint32 index;
- uint32 name_bucket_id;
+ uint32_t program;
+ uint32_t index;
+ uint32_t name_bucket_id;
};
COMPILE_ASSERT(sizeof(BindAttribLocationBucket) == 16,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 buffer;
+ uint32_t target;
+ uint32_t buffer;
};
COMPILE_ASSERT(sizeof(BindBuffer) == 12, Sizeof_BindBuffer_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 framebuffer;
+ uint32_t target;
+ uint32_t framebuffer;
};
COMPILE_ASSERT(sizeof(BindFramebuffer) == 12, Sizeof_BindFramebuffer_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 renderbuffer;
+ uint32_t target;
+ uint32_t renderbuffer;
};
COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 texture;
+ uint32_t target;
+ uint32_t texture;
};
COMPILE_ASSERT(sizeof(BindTexture) == 12, Sizeof_BindTexture_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
+ uint32_t mode;
};
COMPILE_ASSERT(sizeof(BlendEquation) == 8, Sizeof_BlendEquation_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 modeRGB;
- uint32 modeAlpha;
+ uint32_t modeRGB;
+ uint32_t modeAlpha;
};
COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 sfactor;
- uint32 dfactor;
+ uint32_t sfactor;
+ uint32_t dfactor;
};
COMPILE_ASSERT(sizeof(BlendFunc) == 12, Sizeof_BlendFunc_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 srcRGB;
- uint32 dstRGB;
- uint32 srcAlpha;
- uint32 dstAlpha;
+ uint32_t srcRGB;
+ uint32_t dstRGB;
+ uint32_t srcAlpha;
+ uint32_t dstAlpha;
};
COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLsizeiptr _size,
- uint32 _data_shm_id,
- uint32 _data_shm_offset,
+ uint32_t _data_shm_id,
+ uint32_t _data_shm_offset,
GLenum _usage) {
SetHeader();
target = _target;
void* Set(void* cmd,
GLenum _target,
GLsizeiptr _size,
- uint32 _data_shm_id,
- uint32 _data_shm_offset,
+ 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);
}
gpu::CommandHeader header;
- uint32 target;
- int32 size;
- uint32 data_shm_id;
- uint32 data_shm_offset;
- uint32 usage;
+ 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);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ 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 _data_shm_id,
- uint32 _data_shm_offset) {
+ uint32_t _data_shm_id,
+ uint32_t _data_shm_offset) {
SetHeader();
target = _target;
offset = _offset;
GLenum _target,
GLintptr _offset,
GLsizeiptr _size,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
+ 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 target;
- int32 offset;
- int32 size;
- uint32 data_shm_id;
- uint32 data_shm_offset;
+ 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);
typedef GLenum Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _target, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLenum _target,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
target = _target;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLenum _target,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ 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 target;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t target;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 16,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mask;
+ uint32_t mask;
};
COMPILE_ASSERT(sizeof(Clear) == 8, Sizeof_Clear_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 s;
+ int32_t s;
};
COMPILE_ASSERT(sizeof(ClearStencil) == 8, Sizeof_ClearStencil_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 red;
- uint32 green;
- uint32 blue;
- uint32 alpha;
+ uint32_t red;
+ uint32_t green;
+ uint32_t blue;
+ uint32_t alpha;
};
COMPILE_ASSERT(sizeof(ColorMask) == 20, Sizeof_ColorMask_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 shader;
+ uint32_t shader;
};
COMPILE_ASSERT(sizeof(CompileShader) == 8, Sizeof_CompileShader_is_not_8);
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 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLenum _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLsizei _imageSize,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
+ uint32_t _data_shm_id,
+ uint32_t _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;
GLenum _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLsizei _imageSize,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _internalformat,
- _width,
- _height,
- _border,
- _imageSize,
- _data_shm_id,
+ 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 target;
- int32 level;
- uint32 internalformat;
- int32 width;
- int32 height;
- int32 border;
- int32 imageSize;
- uint32 data_shm_id;
- uint32 data_shm_offset;
+ 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) == 40,
- Sizeof_CompressedTexImage2D_is_not_40);
+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_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);
+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 CompressedTexImage2DBucket {
- typedef CompressedTexImage2DBucket ValueType;
- static const CommandId kCmdId = kCompressedTexImage2DBucket;
+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 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ 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 _xoffset,
+ GLint _yoffset,
GLsizei _width,
GLsizei _height,
- GLint _border,
+ GLenum _format,
GLuint _bucket_id) {
SetHeader();
target = _target;
level = _level;
- internalformat = _internalformat;
+ xoffset = _xoffset;
+ yoffset = _yoffset;
width = _width;
height = _height;
- border = _border;
+ format = _format;
bucket_id = _bucket_id;
}
void* Set(void* cmd,
GLenum _target,
GLint _level,
- GLenum _internalformat,
+ GLint _xoffset,
+ GLint _yoffset,
GLsizei _width,
GLsizei _height,
- GLint _border,
+ GLenum _format,
GLuint _bucket_id) {
- static_cast<ValueType*>(cmd)->Init(
- _target, _level, _internalformat, _width, _height, _border, _bucket_id);
+ static_cast<ValueType*>(cmd)->Init(_target, _level, _xoffset, _yoffset,
+ _width, _height, _format, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- int32 level;
- uint32 internalformat;
- int32 width;
- int32 height;
- int32 border;
- uint32 bucket_id;
+ 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(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);
+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 cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLsizei _height,
GLenum _format,
GLsizei _imageSize,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
+ uint32_t _data_shm_id,
+ uint32_t _data_shm_offset) {
SetHeader();
target = _target;
level = _level;
GLsizei _height,
GLenum _format,
GLsizei _imageSize,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _xoffset,
- _yoffset,
- _width,
- _height,
- _format,
- _imageSize,
- _data_shm_id,
- _data_shm_offset);
+ 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 target;
- int32 level;
- int32 xoffset;
- int32 yoffset;
- int32 width;
- int32 height;
- uint32 format;
- int32 imageSize;
- uint32 data_shm_id;
- uint32 data_shm_offset;
+ 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,
COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40,
OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40);
-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 ComputeSize() {
- return static_cast<uint32>(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 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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLint _x,
GLint _y,
GLsizei _width,
- GLsizei _height,
- GLint _border) {
+ GLsizei _height) {
SetHeader();
target = _target;
level = _level;
y = _y;
width = _width;
height = _height;
- border = _border;
}
void* Set(void* cmd,
GLint _x,
GLint _y,
GLsizei _width,
- GLsizei _height,
- GLint _border) {
- static_cast<ValueType*>(cmd)->Init(
- _target, _level, _internalformat, _x, _y, _width, _height, _border);
+ GLsizei _height) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _level, _internalformat, _x, _y, _width, _height);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- int32 level;
- uint32 internalformat;
- int32 x;
- int32 y;
- int32 width;
- int32 height;
- int32 border;
+ 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) == 36, Sizeof_CopyTexImage2D_is_not_36);
+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_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 cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 level;
- int32 xoffset;
- int32 yoffset;
- int32 x;
- int32 y;
- int32 width;
- int32 height;
+ 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,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(uint32 _client_id) {
+ void Init(uint32_t _client_id) {
SetHeader();
client_id = _client_id;
}
- void* Set(void* cmd, uint32 _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 client_id;
+ uint32_t client_id;
};
COMPILE_ASSERT(sizeof(CreateProgram) == 8, Sizeof_CreateProgram_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _type, uint32 _client_id) {
+ void Init(GLenum _type, uint32_t _client_id) {
SetHeader();
type = _type;
client_id = _client_id;
}
- void* Set(void* cmd, GLenum _type, uint32 _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 type;
- uint32 client_id;
+ uint32_t type;
+ uint32_t client_id;
};
COMPILE_ASSERT(sizeof(CreateShader) == 12, Sizeof_CreateShader_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
+ 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 DeleteBuffers {
- typedef DeleteBuffers ValueType;
- static const CommandId kCmdId = kDeleteBuffers;
- static const cmd::ArgFlags kArgFlags = cmd::kFixed;
- static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _buffers_shm_id, _buffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) {
static_cast<ValueType*>(cmd)->Init(_n, _buffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) {
static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
+ uint32_t program;
};
COMPILE_ASSERT(sizeof(DeleteProgram) == 8, Sizeof_DeleteProgram_is_not_8);
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;
+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 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
- }
-
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) {
static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 shader;
+ uint32_t shader;
};
COMPILE_ASSERT(sizeof(DeleteShader) == 8, Sizeof_DeleteShader_is_not_8);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _textures_shm_id, _textures_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _textures) {
static_cast<ValueType*>(cmd)->Init(_n, _textures);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 func;
+ uint32_t func;
};
COMPILE_ASSERT(sizeof(DepthFunc) == 8, Sizeof_DepthFunc_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 flag;
+ uint32_t flag;
};
COMPILE_ASSERT(sizeof(DepthMask) == 8, Sizeof_DepthMask_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
- uint32 shader;
+ uint32_t program;
+ uint32_t shader;
};
COMPILE_ASSERT(sizeof(DetachShader) == 12, Sizeof_DetachShader_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 cap;
+ uint32_t cap;
};
COMPILE_ASSERT(sizeof(Disable) == 8, Sizeof_Disable_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 index;
+ uint32_t index;
};
COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
- int32 first;
- int32 count;
+ uint32_t mode;
+ int32_t first;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(DrawArrays) == 16, Sizeof_DrawArrays_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
- int32 count;
- uint32 type;
- uint32 index_offset;
+ uint32_t mode;
+ int32_t count;
+ uint32_t type;
+ uint32_t index_offset;
};
COMPILE_ASSERT(sizeof(DrawElements) == 20, Sizeof_DrawElements_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 cap;
+ uint32_t cap;
};
COMPILE_ASSERT(sizeof(Enable) == 8, Sizeof_Enable_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 index;
+ uint32_t index;
};
COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 attachment;
- uint32 renderbuffertarget;
- uint32 renderbuffer;
+ uint32_t target;
+ uint32_t attachment;
+ uint32_t renderbuffertarget;
+ uint32_t renderbuffer;
};
COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ 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,
- GLint _level) {
+ GLuint _texture) {
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) {
+ GLuint _texture) {
static_cast<ValueType*>(cmd)
- ->Init(_target, _attachment, _textarget, _texture, _level);
+ ->Init(_target, _attachment, _textarget, _texture);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 attachment;
- uint32 textarget;
- uint32 texture;
- int32 level;
+ uint32_t target;
+ uint32_t attachment;
+ uint32_t textarget;
+ uint32_t texture;
+ static const int32_t level = 0;
};
-COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24,
- Sizeof_FramebufferTexture2D_is_not_24);
+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_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 cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
+ uint32_t mode;
};
COMPILE_ASSERT(sizeof(FrontFace) == 8, Sizeof_FrontFace_is_not_8);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _buffers_shm_id, _buffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _buffers) {
static_cast<ValueType*>(cmd)->Init(_n, _buffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
+ uint32_t target;
};
COMPILE_ASSERT(sizeof(GenerateMipmap) == 8, Sizeof_GenerateMipmap_is_not_8);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) {
static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) {
static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _textures_shm_id, _textures_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _textures) {
static_cast<ValueType*>(cmd)->Init(_n, _textures);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8,
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
- int32 success;
- int32 size;
- uint32 type;
+ int32_t success;
+ int32_t size;
+ uint32_t type;
};
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLuint _index,
- uint32 _name_bucket_id,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _name_bucket_id,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
program = _program;
index = _index;
void* Set(void* cmd,
GLuint _program,
GLuint _index,
- uint32 _name_bucket_id,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(
- _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset);
+ 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 program;
- uint32 index;
- uint32 name_bucket_id;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ 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);
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
- int32 success;
- int32 size;
- uint32 type;
+ int32_t success;
+ int32_t size;
+ uint32_t type;
};
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLuint _index,
- uint32 _name_bucket_id,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _name_bucket_id,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
program = _program;
index = _index;
void* Set(void* cmd,
GLuint _program,
GLuint _index,
- uint32 _name_bucket_id,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(
- _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset);
+ 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 program;
- uint32 index;
- uint32 name_bucket_id;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ 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,
typedef SizedResult<GLuint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
- uint32 _result_shm_id,
- uint32 _result_shm_offset,
- uint32 _result_size) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset,
+ uint32_t _result_size) {
SetHeader();
program = _program;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _program,
- uint32 _result_shm_id,
- uint32 _result_shm_offset,
- uint32 _result_size) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset,
+ uint32_t _result_size) {
static_cast<ValueType*>(cmd)
->Init(_program, _result_shm_id, _result_shm_offset, _result_size);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- uint32 result_shm_id;
- uint32 result_shm_offset;
- uint32 result_size;
+ uint32_t program;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
+ uint32_t result_size;
};
COMPILE_ASSERT(sizeof(GetAttachedShaders) == 20,
COMPILE_ASSERT(offsetof(GetAttachedShaders, result_size) == 16,
OffsetOf_GetAttachedShaders_result_size_not_16);
+struct GetAttribLocation {
+ typedef GetAttribLocation ValueType;
+ static const CommandId kCmdId = kGetAttribLocation;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ typedef GLint Result;
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _program,
+ uint32_t _name_bucket_id,
+ uint32_t _location_shm_id,
+ uint32_t _location_shm_offset) {
+ SetHeader();
+ program = _program;
+ name_bucket_id = _name_bucket_id;
+ location_shm_id = _location_shm_id;
+ location_shm_offset = _location_shm_offset;
+ }
+
+ void* Set(void* cmd,
+ GLuint _program,
+ uint32_t _name_bucket_id,
+ uint32_t _location_shm_id,
+ uint32_t _location_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_program, _name_bucket_id,
+ _location_shm_id, _location_shm_offset);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t program;
+ uint32_t name_bucket_id;
+ uint32_t location_shm_id;
+ uint32_t location_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetAttribLocation) == 20,
+ Sizeof_GetAttribLocation_is_not_20);
+COMPILE_ASSERT(offsetof(GetAttribLocation, header) == 0,
+ OffsetOf_GetAttribLocation_header_not_0);
+COMPILE_ASSERT(offsetof(GetAttribLocation, program) == 4,
+ OffsetOf_GetAttribLocation_program_not_4);
+COMPILE_ASSERT(offsetof(GetAttribLocation, name_bucket_id) == 8,
+ OffsetOf_GetAttribLocation_name_bucket_id_not_8);
+COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_id) == 12,
+ OffsetOf_GetAttribLocation_location_shm_id_not_12);
+COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_offset) == 16,
+ OffsetOf_GetAttribLocation_location_shm_offset_not_16);
+
struct GetBooleanv {
typedef GetBooleanv ValueType;
static const CommandId kCmdId = kGetBooleanv;
typedef SizedResult<GLboolean> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) {
+ void Init(GLenum _pname,
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
pname = _pname;
params_shm_id = _params_shm_id;
void* Set(void* cmd,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetBooleanv) == 16, Sizeof_GetBooleanv_is_not_16);
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
target = _target;
pname = _pname;
void* Set(void* cmd,
GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t target;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20,
typedef GLenum Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(uint32_t _result_shm_id, uint32_t _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) {
+ void* Set(void* cmd, uint32_t _result_shm_id, uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)->Init(_result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(GetError) == 12, Sizeof_GetError_is_not_12);
typedef SizedResult<GLfloat> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) {
+ void Init(GLenum _pname,
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
pname = _pname;
params_shm_id = _params_shm_id;
void* Set(void* cmd,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetFloatv) == 16, Sizeof_GetFloatv_is_not_16);
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _attachment,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
target = _target;
attachment = _attachment;
GLenum _target,
GLenum _attachment,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(
- _target, _attachment, _pname, _params_shm_id, _params_shm_offset);
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_target, _attachment, _pname,
+ _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 attachment;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t target;
+ uint32_t attachment;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24,
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) {
+ void Init(GLenum _pname,
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
pname = _pname;
params_shm_id = _params_shm_id;
void* Set(void* cmd,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetIntegerv) == 16, Sizeof_GetIntegerv_is_not_16);
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
program = _program;
pname = _pname;
void* Set(void* cmd,
GLuint _program,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_program, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t program;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetProgramiv) == 20, Sizeof_GetProgramiv_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program, uint32 _bucket_id) {
+ void Init(GLuint _program, uint32_t _bucket_id) {
SetHeader();
program = _program;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLuint _program, uint32 _bucket_id) {
+ void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_program, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- uint32 bucket_id;
+ uint32_t program;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 12,
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
target = _target;
pname = _pname;
void* Set(void* cmd,
GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t target;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20,
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _shader,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
shader = _shader;
pname = _pname;
void* Set(void* cmd,
GLuint _shader,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_shader, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t shader;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetShaderiv) == 20, Sizeof_GetShaderiv_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _shader, uint32 _bucket_id) {
+ void Init(GLuint _shader, uint32_t _bucket_id) {
SetHeader();
shader = _shader;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) {
+ void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 bucket_id;
+ uint32_t shader;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 12,
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
- int32 success;
- int32 min_range;
- int32 max_range;
- int32 precision;
+ int32_t success;
+ int32_t min_range;
+ int32_t max_range;
+ int32_t precision;
};
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _shadertype,
GLenum _precisiontype,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
shadertype = _shadertype;
precisiontype = _precisiontype;
void* Set(void* cmd,
GLenum _shadertype,
GLenum _precisiontype,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_shadertype, _precisiontype, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shadertype;
- uint32 precisiontype;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t shadertype;
+ uint32_t precisiontype;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _shader, uint32 _bucket_id) {
+ void Init(GLuint _shader, uint32_t _bucket_id) {
SetHeader();
shader = _shader;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) {
+ void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 bucket_id;
+ uint32_t shader;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetShaderSource) == 12, Sizeof_GetShaderSource_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _name, uint32 _bucket_id) {
+ void Init(GLenum _name, uint32_t _bucket_id) {
SetHeader();
name = _name;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLenum _name, uint32 _bucket_id) {
+ void* Set(void* cmd, GLenum _name, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_name, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 name;
- uint32 bucket_id;
+ uint32_t name;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetString) == 12, Sizeof_GetString_is_not_12);
typedef SizedResult<GLfloat> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
target = _target;
pname = _pname;
void* Set(void* cmd,
GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t target;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20,
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
target = _target;
pname = _pname;
void* Set(void* cmd,
GLenum _target,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t target;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20,
typedef SizedResult<GLfloat> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLint _location,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
program = _program;
location = _location;
void* Set(void* cmd,
GLuint _program,
GLint _location,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_program, _location, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- int32 location;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t program;
+ int32_t location;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetUniformfv) == 20, Sizeof_GetUniformfv_is_not_20);
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _program,
GLint _location,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
program = _program;
location = _location;
void* Set(void* cmd,
GLuint _program,
GLint _location,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_program, _location, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- int32 location;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t program;
+ int32_t location;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetUniformiv) == 20, Sizeof_GetUniformiv_is_not_20);
COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_offset) == 16,
OffsetOf_GetUniformiv_params_shm_offset_not_16);
+struct GetUniformLocation {
+ typedef GetUniformLocation ValueType;
+ static const CommandId kCmdId = kGetUniformLocation;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ typedef GLint Result;
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _program,
+ uint32_t _name_bucket_id,
+ uint32_t _location_shm_id,
+ uint32_t _location_shm_offset) {
+ SetHeader();
+ program = _program;
+ name_bucket_id = _name_bucket_id;
+ location_shm_id = _location_shm_id;
+ location_shm_offset = _location_shm_offset;
+ }
+
+ void* Set(void* cmd,
+ GLuint _program,
+ uint32_t _name_bucket_id,
+ uint32_t _location_shm_id,
+ uint32_t _location_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_program, _name_bucket_id,
+ _location_shm_id, _location_shm_offset);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t program;
+ uint32_t name_bucket_id;
+ uint32_t location_shm_id;
+ uint32_t location_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetUniformLocation) == 20,
+ Sizeof_GetUniformLocation_is_not_20);
+COMPILE_ASSERT(offsetof(GetUniformLocation, header) == 0,
+ OffsetOf_GetUniformLocation_header_not_0);
+COMPILE_ASSERT(offsetof(GetUniformLocation, program) == 4,
+ OffsetOf_GetUniformLocation_program_not_4);
+COMPILE_ASSERT(offsetof(GetUniformLocation, name_bucket_id) == 8,
+ OffsetOf_GetUniformLocation_name_bucket_id_not_8);
+COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_id) == 12,
+ OffsetOf_GetUniformLocation_location_shm_id_not_12);
+COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_offset) == 16,
+ OffsetOf_GetUniformLocation_location_shm_offset_not_16);
+
struct GetVertexAttribfv {
typedef GetVertexAttribfv ValueType;
static const CommandId kCmdId = kGetVertexAttribfv;
typedef SizedResult<GLfloat> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _index,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
index = _index;
pname = _pname;
void* Set(void* cmd,
GLuint _index,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_index, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 index;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t index;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20,
typedef SizedResult<GLint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _index,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
SetHeader();
index = _index;
pname = _pname;
void* Set(void* cmd,
GLuint _index,
GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_index, _pname, _params_shm_id, _params_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 index;
- uint32 pname;
- uint32 params_shm_id;
- uint32 params_shm_offset;
+ uint32_t index;
+ uint32_t pname;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
};
COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20,
typedef SizedResult<GLuint> Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _index,
GLenum _pname,
- uint32 _pointer_shm_id,
- uint32 _pointer_shm_offset) {
+ uint32_t _pointer_shm_id,
+ uint32_t _pointer_shm_offset) {
SetHeader();
index = _index;
pname = _pname;
void* Set(void* cmd,
GLuint _index,
GLenum _pname,
- uint32 _pointer_shm_id,
- uint32 _pointer_shm_offset) {
+ uint32_t _pointer_shm_id,
+ uint32_t _pointer_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 index;
- uint32 pname;
- uint32 pointer_shm_id;
- uint32 pointer_shm_offset;
+ uint32_t index;
+ uint32_t pname;
+ uint32_t pointer_shm_id;
+ uint32_t pointer_shm_offset;
};
COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 mode;
+ uint32_t target;
+ uint32_t mode;
};
COMPILE_ASSERT(sizeof(Hint) == 12, Sizeof_Hint_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _buffer, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLuint _buffer,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
buffer = _buffer;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _buffer,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_buffer, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 buffer;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t buffer;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsBuffer) == 16, Sizeof_IsBuffer_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLenum _cap, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLenum _cap, uint32_t _result_shm_id, uint32_t _result_shm_offset) {
SetHeader();
cap = _cap;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLenum _cap,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_cap, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 cap;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t cap;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsEnabled) == 16, Sizeof_IsEnabled_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _framebuffer,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
framebuffer = _framebuffer;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _framebuffer,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_framebuffer, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 framebuffer;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t framebuffer;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsFramebuffer) == 16, Sizeof_IsFramebuffer_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLuint _program,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
program = _program;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _program,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_program, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t program;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsProgram) == 16, Sizeof_IsProgram_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLuint _renderbuffer,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
renderbuffer = _renderbuffer;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _renderbuffer,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_renderbuffer, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 renderbuffer;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t renderbuffer;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16, Sizeof_IsRenderbuffer_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _shader, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLuint _shader,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
shader = _shader;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _shader,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_shader, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t shader;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsShader) == 16, Sizeof_IsShader_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _texture, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLuint _texture,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
texture = _texture;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _texture,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_texture, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 texture;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t texture;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsTexture) == 16, Sizeof_IsTexture_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
+ uint32_t program;
};
COMPILE_ASSERT(sizeof(LinkProgram) == 8, Sizeof_LinkProgram_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 pname;
- int32 param;
+ uint32_t pname;
+ int32_t param;
};
COMPILE_ASSERT(sizeof(PixelStorei) == 12, Sizeof_PixelStorei_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset,
- uint32 _result_shm_id,
- uint32 _result_shm_offset,
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset,
GLboolean _async) {
SetHeader();
x = _x;
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset,
- uint32 _result_shm_id,
- uint32 _result_shm_offset,
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset,
GLboolean _async) {
- static_cast<ValueType*>(cmd)->Init(_x,
- _y,
- _width,
- _height,
- _format,
- _type,
- _pixels_shm_id,
- _pixels_shm_offset,
- _result_shm_id,
- _result_shm_offset,
- _async);
- return NextCmdAddress<ValueType>(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;
- uint32 async;
+ static_cast<ValueType*>(cmd)
+ ->Init(_x, _y, _width, _height, _format, _type, _pixels_shm_id,
+ _pixels_shm_offset, _result_shm_id, _result_shm_offset, _async);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t x;
+ int32_t y;
+ int32_t width;
+ int32_t height;
+ uint32_t format;
+ uint32_t type;
+ uint32_t pixels_shm_id;
+ uint32_t pixels_shm_offset;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
+ uint32_t async;
};
COMPILE_ASSERT(sizeof(ReadPixels) == 48, Sizeof_ReadPixels_is_not_48);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 internalformat;
- int32 width;
- int32 height;
+ uint32_t target;
+ uint32_t internalformat;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
gpu::CommandHeader header;
float value;
- uint32 invert;
+ uint32_t invert;
};
COMPILE_ASSERT(sizeof(SampleCoverage) == 12, Sizeof_SampleCoverage_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 x;
- int32 y;
- int32 width;
- int32 height;
+ int32_t x;
+ int32_t y;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(Scissor) == 20, Sizeof_Scissor_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLsizei _n,
- uint32 _shaders_shm_id,
- uint32 _shaders_shm_offset,
+ uint32_t _shaders_shm_id,
+ uint32_t _shaders_shm_offset,
GLenum _binaryformat,
- uint32 _binary_shm_id,
- uint32 _binary_shm_offset,
+ uint32_t _binary_shm_id,
+ uint32_t _binary_shm_offset,
GLsizei _length) {
SetHeader();
n = _n;
void* Set(void* cmd,
GLsizei _n,
- uint32 _shaders_shm_id,
- uint32 _shaders_shm_offset,
+ uint32_t _shaders_shm_id,
+ uint32_t _shaders_shm_offset,
GLenum _binaryformat,
- uint32 _binary_shm_id,
- uint32 _binary_shm_offset,
+ uint32_t _binary_shm_id,
+ uint32_t _binary_shm_offset,
GLsizei _length) {
- static_cast<ValueType*>(cmd)->Init(_n,
- _shaders_shm_id,
- _shaders_shm_offset,
- _binaryformat,
- _binary_shm_id,
- _binary_shm_offset,
- _length);
+ static_cast<ValueType*>(cmd)->Init(_n, _shaders_shm_id, _shaders_shm_offset,
+ _binaryformat, _binary_shm_id,
+ _binary_shm_offset, _length);
return NextCmdAddress<ValueType>(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;
+ int32_t n;
+ uint32_t shaders_shm_id;
+ uint32_t shaders_shm_offset;
+ uint32_t binaryformat;
+ uint32_t binary_shm_id;
+ uint32_t binary_shm_offset;
+ int32_t length;
};
COMPILE_ASSERT(sizeof(ShaderBinary) == 32, Sizeof_ShaderBinary_is_not_32);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_shader, _data_shm_id, _data_shm_offset, _data_size);
- return NextCmdAddress<ValueType>(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 ShaderSourceBucket {
typedef ShaderSourceBucket ValueType;
static const CommandId kCmdId = kShaderSourceBucket;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _shader, uint32 _data_bucket_id) {
+ void Init(GLuint _shader, uint32_t _data_bucket_id) {
SetHeader();
shader = _shader;
data_bucket_id = _data_bucket_id;
}
- void* Set(void* cmd, GLuint _shader, uint32 _data_bucket_id) {
+ void* Set(void* cmd, GLuint _shader, uint32_t _data_bucket_id) {
static_cast<ValueType*>(cmd)->Init(_shader, _data_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 data_bucket_id;
+ uint32_t shader;
+ uint32_t data_bucket_id;
};
COMPILE_ASSERT(sizeof(ShaderSourceBucket) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 func;
- int32 ref;
- uint32 mask;
+ uint32_t func;
+ int32_t ref;
+ uint32_t mask;
};
COMPILE_ASSERT(sizeof(StencilFunc) == 16, Sizeof_StencilFunc_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 face;
- uint32 func;
- int32 ref;
- uint32 mask;
+ uint32_t face;
+ uint32_t func;
+ int32_t ref;
+ uint32_t mask;
};
COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mask;
+ uint32_t mask;
};
COMPILE_ASSERT(sizeof(StencilMask) == 8, Sizeof_StencilMask_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 face;
- uint32 mask;
+ uint32_t face;
+ uint32_t mask;
};
COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 fail;
- uint32 zfail;
- uint32 zpass;
+ uint32_t fail;
+ uint32_t zfail;
+ uint32_t zpass;
};
COMPILE_ASSERT(sizeof(StencilOp) == 16, Sizeof_StencilOp_is_not_16);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 face;
- uint32 fail;
- uint32 zfail;
- uint32 zpass;
+ uint32_t face;
+ uint32_t fail;
+ uint32_t zfail;
+ uint32_t zpass;
};
COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLint _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset) {
+ uint32_t _pixels_shm_id,
+ uint32_t _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;
GLint _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _internalformat,
- _width,
- _height,
- _border,
- _format,
- _type,
- _pixels_shm_id,
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_target, _level, _internalformat, _width,
+ _height, _format, _type, _pixels_shm_id,
_pixels_shm_offset);
return NextCmdAddress<ValueType>(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;
+ uint32_t target;
+ int32_t level;
+ int32_t internalformat;
+ int32_t width;
+ int32_t height;
+ uint32_t format;
+ uint32_t type;
+ uint32_t pixels_shm_id;
+ uint32_t pixels_shm_offset;
+ static const int32_t border = 0;
};
-COMPILE_ASSERT(sizeof(TexImage2D) == 44, Sizeof_TexImage2D_is_not_44);
+COMPILE_ASSERT(sizeof(TexImage2D) == 40, Sizeof_TexImage2D_is_not_40);
COMPILE_ASSERT(offsetof(TexImage2D, header) == 0,
OffsetOf_TexImage2D_header_not_0);
COMPILE_ASSERT(offsetof(TexImage2D, target) == 4,
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);
+COMPILE_ASSERT(offsetof(TexImage2D, format) == 24,
+ OffsetOf_TexImage2D_format_not_24);
+COMPILE_ASSERT(offsetof(TexImage2D, type) == 28,
+ OffsetOf_TexImage2D_type_not_28);
+COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 32,
+ OffsetOf_TexImage2D_pixels_shm_id_not_32);
+COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 36,
+ OffsetOf_TexImage2D_pixels_shm_offset_not_36);
struct TexParameterf {
typedef TexParameterf ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
+ uint32_t target;
+ uint32_t pname;
float param;
};
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLfloat) * 1); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) {
static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
+ uint32_t target;
+ uint32_t pname;
};
COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
- int32 param;
+ uint32_t target;
+ uint32_t pname;
+ int32_t param;
};
COMPILE_ASSERT(sizeof(TexParameteri) == 16, Sizeof_TexParameteri_is_not_16);
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;
+struct TexParameterivImmediate {
+ typedef TexParameterivImmediate ValueType;
+ static const CommandId kCmdId = kTexParameterivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLint) * 1); // NOLINT
}
- void SetHeader() { header.SetCmd<ValueType>(); }
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
+ }
- void Init(GLenum _target,
- GLenum _pname,
- uint32 _params_shm_id,
- uint32 _params_shm_offset) {
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLenum _target, GLenum _pname, const GLint* _params) {
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<ValueType*>(cmd)
- ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLint) * 1); // NOLINT
- }
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
- }
-
- void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
-
- void Init(GLenum _target, GLenum _pname, const GLint* _params) {
- SetHeader();
- target = _target;
- pname = _pname;
- memcpy(ImmediateDataAddress(this), _params, ComputeDataSize());
+ memcpy(ImmediateDataAddress(this), _params, ComputeDataSize());
}
void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) {
static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 pname;
+ uint32_t target;
+ uint32_t pname;
};
COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset,
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
GLboolean _internal) {
SetHeader();
target = _target;
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset,
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
GLboolean _internal) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _xoffset,
- _yoffset,
- _width,
- _height,
- _format,
- _type,
- _pixels_shm_id,
- _pixels_shm_offset,
- _internal);
- return NextCmdAddress<ValueType>(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;
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _level, _xoffset, _yoffset, _width, _height, _format,
+ _type, _pixels_shm_id, _pixels_shm_offset, _internal);
+ 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 type;
+ uint32_t pixels_shm_id;
+ uint32_t pixels_shm_offset;
+ uint32_t internal;
};
COMPILE_ASSERT(sizeof(TexSubImage2D) == 48, Sizeof_TexSubImage2D_is_not_48);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
+ int32_t location;
float x;
};
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 1 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
- int32 x;
+ int32_t location;
+ int32_t x;
};
COMPILE_ASSERT(sizeof(Uniform1i) == 12, Sizeof_Uniform1i_is_not_12);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLint) * 1 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLint) * 1 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
+ int32_t location;
float x;
float y;
};
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 2 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 2 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
- int32 x;
- int32 y;
+ int32_t location;
+ int32_t x;
+ int32_t y;
};
COMPILE_ASSERT(sizeof(Uniform2i) == 16, Sizeof_Uniform2i_is_not_16);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLint) * 2 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLint) * 2 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
+ int32_t location;
float x;
float y;
float z;
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 3 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 3 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
- int32 x;
- int32 y;
- int32 z;
+ int32_t location;
+ int32_t x;
+ int32_t y;
+ int32_t z;
};
COMPILE_ASSERT(sizeof(Uniform3i) == 20, Sizeof_Uniform3i_is_not_20);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLint) * 3 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLint) * 3 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
+ int32_t location;
float x;
float y;
float z;
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 4 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 location;
- int32 x;
- int32 y;
- int32 z;
- int32 w;
+ int32_t location;
+ int32_t x;
+ int32_t y;
+ int32_t z;
+ int32_t w;
};
COMPILE_ASSERT(sizeof(Uniform4i) == 24, Sizeof_Uniform4i_is_not_24);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _v_shm_id, _v_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLint) * 4 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLint) * 4 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
+ int32_t location;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 4 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
}
- void Init(GLint _location,
- GLsizei _count,
- GLboolean _transpose,
- const GLfloat* _value) {
+ void Init(GLint _location, GLsizei _count, 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<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
- const uint32 size = ComputeSize(_count);
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
- uint32 transpose;
+ int32_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
};
-COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16,
- Sizeof_UniformMatrix2fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 12,
+ Sizeof_UniformMatrix2fvImmediate_is_not_12);
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;
+struct UniformMatrix3fvImmediate {
+ typedef UniformMatrix3fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix3fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 9 * count); // NOLINT
}
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 9 * count); // NOLINT
- }
-
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
}
- void Init(GLint _location,
- GLsizei _count,
- GLboolean _transpose,
- const GLfloat* _value) {
+ void Init(GLint _location, GLsizei _count, 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<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
- const uint32 size = ComputeSize(_count);
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
- uint32 transpose;
+ int32_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
};
-COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16,
- Sizeof_UniformMatrix3fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 12,
+ Sizeof_UniformMatrix3fvImmediate_is_not_12);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
- return NextCmdAddress<ValueType>(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 cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLfloat) * 16 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 16 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
}
- void Init(GLint _location,
- GLsizei _count,
- GLboolean _transpose,
- const GLfloat* _value) {
+ void Init(GLint _location, GLsizei _count, 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<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
- const uint32 size = ComputeSize(_count);
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 location;
- int32 count;
- uint32 transpose;
+ int32_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
};
-COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16,
- Sizeof_UniformMatrix4fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 12,
+ Sizeof_UniformMatrix4fvImmediate_is_not_12);
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 cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
+ uint32_t program;
};
COMPILE_ASSERT(sizeof(UseProgram) == 8, Sizeof_UseProgram_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 program;
+ uint32_t program;
};
COMPILE_ASSERT(sizeof(ValidateProgram) == 8, Sizeof_ValidateProgram_is_not_8);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
float x;
};
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_indx, _values_shm_id, _values_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLfloat) * 1); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
static_cast<ValueType*>(cmd)->Init(_indx, _values);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
};
COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
float x;
float y;
};
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_indx, _values_shm_id, _values_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLfloat) * 2); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 2); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
static_cast<ValueType*>(cmd)->Init(_indx, _values);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
};
COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
float x;
float y;
float z;
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_indx, _values_shm_id, _values_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLfloat) * 3); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 3); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
static_cast<ValueType*>(cmd)->Init(_indx, _values);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
};
COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
float x;
float y;
float z;
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_indx, _values_shm_id, _values_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLfloat) * 4); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 4); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
static_cast<ValueType*>(cmd)->Init(_indx, _values);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 indx;
+ uint32_t indx;
};
COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 indx;
- int32 size;
- uint32 type;
- uint32 normalized;
- int32 stride;
- uint32 offset;
+ uint32_t indx;
+ int32_t size;
+ uint32_t type;
+ uint32_t normalized;
+ int32_t stride;
+ uint32_t offset;
};
COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 x;
- int32 y;
- int32 width;
- int32 height;
+ int32_t x;
+ int32_t y;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(Viewport) == 20, Sizeof_Viewport_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLint _dstY1,
GLbitfield _mask,
GLenum _filter) {
- static_cast<ValueType*>(cmd)->Init(_srcX0,
- _srcY0,
- _srcX1,
- _srcY1,
- _dstX0,
- _dstY0,
- _dstX1,
- _dstY1,
- _mask,
- _filter);
+ static_cast<ValueType*>(cmd)->Init(_srcX0, _srcY0, _srcX1, _srcY1, _dstX0,
+ _dstY0, _dstX1, _dstY1, _mask, _filter);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- int32 srcX0;
- int32 srcY0;
- int32 srcX1;
- int32 srcY1;
- int32 dstX0;
- int32 dstY0;
- int32 dstX1;
- int32 dstY1;
- uint32 mask;
- uint32 filter;
+ int32_t srcX0;
+ int32_t srcY0;
+ int32_t srcX1;
+ int32_t srcY1;
+ int32_t dstX0;
+ int32_t dstY0;
+ int32_t dstX1;
+ int32_t dstY1;
+ uint32_t mask;
+ uint32_t filter;
};
COMPILE_ASSERT(sizeof(BlitFramebufferCHROMIUM) == 44,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 samples;
- uint32 internalformat;
- int32 width;
- int32 height;
+ uint32_t target;
+ int32_t samples;
+ uint32_t internalformat;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleCHROMIUM) == 24,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 samples;
- uint32 internalformat;
- int32 width;
- int32 height;
+ uint32_t target;
+ int32_t samples;
+ uint32_t internalformat;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleEXT) == 24,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLenum _attachment,
GLenum _textarget,
GLuint _texture,
- GLint _level,
GLsizei _samples) {
SetHeader();
target = _target;
attachment = _attachment;
textarget = _textarget;
texture = _texture;
- level = _level;
samples = _samples;
}
GLenum _attachment,
GLenum _textarget,
GLuint _texture,
- GLint _level,
GLsizei _samples) {
static_cast<ValueType*>(cmd)
- ->Init(_target, _attachment, _textarget, _texture, _level, _samples);
+ ->Init(_target, _attachment, _textarget, _texture, _samples);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 attachment;
- uint32 textarget;
- uint32 texture;
- int32 level;
- int32 samples;
+ uint32_t target;
+ uint32_t attachment;
+ uint32_t textarget;
+ uint32_t texture;
+ int32_t samples;
+ static const int32_t level = 0;
};
-COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 28,
- Sizeof_FramebufferTexture2DMultisampleEXT_is_not_28);
+COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 24,
+ Sizeof_FramebufferTexture2DMultisampleEXT_is_not_24);
COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, header) == 0,
OffsetOf_FramebufferTexture2DMultisampleEXT_header_not_0);
COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, target) == 4,
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);
+COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 20,
+ OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_20);
struct TexStorage2DEXT {
typedef TexStorage2DEXT ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 levels;
- uint32 internalFormat;
- int32 width;
- int32 height;
+ uint32_t target;
+ int32_t levels;
+ uint32_t internalFormat;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(TexStorage2DEXT) == 24, Sizeof_TexStorage2DEXT_is_not_24);
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _queries_shm_id, _queries_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _queries) {
static_cast<ValueType*>(cmd)->Init(_n, _queries);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenQueriesEXTImmediate) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_n, _queries_shm_id, _queries_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _queries) {
static_cast<ValueType*>(cmd)->Init(_n, _queries);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteQueriesEXTImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
void Init(GLenum _target,
GLuint _id,
- uint32 _sync_data_shm_id,
- uint32 _sync_data_shm_offset) {
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_shm_offset) {
SetHeader();
target = _target;
id = _id;
void* Set(void* cmd,
GLenum _target,
GLuint _id,
- uint32 _sync_data_shm_id,
- uint32 _sync_data_shm_offset) {
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_target, _id, _sync_data_shm_id, _sync_data_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 id;
- uint32 sync_data_shm_id;
- uint32 sync_data_shm_offset;
+ uint32_t target;
+ uint32_t id;
+ uint32_t sync_data_shm_id;
+ uint32_t sync_data_shm_offset;
};
COMPILE_ASSERT(sizeof(BeginQueryEXT) == 20, Sizeof_BeginQueryEXT_is_not_20);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- uint32 submit_count;
+ uint32_t target;
+ uint32_t submit_count;
};
COMPILE_ASSERT(sizeof(EndQueryEXT) == 12, Sizeof_EndQueryEXT_is_not_12);
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 bucket_id;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(InsertEventMarkerEXT) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 bucket_id;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(PushGroupMarkerEXT) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, GLuint* _arrays) {
static_cast<ValueType*>(cmd)->Init(_n, _arrays);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(GenVertexArraysOESImmediate) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei n) {
- return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT
}
- static uint32 ComputeSize(GLsizei n) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(n)); // NOLINT
+ static uint32_t ComputeSize(GLsizei n) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(n)); // NOLINT
}
void SetHeader(GLsizei n) {
void* Set(void* cmd, GLsizei _n, const GLuint* _arrays) {
static_cast<ValueType*>(cmd)->Init(_n, _arrays);
- const uint32 size = ComputeSize(_n);
+ const uint32_t size = ComputeSize(_n);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 n;
+ int32_t n;
};
COMPILE_ASSERT(sizeof(DeleteVertexArraysOESImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- typedef uint32 Result;
+ typedef uint32_t Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _array, uint32 _result_shm_id, uint32 _result_shm_offset) {
+ void Init(GLuint _array,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
array = _array;
result_shm_id = _result_shm_id;
void* Set(void* cmd,
GLuint _array,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
->Init(_array, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 array;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t array;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(IsVertexArrayOES) == 16,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 array;
+ uint32_t array;
};
COMPILE_ASSERT(sizeof(BindVertexArrayOES) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
typedef GLuint Result;
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLsizei _count,
GLenum _type,
GLuint _offset,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
SetHeader();
buffer_id = _buffer_id;
count = _count;
GLsizei _count,
GLenum _type,
GLuint _offset,
- uint32 _result_shm_id,
- uint32 _result_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(
- _buffer_id, _count, _type, _offset, _result_shm_id, _result_shm_offset);
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_buffer_id, _count, _type, _offset,
+ _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 buffer_id;
- int32 count;
- uint32 type;
- uint32 offset;
- uint32 result_shm_id;
- uint32 result_shm_offset;
+ uint32_t buffer_id;
+ int32_t count;
+ uint32_t type;
+ uint32_t offset;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
COMPILE_ASSERT(sizeof(GetMaxValueInBufferCHROMIUM) == 28,
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;
+struct EnableFeatureCHROMIUM {
+ typedef EnableFeatureCHROMIUM ValueType;
+ static const CommandId kCmdId = kEnableFeatureCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ typedef GLint Result;
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _namespace_id,
- GLuint _id_offset,
- GLsizei _n,
- uint32 _ids_shm_id,
- uint32 _ids_shm_offset) {
+ void Init(GLuint _bucket_id,
+ uint32_t _result_shm_id,
+ uint32_t _result_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;
+ bucket_id = _bucket_id;
+ result_shm_id = _result_shm_id;
+ result_shm_offset = _result_shm_offset;
}
void* Set(void* cmd,
- GLuint _namespace_id,
- GLuint _id_offset,
- GLsizei _n,
- uint32 _ids_shm_id,
- uint32 _ids_shm_offset) {
+ GLuint _bucket_id,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
- ->Init(_namespace_id, _id_offset, _n, _ids_shm_id, _ids_shm_offset);
+ ->Init(_bucket_id, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 namespace_id;
- uint32 id_offset;
- int32 n;
- uint32 ids_shm_id;
- uint32 ids_shm_offset;
+ uint32_t bucket_id;
+ uint32_t result_shm_id;
+ uint32_t result_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);
+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 DeleteSharedIdsCHROMIUM {
- typedef DeleteSharedIdsCHROMIUM ValueType;
- static const CommandId kCmdId = kDeleteSharedIdsCHROMIUM;
+struct ResizeCHROMIUM {
+ typedef ResizeCHROMIUM ValueType;
+ static const CommandId kCmdId = kResizeCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset);
- return NextCmdAddress<ValueType>(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;
- static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- typedef GLint Result;
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_bucket_id, _result_shm_id, _result_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 width;
- uint32 height;
+ uint32_t width;
+ uint32_t height;
float scale_factor;
};
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(uint32 _bucket_id) {
+ void Init(uint32_t _bucket_id) {
SetHeader();
bucket_id = _bucket_id;
}
- void* Set(void* cmd, uint32 _bucket_id) {
+ void* Set(void* cmd, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 bucket_id;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetRequestableExtensionsCHROMIUM) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(uint32 _bucket_id) {
+ void Init(uint32_t _bucket_id) {
SetHeader();
bucket_id = _bucket_id;
}
- void* Set(void* cmd, uint32 _bucket_id) {
+ void* Set(void* cmd, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 bucket_id;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(RequestExtensionCHROMIUM) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(uint32 _pnames_shm_id,
- uint32 _pnames_shm_offset,
+ void Init(uint32_t _pnames_shm_id,
+ uint32_t _pnames_shm_offset,
GLuint _count,
- uint32 _results_shm_id,
- uint32 _results_shm_offset,
+ uint32_t _results_shm_id,
+ uint32_t _results_shm_offset,
GLsizeiptr _size) {
SetHeader();
pnames_shm_id = _pnames_shm_id;
}
void* Set(void* cmd,
- uint32 _pnames_shm_id,
- uint32 _pnames_shm_offset,
+ uint32_t _pnames_shm_id,
+ uint32_t _pnames_shm_offset,
GLuint _count,
- uint32 _results_shm_id,
- uint32 _results_shm_offset,
+ uint32_t _results_shm_id,
+ uint32_t _results_shm_offset,
GLsizeiptr _size) {
- static_cast<ValueType*>(cmd)->Init(_pnames_shm_id,
- _pnames_shm_offset,
- _count,
- _results_shm_id,
- _results_shm_offset,
- _size);
+ static_cast<ValueType*>(cmd)->Init(_pnames_shm_id, _pnames_shm_offset,
+ _count, _results_shm_id,
+ _results_shm_offset, _size);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 pnames_shm_id;
- uint32 pnames_shm_offset;
- uint32 count;
- uint32 results_shm_id;
- uint32 results_shm_offset;
- int32 size;
+ uint32_t pnames_shm_id;
+ uint32_t pnames_shm_offset;
+ uint32_t count;
+ uint32_t results_shm_id;
+ uint32_t results_shm_offset;
+ int32_t size;
};
COMPILE_ASSERT(sizeof(GetMultipleIntegervCHROMIUM) == 28,
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
struct Result {
- uint32 link_status;
- uint32 num_attribs;
- uint32 num_uniforms;
+ uint32_t link_status;
+ uint32_t num_attribs;
+ uint32_t num_uniforms;
};
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program, uint32 _bucket_id) {
+ void Init(GLuint _program, uint32_t _bucket_id) {
SetHeader();
program = _program;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLuint _program, uint32 _bucket_id) {
+ void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_program, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- uint32 bucket_id;
+ uint32_t program;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetProgramInfoCHROMIUM) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _shader, uint32 _bucket_id) {
+ void Init(GLuint _shader, uint32_t _bucket_id) {
SetHeader();
shader = _shader;
bucket_id = _bucket_id;
}
- void* Set(void* cmd, GLuint _shader, uint32 _bucket_id) {
+ void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 shader;
- uint32 bucket_id;
+ uint32_t shader;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(GetTranslatedShaderSourceANGLE) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- int32 x;
- int32 y;
- int32 width;
- int32 height;
+ int32_t x;
+ int32_t y;
+ int32_t width;
+ int32_t height;
};
COMPILE_ASSERT(sizeof(PostSubBufferCHROMIUM) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 width;
- int32 height;
- uint32 ioSurfaceId;
- uint32 plane;
+ uint32_t target;
+ int32_t width;
+ int32_t height;
+ uint32_t ioSurfaceId;
+ uint32_t plane;
};
COMPILE_ASSERT(sizeof(TexImageIOSurface2DCHROMIUM) == 24,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLint _level,
GLint _internalformat,
GLenum _dest_type) {
- static_cast<ValueType*>(cmd)->Init(
- _target, _source_id, _dest_id, _level, _internalformat, _dest_type);
+ static_cast<ValueType*>(cmd)->Init(_target, _source_id, _dest_id, _level,
+ _internalformat, _dest_type);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 source_id;
- uint32 dest_id;
- int32 level;
- int32 internalformat;
- uint32 dest_type;
+ uint32_t target;
+ uint32_t source_id;
+ uint32_t dest_id;
+ int32_t level;
+ int32_t internalformat;
+ uint32_t dest_type;
};
COMPILE_ASSERT(sizeof(CopyTextureCHROMIUM) == 28,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
- int32 first;
- int32 count;
- int32 primcount;
+ uint32_t mode;
+ int32_t first;
+ int32_t count;
+ int32_t primcount;
};
COMPILE_ASSERT(sizeof(DrawArraysInstancedANGLE) == 20,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 mode;
- int32 count;
- uint32 type;
- uint32 index_offset;
- int32 primcount;
+ uint32_t mode;
+ int32_t count;
+ uint32_t type;
+ uint32_t index_offset;
+ int32_t primcount;
};
COMPILE_ASSERT(sizeof(DrawElementsInstancedANGLE) == 24,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 index;
- uint32 divisor;
+ uint32_t index;
+ uint32_t divisor;
};
COMPILE_ASSERT(sizeof(VertexAttribDivisorANGLE) == 12,
COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, divisor) == 8,
OffsetOf_VertexAttribDivisorANGLE_divisor_not_8);
-struct ProduceTextureCHROMIUM {
- typedef ProduceTextureCHROMIUM ValueType;
- static const CommandId kCmdId = kProduceTextureCHROMIUM;
- static const cmd::ArgFlags kArgFlags = cmd::kFixed;
- static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)
- ->Init(_target, _mailbox_shm_id, _mailbox_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLbyte) * 64); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) {
static_cast<ValueType*>(cmd)->Init(_target, _mailbox);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
+ uint32_t target;
};
COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUMImmediate) == 8,
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;
+struct ProduceTextureDirectCHROMIUMImmediate {
+ typedef ProduceTextureDirectCHROMIUMImmediate ValueType;
+ static const CommandId kCmdId = kProduceTextureDirectCHROMIUMImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
}
- void SetHeader() { header.SetCmd<ValueType>(); }
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
+ }
- void Init(GLenum _target,
- uint32 _mailbox_shm_id,
- uint32 _mailbox_shm_offset) {
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLuint _texture, GLenum _target, const GLbyte* _mailbox) {
SetHeader();
+ texture = _texture;
target = _target;
- mailbox_shm_id = _mailbox_shm_id;
- mailbox_shm_offset = _mailbox_shm_offset;
+ memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize());
}
void* Set(void* cmd,
+ GLuint _texture,
GLenum _target,
- uint32 _mailbox_shm_id,
- uint32 _mailbox_shm_offset) {
- static_cast<ValueType*>(cmd)
- ->Init(_target, _mailbox_shm_id, _mailbox_shm_offset);
- return NextCmdAddress<ValueType>(cmd);
+ const GLbyte* _mailbox) {
+ static_cast<ValueType*>(cmd)->Init(_texture, _target, _mailbox);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
- uint32 mailbox_shm_id;
- uint32 mailbox_shm_offset;
+ uint32_t texture;
+ uint32_t target;
};
-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);
+COMPILE_ASSERT(sizeof(ProduceTextureDirectCHROMIUMImmediate) == 12,
+ Sizeof_ProduceTextureDirectCHROMIUMImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, header) == 0,
+ OffsetOf_ProduceTextureDirectCHROMIUMImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, texture) == 4,
+ OffsetOf_ProduceTextureDirectCHROMIUMImmediate_texture_not_4);
+COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, target) == 8,
+ OffsetOf_ProduceTextureDirectCHROMIUMImmediate_target_not_8);
struct ConsumeTextureCHROMIUMImmediate {
typedef ConsumeTextureCHROMIUMImmediate ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeDataSize() {
- return static_cast<uint32>(sizeof(GLbyte) * 64); // NOLINT
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
}
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) {
static_cast<ValueType*>(cmd)->Init(_target, _mailbox);
- const uint32 size = ComputeSize();
+ const uint32_t size = ComputeSize();
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
+ uint32_t target;
};
COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUMImmediate) == 8,
COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, target) == 4,
OffsetOf_ConsumeTextureCHROMIUMImmediate_target_not_4);
-struct BindUniformLocationCHROMIUM {
- typedef BindUniformLocationCHROMIUM ValueType;
- static const CommandId kCmdId = kBindUniformLocationCHROMIUM;
+struct BindUniformLocationCHROMIUMBucket {
+ typedef BindUniformLocationCHROMIUMBucket ValueType;
+ static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program,
- GLint _location,
- uint32 _name_shm_id,
- uint32 _name_shm_offset,
- uint32 _data_size) {
+ void Init(GLuint _program, GLint _location, uint32_t _name_bucket_id) {
SetHeader();
program = _program;
location = _location;
- name_shm_id = _name_shm_id;
- name_shm_offset = _name_shm_offset;
- data_size = _data_size;
+ name_bucket_id = _name_bucket_id;
}
void* Set(void* cmd,
GLuint _program,
GLint _location,
- uint32 _name_shm_id,
- uint32 _name_shm_offset,
- uint32 _data_size) {
+ uint32_t _name_bucket_id) {
+ static_cast<ValueType*>(cmd)->Init(_program, _location, _name_bucket_id);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t program;
+ int32_t location;
+ uint32_t 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);
+
+struct GenValuebuffersCHROMIUMImmediate {
+ typedef GenValuebuffersCHROMIUMImmediate ValueType;
+ static const CommandId kCmdId = kGenValuebuffersCHROMIUMImmediate;
+ 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(GenValuebuffersCHROMIUMImmediate) == 8,
+ Sizeof_GenValuebuffersCHROMIUMImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(GenValuebuffersCHROMIUMImmediate, header) == 0,
+ OffsetOf_GenValuebuffersCHROMIUMImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(GenValuebuffersCHROMIUMImmediate, n) == 4,
+ OffsetOf_GenValuebuffersCHROMIUMImmediate_n_not_4);
+
+struct DeleteValuebuffersCHROMIUMImmediate {
+ typedef DeleteValuebuffersCHROMIUMImmediate ValueType;
+ static const CommandId kCmdId = kDeleteValuebuffersCHROMIUMImmediate;
+ 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* _valuebuffers) {
+ SetHeader(_n);
+ n = _n;
+ memcpy(ImmediateDataAddress(this), _valuebuffers, ComputeDataSize(_n));
+ }
+
+ void* Set(void* cmd, GLsizei _n, const GLuint* _valuebuffers) {
+ static_cast<ValueType*>(cmd)->Init(_n, _valuebuffers);
+ const uint32_t size = ComputeSize(_n);
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ int32_t n;
+};
+
+COMPILE_ASSERT(sizeof(DeleteValuebuffersCHROMIUMImmediate) == 8,
+ Sizeof_DeleteValuebuffersCHROMIUMImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(DeleteValuebuffersCHROMIUMImmediate, header) == 0,
+ OffsetOf_DeleteValuebuffersCHROMIUMImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(DeleteValuebuffersCHROMIUMImmediate, n) == 4,
+ OffsetOf_DeleteValuebuffersCHROMIUMImmediate_n_not_4);
+
+struct IsValuebufferCHROMIUM {
+ typedef IsValuebufferCHROMIUM ValueType;
+ static const CommandId kCmdId = kIsValuebufferCHROMIUM;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ typedef uint32_t Result;
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _valuebuffer,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
+ SetHeader();
+ valuebuffer = _valuebuffer;
+ result_shm_id = _result_shm_id;
+ result_shm_offset = _result_shm_offset;
+ }
+
+ void* Set(void* cmd,
+ GLuint _valuebuffer,
+ uint32_t _result_shm_id,
+ uint32_t _result_shm_offset) {
static_cast<ValueType*>(cmd)
- ->Init(_program, _location, _name_shm_id, _name_shm_offset, _data_size);
+ ->Init(_valuebuffer, _result_shm_id, _result_shm_offset);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- int32 location;
- uint32 name_shm_id;
- uint32 name_shm_offset;
- uint32 data_size;
+ uint32_t valuebuffer;
+ uint32_t result_shm_id;
+ uint32_t result_shm_offset;
};
-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);
+COMPILE_ASSERT(sizeof(IsValuebufferCHROMIUM) == 16,
+ Sizeof_IsValuebufferCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, header) == 0,
+ OffsetOf_IsValuebufferCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, valuebuffer) == 4,
+ OffsetOf_IsValuebufferCHROMIUM_valuebuffer_not_4);
+COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, result_shm_id) == 8,
+ OffsetOf_IsValuebufferCHROMIUM_result_shm_id_not_8);
+COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, result_shm_offset) == 12,
+ OffsetOf_IsValuebufferCHROMIUM_result_shm_offset_not_12);
-struct BindUniformLocationCHROMIUMBucket {
- typedef BindUniformLocationCHROMIUMBucket ValueType;
- static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket;
+struct BindValuebufferCHROMIUM {
+ typedef BindValuebufferCHROMIUM ValueType;
+ static const CommandId kCmdId = kBindValuebufferCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _program, GLint _location, uint32 _name_bucket_id) {
+ void Init(GLenum _target, GLuint _valuebuffer) {
+ SetHeader();
+ target = _target;
+ valuebuffer = _valuebuffer;
+ }
+
+ void* Set(void* cmd, GLenum _target, GLuint _valuebuffer) {
+ static_cast<ValueType*>(cmd)->Init(_target, _valuebuffer);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t target;
+ uint32_t valuebuffer;
+};
+
+COMPILE_ASSERT(sizeof(BindValuebufferCHROMIUM) == 12,
+ Sizeof_BindValuebufferCHROMIUM_is_not_12);
+COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, header) == 0,
+ OffsetOf_BindValuebufferCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, target) == 4,
+ OffsetOf_BindValuebufferCHROMIUM_target_not_4);
+COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, valuebuffer) == 8,
+ OffsetOf_BindValuebufferCHROMIUM_valuebuffer_not_8);
+
+struct SubscribeValueCHROMIUM {
+ typedef SubscribeValueCHROMIUM ValueType;
+ static const CommandId kCmdId = kSubscribeValueCHROMIUM;
+ 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 _subscription) {
+ SetHeader();
+ target = _target;
+ subscription = _subscription;
+ }
+
+ void* Set(void* cmd, GLenum _target, GLenum _subscription) {
+ static_cast<ValueType*>(cmd)->Init(_target, _subscription);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t target;
+ uint32_t subscription;
+};
+
+COMPILE_ASSERT(sizeof(SubscribeValueCHROMIUM) == 12,
+ Sizeof_SubscribeValueCHROMIUM_is_not_12);
+COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, header) == 0,
+ OffsetOf_SubscribeValueCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, target) == 4,
+ OffsetOf_SubscribeValueCHROMIUM_target_not_4);
+COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, subscription) == 8,
+ OffsetOf_SubscribeValueCHROMIUM_subscription_not_8);
+
+struct PopulateSubscribedValuesCHROMIUM {
+ typedef PopulateSubscribedValuesCHROMIUM ValueType;
+ static const CommandId kCmdId = kPopulateSubscribedValuesCHROMIUM;
+ 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(PopulateSubscribedValuesCHROMIUM) == 8,
+ Sizeof_PopulateSubscribedValuesCHROMIUM_is_not_8);
+COMPILE_ASSERT(offsetof(PopulateSubscribedValuesCHROMIUM, header) == 0,
+ OffsetOf_PopulateSubscribedValuesCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(PopulateSubscribedValuesCHROMIUM, target) == 4,
+ OffsetOf_PopulateSubscribedValuesCHROMIUM_target_not_4);
+
+struct UniformValuebufferCHROMIUM {
+ typedef UniformValuebufferCHROMIUM ValueType;
+ static const CommandId kCmdId = kUniformValuebufferCHROMIUM;
+ 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 _location, GLenum _target, GLenum _subscription) {
SetHeader();
- program = _program;
location = _location;
- name_bucket_id = _name_bucket_id;
+ target = _target;
+ subscription = _subscription;
}
- void* Set(void* cmd,
- GLuint _program,
- GLint _location,
- uint32 _name_bucket_id) {
- static_cast<ValueType*>(cmd)->Init(_program, _location, _name_bucket_id);
+ void* Set(void* cmd, GLint _location, GLenum _target, GLenum _subscription) {
+ static_cast<ValueType*>(cmd)->Init(_location, _target, _subscription);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32 program;
- int32 location;
- uint32 name_bucket_id;
+ int32_t location;
+ uint32_t target;
+ uint32_t subscription;
};
-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);
+COMPILE_ASSERT(sizeof(UniformValuebufferCHROMIUM) == 16,
+ Sizeof_UniformValuebufferCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, header) == 0,
+ OffsetOf_UniformValuebufferCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, location) == 4,
+ OffsetOf_UniformValuebufferCHROMIUM_location_not_4);
+COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, target) == 8,
+ OffsetOf_UniformValuebufferCHROMIUM_target_not_8);
+COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, subscription) == 12,
+ OffsetOf_UniformValuebufferCHROMIUM_subscription_not_12);
struct BindTexImage2DCHROMIUM {
typedef BindTexImage2DCHROMIUM ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 imageId;
+ uint32_t target;
+ int32_t imageId;
};
COMPILE_ASSERT(sizeof(BindTexImage2DCHROMIUM) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
- int32 imageId;
+ uint32_t target;
+ int32_t imageId;
};
COMPILE_ASSERT(sizeof(ReleaseTexImage2DCHROMIUM) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 bucket_id;
+ uint32_t bucket_id;
};
COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
+ uint32_t _data_shm_id,
+ uint32_t _data_shm_offset,
+ uint32_t _async_upload_token,
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_shm_offset) {
SetHeader();
target = _target;
level = _level;
type = _type;
data_shm_id = _data_shm_id;
data_shm_offset = _data_shm_offset;
+ async_upload_token = _async_upload_token;
+ sync_data_shm_id = _sync_data_shm_id;
+ sync_data_shm_offset = _sync_data_shm_offset;
}
void* Set(void* cmd,
GLsizei _height,
GLenum _format,
GLenum _type,
- uint32 _data_shm_id,
- uint32 _data_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _xoffset,
- _yoffset,
- _width,
- _height,
- _format,
- _type,
- _data_shm_id,
- _data_shm_offset);
+ uint32_t _data_shm_id,
+ uint32_t _data_shm_offset,
+ uint32_t _async_upload_token,
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_shm_offset) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _level, _xoffset, _yoffset, _width, _height, _format,
+ _type, _data_shm_id, _data_shm_offset, _async_upload_token,
+ _sync_data_shm_id, _sync_data_shm_offset);
return NextCmdAddress<ValueType>(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;
+ uint32_t target;
+ int32_t level;
+ int32_t xoffset;
+ int32_t yoffset;
+ int32_t width;
+ int32_t height;
+ uint32_t format;
+ uint32_t type;
+ uint32_t data_shm_id;
+ uint32_t data_shm_offset;
+ uint32_t async_upload_token;
+ uint32_t sync_data_shm_id;
+ uint32_t sync_data_shm_offset;
};
-COMPILE_ASSERT(sizeof(AsyncTexSubImage2DCHROMIUM) == 44,
- Sizeof_AsyncTexSubImage2DCHROMIUM_is_not_44);
+COMPILE_ASSERT(sizeof(AsyncTexSubImage2DCHROMIUM) == 56,
+ Sizeof_AsyncTexSubImage2DCHROMIUM_is_not_56);
COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, header) == 0,
OffsetOf_AsyncTexSubImage2DCHROMIUM_header_not_0);
COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, target) == 4,
OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_id_not_36);
COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_offset) == 40,
OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_offset_not_40);
+COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, async_upload_token) == 44,
+ OffsetOf_AsyncTexSubImage2DCHROMIUM_async_upload_token_not_44);
+COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_id) == 48,
+ OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_id_not_48);
+COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_offset) == 52,
+ OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_offset_not_52);
struct AsyncTexImage2DCHROMIUM {
typedef AsyncTexImage2DCHROMIUM ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
GLint _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset) {
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
+ uint32_t _async_upload_token,
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_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;
+ async_upload_token = _async_upload_token;
+ sync_data_shm_id = _sync_data_shm_id;
+ sync_data_shm_offset = _sync_data_shm_offset;
}
void* Set(void* cmd,
GLint _internalformat,
GLsizei _width,
GLsizei _height,
- GLint _border,
GLenum _format,
GLenum _type,
- uint32 _pixels_shm_id,
- uint32 _pixels_shm_offset) {
- static_cast<ValueType*>(cmd)->Init(_target,
- _level,
- _internalformat,
- _width,
- _height,
- _border,
- _format,
- _type,
- _pixels_shm_id,
- _pixels_shm_offset);
+ uint32_t _pixels_shm_id,
+ uint32_t _pixels_shm_offset,
+ uint32_t _async_upload_token,
+ uint32_t _sync_data_shm_id,
+ uint32_t _sync_data_shm_offset) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _level, _internalformat, _width, _height, _format,
+ _type, _pixels_shm_id, _pixels_shm_offset, _async_upload_token,
+ _sync_data_shm_id, _sync_data_shm_offset);
return NextCmdAddress<ValueType>(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;
+ uint32_t target;
+ int32_t level;
+ int32_t internalformat;
+ int32_t width;
+ int32_t height;
+ uint32_t format;
+ uint32_t type;
+ uint32_t pixels_shm_id;
+ uint32_t pixels_shm_offset;
+ uint32_t async_upload_token;
+ uint32_t sync_data_shm_id;
+ uint32_t sync_data_shm_offset;
+ static const int32_t border = 0;
};
-COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 44,
- Sizeof_AsyncTexImage2DCHROMIUM_is_not_44);
+COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 52,
+ Sizeof_AsyncTexImage2DCHROMIUM_is_not_52);
COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, header) == 0,
OffsetOf_AsyncTexImage2DCHROMIUM_header_not_0);
COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, target) == 4,
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);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 24,
+ OffsetOf_AsyncTexImage2DCHROMIUM_format_not_24);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 28,
+ OffsetOf_AsyncTexImage2DCHROMIUM_type_not_28);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 32,
+ OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_32);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 36,
+ OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_36);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 40,
+ OffsetOf_AsyncTexImage2DCHROMIUM_async_upload_token_not_40);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 44,
+ OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_id_not_44);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 48,
+ OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_offset_not_48);
struct WaitAsyncTexImage2DCHROMIUM {
typedef WaitAsyncTexImage2DCHROMIUM ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 target;
+ uint32_t target;
};
COMPILE_ASSERT(sizeof(WaitAsyncTexImage2DCHROMIUM) == 8,
COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, target) == 4,
OffsetOf_WaitAsyncTexImage2DCHROMIUM_target_not_4);
-struct DiscardFramebufferEXT {
- typedef DiscardFramebufferEXT ValueType;
- static const CommandId kCmdId = kDiscardFramebufferEXT;
+struct WaitAllAsyncTexImage2DCHROMIUM {
+ typedef WaitAllAsyncTexImage2DCHROMIUM ValueType;
+ static const CommandId kCmdId = kWaitAllAsyncTexImage2DCHROMIUM;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
- 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 Init() { SetHeader(); }
- void* Set(void* cmd,
- GLenum _target,
- GLsizei _count,
- uint32 _attachments_shm_id,
- uint32 _attachments_shm_offset) {
- static_cast<ValueType*>(cmd)
- ->Init(_target, _count, _attachments_shm_id, _attachments_shm_offset);
+ void* Set(void* cmd) {
+ static_cast<ValueType*>(cmd)->Init();
return NextCmdAddress<ValueType>(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);
+COMPILE_ASSERT(sizeof(WaitAllAsyncTexImage2DCHROMIUM) == 4,
+ Sizeof_WaitAllAsyncTexImage2DCHROMIUM_is_not_4);
+COMPILE_ASSERT(offsetof(WaitAllAsyncTexImage2DCHROMIUM, header) == 0,
+ OffsetOf_WaitAllAsyncTexImage2DCHROMIUM_header_not_0);
struct DiscardFramebufferEXTImmediate {
typedef DiscardFramebufferEXTImmediate ValueType;
static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLenum) * 1 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLenum) * 1 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
GLsizei _count,
const GLenum* _attachments) {
static_cast<ValueType*>(cmd)->Init(_target, _count, _attachments);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- uint32 target;
- int32 count;
+ uint32_t target;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(DiscardFramebufferEXTImmediate) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 current;
- uint32 other;
+ uint32_t current;
+ uint32_t other;
};
COMPILE_ASSERT(sizeof(LoseContextCHROMIUM) == 12,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
}
gpu::CommandHeader header;
- uint32 sync_point;
+ uint32_t sync_point;
};
COMPILE_ASSERT(sizeof(WaitSyncPointCHROMIUM) == 8,
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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
- }
-
- void SetHeader() { header.SetCmd<ValueType>(); }
-
- 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<ValueType*>(cmd)->Init(_count, _bufs_shm_id, _bufs_shm_offset);
- return NextCmdAddress<ValueType>(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 const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeDataSize(GLsizei count) {
- return static_cast<uint32>(sizeof(GLenum) * 1 * count); // NOLINT
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLenum) * 1 * count); // NOLINT
}
- static uint32 ComputeSize(GLsizei count) {
- return static_cast<uint32>(sizeof(ValueType) +
- ComputeDataSize(count)); // NOLINT
+ static uint32_t ComputeSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize(count)); // NOLINT
}
void SetHeader(GLsizei count) {
void* Set(void* cmd, GLsizei _count, const GLenum* _bufs) {
static_cast<ValueType*>(cmd)->Init(_count, _bufs);
- const uint32 size = ComputeSize(_count);
+ const uint32_t size = ComputeSize(_count);
return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
}
gpu::CommandHeader header;
- int32 count;
+ int32_t count;
};
COMPILE_ASSERT(sizeof(DrawBuffersEXTImmediate) == 8,
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
- static uint32 ComputeSize() {
- return static_cast<uint32>(sizeof(ValueType)); // NOLINT
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
}
void SetHeader() { header.SetCmd<ValueType>(); }
COMPILE_ASSERT(offsetof(DiscardBackbufferCHROMIUM, header) == 0,
OffsetOf_DiscardBackbufferCHROMIUM_header_not_0);
+struct ScheduleOverlayPlaneCHROMIUM {
+ typedef ScheduleOverlayPlaneCHROMIUM ValueType;
+ static const CommandId kCmdId = kScheduleOverlayPlaneCHROMIUM;
+ 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 _plane_z_order,
+ GLenum _plane_transform,
+ GLuint _overlay_texture_id,
+ GLint _bounds_x,
+ GLint _bounds_y,
+ GLint _bounds_width,
+ GLint _bounds_height,
+ GLfloat _uv_x,
+ GLfloat _uv_y,
+ GLfloat _uv_width,
+ GLfloat _uv_height) {
+ SetHeader();
+ plane_z_order = _plane_z_order;
+ plane_transform = _plane_transform;
+ overlay_texture_id = _overlay_texture_id;
+ bounds_x = _bounds_x;
+ bounds_y = _bounds_y;
+ bounds_width = _bounds_width;
+ bounds_height = _bounds_height;
+ uv_x = _uv_x;
+ uv_y = _uv_y;
+ uv_width = _uv_width;
+ uv_height = _uv_height;
+ }
+
+ void* Set(void* cmd,
+ GLint _plane_z_order,
+ GLenum _plane_transform,
+ GLuint _overlay_texture_id,
+ GLint _bounds_x,
+ GLint _bounds_y,
+ GLint _bounds_width,
+ GLint _bounds_height,
+ GLfloat _uv_x,
+ GLfloat _uv_y,
+ GLfloat _uv_width,
+ GLfloat _uv_height) {
+ static_cast<ValueType*>(cmd)->Init(_plane_z_order, _plane_transform,
+ _overlay_texture_id, _bounds_x,
+ _bounds_y, _bounds_width, _bounds_height,
+ _uv_x, _uv_y, _uv_width, _uv_height);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t plane_z_order;
+ uint32_t plane_transform;
+ uint32_t overlay_texture_id;
+ int32_t bounds_x;
+ int32_t bounds_y;
+ int32_t bounds_width;
+ int32_t bounds_height;
+ float uv_x;
+ float uv_y;
+ float uv_width;
+ float uv_height;
+};
+
+COMPILE_ASSERT(sizeof(ScheduleOverlayPlaneCHROMIUM) == 48,
+ Sizeof_ScheduleOverlayPlaneCHROMIUM_is_not_48);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, header) == 0,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_z_order) == 4,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_z_order_not_4);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_transform) == 8,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_transform_not_8);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, overlay_texture_id) == 12,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_overlay_texture_id_not_12);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_x) == 16,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_x_not_16);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_y) == 20,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_y_not_20);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_width) == 24,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_width_not_24);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_height) == 28,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_height_not_28);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_x) == 32,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_x_not_32);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_y) == 36,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_y_not_36);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_width) == 40,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_width_not_40);
+COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_height) == 44,
+ OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_height_not_44);
+
+struct MatrixLoadfCHROMIUMImmediate {
+ typedef MatrixLoadfCHROMIUMImmediate ValueType;
+ static const CommandId kCmdId = kMatrixLoadfCHROMIUMImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 16); // NOLINT
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLenum _matrixMode, const GLfloat* _m) {
+ SetHeader();
+ matrixMode = _matrixMode;
+ memcpy(ImmediateDataAddress(this), _m, ComputeDataSize());
+ }
+
+ void* Set(void* cmd, GLenum _matrixMode, const GLfloat* _m) {
+ static_cast<ValueType*>(cmd)->Init(_matrixMode, _m);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t matrixMode;
+};
+
+COMPILE_ASSERT(sizeof(MatrixLoadfCHROMIUMImmediate) == 8,
+ Sizeof_MatrixLoadfCHROMIUMImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(MatrixLoadfCHROMIUMImmediate, header) == 0,
+ OffsetOf_MatrixLoadfCHROMIUMImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(MatrixLoadfCHROMIUMImmediate, matrixMode) == 4,
+ OffsetOf_MatrixLoadfCHROMIUMImmediate_matrixMode_not_4);
+
+struct MatrixLoadIdentityCHROMIUM {
+ typedef MatrixLoadIdentityCHROMIUM ValueType;
+ static const CommandId kCmdId = kMatrixLoadIdentityCHROMIUM;
+ 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 _matrixMode) {
+ SetHeader();
+ matrixMode = _matrixMode;
+ }
+
+ void* Set(void* cmd, GLenum _matrixMode) {
+ static_cast<ValueType*>(cmd)->Init(_matrixMode);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t matrixMode;
+};
+
+COMPILE_ASSERT(sizeof(MatrixLoadIdentityCHROMIUM) == 8,
+ Sizeof_MatrixLoadIdentityCHROMIUM_is_not_8);
+COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0,
+ OffsetOf_MatrixLoadIdentityCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4,
+ OffsetOf_MatrixLoadIdentityCHROMIUM_matrixMode_not_4);
+
+struct BlendBarrierKHR {
+ typedef BlendBarrierKHR ValueType;
+ static const CommandId kCmdId = kBlendBarrierKHR;
+ 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(BlendBarrierKHR) == 4, Sizeof_BlendBarrierKHR_is_not_4);
+COMPILE_ASSERT(offsetof(BlendBarrierKHR, header) == 0,
+ OffsetOf_BlendBarrierKHR_header_not_0);
+
#endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_
projects / platform / framework / web / crosswalk.git / blobdiff