Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(170)

Unified Diff: gpu/command_buffer/common/gles2_cmd_format_autogen.h

Issue 761903003: Update from https://crrev.com/306655 (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: gpu/command_buffer/common/gles2_cmd_format_autogen.h
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 14f07282789ea29a0ddd7327d4489544924bd3d2..c451b98ba72c667033915459c225764860c5f3c7 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -1168,6 +1168,65 @@ COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36,
COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40,
OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40);
+struct CopyBufferSubData {
+ typedef CopyBufferSubData ValueType;
+ static const CommandId kCmdId = kCopyBufferSubData;
+ 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 _readtarget,
+ GLenum _writetarget,
+ GLintptr _readoffset,
+ GLintptr _writeoffset,
+ GLsizeiptr _size) {
+ SetHeader();
+ readtarget = _readtarget;
+ writetarget = _writetarget;
+ readoffset = _readoffset;
+ writeoffset = _writeoffset;
+ size = _size;
+ }
+
+ void* Set(void* cmd,
+ GLenum _readtarget,
+ GLenum _writetarget,
+ GLintptr _readoffset,
+ GLintptr _writeoffset,
+ GLsizeiptr _size) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_readtarget, _writetarget, _readoffset, _writeoffset, _size);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t readtarget;
+ uint32_t writetarget;
+ int32_t readoffset;
+ int32_t writeoffset;
+ int32_t size;
+};
+
+COMPILE_ASSERT(sizeof(CopyBufferSubData) == 24,
+ Sizeof_CopyBufferSubData_is_not_24);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, header) == 0,
+ OffsetOf_CopyBufferSubData_header_not_0);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, readtarget) == 4,
+ OffsetOf_CopyBufferSubData_readtarget_not_4);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, writetarget) == 8,
+ OffsetOf_CopyBufferSubData_writetarget_not_8);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, readoffset) == 12,
+ OffsetOf_CopyBufferSubData_readoffset_not_12);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, writeoffset) == 16,
+ OffsetOf_CopyBufferSubData_writeoffset_not_16);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, size) == 20,
+ OffsetOf_CopyBufferSubData_size_not_20);
+
struct CopyTexImage2D {
typedef CopyTexImage2D ValueType;
static const CommandId kCmdId = kCopyTexImage2D;
@@ -2150,6 +2209,65 @@ COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12,
COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16,
OffsetOf_FramebufferTexture2D_texture_not_16);
+struct FramebufferTextureLayer {
+ typedef FramebufferTextureLayer ValueType;
+ static const CommandId kCmdId = kFramebufferTextureLayer;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLenum _target,
+ GLenum _attachment,
+ GLuint _texture,
+ GLint _level,
+ GLint _layer) {
+ SetHeader();
+ target = _target;
+ attachment = _attachment;
+ texture = _texture;
+ level = _level;
+ layer = _layer;
+ }
+
+ void* Set(void* cmd,
+ GLenum _target,
+ GLenum _attachment,
+ GLuint _texture,
+ GLint _level,
+ GLint _layer) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _attachment, _texture, _level, _layer);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t target;
+ uint32_t attachment;
+ uint32_t texture;
+ int32_t level;
+ int32_t layer;
+};
+
+COMPILE_ASSERT(sizeof(FramebufferTextureLayer) == 24,
+ Sizeof_FramebufferTextureLayer_is_not_24);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, header) == 0,
+ OffsetOf_FramebufferTextureLayer_header_not_0);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, target) == 4,
+ OffsetOf_FramebufferTextureLayer_target_not_4);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, attachment) == 8,
+ OffsetOf_FramebufferTextureLayer_attachment_not_8);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, texture) == 12,
+ OffsetOf_FramebufferTextureLayer_texture_not_12);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, level) == 16,
+ OffsetOf_FramebufferTextureLayer_level_not_16);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, layer) == 20,
+ OffsetOf_FramebufferTextureLayer_layer_not_20);
+
struct FrontFace {
typedef FrontFace ValueType;
static const CommandId kCmdId = kFrontFace;
@@ -2930,6 +3048,73 @@ COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8,
COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12,
OffsetOf_GetIntegerv_params_shm_offset_not_12);
+struct GetInternalformativ {
+ typedef GetInternalformativ ValueType;
+ static const CommandId kCmdId = kGetInternalformativ;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ typedef SizedResult<GLint> Result;
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLenum _target,
+ GLenum _format,
+ GLenum _pname,
+ GLsizei _bufSize,
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
+ SetHeader();
+ target = _target;
+ format = _format;
+ pname = _pname;
+ bufSize = _bufSize;
+ params_shm_id = _params_shm_id;
+ params_shm_offset = _params_shm_offset;
+ }
+
+ void* Set(void* cmd,
+ GLenum _target,
+ GLenum _format,
+ GLenum _pname,
+ GLsizei _bufSize,
+ uint32_t _params_shm_id,
+ uint32_t _params_shm_offset) {
+ static_cast<ValueType*>(cmd)->Init(_target, _format, _pname, _bufSize,
+ _params_shm_id, _params_shm_offset);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t target;
+ uint32_t format;
+ uint32_t pname;
+ int32_t bufSize;
+ uint32_t params_shm_id;
+ uint32_t params_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetInternalformativ) == 28,
+ Sizeof_GetInternalformativ_is_not_28);
+COMPILE_ASSERT(offsetof(GetInternalformativ, header) == 0,
+ OffsetOf_GetInternalformativ_header_not_0);
+COMPILE_ASSERT(offsetof(GetInternalformativ, target) == 4,
+ OffsetOf_GetInternalformativ_target_not_4);
+COMPILE_ASSERT(offsetof(GetInternalformativ, format) == 8,
+ OffsetOf_GetInternalformativ_format_not_8);
+COMPILE_ASSERT(offsetof(GetInternalformativ, pname) == 12,
+ OffsetOf_GetInternalformativ_pname_not_12);
+COMPILE_ASSERT(offsetof(GetInternalformativ, bufSize) == 16,
+ OffsetOf_GetInternalformativ_bufSize_not_16);
+COMPILE_ASSERT(offsetof(GetInternalformativ, params_shm_id) == 20,
+ OffsetOf_GetInternalformativ_params_shm_id_not_20);
+COMPILE_ASSERT(offsetof(GetInternalformativ, params_shm_offset) == 24,
+ OffsetOf_GetInternalformativ_params_shm_offset_not_24);
+
struct GetProgramiv {
typedef GetProgramiv ValueType;
static const CommandId kCmdId = kGetProgramiv;
@@ -5093,6 +5278,70 @@ COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4,
COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8,
OffsetOf_TexParameterivImmediate_pname_not_8);
+struct TexStorage3D {
+ typedef TexStorage3D ValueType;
+ static const CommandId kCmdId = kTexStorage3D;
+ 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,
+ GLsizei _levels,
+ GLenum _internalFormat,
+ GLsizei _width,
+ GLsizei _height,
+ GLsizei _depth) {
+ SetHeader();
+ target = _target;
+ levels = _levels;
+ internalFormat = _internalFormat;
+ width = _width;
+ height = _height;
+ depth = _depth;
+ }
+
+ void* Set(void* cmd,
+ GLenum _target,
+ GLsizei _levels,
+ GLenum _internalFormat,
+ GLsizei _width,
+ GLsizei _height,
+ GLsizei _depth) {
+ static_cast<ValueType*>(cmd)
+ ->Init(_target, _levels, _internalFormat, _width, _height, _depth);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t target;
+ int32_t levels;
+ uint32_t internalFormat;
+ int32_t width;
+ int32_t height;
+ int32_t depth;
+};
+
+COMPILE_ASSERT(sizeof(TexStorage3D) == 28, Sizeof_TexStorage3D_is_not_28);
+COMPILE_ASSERT(offsetof(TexStorage3D, header) == 0,
+ OffsetOf_TexStorage3D_header_not_0);
+COMPILE_ASSERT(offsetof(TexStorage3D, target) == 4,
+ OffsetOf_TexStorage3D_target_not_4);
+COMPILE_ASSERT(offsetof(TexStorage3D, levels) == 8,
+ OffsetOf_TexStorage3D_levels_not_8);
+COMPILE_ASSERT(offsetof(TexStorage3D, internalFormat) == 12,
+ OffsetOf_TexStorage3D_internalFormat_not_12);
+COMPILE_ASSERT(offsetof(TexStorage3D, width) == 16,
+ OffsetOf_TexStorage3D_width_not_16);
+COMPILE_ASSERT(offsetof(TexStorage3D, height) == 20,
+ OffsetOf_TexStorage3D_height_not_20);
+COMPILE_ASSERT(offsetof(TexStorage3D, depth) == 24,
+ OffsetOf_TexStorage3D_depth_not_24);
+
struct TexSubImage2D {
typedef TexSubImage2D ValueType;
static const CommandId kCmdId = kTexSubImage2D;
@@ -5350,6 +5599,87 @@ COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4,
COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8,
OffsetOf_Uniform1ivImmediate_count_not_8);
+struct Uniform1ui {
+ typedef Uniform1ui ValueType;
+ static const CommandId kCmdId = kUniform1ui;
+ 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, GLuint _x) {
+ SetHeader();
+ location = _location;
+ x = _x;
+ }
+
+ void* Set(void* cmd, GLint _location, GLuint _x) {
+ static_cast<ValueType*>(cmd)->Init(_location, _x);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ uint32_t x;
+};
+
+COMPILE_ASSERT(sizeof(Uniform1ui) == 12, Sizeof_Uniform1ui_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform1ui, header) == 0,
+ OffsetOf_Uniform1ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform1ui, location) == 4,
+ OffsetOf_Uniform1ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform1ui, x) == 8, OffsetOf_Uniform1ui_x_not_8);
+
+struct Uniform1uivImmediate {
+ typedef Uniform1uivImmediate ValueType;
+ static const CommandId kCmdId = kUniform1uivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLuint) * 1 * 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, const GLuint* _v) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+ }
+
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+ const uint32_t size = ComputeSize(_count);
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform1uivImmediate) == 12,
+ Sizeof_Uniform1uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, header) == 0,
+ OffsetOf_Uniform1uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, location) == 4,
+ OffsetOf_Uniform1uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, count) == 8,
+ OffsetOf_Uniform1uivImmediate_count_not_8);
+
struct Uniform2f {
typedef Uniform2f ValueType;
static const CommandId kCmdId = kUniform2f;
@@ -5518,6 +5848,90 @@ COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4,
COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8,
OffsetOf_Uniform2ivImmediate_count_not_8);
+struct Uniform2ui {
+ typedef Uniform2ui ValueType;
+ static const CommandId kCmdId = kUniform2ui;
+ 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, GLuint _x, GLuint _y) {
+ SetHeader();
+ location = _location;
+ x = _x;
+ y = _y;
+ }
+
+ void* Set(void* cmd, GLint _location, GLuint _x, GLuint _y) {
+ static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ uint32_t x;
+ uint32_t y;
+};
+
+COMPILE_ASSERT(sizeof(Uniform2ui) == 16, Sizeof_Uniform2ui_is_not_16);
+COMPILE_ASSERT(offsetof(Uniform2ui, header) == 0,
+ OffsetOf_Uniform2ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform2ui, location) == 4,
+ OffsetOf_Uniform2ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform2ui, x) == 8, OffsetOf_Uniform2ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform2ui, y) == 12, OffsetOf_Uniform2ui_y_not_12);
+
+struct Uniform2uivImmediate {
+ typedef Uniform2uivImmediate ValueType;
+ static const CommandId kCmdId = kUniform2uivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLuint) * 2 * 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, const GLuint* _v) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+ }
+
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+ const uint32_t size = ComputeSize(_count);
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform2uivImmediate) == 12,
+ Sizeof_Uniform2uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, header) == 0,
+ OffsetOf_Uniform2uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, location) == 4,
+ OffsetOf_Uniform2uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, count) == 8,
+ OffsetOf_Uniform2uivImmediate_count_not_8);
+
struct Uniform3f {
typedef Uniform3f ValueType;
static const CommandId kCmdId = kUniform3f;
@@ -5692,9 +6106,9 @@ COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4,
COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8,
OffsetOf_Uniform3ivImmediate_count_not_8);
-struct Uniform4f {
- typedef Uniform4f ValueType;
- static const CommandId kCmdId = kUniform4f;
+struct Uniform3ui {
+ typedef Uniform3ui ValueType;
+ static const CommandId kCmdId = kUniform3ui;
static const cmd::ArgFlags kArgFlags = cmd::kFixed;
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
@@ -5704,7 +6118,94 @@ struct Uniform4f {
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
+ void Init(GLint _location, GLuint _x, GLuint _y, GLuint _z) {
+ SetHeader();
+ location = _location;
+ x = _x;
+ y = _y;
+ z = _z;
+ }
+
+ void* Set(void* cmd, GLint _location, GLuint _x, GLuint _y, GLuint _z) {
+ static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+};
+
+COMPILE_ASSERT(sizeof(Uniform3ui) == 20, Sizeof_Uniform3ui_is_not_20);
+COMPILE_ASSERT(offsetof(Uniform3ui, header) == 0,
+ OffsetOf_Uniform3ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform3ui, location) == 4,
+ OffsetOf_Uniform3ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform3ui, x) == 8, OffsetOf_Uniform3ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform3ui, y) == 12, OffsetOf_Uniform3ui_y_not_12);
+COMPILE_ASSERT(offsetof(Uniform3ui, z) == 16, OffsetOf_Uniform3ui_z_not_16);
+
+struct Uniform3uivImmediate {
+ typedef Uniform3uivImmediate ValueType;
+ static const CommandId kCmdId = kUniform3uivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLuint) * 3 * 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, const GLuint* _v) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+ }
+
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+ const uint32_t size = ComputeSize(_count);
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform3uivImmediate) == 12,
+ Sizeof_Uniform3uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, header) == 0,
+ OffsetOf_Uniform3uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, location) == 4,
+ OffsetOf_Uniform3uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, count) == 8,
+ OffsetOf_Uniform3uivImmediate_count_not_8);
+
+struct Uniform4f {
+ typedef Uniform4f ValueType;
+ static const CommandId kCmdId = kUniform4f;
+ 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, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
SetHeader();
location = _location;
x = _x;
@@ -5882,6 +6383,101 @@ COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8,
OffsetOf_Uniform4ivImmediate_count_not_8);
+struct Uniform4ui {
+ typedef Uniform4ui ValueType;
+ static const CommandId kCmdId = kUniform4ui;
+ 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, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
+ SetHeader();
+ location = _location;
+ x = _x;
+ y = _y;
+ z = _z;
+ w = _w;
+ }
+
+ void* Set(void* cmd,
+ GLint _location,
+ GLuint _x,
+ GLuint _y,
+ GLuint _z,
+ GLuint _w) {
+ static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+ uint32_t w;
+};
+
+COMPILE_ASSERT(sizeof(Uniform4ui) == 24, Sizeof_Uniform4ui_is_not_24);
+COMPILE_ASSERT(offsetof(Uniform4ui, header) == 0,
+ OffsetOf_Uniform4ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform4ui, location) == 4,
+ OffsetOf_Uniform4ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform4ui, x) == 8, OffsetOf_Uniform4ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform4ui, y) == 12, OffsetOf_Uniform4ui_y_not_12);
+COMPILE_ASSERT(offsetof(Uniform4ui, z) == 16, OffsetOf_Uniform4ui_z_not_16);
+COMPILE_ASSERT(offsetof(Uniform4ui, w) == 20, OffsetOf_Uniform4ui_w_not_20);
+
+struct Uniform4uivImmediate {
+ typedef Uniform4uivImmediate ValueType;
+ static const CommandId kCmdId = kUniform4uivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLuint) * 4 * 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, const GLuint* _v) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+ }
+
+ void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+ static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+ const uint32_t size = ComputeSize(_count);
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ int32_t location;
+ int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform4uivImmediate) == 12,
+ Sizeof_Uniform4uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, header) == 0,
+ OffsetOf_Uniform4uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, location) == 4,
+ OffsetOf_Uniform4uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, count) == 8,
+ OffsetOf_Uniform4uivImmediate_count_not_8);
+
struct UniformMatrix2fvImmediate {
typedef UniformMatrix2fvImmediate ValueType;
static const CommandId kCmdId = kUniformMatrix2fvImmediate;
@@ -5929,6 +6525,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
OffsetOf_UniformMatrix2fvImmediate_count_not_8);
+struct UniformMatrix2x3fvImmediate {
+ typedef UniformMatrix2x3fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix2x3fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 6 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix2x3fvImmediate) == 12,
+ Sizeof_UniformMatrix2x3fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix2x3fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix2x3fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix2x3fvImmediate_count_not_8);
+
+struct UniformMatrix2x4fvImmediate {
+ typedef UniformMatrix2x4fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix2x4fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 8 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix2x4fvImmediate) == 12,
+ Sizeof_UniformMatrix2x4fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix2x4fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix2x4fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix2x4fvImmediate_count_not_8);
+
struct UniformMatrix3fvImmediate {
typedef UniformMatrix3fvImmediate ValueType;
static const CommandId kCmdId = kUniformMatrix3fvImmediate;
@@ -5976,6 +6666,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
OffsetOf_UniformMatrix3fvImmediate_count_not_8);
+struct UniformMatrix3x2fvImmediate {
+ typedef UniformMatrix3x2fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix3x2fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 6 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix3x2fvImmediate) == 12,
+ Sizeof_UniformMatrix3x2fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix3x2fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix3x2fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix3x2fvImmediate_count_not_8);
+
+struct UniformMatrix3x4fvImmediate {
+ typedef UniformMatrix3x4fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix3x4fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 12 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix3x4fvImmediate) == 12,
+ Sizeof_UniformMatrix3x4fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix3x4fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix3x4fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix3x4fvImmediate_count_not_8);
+
struct UniformMatrix4fvImmediate {
typedef UniformMatrix4fvImmediate ValueType;
static const CommandId kCmdId = kUniformMatrix4fvImmediate;
@@ -6023,6 +6807,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8,
OffsetOf_UniformMatrix4fvImmediate_count_not_8);
+struct UniformMatrix4x2fvImmediate {
+ typedef UniformMatrix4x2fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix4x2fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 8 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix4x2fvImmediate) == 12,
+ Sizeof_UniformMatrix4x2fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix4x2fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix4x2fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix4x2fvImmediate_count_not_8);
+
+struct UniformMatrix4x3fvImmediate {
+ typedef UniformMatrix4x3fvImmediate ValueType;
+ static const CommandId kCmdId = kUniformMatrix4x3fvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize(GLsizei count) {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 12 * 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, const GLfloat* _value) {
+ SetHeader(_count);
+ location = _location;
+ count = _count;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_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_t location;
+ int32_t count;
+ static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix4x3fvImmediate) == 12,
+ Sizeof_UniformMatrix4x3fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, header) == 0,
+ OffsetOf_UniformMatrix4x3fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, location) == 4,
+ OffsetOf_UniformMatrix4x3fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, count) == 8,
+ OffsetOf_UniformMatrix4x3fvImmediate_count_not_8);
+
struct UseProgram {
typedef UseProgram ValueType;
static const CommandId kCmdId = kUseProgram;
@@ -6420,6 +7298,246 @@ COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0,
COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4,
OffsetOf_VertexAttrib4fvImmediate_indx_not_4);
+struct VertexAttribI4i {
+ typedef VertexAttribI4i ValueType;
+ static const CommandId kCmdId = kVertexAttribI4i;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _indx, GLint _x, GLint _y, GLint _z, GLint _w) {
+ SetHeader();
+ indx = _indx;
+ x = _x;
+ y = _y;
+ z = _z;
+ w = _w;
+ }
+
+ void* Set(void* cmd, GLuint _indx, GLint _x, GLint _y, GLint _z, GLint _w) {
+ static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t indx;
+ int32_t x;
+ int32_t y;
+ int32_t z;
+ int32_t w;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4i) == 24, Sizeof_VertexAttribI4i_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, header) == 0,
+ OffsetOf_VertexAttribI4i_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, indx) == 4,
+ OffsetOf_VertexAttribI4i_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, x) == 8,
+ OffsetOf_VertexAttribI4i_x_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, y) == 12,
+ OffsetOf_VertexAttribI4i_y_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, z) == 16,
+ OffsetOf_VertexAttribI4i_z_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, w) == 20,
+ OffsetOf_VertexAttribI4i_w_not_20);
+
+struct VertexAttribI4ivImmediate {
+ typedef VertexAttribI4ivImmediate ValueType;
+ static const CommandId kCmdId = kVertexAttribI4ivImmediate;
+ 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(GLint) * 4); // NOLINT
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLuint _indx, const GLint* _values) {
+ SetHeader();
+ indx = _indx;
+ memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
+ }
+
+ void* Set(void* cmd, GLuint _indx, const GLint* _values) {
+ static_cast<ValueType*>(cmd)->Init(_indx, _values);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t indx;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4ivImmediate) == 8,
+ Sizeof_VertexAttribI4ivImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4ivImmediate, header) == 0,
+ OffsetOf_VertexAttribI4ivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4ivImmediate, indx) == 4,
+ OffsetOf_VertexAttribI4ivImmediate_indx_not_4);
+
+struct VertexAttribI4ui {
+ typedef VertexAttribI4ui ValueType;
+ static const CommandId kCmdId = kVertexAttribI4ui;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _indx, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
+ SetHeader();
+ indx = _indx;
+ x = _x;
+ y = _y;
+ z = _z;
+ w = _w;
+ }
+
+ void* Set(void* cmd,
+ GLuint _indx,
+ GLuint _x,
+ GLuint _y,
+ GLuint _z,
+ GLuint _w) {
+ static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t indx;
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+ uint32_t w;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4ui) == 24,
+ Sizeof_VertexAttribI4ui_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, header) == 0,
+ OffsetOf_VertexAttribI4ui_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, indx) == 4,
+ OffsetOf_VertexAttribI4ui_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, x) == 8,
+ OffsetOf_VertexAttribI4ui_x_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, y) == 12,
+ OffsetOf_VertexAttribI4ui_y_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, z) == 16,
+ OffsetOf_VertexAttribI4ui_z_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, w) == 20,
+ OffsetOf_VertexAttribI4ui_w_not_20);
+
+struct VertexAttribI4uivImmediate {
+ typedef VertexAttribI4uivImmediate ValueType;
+ static const CommandId kCmdId = kVertexAttribI4uivImmediate;
+ 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(GLuint) * 4); // NOLINT
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) +
+ ComputeDataSize()); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLuint _indx, const GLuint* _values) {
+ SetHeader();
+ indx = _indx;
+ memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
+ }
+
+ void* Set(void* cmd, GLuint _indx, const GLuint* _values) {
+ static_cast<ValueType*>(cmd)->Init(_indx, _values);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t indx;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4uivImmediate) == 8,
+ Sizeof_VertexAttribI4uivImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4uivImmediate, header) == 0,
+ OffsetOf_VertexAttribI4uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4uivImmediate, indx) == 4,
+ OffsetOf_VertexAttribI4uivImmediate_indx_not_4);
+
+struct VertexAttribIPointer {
+ typedef VertexAttribIPointer ValueType;
+ static const CommandId kCmdId = kVertexAttribIPointer;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLuint _indx,
+ GLint _size,
+ GLenum _type,
+ GLsizei _stride,
+ GLuint _offset) {
+ SetHeader();
+ indx = _indx;
+ size = _size;
+ type = _type;
+ stride = _stride;
+ offset = _offset;
+ }
+
+ void* Set(void* cmd,
+ GLuint _indx,
+ GLint _size,
+ GLenum _type,
+ GLsizei _stride,
+ GLuint _offset) {
+ static_cast<ValueType*>(cmd)->Init(_indx, _size, _type, _stride, _offset);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t indx;
+ int32_t size;
+ uint32_t type;
+ int32_t stride;
+ uint32_t offset;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribIPointer) == 24,
+ Sizeof_VertexAttribIPointer_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, header) == 0,
+ OffsetOf_VertexAttribIPointer_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, indx) == 4,
+ OffsetOf_VertexAttribIPointer_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, size) == 8,
+ OffsetOf_VertexAttribIPointer_size_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, type) == 12,
+ OffsetOf_VertexAttribIPointer_type_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, stride) == 16,
+ OffsetOf_VertexAttribIPointer_stride_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, offset) == 20,
+ OffsetOf_VertexAttribIPointer_offset_not_20);
+
struct VertexAttribPointer {
typedef VertexAttribPointer ValueType;
static const CommandId kCmdId = kVertexAttribPointer;
« no previous file with comments | « gpu/command_buffer/common/capabilities.cc ('k') | gpu/command_buffer/common/gles2_cmd_format_test_autogen.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698