1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This file is auto-generated from 6 // gpu/command_buffer/build_gles2_cmd_buffer.py 7 // It's formatted by clang-format using chromium coding style: 8 // clang-format -i -style=chromium filename 9 // DO NOT EDIT! 10 11 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ 12 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ 13 14 struct ActiveTexture { 15 typedef ActiveTexture ValueType; 16 static const CommandId kCmdId = kActiveTexture; 17 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 18 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 19 20 static uint32_t ComputeSize() { 21 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 22 } 23 24 void SetHeader() { header.SetCmd<ValueType>(); } 25 26 void Init(GLenum _texture) { 27 SetHeader(); 28 texture = _texture; 29 } 30 31 void* Set(void* cmd, GLenum _texture) { 32 static_cast<ValueType*>(cmd)->Init(_texture); 33 return NextCmdAddress<ValueType>(cmd); 34 } 35 36 gpu::CommandHeader header; 37 uint32_t texture; 38 }; 39 40 COMPILE_ASSERT(sizeof(ActiveTexture) == 8, Sizeof_ActiveTexture_is_not_8); 41 COMPILE_ASSERT(offsetof(ActiveTexture, header) == 0, 42 OffsetOf_ActiveTexture_header_not_0); 43 COMPILE_ASSERT(offsetof(ActiveTexture, texture) == 4, 44 OffsetOf_ActiveTexture_texture_not_4); 45 46 struct AttachShader { 47 typedef AttachShader ValueType; 48 static const CommandId kCmdId = kAttachShader; 49 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 50 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 51 52 static uint32_t ComputeSize() { 53 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 54 } 55 56 void SetHeader() { header.SetCmd<ValueType>(); } 57 58 void Init(GLuint _program, GLuint _shader) { 59 SetHeader(); 60 program = _program; 61 shader = _shader; 62 } 63 64 void* Set(void* cmd, GLuint _program, GLuint _shader) { 65 static_cast<ValueType*>(cmd)->Init(_program, _shader); 66 return NextCmdAddress<ValueType>(cmd); 67 } 68 69 gpu::CommandHeader header; 70 uint32_t program; 71 uint32_t shader; 72 }; 73 74 COMPILE_ASSERT(sizeof(AttachShader) == 12, Sizeof_AttachShader_is_not_12); 75 COMPILE_ASSERT(offsetof(AttachShader, header) == 0, 76 OffsetOf_AttachShader_header_not_0); 77 COMPILE_ASSERT(offsetof(AttachShader, program) == 4, 78 OffsetOf_AttachShader_program_not_4); 79 COMPILE_ASSERT(offsetof(AttachShader, shader) == 8, 80 OffsetOf_AttachShader_shader_not_8); 81 82 struct BindAttribLocationBucket { 83 typedef BindAttribLocationBucket ValueType; 84 static const CommandId kCmdId = kBindAttribLocationBucket; 85 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 86 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 87 88 static uint32_t ComputeSize() { 89 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 90 } 91 92 void SetHeader() { header.SetCmd<ValueType>(); } 93 94 void Init(GLuint _program, GLuint _index, uint32_t _name_bucket_id) { 95 SetHeader(); 96 program = _program; 97 index = _index; 98 name_bucket_id = _name_bucket_id; 99 } 100 101 void* Set(void* cmd, 102 GLuint _program, 103 GLuint _index, 104 uint32_t _name_bucket_id) { 105 static_cast<ValueType*>(cmd)->Init(_program, _index, _name_bucket_id); 106 return NextCmdAddress<ValueType>(cmd); 107 } 108 109 gpu::CommandHeader header; 110 uint32_t program; 111 uint32_t index; 112 uint32_t name_bucket_id; 113 }; 114 115 COMPILE_ASSERT(sizeof(BindAttribLocationBucket) == 16, 116 Sizeof_BindAttribLocationBucket_is_not_16); 117 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, header) == 0, 118 OffsetOf_BindAttribLocationBucket_header_not_0); 119 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, program) == 4, 120 OffsetOf_BindAttribLocationBucket_program_not_4); 121 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, index) == 8, 122 OffsetOf_BindAttribLocationBucket_index_not_8); 123 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, name_bucket_id) == 12, 124 OffsetOf_BindAttribLocationBucket_name_bucket_id_not_12); 125 126 struct BindBuffer { 127 typedef BindBuffer ValueType; 128 static const CommandId kCmdId = kBindBuffer; 129 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 130 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 131 132 static uint32_t ComputeSize() { 133 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 134 } 135 136 void SetHeader() { header.SetCmd<ValueType>(); } 137 138 void Init(GLenum _target, GLuint _buffer) { 139 SetHeader(); 140 target = _target; 141 buffer = _buffer; 142 } 143 144 void* Set(void* cmd, GLenum _target, GLuint _buffer) { 145 static_cast<ValueType*>(cmd)->Init(_target, _buffer); 146 return NextCmdAddress<ValueType>(cmd); 147 } 148 149 gpu::CommandHeader header; 150 uint32_t target; 151 uint32_t buffer; 152 }; 153 154 COMPILE_ASSERT(sizeof(BindBuffer) == 12, Sizeof_BindBuffer_is_not_12); 155 COMPILE_ASSERT(offsetof(BindBuffer, header) == 0, 156 OffsetOf_BindBuffer_header_not_0); 157 COMPILE_ASSERT(offsetof(BindBuffer, target) == 4, 158 OffsetOf_BindBuffer_target_not_4); 159 COMPILE_ASSERT(offsetof(BindBuffer, buffer) == 8, 160 OffsetOf_BindBuffer_buffer_not_8); 161 162 struct BindFramebuffer { 163 typedef BindFramebuffer ValueType; 164 static const CommandId kCmdId = kBindFramebuffer; 165 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 166 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 167 168 static uint32_t ComputeSize() { 169 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 170 } 171 172 void SetHeader() { header.SetCmd<ValueType>(); } 173 174 void Init(GLenum _target, GLuint _framebuffer) { 175 SetHeader(); 176 target = _target; 177 framebuffer = _framebuffer; 178 } 179 180 void* Set(void* cmd, GLenum _target, GLuint _framebuffer) { 181 static_cast<ValueType*>(cmd)->Init(_target, _framebuffer); 182 return NextCmdAddress<ValueType>(cmd); 183 } 184 185 gpu::CommandHeader header; 186 uint32_t target; 187 uint32_t framebuffer; 188 }; 189 190 COMPILE_ASSERT(sizeof(BindFramebuffer) == 12, Sizeof_BindFramebuffer_is_not_12); 191 COMPILE_ASSERT(offsetof(BindFramebuffer, header) == 0, 192 OffsetOf_BindFramebuffer_header_not_0); 193 COMPILE_ASSERT(offsetof(BindFramebuffer, target) == 4, 194 OffsetOf_BindFramebuffer_target_not_4); 195 COMPILE_ASSERT(offsetof(BindFramebuffer, framebuffer) == 8, 196 OffsetOf_BindFramebuffer_framebuffer_not_8); 197 198 struct BindRenderbuffer { 199 typedef BindRenderbuffer ValueType; 200 static const CommandId kCmdId = kBindRenderbuffer; 201 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 202 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 203 204 static uint32_t ComputeSize() { 205 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 206 } 207 208 void SetHeader() { header.SetCmd<ValueType>(); } 209 210 void Init(GLenum _target, GLuint _renderbuffer) { 211 SetHeader(); 212 target = _target; 213 renderbuffer = _renderbuffer; 214 } 215 216 void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) { 217 static_cast<ValueType*>(cmd)->Init(_target, _renderbuffer); 218 return NextCmdAddress<ValueType>(cmd); 219 } 220 221 gpu::CommandHeader header; 222 uint32_t target; 223 uint32_t renderbuffer; 224 }; 225 226 COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12, 227 Sizeof_BindRenderbuffer_is_not_12); 228 COMPILE_ASSERT(offsetof(BindRenderbuffer, header) == 0, 229 OffsetOf_BindRenderbuffer_header_not_0); 230 COMPILE_ASSERT(offsetof(BindRenderbuffer, target) == 4, 231 OffsetOf_BindRenderbuffer_target_not_4); 232 COMPILE_ASSERT(offsetof(BindRenderbuffer, renderbuffer) == 8, 233 OffsetOf_BindRenderbuffer_renderbuffer_not_8); 234 235 struct BindTexture { 236 typedef BindTexture ValueType; 237 static const CommandId kCmdId = kBindTexture; 238 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 239 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 240 241 static uint32_t ComputeSize() { 242 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 243 } 244 245 void SetHeader() { header.SetCmd<ValueType>(); } 246 247 void Init(GLenum _target, GLuint _texture) { 248 SetHeader(); 249 target = _target; 250 texture = _texture; 251 } 252 253 void* Set(void* cmd, GLenum _target, GLuint _texture) { 254 static_cast<ValueType*>(cmd)->Init(_target, _texture); 255 return NextCmdAddress<ValueType>(cmd); 256 } 257 258 gpu::CommandHeader header; 259 uint32_t target; 260 uint32_t texture; 261 }; 262 263 COMPILE_ASSERT(sizeof(BindTexture) == 12, Sizeof_BindTexture_is_not_12); 264 COMPILE_ASSERT(offsetof(BindTexture, header) == 0, 265 OffsetOf_BindTexture_header_not_0); 266 COMPILE_ASSERT(offsetof(BindTexture, target) == 4, 267 OffsetOf_BindTexture_target_not_4); 268 COMPILE_ASSERT(offsetof(BindTexture, texture) == 8, 269 OffsetOf_BindTexture_texture_not_8); 270 271 struct BlendColor { 272 typedef BlendColor ValueType; 273 static const CommandId kCmdId = kBlendColor; 274 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 275 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 276 277 static uint32_t ComputeSize() { 278 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 279 } 280 281 void SetHeader() { header.SetCmd<ValueType>(); } 282 283 void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { 284 SetHeader(); 285 red = _red; 286 green = _green; 287 blue = _blue; 288 alpha = _alpha; 289 } 290 291 void* Set(void* cmd, 292 GLclampf _red, 293 GLclampf _green, 294 GLclampf _blue, 295 GLclampf _alpha) { 296 static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); 297 return NextCmdAddress<ValueType>(cmd); 298 } 299 300 gpu::CommandHeader header; 301 float red; 302 float green; 303 float blue; 304 float alpha; 305 }; 306 307 COMPILE_ASSERT(sizeof(BlendColor) == 20, Sizeof_BlendColor_is_not_20); 308 COMPILE_ASSERT(offsetof(BlendColor, header) == 0, 309 OffsetOf_BlendColor_header_not_0); 310 COMPILE_ASSERT(offsetof(BlendColor, red) == 4, OffsetOf_BlendColor_red_not_4); 311 COMPILE_ASSERT(offsetof(BlendColor, green) == 8, 312 OffsetOf_BlendColor_green_not_8); 313 COMPILE_ASSERT(offsetof(BlendColor, blue) == 12, 314 OffsetOf_BlendColor_blue_not_12); 315 COMPILE_ASSERT(offsetof(BlendColor, alpha) == 16, 316 OffsetOf_BlendColor_alpha_not_16); 317 318 struct BlendEquation { 319 typedef BlendEquation ValueType; 320 static const CommandId kCmdId = kBlendEquation; 321 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 322 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 323 324 static uint32_t ComputeSize() { 325 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 326 } 327 328 void SetHeader() { header.SetCmd<ValueType>(); } 329 330 void Init(GLenum _mode) { 331 SetHeader(); 332 mode = _mode; 333 } 334 335 void* Set(void* cmd, GLenum _mode) { 336 static_cast<ValueType*>(cmd)->Init(_mode); 337 return NextCmdAddress<ValueType>(cmd); 338 } 339 340 gpu::CommandHeader header; 341 uint32_t mode; 342 }; 343 344 COMPILE_ASSERT(sizeof(BlendEquation) == 8, Sizeof_BlendEquation_is_not_8); 345 COMPILE_ASSERT(offsetof(BlendEquation, header) == 0, 346 OffsetOf_BlendEquation_header_not_0); 347 COMPILE_ASSERT(offsetof(BlendEquation, mode) == 4, 348 OffsetOf_BlendEquation_mode_not_4); 349 350 struct BlendEquationSeparate { 351 typedef BlendEquationSeparate ValueType; 352 static const CommandId kCmdId = kBlendEquationSeparate; 353 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 354 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 355 356 static uint32_t ComputeSize() { 357 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 358 } 359 360 void SetHeader() { header.SetCmd<ValueType>(); } 361 362 void Init(GLenum _modeRGB, GLenum _modeAlpha) { 363 SetHeader(); 364 modeRGB = _modeRGB; 365 modeAlpha = _modeAlpha; 366 } 367 368 void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) { 369 static_cast<ValueType*>(cmd)->Init(_modeRGB, _modeAlpha); 370 return NextCmdAddress<ValueType>(cmd); 371 } 372 373 gpu::CommandHeader header; 374 uint32_t modeRGB; 375 uint32_t modeAlpha; 376 }; 377 378 COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12, 379 Sizeof_BlendEquationSeparate_is_not_12); 380 COMPILE_ASSERT(offsetof(BlendEquationSeparate, header) == 0, 381 OffsetOf_BlendEquationSeparate_header_not_0); 382 COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeRGB) == 4, 383 OffsetOf_BlendEquationSeparate_modeRGB_not_4); 384 COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeAlpha) == 8, 385 OffsetOf_BlendEquationSeparate_modeAlpha_not_8); 386 387 struct BlendFunc { 388 typedef BlendFunc ValueType; 389 static const CommandId kCmdId = kBlendFunc; 390 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 391 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 392 393 static uint32_t ComputeSize() { 394 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 395 } 396 397 void SetHeader() { header.SetCmd<ValueType>(); } 398 399 void Init(GLenum _sfactor, GLenum _dfactor) { 400 SetHeader(); 401 sfactor = _sfactor; 402 dfactor = _dfactor; 403 } 404 405 void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) { 406 static_cast<ValueType*>(cmd)->Init(_sfactor, _dfactor); 407 return NextCmdAddress<ValueType>(cmd); 408 } 409 410 gpu::CommandHeader header; 411 uint32_t sfactor; 412 uint32_t dfactor; 413 }; 414 415 COMPILE_ASSERT(sizeof(BlendFunc) == 12, Sizeof_BlendFunc_is_not_12); 416 COMPILE_ASSERT(offsetof(BlendFunc, header) == 0, 417 OffsetOf_BlendFunc_header_not_0); 418 COMPILE_ASSERT(offsetof(BlendFunc, sfactor) == 4, 419 OffsetOf_BlendFunc_sfactor_not_4); 420 COMPILE_ASSERT(offsetof(BlendFunc, dfactor) == 8, 421 OffsetOf_BlendFunc_dfactor_not_8); 422 423 struct BlendFuncSeparate { 424 typedef BlendFuncSeparate ValueType; 425 static const CommandId kCmdId = kBlendFuncSeparate; 426 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 427 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 428 429 static uint32_t ComputeSize() { 430 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 431 } 432 433 void SetHeader() { header.SetCmd<ValueType>(); } 434 435 void Init(GLenum _srcRGB, 436 GLenum _dstRGB, 437 GLenum _srcAlpha, 438 GLenum _dstAlpha) { 439 SetHeader(); 440 srcRGB = _srcRGB; 441 dstRGB = _dstRGB; 442 srcAlpha = _srcAlpha; 443 dstAlpha = _dstAlpha; 444 } 445 446 void* Set(void* cmd, 447 GLenum _srcRGB, 448 GLenum _dstRGB, 449 GLenum _srcAlpha, 450 GLenum _dstAlpha) { 451 static_cast<ValueType*>(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha); 452 return NextCmdAddress<ValueType>(cmd); 453 } 454 455 gpu::CommandHeader header; 456 uint32_t srcRGB; 457 uint32_t dstRGB; 458 uint32_t srcAlpha; 459 uint32_t dstAlpha; 460 }; 461 462 COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20, 463 Sizeof_BlendFuncSeparate_is_not_20); 464 COMPILE_ASSERT(offsetof(BlendFuncSeparate, header) == 0, 465 OffsetOf_BlendFuncSeparate_header_not_0); 466 COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcRGB) == 4, 467 OffsetOf_BlendFuncSeparate_srcRGB_not_4); 468 COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstRGB) == 8, 469 OffsetOf_BlendFuncSeparate_dstRGB_not_8); 470 COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcAlpha) == 12, 471 OffsetOf_BlendFuncSeparate_srcAlpha_not_12); 472 COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstAlpha) == 16, 473 OffsetOf_BlendFuncSeparate_dstAlpha_not_16); 474 475 struct BufferData { 476 typedef BufferData ValueType; 477 static const CommandId kCmdId = kBufferData; 478 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 479 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 480 481 static uint32_t ComputeSize() { 482 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 483 } 484 485 void SetHeader() { header.SetCmd<ValueType>(); } 486 487 void Init(GLenum _target, 488 GLsizeiptr _size, 489 uint32_t _data_shm_id, 490 uint32_t _data_shm_offset, 491 GLenum _usage) { 492 SetHeader(); 493 target = _target; 494 size = _size; 495 data_shm_id = _data_shm_id; 496 data_shm_offset = _data_shm_offset; 497 usage = _usage; 498 } 499 500 void* Set(void* cmd, 501 GLenum _target, 502 GLsizeiptr _size, 503 uint32_t _data_shm_id, 504 uint32_t _data_shm_offset, 505 GLenum _usage) { 506 static_cast<ValueType*>(cmd) 507 ->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage); 508 return NextCmdAddress<ValueType>(cmd); 509 } 510 511 gpu::CommandHeader header; 512 uint32_t target; 513 int32_t size; 514 uint32_t data_shm_id; 515 uint32_t data_shm_offset; 516 uint32_t usage; 517 }; 518 519 COMPILE_ASSERT(sizeof(BufferData) == 24, Sizeof_BufferData_is_not_24); 520 COMPILE_ASSERT(offsetof(BufferData, header) == 0, 521 OffsetOf_BufferData_header_not_0); 522 COMPILE_ASSERT(offsetof(BufferData, target) == 4, 523 OffsetOf_BufferData_target_not_4); 524 COMPILE_ASSERT(offsetof(BufferData, size) == 8, OffsetOf_BufferData_size_not_8); 525 COMPILE_ASSERT(offsetof(BufferData, data_shm_id) == 12, 526 OffsetOf_BufferData_data_shm_id_not_12); 527 COMPILE_ASSERT(offsetof(BufferData, data_shm_offset) == 16, 528 OffsetOf_BufferData_data_shm_offset_not_16); 529 COMPILE_ASSERT(offsetof(BufferData, usage) == 20, 530 OffsetOf_BufferData_usage_not_20); 531 532 struct BufferSubData { 533 typedef BufferSubData ValueType; 534 static const CommandId kCmdId = kBufferSubData; 535 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 536 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 537 538 static uint32_t ComputeSize() { 539 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 540 } 541 542 void SetHeader() { header.SetCmd<ValueType>(); } 543 544 void Init(GLenum _target, 545 GLintptr _offset, 546 GLsizeiptr _size, 547 uint32_t _data_shm_id, 548 uint32_t _data_shm_offset) { 549 SetHeader(); 550 target = _target; 551 offset = _offset; 552 size = _size; 553 data_shm_id = _data_shm_id; 554 data_shm_offset = _data_shm_offset; 555 } 556 557 void* Set(void* cmd, 558 GLenum _target, 559 GLintptr _offset, 560 GLsizeiptr _size, 561 uint32_t _data_shm_id, 562 uint32_t _data_shm_offset) { 563 static_cast<ValueType*>(cmd) 564 ->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset); 565 return NextCmdAddress<ValueType>(cmd); 566 } 567 568 gpu::CommandHeader header; 569 uint32_t target; 570 int32_t offset; 571 int32_t size; 572 uint32_t data_shm_id; 573 uint32_t data_shm_offset; 574 }; 575 576 COMPILE_ASSERT(sizeof(BufferSubData) == 24, Sizeof_BufferSubData_is_not_24); 577 COMPILE_ASSERT(offsetof(BufferSubData, header) == 0, 578 OffsetOf_BufferSubData_header_not_0); 579 COMPILE_ASSERT(offsetof(BufferSubData, target) == 4, 580 OffsetOf_BufferSubData_target_not_4); 581 COMPILE_ASSERT(offsetof(BufferSubData, offset) == 8, 582 OffsetOf_BufferSubData_offset_not_8); 583 COMPILE_ASSERT(offsetof(BufferSubData, size) == 12, 584 OffsetOf_BufferSubData_size_not_12); 585 COMPILE_ASSERT(offsetof(BufferSubData, data_shm_id) == 16, 586 OffsetOf_BufferSubData_data_shm_id_not_16); 587 COMPILE_ASSERT(offsetof(BufferSubData, data_shm_offset) == 20, 588 OffsetOf_BufferSubData_data_shm_offset_not_20); 589 590 struct CheckFramebufferStatus { 591 typedef CheckFramebufferStatus ValueType; 592 static const CommandId kCmdId = kCheckFramebufferStatus; 593 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 594 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 595 596 typedef GLenum Result; 597 598 static uint32_t ComputeSize() { 599 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 600 } 601 602 void SetHeader() { header.SetCmd<ValueType>(); } 603 604 void Init(GLenum _target, 605 uint32_t _result_shm_id, 606 uint32_t _result_shm_offset) { 607 SetHeader(); 608 target = _target; 609 result_shm_id = _result_shm_id; 610 result_shm_offset = _result_shm_offset; 611 } 612 613 void* Set(void* cmd, 614 GLenum _target, 615 uint32_t _result_shm_id, 616 uint32_t _result_shm_offset) { 617 static_cast<ValueType*>(cmd) 618 ->Init(_target, _result_shm_id, _result_shm_offset); 619 return NextCmdAddress<ValueType>(cmd); 620 } 621 622 gpu::CommandHeader header; 623 uint32_t target; 624 uint32_t result_shm_id; 625 uint32_t result_shm_offset; 626 }; 627 628 COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 16, 629 Sizeof_CheckFramebufferStatus_is_not_16); 630 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, header) == 0, 631 OffsetOf_CheckFramebufferStatus_header_not_0); 632 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, target) == 4, 633 OffsetOf_CheckFramebufferStatus_target_not_4); 634 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_id) == 8, 635 OffsetOf_CheckFramebufferStatus_result_shm_id_not_8); 636 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_offset) == 12, 637 OffsetOf_CheckFramebufferStatus_result_shm_offset_not_12); 638 639 struct Clear { 640 typedef Clear ValueType; 641 static const CommandId kCmdId = kClear; 642 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 643 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 644 645 static uint32_t ComputeSize() { 646 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 647 } 648 649 void SetHeader() { header.SetCmd<ValueType>(); } 650 651 void Init(GLbitfield _mask) { 652 SetHeader(); 653 mask = _mask; 654 } 655 656 void* Set(void* cmd, GLbitfield _mask) { 657 static_cast<ValueType*>(cmd)->Init(_mask); 658 return NextCmdAddress<ValueType>(cmd); 659 } 660 661 gpu::CommandHeader header; 662 uint32_t mask; 663 }; 664 665 COMPILE_ASSERT(sizeof(Clear) == 8, Sizeof_Clear_is_not_8); 666 COMPILE_ASSERT(offsetof(Clear, header) == 0, OffsetOf_Clear_header_not_0); 667 COMPILE_ASSERT(offsetof(Clear, mask) == 4, OffsetOf_Clear_mask_not_4); 668 669 struct ClearColor { 670 typedef ClearColor ValueType; 671 static const CommandId kCmdId = kClearColor; 672 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 673 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 674 675 static uint32_t ComputeSize() { 676 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 677 } 678 679 void SetHeader() { header.SetCmd<ValueType>(); } 680 681 void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { 682 SetHeader(); 683 red = _red; 684 green = _green; 685 blue = _blue; 686 alpha = _alpha; 687 } 688 689 void* Set(void* cmd, 690 GLclampf _red, 691 GLclampf _green, 692 GLclampf _blue, 693 GLclampf _alpha) { 694 static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); 695 return NextCmdAddress<ValueType>(cmd); 696 } 697 698 gpu::CommandHeader header; 699 float red; 700 float green; 701 float blue; 702 float alpha; 703 }; 704 705 COMPILE_ASSERT(sizeof(ClearColor) == 20, Sizeof_ClearColor_is_not_20); 706 COMPILE_ASSERT(offsetof(ClearColor, header) == 0, 707 OffsetOf_ClearColor_header_not_0); 708 COMPILE_ASSERT(offsetof(ClearColor, red) == 4, OffsetOf_ClearColor_red_not_4); 709 COMPILE_ASSERT(offsetof(ClearColor, green) == 8, 710 OffsetOf_ClearColor_green_not_8); 711 COMPILE_ASSERT(offsetof(ClearColor, blue) == 12, 712 OffsetOf_ClearColor_blue_not_12); 713 COMPILE_ASSERT(offsetof(ClearColor, alpha) == 16, 714 OffsetOf_ClearColor_alpha_not_16); 715 716 struct ClearDepthf { 717 typedef ClearDepthf ValueType; 718 static const CommandId kCmdId = kClearDepthf; 719 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 720 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 721 722 static uint32_t ComputeSize() { 723 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 724 } 725 726 void SetHeader() { header.SetCmd<ValueType>(); } 727 728 void Init(GLclampf _depth) { 729 SetHeader(); 730 depth = _depth; 731 } 732 733 void* Set(void* cmd, GLclampf _depth) { 734 static_cast<ValueType*>(cmd)->Init(_depth); 735 return NextCmdAddress<ValueType>(cmd); 736 } 737 738 gpu::CommandHeader header; 739 float depth; 740 }; 741 742 COMPILE_ASSERT(sizeof(ClearDepthf) == 8, Sizeof_ClearDepthf_is_not_8); 743 COMPILE_ASSERT(offsetof(ClearDepthf, header) == 0, 744 OffsetOf_ClearDepthf_header_not_0); 745 COMPILE_ASSERT(offsetof(ClearDepthf, depth) == 4, 746 OffsetOf_ClearDepthf_depth_not_4); 747 748 struct ClearStencil { 749 typedef ClearStencil ValueType; 750 static const CommandId kCmdId = kClearStencil; 751 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 752 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 753 754 static uint32_t ComputeSize() { 755 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 756 } 757 758 void SetHeader() { header.SetCmd<ValueType>(); } 759 760 void Init(GLint _s) { 761 SetHeader(); 762 s = _s; 763 } 764 765 void* Set(void* cmd, GLint _s) { 766 static_cast<ValueType*>(cmd)->Init(_s); 767 return NextCmdAddress<ValueType>(cmd); 768 } 769 770 gpu::CommandHeader header; 771 int32_t s; 772 }; 773 774 COMPILE_ASSERT(sizeof(ClearStencil) == 8, Sizeof_ClearStencil_is_not_8); 775 COMPILE_ASSERT(offsetof(ClearStencil, header) == 0, 776 OffsetOf_ClearStencil_header_not_0); 777 COMPILE_ASSERT(offsetof(ClearStencil, s) == 4, OffsetOf_ClearStencil_s_not_4); 778 779 struct ColorMask { 780 typedef ColorMask ValueType; 781 static const CommandId kCmdId = kColorMask; 782 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 783 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 784 785 static uint32_t ComputeSize() { 786 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 787 } 788 789 void SetHeader() { header.SetCmd<ValueType>(); } 790 791 void Init(GLboolean _red, 792 GLboolean _green, 793 GLboolean _blue, 794 GLboolean _alpha) { 795 SetHeader(); 796 red = _red; 797 green = _green; 798 blue = _blue; 799 alpha = _alpha; 800 } 801 802 void* Set(void* cmd, 803 GLboolean _red, 804 GLboolean _green, 805 GLboolean _blue, 806 GLboolean _alpha) { 807 static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); 808 return NextCmdAddress<ValueType>(cmd); 809 } 810 811 gpu::CommandHeader header; 812 uint32_t red; 813 uint32_t green; 814 uint32_t blue; 815 uint32_t alpha; 816 }; 817 818 COMPILE_ASSERT(sizeof(ColorMask) == 20, Sizeof_ColorMask_is_not_20); 819 COMPILE_ASSERT(offsetof(ColorMask, header) == 0, 820 OffsetOf_ColorMask_header_not_0); 821 COMPILE_ASSERT(offsetof(ColorMask, red) == 4, OffsetOf_ColorMask_red_not_4); 822 COMPILE_ASSERT(offsetof(ColorMask, green) == 8, OffsetOf_ColorMask_green_not_8); 823 COMPILE_ASSERT(offsetof(ColorMask, blue) == 12, OffsetOf_ColorMask_blue_not_12); 824 COMPILE_ASSERT(offsetof(ColorMask, alpha) == 16, 825 OffsetOf_ColorMask_alpha_not_16); 826 827 struct CompileShader { 828 typedef CompileShader ValueType; 829 static const CommandId kCmdId = kCompileShader; 830 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 831 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 832 833 static uint32_t ComputeSize() { 834 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 835 } 836 837 void SetHeader() { header.SetCmd<ValueType>(); } 838 839 void Init(GLuint _shader) { 840 SetHeader(); 841 shader = _shader; 842 } 843 844 void* Set(void* cmd, GLuint _shader) { 845 static_cast<ValueType*>(cmd)->Init(_shader); 846 return NextCmdAddress<ValueType>(cmd); 847 } 848 849 gpu::CommandHeader header; 850 uint32_t shader; 851 }; 852 853 COMPILE_ASSERT(sizeof(CompileShader) == 8, Sizeof_CompileShader_is_not_8); 854 COMPILE_ASSERT(offsetof(CompileShader, header) == 0, 855 OffsetOf_CompileShader_header_not_0); 856 COMPILE_ASSERT(offsetof(CompileShader, shader) == 4, 857 OffsetOf_CompileShader_shader_not_4); 858 859 struct CompressedTexImage2DBucket { 860 typedef CompressedTexImage2DBucket ValueType; 861 static const CommandId kCmdId = kCompressedTexImage2DBucket; 862 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 863 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 864 865 static uint32_t ComputeSize() { 866 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 867 } 868 869 void SetHeader() { header.SetCmd<ValueType>(); } 870 871 void Init(GLenum _target, 872 GLint _level, 873 GLenum _internalformat, 874 GLsizei _width, 875 GLsizei _height, 876 GLuint _bucket_id) { 877 SetHeader(); 878 target = _target; 879 level = _level; 880 internalformat = _internalformat; 881 width = _width; 882 height = _height; 883 bucket_id = _bucket_id; 884 } 885 886 void* Set(void* cmd, 887 GLenum _target, 888 GLint _level, 889 GLenum _internalformat, 890 GLsizei _width, 891 GLsizei _height, 892 GLuint _bucket_id) { 893 static_cast<ValueType*>(cmd) 894 ->Init(_target, _level, _internalformat, _width, _height, _bucket_id); 895 return NextCmdAddress<ValueType>(cmd); 896 } 897 898 gpu::CommandHeader header; 899 uint32_t target; 900 int32_t level; 901 uint32_t internalformat; 902 int32_t width; 903 int32_t height; 904 uint32_t bucket_id; 905 static const int32_t border = 0; 906 }; 907 908 COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 28, 909 Sizeof_CompressedTexImage2DBucket_is_not_28); 910 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, header) == 0, 911 OffsetOf_CompressedTexImage2DBucket_header_not_0); 912 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, target) == 4, 913 OffsetOf_CompressedTexImage2DBucket_target_not_4); 914 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, level) == 8, 915 OffsetOf_CompressedTexImage2DBucket_level_not_8); 916 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, internalformat) == 12, 917 OffsetOf_CompressedTexImage2DBucket_internalformat_not_12); 918 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, width) == 16, 919 OffsetOf_CompressedTexImage2DBucket_width_not_16); 920 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, height) == 20, 921 OffsetOf_CompressedTexImage2DBucket_height_not_20); 922 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, bucket_id) == 24, 923 OffsetOf_CompressedTexImage2DBucket_bucket_id_not_24); 924 925 struct CompressedTexImage2D { 926 typedef CompressedTexImage2D ValueType; 927 static const CommandId kCmdId = kCompressedTexImage2D; 928 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 929 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 930 931 static uint32_t ComputeSize() { 932 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 933 } 934 935 void SetHeader() { header.SetCmd<ValueType>(); } 936 937 void Init(GLenum _target, 938 GLint _level, 939 GLenum _internalformat, 940 GLsizei _width, 941 GLsizei _height, 942 GLsizei _imageSize, 943 uint32_t _data_shm_id, 944 uint32_t _data_shm_offset) { 945 SetHeader(); 946 target = _target; 947 level = _level; 948 internalformat = _internalformat; 949 width = _width; 950 height = _height; 951 imageSize = _imageSize; 952 data_shm_id = _data_shm_id; 953 data_shm_offset = _data_shm_offset; 954 } 955 956 void* Set(void* cmd, 957 GLenum _target, 958 GLint _level, 959 GLenum _internalformat, 960 GLsizei _width, 961 GLsizei _height, 962 GLsizei _imageSize, 963 uint32_t _data_shm_id, 964 uint32_t _data_shm_offset) { 965 static_cast<ValueType*>(cmd)->Init(_target, 966 _level, 967 _internalformat, 968 _width, 969 _height, 970 _imageSize, 971 _data_shm_id, 972 _data_shm_offset); 973 return NextCmdAddress<ValueType>(cmd); 974 } 975 976 gpu::CommandHeader header; 977 uint32_t target; 978 int32_t level; 979 uint32_t internalformat; 980 int32_t width; 981 int32_t height; 982 int32_t imageSize; 983 uint32_t data_shm_id; 984 uint32_t data_shm_offset; 985 static const int32_t border = 0; 986 }; 987 988 COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 36, 989 Sizeof_CompressedTexImage2D_is_not_36); 990 COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0, 991 OffsetOf_CompressedTexImage2D_header_not_0); 992 COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4, 993 OffsetOf_CompressedTexImage2D_target_not_4); 994 COMPILE_ASSERT(offsetof(CompressedTexImage2D, level) == 8, 995 OffsetOf_CompressedTexImage2D_level_not_8); 996 COMPILE_ASSERT(offsetof(CompressedTexImage2D, internalformat) == 12, 997 OffsetOf_CompressedTexImage2D_internalformat_not_12); 998 COMPILE_ASSERT(offsetof(CompressedTexImage2D, width) == 16, 999 OffsetOf_CompressedTexImage2D_width_not_16); 1000 COMPILE_ASSERT(offsetof(CompressedTexImage2D, height) == 20, 1001 OffsetOf_CompressedTexImage2D_height_not_20); 1002 COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 24, 1003 OffsetOf_CompressedTexImage2D_imageSize_not_24); 1004 COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 28, 1005 OffsetOf_CompressedTexImage2D_data_shm_id_not_28); 1006 COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 32, 1007 OffsetOf_CompressedTexImage2D_data_shm_offset_not_32); 1008 1009 struct CompressedTexSubImage2DBucket { 1010 typedef CompressedTexSubImage2DBucket ValueType; 1011 static const CommandId kCmdId = kCompressedTexSubImage2DBucket; 1012 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1013 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1014 1015 static uint32_t ComputeSize() { 1016 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1017 } 1018 1019 void SetHeader() { header.SetCmd<ValueType>(); } 1020 1021 void Init(GLenum _target, 1022 GLint _level, 1023 GLint _xoffset, 1024 GLint _yoffset, 1025 GLsizei _width, 1026 GLsizei _height, 1027 GLenum _format, 1028 GLuint _bucket_id) { 1029 SetHeader(); 1030 target = _target; 1031 level = _level; 1032 xoffset = _xoffset; 1033 yoffset = _yoffset; 1034 width = _width; 1035 height = _height; 1036 format = _format; 1037 bucket_id = _bucket_id; 1038 } 1039 1040 void* Set(void* cmd, 1041 GLenum _target, 1042 GLint _level, 1043 GLint _xoffset, 1044 GLint _yoffset, 1045 GLsizei _width, 1046 GLsizei _height, 1047 GLenum _format, 1048 GLuint _bucket_id) { 1049 static_cast<ValueType*>(cmd)->Init(_target, 1050 _level, 1051 _xoffset, 1052 _yoffset, 1053 _width, 1054 _height, 1055 _format, 1056 _bucket_id); 1057 return NextCmdAddress<ValueType>(cmd); 1058 } 1059 1060 gpu::CommandHeader header; 1061 uint32_t target; 1062 int32_t level; 1063 int32_t xoffset; 1064 int32_t yoffset; 1065 int32_t width; 1066 int32_t height; 1067 uint32_t format; 1068 uint32_t bucket_id; 1069 }; 1070 1071 COMPILE_ASSERT(sizeof(CompressedTexSubImage2DBucket) == 36, 1072 Sizeof_CompressedTexSubImage2DBucket_is_not_36); 1073 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, header) == 0, 1074 OffsetOf_CompressedTexSubImage2DBucket_header_not_0); 1075 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, target) == 4, 1076 OffsetOf_CompressedTexSubImage2DBucket_target_not_4); 1077 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, level) == 8, 1078 OffsetOf_CompressedTexSubImage2DBucket_level_not_8); 1079 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, xoffset) == 12, 1080 OffsetOf_CompressedTexSubImage2DBucket_xoffset_not_12); 1081 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, yoffset) == 16, 1082 OffsetOf_CompressedTexSubImage2DBucket_yoffset_not_16); 1083 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, width) == 20, 1084 OffsetOf_CompressedTexSubImage2DBucket_width_not_20); 1085 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, height) == 24, 1086 OffsetOf_CompressedTexSubImage2DBucket_height_not_24); 1087 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, format) == 28, 1088 OffsetOf_CompressedTexSubImage2DBucket_format_not_28); 1089 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, bucket_id) == 32, 1090 OffsetOf_CompressedTexSubImage2DBucket_bucket_id_not_32); 1091 1092 struct CompressedTexSubImage2D { 1093 typedef CompressedTexSubImage2D ValueType; 1094 static const CommandId kCmdId = kCompressedTexSubImage2D; 1095 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1096 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1097 1098 static uint32_t ComputeSize() { 1099 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1100 } 1101 1102 void SetHeader() { header.SetCmd<ValueType>(); } 1103 1104 void Init(GLenum _target, 1105 GLint _level, 1106 GLint _xoffset, 1107 GLint _yoffset, 1108 GLsizei _width, 1109 GLsizei _height, 1110 GLenum _format, 1111 GLsizei _imageSize, 1112 uint32_t _data_shm_id, 1113 uint32_t _data_shm_offset) { 1114 SetHeader(); 1115 target = _target; 1116 level = _level; 1117 xoffset = _xoffset; 1118 yoffset = _yoffset; 1119 width = _width; 1120 height = _height; 1121 format = _format; 1122 imageSize = _imageSize; 1123 data_shm_id = _data_shm_id; 1124 data_shm_offset = _data_shm_offset; 1125 } 1126 1127 void* Set(void* cmd, 1128 GLenum _target, 1129 GLint _level, 1130 GLint _xoffset, 1131 GLint _yoffset, 1132 GLsizei _width, 1133 GLsizei _height, 1134 GLenum _format, 1135 GLsizei _imageSize, 1136 uint32_t _data_shm_id, 1137 uint32_t _data_shm_offset) { 1138 static_cast<ValueType*>(cmd)->Init(_target, 1139 _level, 1140 _xoffset, 1141 _yoffset, 1142 _width, 1143 _height, 1144 _format, 1145 _imageSize, 1146 _data_shm_id, 1147 _data_shm_offset); 1148 return NextCmdAddress<ValueType>(cmd); 1149 } 1150 1151 gpu::CommandHeader header; 1152 uint32_t target; 1153 int32_t level; 1154 int32_t xoffset; 1155 int32_t yoffset; 1156 int32_t width; 1157 int32_t height; 1158 uint32_t format; 1159 int32_t imageSize; 1160 uint32_t data_shm_id; 1161 uint32_t data_shm_offset; 1162 }; 1163 1164 COMPILE_ASSERT(sizeof(CompressedTexSubImage2D) == 44, 1165 Sizeof_CompressedTexSubImage2D_is_not_44); 1166 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, header) == 0, 1167 OffsetOf_CompressedTexSubImage2D_header_not_0); 1168 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, target) == 4, 1169 OffsetOf_CompressedTexSubImage2D_target_not_4); 1170 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, level) == 8, 1171 OffsetOf_CompressedTexSubImage2D_level_not_8); 1172 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, xoffset) == 12, 1173 OffsetOf_CompressedTexSubImage2D_xoffset_not_12); 1174 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, yoffset) == 16, 1175 OffsetOf_CompressedTexSubImage2D_yoffset_not_16); 1176 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, width) == 20, 1177 OffsetOf_CompressedTexSubImage2D_width_not_20); 1178 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, height) == 24, 1179 OffsetOf_CompressedTexSubImage2D_height_not_24); 1180 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, format) == 28, 1181 OffsetOf_CompressedTexSubImage2D_format_not_28); 1182 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, imageSize) == 32, 1183 OffsetOf_CompressedTexSubImage2D_imageSize_not_32); 1184 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36, 1185 OffsetOf_CompressedTexSubImage2D_data_shm_id_not_36); 1186 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40, 1187 OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40); 1188 1189 struct CopyTexImage2D { 1190 typedef CopyTexImage2D ValueType; 1191 static const CommandId kCmdId = kCopyTexImage2D; 1192 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1193 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1194 1195 static uint32_t ComputeSize() { 1196 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1197 } 1198 1199 void SetHeader() { header.SetCmd<ValueType>(); } 1200 1201 void Init(GLenum _target, 1202 GLint _level, 1203 GLenum _internalformat, 1204 GLint _x, 1205 GLint _y, 1206 GLsizei _width, 1207 GLsizei _height) { 1208 SetHeader(); 1209 target = _target; 1210 level = _level; 1211 internalformat = _internalformat; 1212 x = _x; 1213 y = _y; 1214 width = _width; 1215 height = _height; 1216 } 1217 1218 void* Set(void* cmd, 1219 GLenum _target, 1220 GLint _level, 1221 GLenum _internalformat, 1222 GLint _x, 1223 GLint _y, 1224 GLsizei _width, 1225 GLsizei _height) { 1226 static_cast<ValueType*>(cmd) 1227 ->Init(_target, _level, _internalformat, _x, _y, _width, _height); 1228 return NextCmdAddress<ValueType>(cmd); 1229 } 1230 1231 gpu::CommandHeader header; 1232 uint32_t target; 1233 int32_t level; 1234 uint32_t internalformat; 1235 int32_t x; 1236 int32_t y; 1237 int32_t width; 1238 int32_t height; 1239 static const int32_t border = 0; 1240 }; 1241 1242 COMPILE_ASSERT(sizeof(CopyTexImage2D) == 32, Sizeof_CopyTexImage2D_is_not_32); 1243 COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0, 1244 OffsetOf_CopyTexImage2D_header_not_0); 1245 COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4, 1246 OffsetOf_CopyTexImage2D_target_not_4); 1247 COMPILE_ASSERT(offsetof(CopyTexImage2D, level) == 8, 1248 OffsetOf_CopyTexImage2D_level_not_8); 1249 COMPILE_ASSERT(offsetof(CopyTexImage2D, internalformat) == 12, 1250 OffsetOf_CopyTexImage2D_internalformat_not_12); 1251 COMPILE_ASSERT(offsetof(CopyTexImage2D, x) == 16, 1252 OffsetOf_CopyTexImage2D_x_not_16); 1253 COMPILE_ASSERT(offsetof(CopyTexImage2D, y) == 20, 1254 OffsetOf_CopyTexImage2D_y_not_20); 1255 COMPILE_ASSERT(offsetof(CopyTexImage2D, width) == 24, 1256 OffsetOf_CopyTexImage2D_width_not_24); 1257 COMPILE_ASSERT(offsetof(CopyTexImage2D, height) == 28, 1258 OffsetOf_CopyTexImage2D_height_not_28); 1259 1260 struct CopyTexSubImage2D { 1261 typedef CopyTexSubImage2D ValueType; 1262 static const CommandId kCmdId = kCopyTexSubImage2D; 1263 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1264 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1265 1266 static uint32_t ComputeSize() { 1267 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1268 } 1269 1270 void SetHeader() { header.SetCmd<ValueType>(); } 1271 1272 void Init(GLenum _target, 1273 GLint _level, 1274 GLint _xoffset, 1275 GLint _yoffset, 1276 GLint _x, 1277 GLint _y, 1278 GLsizei _width, 1279 GLsizei _height) { 1280 SetHeader(); 1281 target = _target; 1282 level = _level; 1283 xoffset = _xoffset; 1284 yoffset = _yoffset; 1285 x = _x; 1286 y = _y; 1287 width = _width; 1288 height = _height; 1289 } 1290 1291 void* Set(void* cmd, 1292 GLenum _target, 1293 GLint _level, 1294 GLint _xoffset, 1295 GLint _yoffset, 1296 GLint _x, 1297 GLint _y, 1298 GLsizei _width, 1299 GLsizei _height) { 1300 static_cast<ValueType*>(cmd) 1301 ->Init(_target, _level, _xoffset, _yoffset, _x, _y, _width, _height); 1302 return NextCmdAddress<ValueType>(cmd); 1303 } 1304 1305 gpu::CommandHeader header; 1306 uint32_t target; 1307 int32_t level; 1308 int32_t xoffset; 1309 int32_t yoffset; 1310 int32_t x; 1311 int32_t y; 1312 int32_t width; 1313 int32_t height; 1314 }; 1315 1316 COMPILE_ASSERT(sizeof(CopyTexSubImage2D) == 36, 1317 Sizeof_CopyTexSubImage2D_is_not_36); 1318 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, header) == 0, 1319 OffsetOf_CopyTexSubImage2D_header_not_0); 1320 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, target) == 4, 1321 OffsetOf_CopyTexSubImage2D_target_not_4); 1322 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, level) == 8, 1323 OffsetOf_CopyTexSubImage2D_level_not_8); 1324 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, xoffset) == 12, 1325 OffsetOf_CopyTexSubImage2D_xoffset_not_12); 1326 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, yoffset) == 16, 1327 OffsetOf_CopyTexSubImage2D_yoffset_not_16); 1328 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, x) == 20, 1329 OffsetOf_CopyTexSubImage2D_x_not_20); 1330 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, y) == 24, 1331 OffsetOf_CopyTexSubImage2D_y_not_24); 1332 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, width) == 28, 1333 OffsetOf_CopyTexSubImage2D_width_not_28); 1334 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, height) == 32, 1335 OffsetOf_CopyTexSubImage2D_height_not_32); 1336 1337 struct CreateProgram { 1338 typedef CreateProgram ValueType; 1339 static const CommandId kCmdId = kCreateProgram; 1340 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1341 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1342 1343 static uint32_t ComputeSize() { 1344 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1345 } 1346 1347 void SetHeader() { header.SetCmd<ValueType>(); } 1348 1349 void Init(uint32_t _client_id) { 1350 SetHeader(); 1351 client_id = _client_id; 1352 } 1353 1354 void* Set(void* cmd, uint32_t _client_id) { 1355 static_cast<ValueType*>(cmd)->Init(_client_id); 1356 return NextCmdAddress<ValueType>(cmd); 1357 } 1358 1359 gpu::CommandHeader header; 1360 uint32_t client_id; 1361 }; 1362 1363 COMPILE_ASSERT(sizeof(CreateProgram) == 8, Sizeof_CreateProgram_is_not_8); 1364 COMPILE_ASSERT(offsetof(CreateProgram, header) == 0, 1365 OffsetOf_CreateProgram_header_not_0); 1366 COMPILE_ASSERT(offsetof(CreateProgram, client_id) == 4, 1367 OffsetOf_CreateProgram_client_id_not_4); 1368 1369 struct CreateShader { 1370 typedef CreateShader ValueType; 1371 static const CommandId kCmdId = kCreateShader; 1372 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1373 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1374 1375 static uint32_t ComputeSize() { 1376 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1377 } 1378 1379 void SetHeader() { header.SetCmd<ValueType>(); } 1380 1381 void Init(GLenum _type, uint32_t _client_id) { 1382 SetHeader(); 1383 type = _type; 1384 client_id = _client_id; 1385 } 1386 1387 void* Set(void* cmd, GLenum _type, uint32_t _client_id) { 1388 static_cast<ValueType*>(cmd)->Init(_type, _client_id); 1389 return NextCmdAddress<ValueType>(cmd); 1390 } 1391 1392 gpu::CommandHeader header; 1393 uint32_t type; 1394 uint32_t client_id; 1395 }; 1396 1397 COMPILE_ASSERT(sizeof(CreateShader) == 12, Sizeof_CreateShader_is_not_12); 1398 COMPILE_ASSERT(offsetof(CreateShader, header) == 0, 1399 OffsetOf_CreateShader_header_not_0); 1400 COMPILE_ASSERT(offsetof(CreateShader, type) == 4, 1401 OffsetOf_CreateShader_type_not_4); 1402 COMPILE_ASSERT(offsetof(CreateShader, client_id) == 8, 1403 OffsetOf_CreateShader_client_id_not_8); 1404 1405 struct CullFace { 1406 typedef CullFace ValueType; 1407 static const CommandId kCmdId = kCullFace; 1408 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1409 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1410 1411 static uint32_t ComputeSize() { 1412 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1413 } 1414 1415 void SetHeader() { header.SetCmd<ValueType>(); } 1416 1417 void Init(GLenum _mode) { 1418 SetHeader(); 1419 mode = _mode; 1420 } 1421 1422 void* Set(void* cmd, GLenum _mode) { 1423 static_cast<ValueType*>(cmd)->Init(_mode); 1424 return NextCmdAddress<ValueType>(cmd); 1425 } 1426 1427 gpu::CommandHeader header; 1428 uint32_t mode; 1429 }; 1430 1431 COMPILE_ASSERT(sizeof(CullFace) == 8, Sizeof_CullFace_is_not_8); 1432 COMPILE_ASSERT(offsetof(CullFace, header) == 0, OffsetOf_CullFace_header_not_0); 1433 COMPILE_ASSERT(offsetof(CullFace, mode) == 4, OffsetOf_CullFace_mode_not_4); 1434 1435 struct DeleteBuffersImmediate { 1436 typedef DeleteBuffersImmediate ValueType; 1437 static const CommandId kCmdId = kDeleteBuffersImmediate; 1438 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 1439 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1440 1441 static uint32_t ComputeDataSize(GLsizei n) { 1442 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 1443 } 1444 1445 static uint32_t ComputeSize(GLsizei n) { 1446 return static_cast<uint32_t>(sizeof(ValueType) + 1447 ComputeDataSize(n)); // NOLINT 1448 } 1449 1450 void SetHeader(GLsizei n) { 1451 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 1452 } 1453 1454 void Init(GLsizei _n, const GLuint* _buffers) { 1455 SetHeader(_n); 1456 n = _n; 1457 memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n)); 1458 } 1459 1460 void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) { 1461 static_cast<ValueType*>(cmd)->Init(_n, _buffers); 1462 const uint32_t size = ComputeSize(_n); 1463 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 1464 } 1465 1466 gpu::CommandHeader header; 1467 int32_t n; 1468 }; 1469 1470 COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8, 1471 Sizeof_DeleteBuffersImmediate_is_not_8); 1472 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0, 1473 OffsetOf_DeleteBuffersImmediate_header_not_0); 1474 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4, 1475 OffsetOf_DeleteBuffersImmediate_n_not_4); 1476 1477 struct DeleteFramebuffersImmediate { 1478 typedef DeleteFramebuffersImmediate ValueType; 1479 static const CommandId kCmdId = kDeleteFramebuffersImmediate; 1480 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 1481 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1482 1483 static uint32_t ComputeDataSize(GLsizei n) { 1484 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 1485 } 1486 1487 static uint32_t ComputeSize(GLsizei n) { 1488 return static_cast<uint32_t>(sizeof(ValueType) + 1489 ComputeDataSize(n)); // NOLINT 1490 } 1491 1492 void SetHeader(GLsizei n) { 1493 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 1494 } 1495 1496 void Init(GLsizei _n, const GLuint* _framebuffers) { 1497 SetHeader(_n); 1498 n = _n; 1499 memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n)); 1500 } 1501 1502 void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) { 1503 static_cast<ValueType*>(cmd)->Init(_n, _framebuffers); 1504 const uint32_t size = ComputeSize(_n); 1505 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 1506 } 1507 1508 gpu::CommandHeader header; 1509 int32_t n; 1510 }; 1511 1512 COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8, 1513 Sizeof_DeleteFramebuffersImmediate_is_not_8); 1514 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0, 1515 OffsetOf_DeleteFramebuffersImmediate_header_not_0); 1516 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4, 1517 OffsetOf_DeleteFramebuffersImmediate_n_not_4); 1518 1519 struct DeleteProgram { 1520 typedef DeleteProgram ValueType; 1521 static const CommandId kCmdId = kDeleteProgram; 1522 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1523 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1524 1525 static uint32_t ComputeSize() { 1526 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1527 } 1528 1529 void SetHeader() { header.SetCmd<ValueType>(); } 1530 1531 void Init(GLuint _program) { 1532 SetHeader(); 1533 program = _program; 1534 } 1535 1536 void* Set(void* cmd, GLuint _program) { 1537 static_cast<ValueType*>(cmd)->Init(_program); 1538 return NextCmdAddress<ValueType>(cmd); 1539 } 1540 1541 gpu::CommandHeader header; 1542 uint32_t program; 1543 }; 1544 1545 COMPILE_ASSERT(sizeof(DeleteProgram) == 8, Sizeof_DeleteProgram_is_not_8); 1546 COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0, 1547 OffsetOf_DeleteProgram_header_not_0); 1548 COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4, 1549 OffsetOf_DeleteProgram_program_not_4); 1550 1551 struct DeleteRenderbuffersImmediate { 1552 typedef DeleteRenderbuffersImmediate ValueType; 1553 static const CommandId kCmdId = kDeleteRenderbuffersImmediate; 1554 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 1555 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1556 1557 static uint32_t ComputeDataSize(GLsizei n) { 1558 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 1559 } 1560 1561 static uint32_t ComputeSize(GLsizei n) { 1562 return static_cast<uint32_t>(sizeof(ValueType) + 1563 ComputeDataSize(n)); // NOLINT 1564 } 1565 1566 void SetHeader(GLsizei n) { 1567 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 1568 } 1569 1570 void Init(GLsizei _n, const GLuint* _renderbuffers) { 1571 SetHeader(_n); 1572 n = _n; 1573 memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n)); 1574 } 1575 1576 void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) { 1577 static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers); 1578 const uint32_t size = ComputeSize(_n); 1579 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 1580 } 1581 1582 gpu::CommandHeader header; 1583 int32_t n; 1584 }; 1585 1586 COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8, 1587 Sizeof_DeleteRenderbuffersImmediate_is_not_8); 1588 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0, 1589 OffsetOf_DeleteRenderbuffersImmediate_header_not_0); 1590 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4, 1591 OffsetOf_DeleteRenderbuffersImmediate_n_not_4); 1592 1593 struct DeleteShader { 1594 typedef DeleteShader ValueType; 1595 static const CommandId kCmdId = kDeleteShader; 1596 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1597 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1598 1599 static uint32_t ComputeSize() { 1600 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1601 } 1602 1603 void SetHeader() { header.SetCmd<ValueType>(); } 1604 1605 void Init(GLuint _shader) { 1606 SetHeader(); 1607 shader = _shader; 1608 } 1609 1610 void* Set(void* cmd, GLuint _shader) { 1611 static_cast<ValueType*>(cmd)->Init(_shader); 1612 return NextCmdAddress<ValueType>(cmd); 1613 } 1614 1615 gpu::CommandHeader header; 1616 uint32_t shader; 1617 }; 1618 1619 COMPILE_ASSERT(sizeof(DeleteShader) == 8, Sizeof_DeleteShader_is_not_8); 1620 COMPILE_ASSERT(offsetof(DeleteShader, header) == 0, 1621 OffsetOf_DeleteShader_header_not_0); 1622 COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4, 1623 OffsetOf_DeleteShader_shader_not_4); 1624 1625 struct DeleteTexturesImmediate { 1626 typedef DeleteTexturesImmediate ValueType; 1627 static const CommandId kCmdId = kDeleteTexturesImmediate; 1628 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 1629 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1630 1631 static uint32_t ComputeDataSize(GLsizei n) { 1632 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 1633 } 1634 1635 static uint32_t ComputeSize(GLsizei n) { 1636 return static_cast<uint32_t>(sizeof(ValueType) + 1637 ComputeDataSize(n)); // NOLINT 1638 } 1639 1640 void SetHeader(GLsizei n) { 1641 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 1642 } 1643 1644 void Init(GLsizei _n, const GLuint* _textures) { 1645 SetHeader(_n); 1646 n = _n; 1647 memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n)); 1648 } 1649 1650 void* Set(void* cmd, GLsizei _n, const GLuint* _textures) { 1651 static_cast<ValueType*>(cmd)->Init(_n, _textures); 1652 const uint32_t size = ComputeSize(_n); 1653 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 1654 } 1655 1656 gpu::CommandHeader header; 1657 int32_t n; 1658 }; 1659 1660 COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8, 1661 Sizeof_DeleteTexturesImmediate_is_not_8); 1662 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0, 1663 OffsetOf_DeleteTexturesImmediate_header_not_0); 1664 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4, 1665 OffsetOf_DeleteTexturesImmediate_n_not_4); 1666 1667 struct DepthFunc { 1668 typedef DepthFunc ValueType; 1669 static const CommandId kCmdId = kDepthFunc; 1670 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1671 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1672 1673 static uint32_t ComputeSize() { 1674 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1675 } 1676 1677 void SetHeader() { header.SetCmd<ValueType>(); } 1678 1679 void Init(GLenum _func) { 1680 SetHeader(); 1681 func = _func; 1682 } 1683 1684 void* Set(void* cmd, GLenum _func) { 1685 static_cast<ValueType*>(cmd)->Init(_func); 1686 return NextCmdAddress<ValueType>(cmd); 1687 } 1688 1689 gpu::CommandHeader header; 1690 uint32_t func; 1691 }; 1692 1693 COMPILE_ASSERT(sizeof(DepthFunc) == 8, Sizeof_DepthFunc_is_not_8); 1694 COMPILE_ASSERT(offsetof(DepthFunc, header) == 0, 1695 OffsetOf_DepthFunc_header_not_0); 1696 COMPILE_ASSERT(offsetof(DepthFunc, func) == 4, OffsetOf_DepthFunc_func_not_4); 1697 1698 struct DepthMask { 1699 typedef DepthMask ValueType; 1700 static const CommandId kCmdId = kDepthMask; 1701 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1702 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1703 1704 static uint32_t ComputeSize() { 1705 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1706 } 1707 1708 void SetHeader() { header.SetCmd<ValueType>(); } 1709 1710 void Init(GLboolean _flag) { 1711 SetHeader(); 1712 flag = _flag; 1713 } 1714 1715 void* Set(void* cmd, GLboolean _flag) { 1716 static_cast<ValueType*>(cmd)->Init(_flag); 1717 return NextCmdAddress<ValueType>(cmd); 1718 } 1719 1720 gpu::CommandHeader header; 1721 uint32_t flag; 1722 }; 1723 1724 COMPILE_ASSERT(sizeof(DepthMask) == 8, Sizeof_DepthMask_is_not_8); 1725 COMPILE_ASSERT(offsetof(DepthMask, header) == 0, 1726 OffsetOf_DepthMask_header_not_0); 1727 COMPILE_ASSERT(offsetof(DepthMask, flag) == 4, OffsetOf_DepthMask_flag_not_4); 1728 1729 struct DepthRangef { 1730 typedef DepthRangef ValueType; 1731 static const CommandId kCmdId = kDepthRangef; 1732 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1733 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1734 1735 static uint32_t ComputeSize() { 1736 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1737 } 1738 1739 void SetHeader() { header.SetCmd<ValueType>(); } 1740 1741 void Init(GLclampf _zNear, GLclampf _zFar) { 1742 SetHeader(); 1743 zNear = _zNear; 1744 zFar = _zFar; 1745 } 1746 1747 void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) { 1748 static_cast<ValueType*>(cmd)->Init(_zNear, _zFar); 1749 return NextCmdAddress<ValueType>(cmd); 1750 } 1751 1752 gpu::CommandHeader header; 1753 float zNear; 1754 float zFar; 1755 }; 1756 1757 COMPILE_ASSERT(sizeof(DepthRangef) == 12, Sizeof_DepthRangef_is_not_12); 1758 COMPILE_ASSERT(offsetof(DepthRangef, header) == 0, 1759 OffsetOf_DepthRangef_header_not_0); 1760 COMPILE_ASSERT(offsetof(DepthRangef, zNear) == 4, 1761 OffsetOf_DepthRangef_zNear_not_4); 1762 COMPILE_ASSERT(offsetof(DepthRangef, zFar) == 8, 1763 OffsetOf_DepthRangef_zFar_not_8); 1764 1765 struct DetachShader { 1766 typedef DetachShader ValueType; 1767 static const CommandId kCmdId = kDetachShader; 1768 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1769 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1770 1771 static uint32_t ComputeSize() { 1772 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1773 } 1774 1775 void SetHeader() { header.SetCmd<ValueType>(); } 1776 1777 void Init(GLuint _program, GLuint _shader) { 1778 SetHeader(); 1779 program = _program; 1780 shader = _shader; 1781 } 1782 1783 void* Set(void* cmd, GLuint _program, GLuint _shader) { 1784 static_cast<ValueType*>(cmd)->Init(_program, _shader); 1785 return NextCmdAddress<ValueType>(cmd); 1786 } 1787 1788 gpu::CommandHeader header; 1789 uint32_t program; 1790 uint32_t shader; 1791 }; 1792 1793 COMPILE_ASSERT(sizeof(DetachShader) == 12, Sizeof_DetachShader_is_not_12); 1794 COMPILE_ASSERT(offsetof(DetachShader, header) == 0, 1795 OffsetOf_DetachShader_header_not_0); 1796 COMPILE_ASSERT(offsetof(DetachShader, program) == 4, 1797 OffsetOf_DetachShader_program_not_4); 1798 COMPILE_ASSERT(offsetof(DetachShader, shader) == 8, 1799 OffsetOf_DetachShader_shader_not_8); 1800 1801 struct Disable { 1802 typedef Disable ValueType; 1803 static const CommandId kCmdId = kDisable; 1804 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1805 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1806 1807 static uint32_t ComputeSize() { 1808 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1809 } 1810 1811 void SetHeader() { header.SetCmd<ValueType>(); } 1812 1813 void Init(GLenum _cap) { 1814 SetHeader(); 1815 cap = _cap; 1816 } 1817 1818 void* Set(void* cmd, GLenum _cap) { 1819 static_cast<ValueType*>(cmd)->Init(_cap); 1820 return NextCmdAddress<ValueType>(cmd); 1821 } 1822 1823 gpu::CommandHeader header; 1824 uint32_t cap; 1825 }; 1826 1827 COMPILE_ASSERT(sizeof(Disable) == 8, Sizeof_Disable_is_not_8); 1828 COMPILE_ASSERT(offsetof(Disable, header) == 0, OffsetOf_Disable_header_not_0); 1829 COMPILE_ASSERT(offsetof(Disable, cap) == 4, OffsetOf_Disable_cap_not_4); 1830 1831 struct DisableVertexAttribArray { 1832 typedef DisableVertexAttribArray ValueType; 1833 static const CommandId kCmdId = kDisableVertexAttribArray; 1834 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1835 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1836 1837 static uint32_t ComputeSize() { 1838 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1839 } 1840 1841 void SetHeader() { header.SetCmd<ValueType>(); } 1842 1843 void Init(GLuint _index) { 1844 SetHeader(); 1845 index = _index; 1846 } 1847 1848 void* Set(void* cmd, GLuint _index) { 1849 static_cast<ValueType*>(cmd)->Init(_index); 1850 return NextCmdAddress<ValueType>(cmd); 1851 } 1852 1853 gpu::CommandHeader header; 1854 uint32_t index; 1855 }; 1856 1857 COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8, 1858 Sizeof_DisableVertexAttribArray_is_not_8); 1859 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, header) == 0, 1860 OffsetOf_DisableVertexAttribArray_header_not_0); 1861 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, index) == 4, 1862 OffsetOf_DisableVertexAttribArray_index_not_4); 1863 1864 struct DrawArrays { 1865 typedef DrawArrays ValueType; 1866 static const CommandId kCmdId = kDrawArrays; 1867 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1868 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2); 1869 1870 static uint32_t ComputeSize() { 1871 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1872 } 1873 1874 void SetHeader() { header.SetCmd<ValueType>(); } 1875 1876 void Init(GLenum _mode, GLint _first, GLsizei _count) { 1877 SetHeader(); 1878 mode = _mode; 1879 first = _first; 1880 count = _count; 1881 } 1882 1883 void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) { 1884 static_cast<ValueType*>(cmd)->Init(_mode, _first, _count); 1885 return NextCmdAddress<ValueType>(cmd); 1886 } 1887 1888 gpu::CommandHeader header; 1889 uint32_t mode; 1890 int32_t first; 1891 int32_t count; 1892 }; 1893 1894 COMPILE_ASSERT(sizeof(DrawArrays) == 16, Sizeof_DrawArrays_is_not_16); 1895 COMPILE_ASSERT(offsetof(DrawArrays, header) == 0, 1896 OffsetOf_DrawArrays_header_not_0); 1897 COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4, OffsetOf_DrawArrays_mode_not_4); 1898 COMPILE_ASSERT(offsetof(DrawArrays, first) == 8, 1899 OffsetOf_DrawArrays_first_not_8); 1900 COMPILE_ASSERT(offsetof(DrawArrays, count) == 12, 1901 OffsetOf_DrawArrays_count_not_12); 1902 1903 struct DrawElements { 1904 typedef DrawElements ValueType; 1905 static const CommandId kCmdId = kDrawElements; 1906 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1907 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2); 1908 1909 static uint32_t ComputeSize() { 1910 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1911 } 1912 1913 void SetHeader() { header.SetCmd<ValueType>(); } 1914 1915 void Init(GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) { 1916 SetHeader(); 1917 mode = _mode; 1918 count = _count; 1919 type = _type; 1920 index_offset = _index_offset; 1921 } 1922 1923 void* Set(void* cmd, 1924 GLenum _mode, 1925 GLsizei _count, 1926 GLenum _type, 1927 GLuint _index_offset) { 1928 static_cast<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset); 1929 return NextCmdAddress<ValueType>(cmd); 1930 } 1931 1932 gpu::CommandHeader header; 1933 uint32_t mode; 1934 int32_t count; 1935 uint32_t type; 1936 uint32_t index_offset; 1937 }; 1938 1939 COMPILE_ASSERT(sizeof(DrawElements) == 20, Sizeof_DrawElements_is_not_20); 1940 COMPILE_ASSERT(offsetof(DrawElements, header) == 0, 1941 OffsetOf_DrawElements_header_not_0); 1942 COMPILE_ASSERT(offsetof(DrawElements, mode) == 4, 1943 OffsetOf_DrawElements_mode_not_4); 1944 COMPILE_ASSERT(offsetof(DrawElements, count) == 8, 1945 OffsetOf_DrawElements_count_not_8); 1946 COMPILE_ASSERT(offsetof(DrawElements, type) == 12, 1947 OffsetOf_DrawElements_type_not_12); 1948 COMPILE_ASSERT(offsetof(DrawElements, index_offset) == 16, 1949 OffsetOf_DrawElements_index_offset_not_16); 1950 1951 struct Enable { 1952 typedef Enable ValueType; 1953 static const CommandId kCmdId = kEnable; 1954 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1955 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1956 1957 static uint32_t ComputeSize() { 1958 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1959 } 1960 1961 void SetHeader() { header.SetCmd<ValueType>(); } 1962 1963 void Init(GLenum _cap) { 1964 SetHeader(); 1965 cap = _cap; 1966 } 1967 1968 void* Set(void* cmd, GLenum _cap) { 1969 static_cast<ValueType*>(cmd)->Init(_cap); 1970 return NextCmdAddress<ValueType>(cmd); 1971 } 1972 1973 gpu::CommandHeader header; 1974 uint32_t cap; 1975 }; 1976 1977 COMPILE_ASSERT(sizeof(Enable) == 8, Sizeof_Enable_is_not_8); 1978 COMPILE_ASSERT(offsetof(Enable, header) == 0, OffsetOf_Enable_header_not_0); 1979 COMPILE_ASSERT(offsetof(Enable, cap) == 4, OffsetOf_Enable_cap_not_4); 1980 1981 struct EnableVertexAttribArray { 1982 typedef EnableVertexAttribArray ValueType; 1983 static const CommandId kCmdId = kEnableVertexAttribArray; 1984 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 1985 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 1986 1987 static uint32_t ComputeSize() { 1988 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 1989 } 1990 1991 void SetHeader() { header.SetCmd<ValueType>(); } 1992 1993 void Init(GLuint _index) { 1994 SetHeader(); 1995 index = _index; 1996 } 1997 1998 void* Set(void* cmd, GLuint _index) { 1999 static_cast<ValueType*>(cmd)->Init(_index); 2000 return NextCmdAddress<ValueType>(cmd); 2001 } 2002 2003 gpu::CommandHeader header; 2004 uint32_t index; 2005 }; 2006 2007 COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8, 2008 Sizeof_EnableVertexAttribArray_is_not_8); 2009 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, header) == 0, 2010 OffsetOf_EnableVertexAttribArray_header_not_0); 2011 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, index) == 4, 2012 OffsetOf_EnableVertexAttribArray_index_not_4); 2013 2014 struct Finish { 2015 typedef Finish ValueType; 2016 static const CommandId kCmdId = kFinish; 2017 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2018 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2019 2020 static uint32_t ComputeSize() { 2021 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2022 } 2023 2024 void SetHeader() { header.SetCmd<ValueType>(); } 2025 2026 void Init() { SetHeader(); } 2027 2028 void* Set(void* cmd) { 2029 static_cast<ValueType*>(cmd)->Init(); 2030 return NextCmdAddress<ValueType>(cmd); 2031 } 2032 2033 gpu::CommandHeader header; 2034 }; 2035 2036 COMPILE_ASSERT(sizeof(Finish) == 4, Sizeof_Finish_is_not_4); 2037 COMPILE_ASSERT(offsetof(Finish, header) == 0, OffsetOf_Finish_header_not_0); 2038 2039 struct Flush { 2040 typedef Flush ValueType; 2041 static const CommandId kCmdId = kFlush; 2042 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2043 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2044 2045 static uint32_t ComputeSize() { 2046 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2047 } 2048 2049 void SetHeader() { header.SetCmd<ValueType>(); } 2050 2051 void Init() { SetHeader(); } 2052 2053 void* Set(void* cmd) { 2054 static_cast<ValueType*>(cmd)->Init(); 2055 return NextCmdAddress<ValueType>(cmd); 2056 } 2057 2058 gpu::CommandHeader header; 2059 }; 2060 2061 COMPILE_ASSERT(sizeof(Flush) == 4, Sizeof_Flush_is_not_4); 2062 COMPILE_ASSERT(offsetof(Flush, header) == 0, OffsetOf_Flush_header_not_0); 2063 2064 struct FramebufferRenderbuffer { 2065 typedef FramebufferRenderbuffer ValueType; 2066 static const CommandId kCmdId = kFramebufferRenderbuffer; 2067 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2068 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2069 2070 static uint32_t ComputeSize() { 2071 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2072 } 2073 2074 void SetHeader() { header.SetCmd<ValueType>(); } 2075 2076 void Init(GLenum _target, 2077 GLenum _attachment, 2078 GLenum _renderbuffertarget, 2079 GLuint _renderbuffer) { 2080 SetHeader(); 2081 target = _target; 2082 attachment = _attachment; 2083 renderbuffertarget = _renderbuffertarget; 2084 renderbuffer = _renderbuffer; 2085 } 2086 2087 void* Set(void* cmd, 2088 GLenum _target, 2089 GLenum _attachment, 2090 GLenum _renderbuffertarget, 2091 GLuint _renderbuffer) { 2092 static_cast<ValueType*>(cmd) 2093 ->Init(_target, _attachment, _renderbuffertarget, _renderbuffer); 2094 return NextCmdAddress<ValueType>(cmd); 2095 } 2096 2097 gpu::CommandHeader header; 2098 uint32_t target; 2099 uint32_t attachment; 2100 uint32_t renderbuffertarget; 2101 uint32_t renderbuffer; 2102 }; 2103 2104 COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20, 2105 Sizeof_FramebufferRenderbuffer_is_not_20); 2106 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, header) == 0, 2107 OffsetOf_FramebufferRenderbuffer_header_not_0); 2108 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, target) == 4, 2109 OffsetOf_FramebufferRenderbuffer_target_not_4); 2110 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, attachment) == 8, 2111 OffsetOf_FramebufferRenderbuffer_attachment_not_8); 2112 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffertarget) == 12, 2113 OffsetOf_FramebufferRenderbuffer_renderbuffertarget_not_12); 2114 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffer) == 16, 2115 OffsetOf_FramebufferRenderbuffer_renderbuffer_not_16); 2116 2117 struct FramebufferTexture2D { 2118 typedef FramebufferTexture2D ValueType; 2119 static const CommandId kCmdId = kFramebufferTexture2D; 2120 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2121 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 2122 2123 static uint32_t ComputeSize() { 2124 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2125 } 2126 2127 void SetHeader() { header.SetCmd<ValueType>(); } 2128 2129 void Init(GLenum _target, 2130 GLenum _attachment, 2131 GLenum _textarget, 2132 GLuint _texture) { 2133 SetHeader(); 2134 target = _target; 2135 attachment = _attachment; 2136 textarget = _textarget; 2137 texture = _texture; 2138 } 2139 2140 void* Set(void* cmd, 2141 GLenum _target, 2142 GLenum _attachment, 2143 GLenum _textarget, 2144 GLuint _texture) { 2145 static_cast<ValueType*>(cmd) 2146 ->Init(_target, _attachment, _textarget, _texture); 2147 return NextCmdAddress<ValueType>(cmd); 2148 } 2149 2150 gpu::CommandHeader header; 2151 uint32_t target; 2152 uint32_t attachment; 2153 uint32_t textarget; 2154 uint32_t texture; 2155 static const int32_t level = 0; 2156 }; 2157 2158 COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 20, 2159 Sizeof_FramebufferTexture2D_is_not_20); 2160 COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0, 2161 OffsetOf_FramebufferTexture2D_header_not_0); 2162 COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4, 2163 OffsetOf_FramebufferTexture2D_target_not_4); 2164 COMPILE_ASSERT(offsetof(FramebufferTexture2D, attachment) == 8, 2165 OffsetOf_FramebufferTexture2D_attachment_not_8); 2166 COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12, 2167 OffsetOf_FramebufferTexture2D_textarget_not_12); 2168 COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16, 2169 OffsetOf_FramebufferTexture2D_texture_not_16); 2170 2171 struct FrontFace { 2172 typedef FrontFace ValueType; 2173 static const CommandId kCmdId = kFrontFace; 2174 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2175 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2176 2177 static uint32_t ComputeSize() { 2178 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2179 } 2180 2181 void SetHeader() { header.SetCmd<ValueType>(); } 2182 2183 void Init(GLenum _mode) { 2184 SetHeader(); 2185 mode = _mode; 2186 } 2187 2188 void* Set(void* cmd, GLenum _mode) { 2189 static_cast<ValueType*>(cmd)->Init(_mode); 2190 return NextCmdAddress<ValueType>(cmd); 2191 } 2192 2193 gpu::CommandHeader header; 2194 uint32_t mode; 2195 }; 2196 2197 COMPILE_ASSERT(sizeof(FrontFace) == 8, Sizeof_FrontFace_is_not_8); 2198 COMPILE_ASSERT(offsetof(FrontFace, header) == 0, 2199 OffsetOf_FrontFace_header_not_0); 2200 COMPILE_ASSERT(offsetof(FrontFace, mode) == 4, OffsetOf_FrontFace_mode_not_4); 2201 2202 struct GenBuffersImmediate { 2203 typedef GenBuffersImmediate ValueType; 2204 static const CommandId kCmdId = kGenBuffersImmediate; 2205 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 2206 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2207 2208 static uint32_t ComputeDataSize(GLsizei n) { 2209 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 2210 } 2211 2212 static uint32_t ComputeSize(GLsizei n) { 2213 return static_cast<uint32_t>(sizeof(ValueType) + 2214 ComputeDataSize(n)); // NOLINT 2215 } 2216 2217 void SetHeader(GLsizei n) { 2218 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 2219 } 2220 2221 void Init(GLsizei _n, GLuint* _buffers) { 2222 SetHeader(_n); 2223 n = _n; 2224 memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n)); 2225 } 2226 2227 void* Set(void* cmd, GLsizei _n, GLuint* _buffers) { 2228 static_cast<ValueType*>(cmd)->Init(_n, _buffers); 2229 const uint32_t size = ComputeSize(_n); 2230 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 2231 } 2232 2233 gpu::CommandHeader header; 2234 int32_t n; 2235 }; 2236 2237 COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8, 2238 Sizeof_GenBuffersImmediate_is_not_8); 2239 COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0, 2240 OffsetOf_GenBuffersImmediate_header_not_0); 2241 COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4, 2242 OffsetOf_GenBuffersImmediate_n_not_4); 2243 2244 struct GenerateMipmap { 2245 typedef GenerateMipmap ValueType; 2246 static const CommandId kCmdId = kGenerateMipmap; 2247 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2248 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2249 2250 static uint32_t ComputeSize() { 2251 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2252 } 2253 2254 void SetHeader() { header.SetCmd<ValueType>(); } 2255 2256 void Init(GLenum _target) { 2257 SetHeader(); 2258 target = _target; 2259 } 2260 2261 void* Set(void* cmd, GLenum _target) { 2262 static_cast<ValueType*>(cmd)->Init(_target); 2263 return NextCmdAddress<ValueType>(cmd); 2264 } 2265 2266 gpu::CommandHeader header; 2267 uint32_t target; 2268 }; 2269 2270 COMPILE_ASSERT(sizeof(GenerateMipmap) == 8, Sizeof_GenerateMipmap_is_not_8); 2271 COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0, 2272 OffsetOf_GenerateMipmap_header_not_0); 2273 COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4, 2274 OffsetOf_GenerateMipmap_target_not_4); 2275 2276 struct GenFramebuffersImmediate { 2277 typedef GenFramebuffersImmediate ValueType; 2278 static const CommandId kCmdId = kGenFramebuffersImmediate; 2279 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 2280 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2281 2282 static uint32_t ComputeDataSize(GLsizei n) { 2283 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 2284 } 2285 2286 static uint32_t ComputeSize(GLsizei n) { 2287 return static_cast<uint32_t>(sizeof(ValueType) + 2288 ComputeDataSize(n)); // NOLINT 2289 } 2290 2291 void SetHeader(GLsizei n) { 2292 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 2293 } 2294 2295 void Init(GLsizei _n, GLuint* _framebuffers) { 2296 SetHeader(_n); 2297 n = _n; 2298 memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n)); 2299 } 2300 2301 void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) { 2302 static_cast<ValueType*>(cmd)->Init(_n, _framebuffers); 2303 const uint32_t size = ComputeSize(_n); 2304 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 2305 } 2306 2307 gpu::CommandHeader header; 2308 int32_t n; 2309 }; 2310 2311 COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8, 2312 Sizeof_GenFramebuffersImmediate_is_not_8); 2313 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0, 2314 OffsetOf_GenFramebuffersImmediate_header_not_0); 2315 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4, 2316 OffsetOf_GenFramebuffersImmediate_n_not_4); 2317 2318 struct GenRenderbuffersImmediate { 2319 typedef GenRenderbuffersImmediate ValueType; 2320 static const CommandId kCmdId = kGenRenderbuffersImmediate; 2321 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 2322 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2323 2324 static uint32_t ComputeDataSize(GLsizei n) { 2325 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 2326 } 2327 2328 static uint32_t ComputeSize(GLsizei n) { 2329 return static_cast<uint32_t>(sizeof(ValueType) + 2330 ComputeDataSize(n)); // NOLINT 2331 } 2332 2333 void SetHeader(GLsizei n) { 2334 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 2335 } 2336 2337 void Init(GLsizei _n, GLuint* _renderbuffers) { 2338 SetHeader(_n); 2339 n = _n; 2340 memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n)); 2341 } 2342 2343 void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) { 2344 static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers); 2345 const uint32_t size = ComputeSize(_n); 2346 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 2347 } 2348 2349 gpu::CommandHeader header; 2350 int32_t n; 2351 }; 2352 2353 COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8, 2354 Sizeof_GenRenderbuffersImmediate_is_not_8); 2355 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0, 2356 OffsetOf_GenRenderbuffersImmediate_header_not_0); 2357 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4, 2358 OffsetOf_GenRenderbuffersImmediate_n_not_4); 2359 2360 struct GenTexturesImmediate { 2361 typedef GenTexturesImmediate ValueType; 2362 static const CommandId kCmdId = kGenTexturesImmediate; 2363 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 2364 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2365 2366 static uint32_t ComputeDataSize(GLsizei n) { 2367 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 2368 } 2369 2370 static uint32_t ComputeSize(GLsizei n) { 2371 return static_cast<uint32_t>(sizeof(ValueType) + 2372 ComputeDataSize(n)); // NOLINT 2373 } 2374 2375 void SetHeader(GLsizei n) { 2376 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 2377 } 2378 2379 void Init(GLsizei _n, GLuint* _textures) { 2380 SetHeader(_n); 2381 n = _n; 2382 memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n)); 2383 } 2384 2385 void* Set(void* cmd, GLsizei _n, GLuint* _textures) { 2386 static_cast<ValueType*>(cmd)->Init(_n, _textures); 2387 const uint32_t size = ComputeSize(_n); 2388 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 2389 } 2390 2391 gpu::CommandHeader header; 2392 int32_t n; 2393 }; 2394 2395 COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8, 2396 Sizeof_GenTexturesImmediate_is_not_8); 2397 COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0, 2398 OffsetOf_GenTexturesImmediate_header_not_0); 2399 COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4, 2400 OffsetOf_GenTexturesImmediate_n_not_4); 2401 2402 struct GetActiveAttrib { 2403 typedef GetActiveAttrib ValueType; 2404 static const CommandId kCmdId = kGetActiveAttrib; 2405 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2406 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2407 2408 struct Result { 2409 int32_t success; 2410 int32_t size; 2411 uint32_t type; 2412 }; 2413 2414 static uint32_t ComputeSize() { 2415 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2416 } 2417 2418 void SetHeader() { header.SetCmd<ValueType>(); } 2419 2420 void Init(GLuint _program, 2421 GLuint _index, 2422 uint32_t _name_bucket_id, 2423 uint32_t _result_shm_id, 2424 uint32_t _result_shm_offset) { 2425 SetHeader(); 2426 program = _program; 2427 index = _index; 2428 name_bucket_id = _name_bucket_id; 2429 result_shm_id = _result_shm_id; 2430 result_shm_offset = _result_shm_offset; 2431 } 2432 2433 void* Set(void* cmd, 2434 GLuint _program, 2435 GLuint _index, 2436 uint32_t _name_bucket_id, 2437 uint32_t _result_shm_id, 2438 uint32_t _result_shm_offset) { 2439 static_cast<ValueType*>(cmd)->Init( 2440 _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset); 2441 return NextCmdAddress<ValueType>(cmd); 2442 } 2443 2444 gpu::CommandHeader header; 2445 uint32_t program; 2446 uint32_t index; 2447 uint32_t name_bucket_id; 2448 uint32_t result_shm_id; 2449 uint32_t result_shm_offset; 2450 }; 2451 2452 COMPILE_ASSERT(sizeof(GetActiveAttrib) == 24, Sizeof_GetActiveAttrib_is_not_24); 2453 COMPILE_ASSERT(offsetof(GetActiveAttrib, header) == 0, 2454 OffsetOf_GetActiveAttrib_header_not_0); 2455 COMPILE_ASSERT(offsetof(GetActiveAttrib, program) == 4, 2456 OffsetOf_GetActiveAttrib_program_not_4); 2457 COMPILE_ASSERT(offsetof(GetActiveAttrib, index) == 8, 2458 OffsetOf_GetActiveAttrib_index_not_8); 2459 COMPILE_ASSERT(offsetof(GetActiveAttrib, name_bucket_id) == 12, 2460 OffsetOf_GetActiveAttrib_name_bucket_id_not_12); 2461 COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_id) == 16, 2462 OffsetOf_GetActiveAttrib_result_shm_id_not_16); 2463 COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_offset) == 20, 2464 OffsetOf_GetActiveAttrib_result_shm_offset_not_20); 2465 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, success) == 0, 2466 OffsetOf_GetActiveAttrib_Result_success_not_0); 2467 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, size) == 4, 2468 OffsetOf_GetActiveAttrib_Result_size_not_4); 2469 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, type) == 8, 2470 OffsetOf_GetActiveAttrib_Result_type_not_8); 2471 2472 struct GetActiveUniform { 2473 typedef GetActiveUniform ValueType; 2474 static const CommandId kCmdId = kGetActiveUniform; 2475 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2476 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2477 2478 struct Result { 2479 int32_t success; 2480 int32_t size; 2481 uint32_t type; 2482 }; 2483 2484 static uint32_t ComputeSize() { 2485 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2486 } 2487 2488 void SetHeader() { header.SetCmd<ValueType>(); } 2489 2490 void Init(GLuint _program, 2491 GLuint _index, 2492 uint32_t _name_bucket_id, 2493 uint32_t _result_shm_id, 2494 uint32_t _result_shm_offset) { 2495 SetHeader(); 2496 program = _program; 2497 index = _index; 2498 name_bucket_id = _name_bucket_id; 2499 result_shm_id = _result_shm_id; 2500 result_shm_offset = _result_shm_offset; 2501 } 2502 2503 void* Set(void* cmd, 2504 GLuint _program, 2505 GLuint _index, 2506 uint32_t _name_bucket_id, 2507 uint32_t _result_shm_id, 2508 uint32_t _result_shm_offset) { 2509 static_cast<ValueType*>(cmd)->Init( 2510 _program, _index, _name_bucket_id, _result_shm_id, _result_shm_offset); 2511 return NextCmdAddress<ValueType>(cmd); 2512 } 2513 2514 gpu::CommandHeader header; 2515 uint32_t program; 2516 uint32_t index; 2517 uint32_t name_bucket_id; 2518 uint32_t result_shm_id; 2519 uint32_t result_shm_offset; 2520 }; 2521 2522 COMPILE_ASSERT(sizeof(GetActiveUniform) == 24, 2523 Sizeof_GetActiveUniform_is_not_24); 2524 COMPILE_ASSERT(offsetof(GetActiveUniform, header) == 0, 2525 OffsetOf_GetActiveUniform_header_not_0); 2526 COMPILE_ASSERT(offsetof(GetActiveUniform, program) == 4, 2527 OffsetOf_GetActiveUniform_program_not_4); 2528 COMPILE_ASSERT(offsetof(GetActiveUniform, index) == 8, 2529 OffsetOf_GetActiveUniform_index_not_8); 2530 COMPILE_ASSERT(offsetof(GetActiveUniform, name_bucket_id) == 12, 2531 OffsetOf_GetActiveUniform_name_bucket_id_not_12); 2532 COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_id) == 16, 2533 OffsetOf_GetActiveUniform_result_shm_id_not_16); 2534 COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_offset) == 20, 2535 OffsetOf_GetActiveUniform_result_shm_offset_not_20); 2536 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, success) == 0, 2537 OffsetOf_GetActiveUniform_Result_success_not_0); 2538 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, size) == 4, 2539 OffsetOf_GetActiveUniform_Result_size_not_4); 2540 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, type) == 8, 2541 OffsetOf_GetActiveUniform_Result_type_not_8); 2542 2543 struct GetAttachedShaders { 2544 typedef GetAttachedShaders ValueType; 2545 static const CommandId kCmdId = kGetAttachedShaders; 2546 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2547 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2548 2549 typedef SizedResult<GLuint> Result; 2550 2551 static uint32_t ComputeSize() { 2552 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2553 } 2554 2555 void SetHeader() { header.SetCmd<ValueType>(); } 2556 2557 void Init(GLuint _program, 2558 uint32_t _result_shm_id, 2559 uint32_t _result_shm_offset, 2560 uint32_t _result_size) { 2561 SetHeader(); 2562 program = _program; 2563 result_shm_id = _result_shm_id; 2564 result_shm_offset = _result_shm_offset; 2565 result_size = _result_size; 2566 } 2567 2568 void* Set(void* cmd, 2569 GLuint _program, 2570 uint32_t _result_shm_id, 2571 uint32_t _result_shm_offset, 2572 uint32_t _result_size) { 2573 static_cast<ValueType*>(cmd) 2574 ->Init(_program, _result_shm_id, _result_shm_offset, _result_size); 2575 return NextCmdAddress<ValueType>(cmd); 2576 } 2577 2578 gpu::CommandHeader header; 2579 uint32_t program; 2580 uint32_t result_shm_id; 2581 uint32_t result_shm_offset; 2582 uint32_t result_size; 2583 }; 2584 2585 COMPILE_ASSERT(sizeof(GetAttachedShaders) == 20, 2586 Sizeof_GetAttachedShaders_is_not_20); 2587 COMPILE_ASSERT(offsetof(GetAttachedShaders, header) == 0, 2588 OffsetOf_GetAttachedShaders_header_not_0); 2589 COMPILE_ASSERT(offsetof(GetAttachedShaders, program) == 4, 2590 OffsetOf_GetAttachedShaders_program_not_4); 2591 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_id) == 8, 2592 OffsetOf_GetAttachedShaders_result_shm_id_not_8); 2593 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_offset) == 12, 2594 OffsetOf_GetAttachedShaders_result_shm_offset_not_12); 2595 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_size) == 16, 2596 OffsetOf_GetAttachedShaders_result_size_not_16); 2597 2598 struct GetBooleanv { 2599 typedef GetBooleanv ValueType; 2600 static const CommandId kCmdId = kGetBooleanv; 2601 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2602 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2603 2604 typedef SizedResult<GLboolean> Result; 2605 2606 static uint32_t ComputeSize() { 2607 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2608 } 2609 2610 void SetHeader() { header.SetCmd<ValueType>(); } 2611 2612 void Init(GLenum _pname, 2613 uint32_t _params_shm_id, 2614 uint32_t _params_shm_offset) { 2615 SetHeader(); 2616 pname = _pname; 2617 params_shm_id = _params_shm_id; 2618 params_shm_offset = _params_shm_offset; 2619 } 2620 2621 void* Set(void* cmd, 2622 GLenum _pname, 2623 uint32_t _params_shm_id, 2624 uint32_t _params_shm_offset) { 2625 static_cast<ValueType*>(cmd) 2626 ->Init(_pname, _params_shm_id, _params_shm_offset); 2627 return NextCmdAddress<ValueType>(cmd); 2628 } 2629 2630 gpu::CommandHeader header; 2631 uint32_t pname; 2632 uint32_t params_shm_id; 2633 uint32_t params_shm_offset; 2634 }; 2635 2636 COMPILE_ASSERT(sizeof(GetBooleanv) == 16, Sizeof_GetBooleanv_is_not_16); 2637 COMPILE_ASSERT(offsetof(GetBooleanv, header) == 0, 2638 OffsetOf_GetBooleanv_header_not_0); 2639 COMPILE_ASSERT(offsetof(GetBooleanv, pname) == 4, 2640 OffsetOf_GetBooleanv_pname_not_4); 2641 COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_id) == 8, 2642 OffsetOf_GetBooleanv_params_shm_id_not_8); 2643 COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_offset) == 12, 2644 OffsetOf_GetBooleanv_params_shm_offset_not_12); 2645 2646 struct GetBufferParameteriv { 2647 typedef GetBufferParameteriv ValueType; 2648 static const CommandId kCmdId = kGetBufferParameteriv; 2649 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2650 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2651 2652 typedef SizedResult<GLint> Result; 2653 2654 static uint32_t ComputeSize() { 2655 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2656 } 2657 2658 void SetHeader() { header.SetCmd<ValueType>(); } 2659 2660 void Init(GLenum _target, 2661 GLenum _pname, 2662 uint32_t _params_shm_id, 2663 uint32_t _params_shm_offset) { 2664 SetHeader(); 2665 target = _target; 2666 pname = _pname; 2667 params_shm_id = _params_shm_id; 2668 params_shm_offset = _params_shm_offset; 2669 } 2670 2671 void* Set(void* cmd, 2672 GLenum _target, 2673 GLenum _pname, 2674 uint32_t _params_shm_id, 2675 uint32_t _params_shm_offset) { 2676 static_cast<ValueType*>(cmd) 2677 ->Init(_target, _pname, _params_shm_id, _params_shm_offset); 2678 return NextCmdAddress<ValueType>(cmd); 2679 } 2680 2681 gpu::CommandHeader header; 2682 uint32_t target; 2683 uint32_t pname; 2684 uint32_t params_shm_id; 2685 uint32_t params_shm_offset; 2686 }; 2687 2688 COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20, 2689 Sizeof_GetBufferParameteriv_is_not_20); 2690 COMPILE_ASSERT(offsetof(GetBufferParameteriv, header) == 0, 2691 OffsetOf_GetBufferParameteriv_header_not_0); 2692 COMPILE_ASSERT(offsetof(GetBufferParameteriv, target) == 4, 2693 OffsetOf_GetBufferParameteriv_target_not_4); 2694 COMPILE_ASSERT(offsetof(GetBufferParameteriv, pname) == 8, 2695 OffsetOf_GetBufferParameteriv_pname_not_8); 2696 COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_id) == 12, 2697 OffsetOf_GetBufferParameteriv_params_shm_id_not_12); 2698 COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_offset) == 16, 2699 OffsetOf_GetBufferParameteriv_params_shm_offset_not_16); 2700 2701 struct GetError { 2702 typedef GetError ValueType; 2703 static const CommandId kCmdId = kGetError; 2704 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2705 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2706 2707 typedef GLenum Result; 2708 2709 static uint32_t ComputeSize() { 2710 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2711 } 2712 2713 void SetHeader() { header.SetCmd<ValueType>(); } 2714 2715 void Init(uint32_t _result_shm_id, uint32_t _result_shm_offset) { 2716 SetHeader(); 2717 result_shm_id = _result_shm_id; 2718 result_shm_offset = _result_shm_offset; 2719 } 2720 2721 void* Set(void* cmd, uint32_t _result_shm_id, uint32_t _result_shm_offset) { 2722 static_cast<ValueType*>(cmd)->Init(_result_shm_id, _result_shm_offset); 2723 return NextCmdAddress<ValueType>(cmd); 2724 } 2725 2726 gpu::CommandHeader header; 2727 uint32_t result_shm_id; 2728 uint32_t result_shm_offset; 2729 }; 2730 2731 COMPILE_ASSERT(sizeof(GetError) == 12, Sizeof_GetError_is_not_12); 2732 COMPILE_ASSERT(offsetof(GetError, header) == 0, OffsetOf_GetError_header_not_0); 2733 COMPILE_ASSERT(offsetof(GetError, result_shm_id) == 4, 2734 OffsetOf_GetError_result_shm_id_not_4); 2735 COMPILE_ASSERT(offsetof(GetError, result_shm_offset) == 8, 2736 OffsetOf_GetError_result_shm_offset_not_8); 2737 2738 struct GetFloatv { 2739 typedef GetFloatv ValueType; 2740 static const CommandId kCmdId = kGetFloatv; 2741 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2742 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2743 2744 typedef SizedResult<GLfloat> Result; 2745 2746 static uint32_t ComputeSize() { 2747 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2748 } 2749 2750 void SetHeader() { header.SetCmd<ValueType>(); } 2751 2752 void Init(GLenum _pname, 2753 uint32_t _params_shm_id, 2754 uint32_t _params_shm_offset) { 2755 SetHeader(); 2756 pname = _pname; 2757 params_shm_id = _params_shm_id; 2758 params_shm_offset = _params_shm_offset; 2759 } 2760 2761 void* Set(void* cmd, 2762 GLenum _pname, 2763 uint32_t _params_shm_id, 2764 uint32_t _params_shm_offset) { 2765 static_cast<ValueType*>(cmd) 2766 ->Init(_pname, _params_shm_id, _params_shm_offset); 2767 return NextCmdAddress<ValueType>(cmd); 2768 } 2769 2770 gpu::CommandHeader header; 2771 uint32_t pname; 2772 uint32_t params_shm_id; 2773 uint32_t params_shm_offset; 2774 }; 2775 2776 COMPILE_ASSERT(sizeof(GetFloatv) == 16, Sizeof_GetFloatv_is_not_16); 2777 COMPILE_ASSERT(offsetof(GetFloatv, header) == 0, 2778 OffsetOf_GetFloatv_header_not_0); 2779 COMPILE_ASSERT(offsetof(GetFloatv, pname) == 4, OffsetOf_GetFloatv_pname_not_4); 2780 COMPILE_ASSERT(offsetof(GetFloatv, params_shm_id) == 8, 2781 OffsetOf_GetFloatv_params_shm_id_not_8); 2782 COMPILE_ASSERT(offsetof(GetFloatv, params_shm_offset) == 12, 2783 OffsetOf_GetFloatv_params_shm_offset_not_12); 2784 2785 struct GetFramebufferAttachmentParameteriv { 2786 typedef GetFramebufferAttachmentParameteriv ValueType; 2787 static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv; 2788 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2789 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2790 2791 typedef SizedResult<GLint> Result; 2792 2793 static uint32_t ComputeSize() { 2794 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2795 } 2796 2797 void SetHeader() { header.SetCmd<ValueType>(); } 2798 2799 void Init(GLenum _target, 2800 GLenum _attachment, 2801 GLenum _pname, 2802 uint32_t _params_shm_id, 2803 uint32_t _params_shm_offset) { 2804 SetHeader(); 2805 target = _target; 2806 attachment = _attachment; 2807 pname = _pname; 2808 params_shm_id = _params_shm_id; 2809 params_shm_offset = _params_shm_offset; 2810 } 2811 2812 void* Set(void* cmd, 2813 GLenum _target, 2814 GLenum _attachment, 2815 GLenum _pname, 2816 uint32_t _params_shm_id, 2817 uint32_t _params_shm_offset) { 2818 static_cast<ValueType*>(cmd)->Init( 2819 _target, _attachment, _pname, _params_shm_id, _params_shm_offset); 2820 return NextCmdAddress<ValueType>(cmd); 2821 } 2822 2823 gpu::CommandHeader header; 2824 uint32_t target; 2825 uint32_t attachment; 2826 uint32_t pname; 2827 uint32_t params_shm_id; 2828 uint32_t params_shm_offset; 2829 }; 2830 2831 COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24, 2832 Sizeof_GetFramebufferAttachmentParameteriv_is_not_24); 2833 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, header) == 0, 2834 OffsetOf_GetFramebufferAttachmentParameteriv_header_not_0); 2835 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, target) == 4, 2836 OffsetOf_GetFramebufferAttachmentParameteriv_target_not_4); 2837 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, attachment) == 8, 2838 OffsetOf_GetFramebufferAttachmentParameteriv_attachment_not_8); 2839 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, pname) == 12, 2840 OffsetOf_GetFramebufferAttachmentParameteriv_pname_not_12); 2841 COMPILE_ASSERT( 2842 offsetof(GetFramebufferAttachmentParameteriv, params_shm_id) == 16, 2843 OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_id_not_16); 2844 COMPILE_ASSERT( 2845 offsetof(GetFramebufferAttachmentParameteriv, params_shm_offset) == 20, 2846 OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_offset_not_20); 2847 2848 struct GetIntegerv { 2849 typedef GetIntegerv ValueType; 2850 static const CommandId kCmdId = kGetIntegerv; 2851 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2852 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2853 2854 typedef SizedResult<GLint> Result; 2855 2856 static uint32_t ComputeSize() { 2857 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2858 } 2859 2860 void SetHeader() { header.SetCmd<ValueType>(); } 2861 2862 void Init(GLenum _pname, 2863 uint32_t _params_shm_id, 2864 uint32_t _params_shm_offset) { 2865 SetHeader(); 2866 pname = _pname; 2867 params_shm_id = _params_shm_id; 2868 params_shm_offset = _params_shm_offset; 2869 } 2870 2871 void* Set(void* cmd, 2872 GLenum _pname, 2873 uint32_t _params_shm_id, 2874 uint32_t _params_shm_offset) { 2875 static_cast<ValueType*>(cmd) 2876 ->Init(_pname, _params_shm_id, _params_shm_offset); 2877 return NextCmdAddress<ValueType>(cmd); 2878 } 2879 2880 gpu::CommandHeader header; 2881 uint32_t pname; 2882 uint32_t params_shm_id; 2883 uint32_t params_shm_offset; 2884 }; 2885 2886 COMPILE_ASSERT(sizeof(GetIntegerv) == 16, Sizeof_GetIntegerv_is_not_16); 2887 COMPILE_ASSERT(offsetof(GetIntegerv, header) == 0, 2888 OffsetOf_GetIntegerv_header_not_0); 2889 COMPILE_ASSERT(offsetof(GetIntegerv, pname) == 4, 2890 OffsetOf_GetIntegerv_pname_not_4); 2891 COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8, 2892 OffsetOf_GetIntegerv_params_shm_id_not_8); 2893 COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12, 2894 OffsetOf_GetIntegerv_params_shm_offset_not_12); 2895 2896 struct GetProgramiv { 2897 typedef GetProgramiv ValueType; 2898 static const CommandId kCmdId = kGetProgramiv; 2899 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2900 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2901 2902 typedef SizedResult<GLint> Result; 2903 2904 static uint32_t ComputeSize() { 2905 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2906 } 2907 2908 void SetHeader() { header.SetCmd<ValueType>(); } 2909 2910 void Init(GLuint _program, 2911 GLenum _pname, 2912 uint32_t _params_shm_id, 2913 uint32_t _params_shm_offset) { 2914 SetHeader(); 2915 program = _program; 2916 pname = _pname; 2917 params_shm_id = _params_shm_id; 2918 params_shm_offset = _params_shm_offset; 2919 } 2920 2921 void* Set(void* cmd, 2922 GLuint _program, 2923 GLenum _pname, 2924 uint32_t _params_shm_id, 2925 uint32_t _params_shm_offset) { 2926 static_cast<ValueType*>(cmd) 2927 ->Init(_program, _pname, _params_shm_id, _params_shm_offset); 2928 return NextCmdAddress<ValueType>(cmd); 2929 } 2930 2931 gpu::CommandHeader header; 2932 uint32_t program; 2933 uint32_t pname; 2934 uint32_t params_shm_id; 2935 uint32_t params_shm_offset; 2936 }; 2937 2938 COMPILE_ASSERT(sizeof(GetProgramiv) == 20, Sizeof_GetProgramiv_is_not_20); 2939 COMPILE_ASSERT(offsetof(GetProgramiv, header) == 0, 2940 OffsetOf_GetProgramiv_header_not_0); 2941 COMPILE_ASSERT(offsetof(GetProgramiv, program) == 4, 2942 OffsetOf_GetProgramiv_program_not_4); 2943 COMPILE_ASSERT(offsetof(GetProgramiv, pname) == 8, 2944 OffsetOf_GetProgramiv_pname_not_8); 2945 COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_id) == 12, 2946 OffsetOf_GetProgramiv_params_shm_id_not_12); 2947 COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_offset) == 16, 2948 OffsetOf_GetProgramiv_params_shm_offset_not_16); 2949 2950 struct GetProgramInfoLog { 2951 typedef GetProgramInfoLog ValueType; 2952 static const CommandId kCmdId = kGetProgramInfoLog; 2953 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2954 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2955 2956 static uint32_t ComputeSize() { 2957 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2958 } 2959 2960 void SetHeader() { header.SetCmd<ValueType>(); } 2961 2962 void Init(GLuint _program, uint32_t _bucket_id) { 2963 SetHeader(); 2964 program = _program; 2965 bucket_id = _bucket_id; 2966 } 2967 2968 void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) { 2969 static_cast<ValueType*>(cmd)->Init(_program, _bucket_id); 2970 return NextCmdAddress<ValueType>(cmd); 2971 } 2972 2973 gpu::CommandHeader header; 2974 uint32_t program; 2975 uint32_t bucket_id; 2976 }; 2977 2978 COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 12, 2979 Sizeof_GetProgramInfoLog_is_not_12); 2980 COMPILE_ASSERT(offsetof(GetProgramInfoLog, header) == 0, 2981 OffsetOf_GetProgramInfoLog_header_not_0); 2982 COMPILE_ASSERT(offsetof(GetProgramInfoLog, program) == 4, 2983 OffsetOf_GetProgramInfoLog_program_not_4); 2984 COMPILE_ASSERT(offsetof(GetProgramInfoLog, bucket_id) == 8, 2985 OffsetOf_GetProgramInfoLog_bucket_id_not_8); 2986 2987 struct GetRenderbufferParameteriv { 2988 typedef GetRenderbufferParameteriv ValueType; 2989 static const CommandId kCmdId = kGetRenderbufferParameteriv; 2990 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 2991 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 2992 2993 typedef SizedResult<GLint> Result; 2994 2995 static uint32_t ComputeSize() { 2996 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 2997 } 2998 2999 void SetHeader() { header.SetCmd<ValueType>(); } 3000 3001 void Init(GLenum _target, 3002 GLenum _pname, 3003 uint32_t _params_shm_id, 3004 uint32_t _params_shm_offset) { 3005 SetHeader(); 3006 target = _target; 3007 pname = _pname; 3008 params_shm_id = _params_shm_id; 3009 params_shm_offset = _params_shm_offset; 3010 } 3011 3012 void* Set(void* cmd, 3013 GLenum _target, 3014 GLenum _pname, 3015 uint32_t _params_shm_id, 3016 uint32_t _params_shm_offset) { 3017 static_cast<ValueType*>(cmd) 3018 ->Init(_target, _pname, _params_shm_id, _params_shm_offset); 3019 return NextCmdAddress<ValueType>(cmd); 3020 } 3021 3022 gpu::CommandHeader header; 3023 uint32_t target; 3024 uint32_t pname; 3025 uint32_t params_shm_id; 3026 uint32_t params_shm_offset; 3027 }; 3028 3029 COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20, 3030 Sizeof_GetRenderbufferParameteriv_is_not_20); 3031 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, header) == 0, 3032 OffsetOf_GetRenderbufferParameteriv_header_not_0); 3033 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, target) == 4, 3034 OffsetOf_GetRenderbufferParameteriv_target_not_4); 3035 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, pname) == 8, 3036 OffsetOf_GetRenderbufferParameteriv_pname_not_8); 3037 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_id) == 12, 3038 OffsetOf_GetRenderbufferParameteriv_params_shm_id_not_12); 3039 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_offset) == 16, 3040 OffsetOf_GetRenderbufferParameteriv_params_shm_offset_not_16); 3041 3042 struct GetShaderiv { 3043 typedef GetShaderiv ValueType; 3044 static const CommandId kCmdId = kGetShaderiv; 3045 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3046 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3047 3048 typedef SizedResult<GLint> Result; 3049 3050 static uint32_t ComputeSize() { 3051 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3052 } 3053 3054 void SetHeader() { header.SetCmd<ValueType>(); } 3055 3056 void Init(GLuint _shader, 3057 GLenum _pname, 3058 uint32_t _params_shm_id, 3059 uint32_t _params_shm_offset) { 3060 SetHeader(); 3061 shader = _shader; 3062 pname = _pname; 3063 params_shm_id = _params_shm_id; 3064 params_shm_offset = _params_shm_offset; 3065 } 3066 3067 void* Set(void* cmd, 3068 GLuint _shader, 3069 GLenum _pname, 3070 uint32_t _params_shm_id, 3071 uint32_t _params_shm_offset) { 3072 static_cast<ValueType*>(cmd) 3073 ->Init(_shader, _pname, _params_shm_id, _params_shm_offset); 3074 return NextCmdAddress<ValueType>(cmd); 3075 } 3076 3077 gpu::CommandHeader header; 3078 uint32_t shader; 3079 uint32_t pname; 3080 uint32_t params_shm_id; 3081 uint32_t params_shm_offset; 3082 }; 3083 3084 COMPILE_ASSERT(sizeof(GetShaderiv) == 20, Sizeof_GetShaderiv_is_not_20); 3085 COMPILE_ASSERT(offsetof(GetShaderiv, header) == 0, 3086 OffsetOf_GetShaderiv_header_not_0); 3087 COMPILE_ASSERT(offsetof(GetShaderiv, shader) == 4, 3088 OffsetOf_GetShaderiv_shader_not_4); 3089 COMPILE_ASSERT(offsetof(GetShaderiv, pname) == 8, 3090 OffsetOf_GetShaderiv_pname_not_8); 3091 COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_id) == 12, 3092 OffsetOf_GetShaderiv_params_shm_id_not_12); 3093 COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_offset) == 16, 3094 OffsetOf_GetShaderiv_params_shm_offset_not_16); 3095 3096 struct GetShaderInfoLog { 3097 typedef GetShaderInfoLog ValueType; 3098 static const CommandId kCmdId = kGetShaderInfoLog; 3099 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3100 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3101 3102 static uint32_t ComputeSize() { 3103 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3104 } 3105 3106 void SetHeader() { header.SetCmd<ValueType>(); } 3107 3108 void Init(GLuint _shader, uint32_t _bucket_id) { 3109 SetHeader(); 3110 shader = _shader; 3111 bucket_id = _bucket_id; 3112 } 3113 3114 void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) { 3115 static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id); 3116 return NextCmdAddress<ValueType>(cmd); 3117 } 3118 3119 gpu::CommandHeader header; 3120 uint32_t shader; 3121 uint32_t bucket_id; 3122 }; 3123 3124 COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 12, 3125 Sizeof_GetShaderInfoLog_is_not_12); 3126 COMPILE_ASSERT(offsetof(GetShaderInfoLog, header) == 0, 3127 OffsetOf_GetShaderInfoLog_header_not_0); 3128 COMPILE_ASSERT(offsetof(GetShaderInfoLog, shader) == 4, 3129 OffsetOf_GetShaderInfoLog_shader_not_4); 3130 COMPILE_ASSERT(offsetof(GetShaderInfoLog, bucket_id) == 8, 3131 OffsetOf_GetShaderInfoLog_bucket_id_not_8); 3132 3133 struct GetShaderPrecisionFormat { 3134 typedef GetShaderPrecisionFormat ValueType; 3135 static const CommandId kCmdId = kGetShaderPrecisionFormat; 3136 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3137 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3138 3139 struct Result { 3140 int32_t success; 3141 int32_t min_range; 3142 int32_t max_range; 3143 int32_t precision; 3144 }; 3145 3146 static uint32_t ComputeSize() { 3147 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3148 } 3149 3150 void SetHeader() { header.SetCmd<ValueType>(); } 3151 3152 void Init(GLenum _shadertype, 3153 GLenum _precisiontype, 3154 uint32_t _result_shm_id, 3155 uint32_t _result_shm_offset) { 3156 SetHeader(); 3157 shadertype = _shadertype; 3158 precisiontype = _precisiontype; 3159 result_shm_id = _result_shm_id; 3160 result_shm_offset = _result_shm_offset; 3161 } 3162 3163 void* Set(void* cmd, 3164 GLenum _shadertype, 3165 GLenum _precisiontype, 3166 uint32_t _result_shm_id, 3167 uint32_t _result_shm_offset) { 3168 static_cast<ValueType*>(cmd) 3169 ->Init(_shadertype, _precisiontype, _result_shm_id, _result_shm_offset); 3170 return NextCmdAddress<ValueType>(cmd); 3171 } 3172 3173 gpu::CommandHeader header; 3174 uint32_t shadertype; 3175 uint32_t precisiontype; 3176 uint32_t result_shm_id; 3177 uint32_t result_shm_offset; 3178 }; 3179 3180 COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 20, 3181 Sizeof_GetShaderPrecisionFormat_is_not_20); 3182 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, header) == 0, 3183 OffsetOf_GetShaderPrecisionFormat_header_not_0); 3184 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, shadertype) == 4, 3185 OffsetOf_GetShaderPrecisionFormat_shadertype_not_4); 3186 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precisiontype) == 8, 3187 OffsetOf_GetShaderPrecisionFormat_precisiontype_not_8); 3188 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_id) == 12, 3189 OffsetOf_GetShaderPrecisionFormat_result_shm_id_not_12); 3190 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_offset) == 16, 3191 OffsetOf_GetShaderPrecisionFormat_result_shm_offset_not_16); 3192 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, success) == 0, 3193 OffsetOf_GetShaderPrecisionFormat_Result_success_not_0); 3194 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, min_range) == 4, 3195 OffsetOf_GetShaderPrecisionFormat_Result_min_range_not_4); 3196 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, max_range) == 8, 3197 OffsetOf_GetShaderPrecisionFormat_Result_max_range_not_8); 3198 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, precision) == 12, 3199 OffsetOf_GetShaderPrecisionFormat_Result_precision_not_12); 3200 3201 struct GetShaderSource { 3202 typedef GetShaderSource ValueType; 3203 static const CommandId kCmdId = kGetShaderSource; 3204 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3205 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3206 3207 static uint32_t ComputeSize() { 3208 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3209 } 3210 3211 void SetHeader() { header.SetCmd<ValueType>(); } 3212 3213 void Init(GLuint _shader, uint32_t _bucket_id) { 3214 SetHeader(); 3215 shader = _shader; 3216 bucket_id = _bucket_id; 3217 } 3218 3219 void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) { 3220 static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id); 3221 return NextCmdAddress<ValueType>(cmd); 3222 } 3223 3224 gpu::CommandHeader header; 3225 uint32_t shader; 3226 uint32_t bucket_id; 3227 }; 3228 3229 COMPILE_ASSERT(sizeof(GetShaderSource) == 12, Sizeof_GetShaderSource_is_not_12); 3230 COMPILE_ASSERT(offsetof(GetShaderSource, header) == 0, 3231 OffsetOf_GetShaderSource_header_not_0); 3232 COMPILE_ASSERT(offsetof(GetShaderSource, shader) == 4, 3233 OffsetOf_GetShaderSource_shader_not_4); 3234 COMPILE_ASSERT(offsetof(GetShaderSource, bucket_id) == 8, 3235 OffsetOf_GetShaderSource_bucket_id_not_8); 3236 3237 struct GetString { 3238 typedef GetString ValueType; 3239 static const CommandId kCmdId = kGetString; 3240 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3241 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3242 3243 static uint32_t ComputeSize() { 3244 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3245 } 3246 3247 void SetHeader() { header.SetCmd<ValueType>(); } 3248 3249 void Init(GLenum _name, uint32_t _bucket_id) { 3250 SetHeader(); 3251 name = _name; 3252 bucket_id = _bucket_id; 3253 } 3254 3255 void* Set(void* cmd, GLenum _name, uint32_t _bucket_id) { 3256 static_cast<ValueType*>(cmd)->Init(_name, _bucket_id); 3257 return NextCmdAddress<ValueType>(cmd); 3258 } 3259 3260 gpu::CommandHeader header; 3261 uint32_t name; 3262 uint32_t bucket_id; 3263 }; 3264 3265 COMPILE_ASSERT(sizeof(GetString) == 12, Sizeof_GetString_is_not_12); 3266 COMPILE_ASSERT(offsetof(GetString, header) == 0, 3267 OffsetOf_GetString_header_not_0); 3268 COMPILE_ASSERT(offsetof(GetString, name) == 4, OffsetOf_GetString_name_not_4); 3269 COMPILE_ASSERT(offsetof(GetString, bucket_id) == 8, 3270 OffsetOf_GetString_bucket_id_not_8); 3271 3272 struct GetTexParameterfv { 3273 typedef GetTexParameterfv ValueType; 3274 static const CommandId kCmdId = kGetTexParameterfv; 3275 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3276 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3277 3278 typedef SizedResult<GLfloat> Result; 3279 3280 static uint32_t ComputeSize() { 3281 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3282 } 3283 3284 void SetHeader() { header.SetCmd<ValueType>(); } 3285 3286 void Init(GLenum _target, 3287 GLenum _pname, 3288 uint32_t _params_shm_id, 3289 uint32_t _params_shm_offset) { 3290 SetHeader(); 3291 target = _target; 3292 pname = _pname; 3293 params_shm_id = _params_shm_id; 3294 params_shm_offset = _params_shm_offset; 3295 } 3296 3297 void* Set(void* cmd, 3298 GLenum _target, 3299 GLenum _pname, 3300 uint32_t _params_shm_id, 3301 uint32_t _params_shm_offset) { 3302 static_cast<ValueType*>(cmd) 3303 ->Init(_target, _pname, _params_shm_id, _params_shm_offset); 3304 return NextCmdAddress<ValueType>(cmd); 3305 } 3306 3307 gpu::CommandHeader header; 3308 uint32_t target; 3309 uint32_t pname; 3310 uint32_t params_shm_id; 3311 uint32_t params_shm_offset; 3312 }; 3313 3314 COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20, 3315 Sizeof_GetTexParameterfv_is_not_20); 3316 COMPILE_ASSERT(offsetof(GetTexParameterfv, header) == 0, 3317 OffsetOf_GetTexParameterfv_header_not_0); 3318 COMPILE_ASSERT(offsetof(GetTexParameterfv, target) == 4, 3319 OffsetOf_GetTexParameterfv_target_not_4); 3320 COMPILE_ASSERT(offsetof(GetTexParameterfv, pname) == 8, 3321 OffsetOf_GetTexParameterfv_pname_not_8); 3322 COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_id) == 12, 3323 OffsetOf_GetTexParameterfv_params_shm_id_not_12); 3324 COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_offset) == 16, 3325 OffsetOf_GetTexParameterfv_params_shm_offset_not_16); 3326 3327 struct GetTexParameteriv { 3328 typedef GetTexParameteriv ValueType; 3329 static const CommandId kCmdId = kGetTexParameteriv; 3330 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3331 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3332 3333 typedef SizedResult<GLint> Result; 3334 3335 static uint32_t ComputeSize() { 3336 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3337 } 3338 3339 void SetHeader() { header.SetCmd<ValueType>(); } 3340 3341 void Init(GLenum _target, 3342 GLenum _pname, 3343 uint32_t _params_shm_id, 3344 uint32_t _params_shm_offset) { 3345 SetHeader(); 3346 target = _target; 3347 pname = _pname; 3348 params_shm_id = _params_shm_id; 3349 params_shm_offset = _params_shm_offset; 3350 } 3351 3352 void* Set(void* cmd, 3353 GLenum _target, 3354 GLenum _pname, 3355 uint32_t _params_shm_id, 3356 uint32_t _params_shm_offset) { 3357 static_cast<ValueType*>(cmd) 3358 ->Init(_target, _pname, _params_shm_id, _params_shm_offset); 3359 return NextCmdAddress<ValueType>(cmd); 3360 } 3361 3362 gpu::CommandHeader header; 3363 uint32_t target; 3364 uint32_t pname; 3365 uint32_t params_shm_id; 3366 uint32_t params_shm_offset; 3367 }; 3368 3369 COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20, 3370 Sizeof_GetTexParameteriv_is_not_20); 3371 COMPILE_ASSERT(offsetof(GetTexParameteriv, header) == 0, 3372 OffsetOf_GetTexParameteriv_header_not_0); 3373 COMPILE_ASSERT(offsetof(GetTexParameteriv, target) == 4, 3374 OffsetOf_GetTexParameteriv_target_not_4); 3375 COMPILE_ASSERT(offsetof(GetTexParameteriv, pname) == 8, 3376 OffsetOf_GetTexParameteriv_pname_not_8); 3377 COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_id) == 12, 3378 OffsetOf_GetTexParameteriv_params_shm_id_not_12); 3379 COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_offset) == 16, 3380 OffsetOf_GetTexParameteriv_params_shm_offset_not_16); 3381 3382 struct GetUniformfv { 3383 typedef GetUniformfv ValueType; 3384 static const CommandId kCmdId = kGetUniformfv; 3385 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3386 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3387 3388 typedef SizedResult<GLfloat> Result; 3389 3390 static uint32_t ComputeSize() { 3391 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3392 } 3393 3394 void SetHeader() { header.SetCmd<ValueType>(); } 3395 3396 void Init(GLuint _program, 3397 GLint _location, 3398 uint32_t _params_shm_id, 3399 uint32_t _params_shm_offset) { 3400 SetHeader(); 3401 program = _program; 3402 location = _location; 3403 params_shm_id = _params_shm_id; 3404 params_shm_offset = _params_shm_offset; 3405 } 3406 3407 void* Set(void* cmd, 3408 GLuint _program, 3409 GLint _location, 3410 uint32_t _params_shm_id, 3411 uint32_t _params_shm_offset) { 3412 static_cast<ValueType*>(cmd) 3413 ->Init(_program, _location, _params_shm_id, _params_shm_offset); 3414 return NextCmdAddress<ValueType>(cmd); 3415 } 3416 3417 gpu::CommandHeader header; 3418 uint32_t program; 3419 int32_t location; 3420 uint32_t params_shm_id; 3421 uint32_t params_shm_offset; 3422 }; 3423 3424 COMPILE_ASSERT(sizeof(GetUniformfv) == 20, Sizeof_GetUniformfv_is_not_20); 3425 COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0, 3426 OffsetOf_GetUniformfv_header_not_0); 3427 COMPILE_ASSERT(offsetof(GetUniformfv, program) == 4, 3428 OffsetOf_GetUniformfv_program_not_4); 3429 COMPILE_ASSERT(offsetof(GetUniformfv, location) == 8, 3430 OffsetOf_GetUniformfv_location_not_8); 3431 COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_id) == 12, 3432 OffsetOf_GetUniformfv_params_shm_id_not_12); 3433 COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_offset) == 16, 3434 OffsetOf_GetUniformfv_params_shm_offset_not_16); 3435 3436 struct GetUniformiv { 3437 typedef GetUniformiv ValueType; 3438 static const CommandId kCmdId = kGetUniformiv; 3439 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3440 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3441 3442 typedef SizedResult<GLint> Result; 3443 3444 static uint32_t ComputeSize() { 3445 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3446 } 3447 3448 void SetHeader() { header.SetCmd<ValueType>(); } 3449 3450 void Init(GLuint _program, 3451 GLint _location, 3452 uint32_t _params_shm_id, 3453 uint32_t _params_shm_offset) { 3454 SetHeader(); 3455 program = _program; 3456 location = _location; 3457 params_shm_id = _params_shm_id; 3458 params_shm_offset = _params_shm_offset; 3459 } 3460 3461 void* Set(void* cmd, 3462 GLuint _program, 3463 GLint _location, 3464 uint32_t _params_shm_id, 3465 uint32_t _params_shm_offset) { 3466 static_cast<ValueType*>(cmd) 3467 ->Init(_program, _location, _params_shm_id, _params_shm_offset); 3468 return NextCmdAddress<ValueType>(cmd); 3469 } 3470 3471 gpu::CommandHeader header; 3472 uint32_t program; 3473 int32_t location; 3474 uint32_t params_shm_id; 3475 uint32_t params_shm_offset; 3476 }; 3477 3478 COMPILE_ASSERT(sizeof(GetUniformiv) == 20, Sizeof_GetUniformiv_is_not_20); 3479 COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0, 3480 OffsetOf_GetUniformiv_header_not_0); 3481 COMPILE_ASSERT(offsetof(GetUniformiv, program) == 4, 3482 OffsetOf_GetUniformiv_program_not_4); 3483 COMPILE_ASSERT(offsetof(GetUniformiv, location) == 8, 3484 OffsetOf_GetUniformiv_location_not_8); 3485 COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_id) == 12, 3486 OffsetOf_GetUniformiv_params_shm_id_not_12); 3487 COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_offset) == 16, 3488 OffsetOf_GetUniformiv_params_shm_offset_not_16); 3489 3490 struct GetVertexAttribfv { 3491 typedef GetVertexAttribfv ValueType; 3492 static const CommandId kCmdId = kGetVertexAttribfv; 3493 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3494 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3495 3496 typedef SizedResult<GLfloat> Result; 3497 3498 static uint32_t ComputeSize() { 3499 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3500 } 3501 3502 void SetHeader() { header.SetCmd<ValueType>(); } 3503 3504 void Init(GLuint _index, 3505 GLenum _pname, 3506 uint32_t _params_shm_id, 3507 uint32_t _params_shm_offset) { 3508 SetHeader(); 3509 index = _index; 3510 pname = _pname; 3511 params_shm_id = _params_shm_id; 3512 params_shm_offset = _params_shm_offset; 3513 } 3514 3515 void* Set(void* cmd, 3516 GLuint _index, 3517 GLenum _pname, 3518 uint32_t _params_shm_id, 3519 uint32_t _params_shm_offset) { 3520 static_cast<ValueType*>(cmd) 3521 ->Init(_index, _pname, _params_shm_id, _params_shm_offset); 3522 return NextCmdAddress<ValueType>(cmd); 3523 } 3524 3525 gpu::CommandHeader header; 3526 uint32_t index; 3527 uint32_t pname; 3528 uint32_t params_shm_id; 3529 uint32_t params_shm_offset; 3530 }; 3531 3532 COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20, 3533 Sizeof_GetVertexAttribfv_is_not_20); 3534 COMPILE_ASSERT(offsetof(GetVertexAttribfv, header) == 0, 3535 OffsetOf_GetVertexAttribfv_header_not_0); 3536 COMPILE_ASSERT(offsetof(GetVertexAttribfv, index) == 4, 3537 OffsetOf_GetVertexAttribfv_index_not_4); 3538 COMPILE_ASSERT(offsetof(GetVertexAttribfv, pname) == 8, 3539 OffsetOf_GetVertexAttribfv_pname_not_8); 3540 COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_id) == 12, 3541 OffsetOf_GetVertexAttribfv_params_shm_id_not_12); 3542 COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_offset) == 16, 3543 OffsetOf_GetVertexAttribfv_params_shm_offset_not_16); 3544 3545 struct GetVertexAttribiv { 3546 typedef GetVertexAttribiv ValueType; 3547 static const CommandId kCmdId = kGetVertexAttribiv; 3548 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3549 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3550 3551 typedef SizedResult<GLint> Result; 3552 3553 static uint32_t ComputeSize() { 3554 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3555 } 3556 3557 void SetHeader() { header.SetCmd<ValueType>(); } 3558 3559 void Init(GLuint _index, 3560 GLenum _pname, 3561 uint32_t _params_shm_id, 3562 uint32_t _params_shm_offset) { 3563 SetHeader(); 3564 index = _index; 3565 pname = _pname; 3566 params_shm_id = _params_shm_id; 3567 params_shm_offset = _params_shm_offset; 3568 } 3569 3570 void* Set(void* cmd, 3571 GLuint _index, 3572 GLenum _pname, 3573 uint32_t _params_shm_id, 3574 uint32_t _params_shm_offset) { 3575 static_cast<ValueType*>(cmd) 3576 ->Init(_index, _pname, _params_shm_id, _params_shm_offset); 3577 return NextCmdAddress<ValueType>(cmd); 3578 } 3579 3580 gpu::CommandHeader header; 3581 uint32_t index; 3582 uint32_t pname; 3583 uint32_t params_shm_id; 3584 uint32_t params_shm_offset; 3585 }; 3586 3587 COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20, 3588 Sizeof_GetVertexAttribiv_is_not_20); 3589 COMPILE_ASSERT(offsetof(GetVertexAttribiv, header) == 0, 3590 OffsetOf_GetVertexAttribiv_header_not_0); 3591 COMPILE_ASSERT(offsetof(GetVertexAttribiv, index) == 4, 3592 OffsetOf_GetVertexAttribiv_index_not_4); 3593 COMPILE_ASSERT(offsetof(GetVertexAttribiv, pname) == 8, 3594 OffsetOf_GetVertexAttribiv_pname_not_8); 3595 COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_id) == 12, 3596 OffsetOf_GetVertexAttribiv_params_shm_id_not_12); 3597 COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_offset) == 16, 3598 OffsetOf_GetVertexAttribiv_params_shm_offset_not_16); 3599 3600 struct GetVertexAttribPointerv { 3601 typedef GetVertexAttribPointerv ValueType; 3602 static const CommandId kCmdId = kGetVertexAttribPointerv; 3603 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3604 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3605 3606 typedef SizedResult<GLuint> Result; 3607 3608 static uint32_t ComputeSize() { 3609 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3610 } 3611 3612 void SetHeader() { header.SetCmd<ValueType>(); } 3613 3614 void Init(GLuint _index, 3615 GLenum _pname, 3616 uint32_t _pointer_shm_id, 3617 uint32_t _pointer_shm_offset) { 3618 SetHeader(); 3619 index = _index; 3620 pname = _pname; 3621 pointer_shm_id = _pointer_shm_id; 3622 pointer_shm_offset = _pointer_shm_offset; 3623 } 3624 3625 void* Set(void* cmd, 3626 GLuint _index, 3627 GLenum _pname, 3628 uint32_t _pointer_shm_id, 3629 uint32_t _pointer_shm_offset) { 3630 static_cast<ValueType*>(cmd) 3631 ->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset); 3632 return NextCmdAddress<ValueType>(cmd); 3633 } 3634 3635 gpu::CommandHeader header; 3636 uint32_t index; 3637 uint32_t pname; 3638 uint32_t pointer_shm_id; 3639 uint32_t pointer_shm_offset; 3640 }; 3641 3642 COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20, 3643 Sizeof_GetVertexAttribPointerv_is_not_20); 3644 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, header) == 0, 3645 OffsetOf_GetVertexAttribPointerv_header_not_0); 3646 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, index) == 4, 3647 OffsetOf_GetVertexAttribPointerv_index_not_4); 3648 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pname) == 8, 3649 OffsetOf_GetVertexAttribPointerv_pname_not_8); 3650 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_id) == 12, 3651 OffsetOf_GetVertexAttribPointerv_pointer_shm_id_not_12); 3652 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_offset) == 16, 3653 OffsetOf_GetVertexAttribPointerv_pointer_shm_offset_not_16); 3654 3655 struct Hint { 3656 typedef Hint ValueType; 3657 static const CommandId kCmdId = kHint; 3658 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3659 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3660 3661 static uint32_t ComputeSize() { 3662 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3663 } 3664 3665 void SetHeader() { header.SetCmd<ValueType>(); } 3666 3667 void Init(GLenum _target, GLenum _mode) { 3668 SetHeader(); 3669 target = _target; 3670 mode = _mode; 3671 } 3672 3673 void* Set(void* cmd, GLenum _target, GLenum _mode) { 3674 static_cast<ValueType*>(cmd)->Init(_target, _mode); 3675 return NextCmdAddress<ValueType>(cmd); 3676 } 3677 3678 gpu::CommandHeader header; 3679 uint32_t target; 3680 uint32_t mode; 3681 }; 3682 3683 COMPILE_ASSERT(sizeof(Hint) == 12, Sizeof_Hint_is_not_12); 3684 COMPILE_ASSERT(offsetof(Hint, header) == 0, OffsetOf_Hint_header_not_0); 3685 COMPILE_ASSERT(offsetof(Hint, target) == 4, OffsetOf_Hint_target_not_4); 3686 COMPILE_ASSERT(offsetof(Hint, mode) == 8, OffsetOf_Hint_mode_not_8); 3687 3688 struct IsBuffer { 3689 typedef IsBuffer ValueType; 3690 static const CommandId kCmdId = kIsBuffer; 3691 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3692 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3693 3694 typedef uint32_t Result; 3695 3696 static uint32_t ComputeSize() { 3697 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3698 } 3699 3700 void SetHeader() { header.SetCmd<ValueType>(); } 3701 3702 void Init(GLuint _buffer, 3703 uint32_t _result_shm_id, 3704 uint32_t _result_shm_offset) { 3705 SetHeader(); 3706 buffer = _buffer; 3707 result_shm_id = _result_shm_id; 3708 result_shm_offset = _result_shm_offset; 3709 } 3710 3711 void* Set(void* cmd, 3712 GLuint _buffer, 3713 uint32_t _result_shm_id, 3714 uint32_t _result_shm_offset) { 3715 static_cast<ValueType*>(cmd) 3716 ->Init(_buffer, _result_shm_id, _result_shm_offset); 3717 return NextCmdAddress<ValueType>(cmd); 3718 } 3719 3720 gpu::CommandHeader header; 3721 uint32_t buffer; 3722 uint32_t result_shm_id; 3723 uint32_t result_shm_offset; 3724 }; 3725 3726 COMPILE_ASSERT(sizeof(IsBuffer) == 16, Sizeof_IsBuffer_is_not_16); 3727 COMPILE_ASSERT(offsetof(IsBuffer, header) == 0, OffsetOf_IsBuffer_header_not_0); 3728 COMPILE_ASSERT(offsetof(IsBuffer, buffer) == 4, OffsetOf_IsBuffer_buffer_not_4); 3729 COMPILE_ASSERT(offsetof(IsBuffer, result_shm_id) == 8, 3730 OffsetOf_IsBuffer_result_shm_id_not_8); 3731 COMPILE_ASSERT(offsetof(IsBuffer, result_shm_offset) == 12, 3732 OffsetOf_IsBuffer_result_shm_offset_not_12); 3733 3734 struct IsEnabled { 3735 typedef IsEnabled ValueType; 3736 static const CommandId kCmdId = kIsEnabled; 3737 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3738 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3739 3740 typedef uint32_t Result; 3741 3742 static uint32_t ComputeSize() { 3743 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3744 } 3745 3746 void SetHeader() { header.SetCmd<ValueType>(); } 3747 3748 void Init(GLenum _cap, uint32_t _result_shm_id, uint32_t _result_shm_offset) { 3749 SetHeader(); 3750 cap = _cap; 3751 result_shm_id = _result_shm_id; 3752 result_shm_offset = _result_shm_offset; 3753 } 3754 3755 void* Set(void* cmd, 3756 GLenum _cap, 3757 uint32_t _result_shm_id, 3758 uint32_t _result_shm_offset) { 3759 static_cast<ValueType*>(cmd) 3760 ->Init(_cap, _result_shm_id, _result_shm_offset); 3761 return NextCmdAddress<ValueType>(cmd); 3762 } 3763 3764 gpu::CommandHeader header; 3765 uint32_t cap; 3766 uint32_t result_shm_id; 3767 uint32_t result_shm_offset; 3768 }; 3769 3770 COMPILE_ASSERT(sizeof(IsEnabled) == 16, Sizeof_IsEnabled_is_not_16); 3771 COMPILE_ASSERT(offsetof(IsEnabled, header) == 0, 3772 OffsetOf_IsEnabled_header_not_0); 3773 COMPILE_ASSERT(offsetof(IsEnabled, cap) == 4, OffsetOf_IsEnabled_cap_not_4); 3774 COMPILE_ASSERT(offsetof(IsEnabled, result_shm_id) == 8, 3775 OffsetOf_IsEnabled_result_shm_id_not_8); 3776 COMPILE_ASSERT(offsetof(IsEnabled, result_shm_offset) == 12, 3777 OffsetOf_IsEnabled_result_shm_offset_not_12); 3778 3779 struct IsFramebuffer { 3780 typedef IsFramebuffer ValueType; 3781 static const CommandId kCmdId = kIsFramebuffer; 3782 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3783 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3784 3785 typedef uint32_t Result; 3786 3787 static uint32_t ComputeSize() { 3788 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3789 } 3790 3791 void SetHeader() { header.SetCmd<ValueType>(); } 3792 3793 void Init(GLuint _framebuffer, 3794 uint32_t _result_shm_id, 3795 uint32_t _result_shm_offset) { 3796 SetHeader(); 3797 framebuffer = _framebuffer; 3798 result_shm_id = _result_shm_id; 3799 result_shm_offset = _result_shm_offset; 3800 } 3801 3802 void* Set(void* cmd, 3803 GLuint _framebuffer, 3804 uint32_t _result_shm_id, 3805 uint32_t _result_shm_offset) { 3806 static_cast<ValueType*>(cmd) 3807 ->Init(_framebuffer, _result_shm_id, _result_shm_offset); 3808 return NextCmdAddress<ValueType>(cmd); 3809 } 3810 3811 gpu::CommandHeader header; 3812 uint32_t framebuffer; 3813 uint32_t result_shm_id; 3814 uint32_t result_shm_offset; 3815 }; 3816 3817 COMPILE_ASSERT(sizeof(IsFramebuffer) == 16, Sizeof_IsFramebuffer_is_not_16); 3818 COMPILE_ASSERT(offsetof(IsFramebuffer, header) == 0, 3819 OffsetOf_IsFramebuffer_header_not_0); 3820 COMPILE_ASSERT(offsetof(IsFramebuffer, framebuffer) == 4, 3821 OffsetOf_IsFramebuffer_framebuffer_not_4); 3822 COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_id) == 8, 3823 OffsetOf_IsFramebuffer_result_shm_id_not_8); 3824 COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_offset) == 12, 3825 OffsetOf_IsFramebuffer_result_shm_offset_not_12); 3826 3827 struct IsProgram { 3828 typedef IsProgram ValueType; 3829 static const CommandId kCmdId = kIsProgram; 3830 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3831 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3832 3833 typedef uint32_t Result; 3834 3835 static uint32_t ComputeSize() { 3836 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3837 } 3838 3839 void SetHeader() { header.SetCmd<ValueType>(); } 3840 3841 void Init(GLuint _program, 3842 uint32_t _result_shm_id, 3843 uint32_t _result_shm_offset) { 3844 SetHeader(); 3845 program = _program; 3846 result_shm_id = _result_shm_id; 3847 result_shm_offset = _result_shm_offset; 3848 } 3849 3850 void* Set(void* cmd, 3851 GLuint _program, 3852 uint32_t _result_shm_id, 3853 uint32_t _result_shm_offset) { 3854 static_cast<ValueType*>(cmd) 3855 ->Init(_program, _result_shm_id, _result_shm_offset); 3856 return NextCmdAddress<ValueType>(cmd); 3857 } 3858 3859 gpu::CommandHeader header; 3860 uint32_t program; 3861 uint32_t result_shm_id; 3862 uint32_t result_shm_offset; 3863 }; 3864 3865 COMPILE_ASSERT(sizeof(IsProgram) == 16, Sizeof_IsProgram_is_not_16); 3866 COMPILE_ASSERT(offsetof(IsProgram, header) == 0, 3867 OffsetOf_IsProgram_header_not_0); 3868 COMPILE_ASSERT(offsetof(IsProgram, program) == 4, 3869 OffsetOf_IsProgram_program_not_4); 3870 COMPILE_ASSERT(offsetof(IsProgram, result_shm_id) == 8, 3871 OffsetOf_IsProgram_result_shm_id_not_8); 3872 COMPILE_ASSERT(offsetof(IsProgram, result_shm_offset) == 12, 3873 OffsetOf_IsProgram_result_shm_offset_not_12); 3874 3875 struct IsRenderbuffer { 3876 typedef IsRenderbuffer ValueType; 3877 static const CommandId kCmdId = kIsRenderbuffer; 3878 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3879 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3880 3881 typedef uint32_t Result; 3882 3883 static uint32_t ComputeSize() { 3884 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3885 } 3886 3887 void SetHeader() { header.SetCmd<ValueType>(); } 3888 3889 void Init(GLuint _renderbuffer, 3890 uint32_t _result_shm_id, 3891 uint32_t _result_shm_offset) { 3892 SetHeader(); 3893 renderbuffer = _renderbuffer; 3894 result_shm_id = _result_shm_id; 3895 result_shm_offset = _result_shm_offset; 3896 } 3897 3898 void* Set(void* cmd, 3899 GLuint _renderbuffer, 3900 uint32_t _result_shm_id, 3901 uint32_t _result_shm_offset) { 3902 static_cast<ValueType*>(cmd) 3903 ->Init(_renderbuffer, _result_shm_id, _result_shm_offset); 3904 return NextCmdAddress<ValueType>(cmd); 3905 } 3906 3907 gpu::CommandHeader header; 3908 uint32_t renderbuffer; 3909 uint32_t result_shm_id; 3910 uint32_t result_shm_offset; 3911 }; 3912 3913 COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16, Sizeof_IsRenderbuffer_is_not_16); 3914 COMPILE_ASSERT(offsetof(IsRenderbuffer, header) == 0, 3915 OffsetOf_IsRenderbuffer_header_not_0); 3916 COMPILE_ASSERT(offsetof(IsRenderbuffer, renderbuffer) == 4, 3917 OffsetOf_IsRenderbuffer_renderbuffer_not_4); 3918 COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_id) == 8, 3919 OffsetOf_IsRenderbuffer_result_shm_id_not_8); 3920 COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_offset) == 12, 3921 OffsetOf_IsRenderbuffer_result_shm_offset_not_12); 3922 3923 struct IsShader { 3924 typedef IsShader ValueType; 3925 static const CommandId kCmdId = kIsShader; 3926 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3927 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3928 3929 typedef uint32_t Result; 3930 3931 static uint32_t ComputeSize() { 3932 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3933 } 3934 3935 void SetHeader() { header.SetCmd<ValueType>(); } 3936 3937 void Init(GLuint _shader, 3938 uint32_t _result_shm_id, 3939 uint32_t _result_shm_offset) { 3940 SetHeader(); 3941 shader = _shader; 3942 result_shm_id = _result_shm_id; 3943 result_shm_offset = _result_shm_offset; 3944 } 3945 3946 void* Set(void* cmd, 3947 GLuint _shader, 3948 uint32_t _result_shm_id, 3949 uint32_t _result_shm_offset) { 3950 static_cast<ValueType*>(cmd) 3951 ->Init(_shader, _result_shm_id, _result_shm_offset); 3952 return NextCmdAddress<ValueType>(cmd); 3953 } 3954 3955 gpu::CommandHeader header; 3956 uint32_t shader; 3957 uint32_t result_shm_id; 3958 uint32_t result_shm_offset; 3959 }; 3960 3961 COMPILE_ASSERT(sizeof(IsShader) == 16, Sizeof_IsShader_is_not_16); 3962 COMPILE_ASSERT(offsetof(IsShader, header) == 0, OffsetOf_IsShader_header_not_0); 3963 COMPILE_ASSERT(offsetof(IsShader, shader) == 4, OffsetOf_IsShader_shader_not_4); 3964 COMPILE_ASSERT(offsetof(IsShader, result_shm_id) == 8, 3965 OffsetOf_IsShader_result_shm_id_not_8); 3966 COMPILE_ASSERT(offsetof(IsShader, result_shm_offset) == 12, 3967 OffsetOf_IsShader_result_shm_offset_not_12); 3968 3969 struct IsTexture { 3970 typedef IsTexture ValueType; 3971 static const CommandId kCmdId = kIsTexture; 3972 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 3973 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 3974 3975 typedef uint32_t Result; 3976 3977 static uint32_t ComputeSize() { 3978 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 3979 } 3980 3981 void SetHeader() { header.SetCmd<ValueType>(); } 3982 3983 void Init(GLuint _texture, 3984 uint32_t _result_shm_id, 3985 uint32_t _result_shm_offset) { 3986 SetHeader(); 3987 texture = _texture; 3988 result_shm_id = _result_shm_id; 3989 result_shm_offset = _result_shm_offset; 3990 } 3991 3992 void* Set(void* cmd, 3993 GLuint _texture, 3994 uint32_t _result_shm_id, 3995 uint32_t _result_shm_offset) { 3996 static_cast<ValueType*>(cmd) 3997 ->Init(_texture, _result_shm_id, _result_shm_offset); 3998 return NextCmdAddress<ValueType>(cmd); 3999 } 4000 4001 gpu::CommandHeader header; 4002 uint32_t texture; 4003 uint32_t result_shm_id; 4004 uint32_t result_shm_offset; 4005 }; 4006 4007 COMPILE_ASSERT(sizeof(IsTexture) == 16, Sizeof_IsTexture_is_not_16); 4008 COMPILE_ASSERT(offsetof(IsTexture, header) == 0, 4009 OffsetOf_IsTexture_header_not_0); 4010 COMPILE_ASSERT(offsetof(IsTexture, texture) == 4, 4011 OffsetOf_IsTexture_texture_not_4); 4012 COMPILE_ASSERT(offsetof(IsTexture, result_shm_id) == 8, 4013 OffsetOf_IsTexture_result_shm_id_not_8); 4014 COMPILE_ASSERT(offsetof(IsTexture, result_shm_offset) == 12, 4015 OffsetOf_IsTexture_result_shm_offset_not_12); 4016 4017 struct LineWidth { 4018 typedef LineWidth ValueType; 4019 static const CommandId kCmdId = kLineWidth; 4020 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4021 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4022 4023 static uint32_t ComputeSize() { 4024 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4025 } 4026 4027 void SetHeader() { header.SetCmd<ValueType>(); } 4028 4029 void Init(GLfloat _width) { 4030 SetHeader(); 4031 width = _width; 4032 } 4033 4034 void* Set(void* cmd, GLfloat _width) { 4035 static_cast<ValueType*>(cmd)->Init(_width); 4036 return NextCmdAddress<ValueType>(cmd); 4037 } 4038 4039 gpu::CommandHeader header; 4040 float width; 4041 }; 4042 4043 COMPILE_ASSERT(sizeof(LineWidth) == 8, Sizeof_LineWidth_is_not_8); 4044 COMPILE_ASSERT(offsetof(LineWidth, header) == 0, 4045 OffsetOf_LineWidth_header_not_0); 4046 COMPILE_ASSERT(offsetof(LineWidth, width) == 4, OffsetOf_LineWidth_width_not_4); 4047 4048 struct LinkProgram { 4049 typedef LinkProgram ValueType; 4050 static const CommandId kCmdId = kLinkProgram; 4051 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4052 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4053 4054 static uint32_t ComputeSize() { 4055 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4056 } 4057 4058 void SetHeader() { header.SetCmd<ValueType>(); } 4059 4060 void Init(GLuint _program) { 4061 SetHeader(); 4062 program = _program; 4063 } 4064 4065 void* Set(void* cmd, GLuint _program) { 4066 static_cast<ValueType*>(cmd)->Init(_program); 4067 return NextCmdAddress<ValueType>(cmd); 4068 } 4069 4070 gpu::CommandHeader header; 4071 uint32_t program; 4072 }; 4073 4074 COMPILE_ASSERT(sizeof(LinkProgram) == 8, Sizeof_LinkProgram_is_not_8); 4075 COMPILE_ASSERT(offsetof(LinkProgram, header) == 0, 4076 OffsetOf_LinkProgram_header_not_0); 4077 COMPILE_ASSERT(offsetof(LinkProgram, program) == 4, 4078 OffsetOf_LinkProgram_program_not_4); 4079 4080 struct PixelStorei { 4081 typedef PixelStorei ValueType; 4082 static const CommandId kCmdId = kPixelStorei; 4083 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4084 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4085 4086 static uint32_t ComputeSize() { 4087 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4088 } 4089 4090 void SetHeader() { header.SetCmd<ValueType>(); } 4091 4092 void Init(GLenum _pname, GLint _param) { 4093 SetHeader(); 4094 pname = _pname; 4095 param = _param; 4096 } 4097 4098 void* Set(void* cmd, GLenum _pname, GLint _param) { 4099 static_cast<ValueType*>(cmd)->Init(_pname, _param); 4100 return NextCmdAddress<ValueType>(cmd); 4101 } 4102 4103 gpu::CommandHeader header; 4104 uint32_t pname; 4105 int32_t param; 4106 }; 4107 4108 COMPILE_ASSERT(sizeof(PixelStorei) == 12, Sizeof_PixelStorei_is_not_12); 4109 COMPILE_ASSERT(offsetof(PixelStorei, header) == 0, 4110 OffsetOf_PixelStorei_header_not_0); 4111 COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4, 4112 OffsetOf_PixelStorei_pname_not_4); 4113 COMPILE_ASSERT(offsetof(PixelStorei, param) == 8, 4114 OffsetOf_PixelStorei_param_not_8); 4115 4116 struct PolygonOffset { 4117 typedef PolygonOffset ValueType; 4118 static const CommandId kCmdId = kPolygonOffset; 4119 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4120 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4121 4122 static uint32_t ComputeSize() { 4123 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4124 } 4125 4126 void SetHeader() { header.SetCmd<ValueType>(); } 4127 4128 void Init(GLfloat _factor, GLfloat _units) { 4129 SetHeader(); 4130 factor = _factor; 4131 units = _units; 4132 } 4133 4134 void* Set(void* cmd, GLfloat _factor, GLfloat _units) { 4135 static_cast<ValueType*>(cmd)->Init(_factor, _units); 4136 return NextCmdAddress<ValueType>(cmd); 4137 } 4138 4139 gpu::CommandHeader header; 4140 float factor; 4141 float units; 4142 }; 4143 4144 COMPILE_ASSERT(sizeof(PolygonOffset) == 12, Sizeof_PolygonOffset_is_not_12); 4145 COMPILE_ASSERT(offsetof(PolygonOffset, header) == 0, 4146 OffsetOf_PolygonOffset_header_not_0); 4147 COMPILE_ASSERT(offsetof(PolygonOffset, factor) == 4, 4148 OffsetOf_PolygonOffset_factor_not_4); 4149 COMPILE_ASSERT(offsetof(PolygonOffset, units) == 8, 4150 OffsetOf_PolygonOffset_units_not_8); 4151 4152 // ReadPixels has the result separated from the pixel buffer so that 4153 // it is easier to specify the result going to some specific place 4154 // that exactly fits the rectangle of pixels. 4155 struct ReadPixels { 4156 typedef ReadPixels ValueType; 4157 static const CommandId kCmdId = kReadPixels; 4158 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4159 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4160 4161 typedef uint32_t Result; 4162 4163 static uint32_t ComputeSize() { 4164 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4165 } 4166 4167 void SetHeader() { header.SetCmd<ValueType>(); } 4168 4169 void Init(GLint _x, 4170 GLint _y, 4171 GLsizei _width, 4172 GLsizei _height, 4173 GLenum _format, 4174 GLenum _type, 4175 uint32_t _pixels_shm_id, 4176 uint32_t _pixels_shm_offset, 4177 uint32_t _result_shm_id, 4178 uint32_t _result_shm_offset, 4179 GLboolean _async) { 4180 SetHeader(); 4181 x = _x; 4182 y = _y; 4183 width = _width; 4184 height = _height; 4185 format = _format; 4186 type = _type; 4187 pixels_shm_id = _pixels_shm_id; 4188 pixels_shm_offset = _pixels_shm_offset; 4189 result_shm_id = _result_shm_id; 4190 result_shm_offset = _result_shm_offset; 4191 async = _async; 4192 } 4193 4194 void* Set(void* cmd, 4195 GLint _x, 4196 GLint _y, 4197 GLsizei _width, 4198 GLsizei _height, 4199 GLenum _format, 4200 GLenum _type, 4201 uint32_t _pixels_shm_id, 4202 uint32_t _pixels_shm_offset, 4203 uint32_t _result_shm_id, 4204 uint32_t _result_shm_offset, 4205 GLboolean _async) { 4206 static_cast<ValueType*>(cmd)->Init(_x, 4207 _y, 4208 _width, 4209 _height, 4210 _format, 4211 _type, 4212 _pixels_shm_id, 4213 _pixels_shm_offset, 4214 _result_shm_id, 4215 _result_shm_offset, 4216 _async); 4217 return NextCmdAddress<ValueType>(cmd); 4218 } 4219 4220 gpu::CommandHeader header; 4221 int32_t x; 4222 int32_t y; 4223 int32_t width; 4224 int32_t height; 4225 uint32_t format; 4226 uint32_t type; 4227 uint32_t pixels_shm_id; 4228 uint32_t pixels_shm_offset; 4229 uint32_t result_shm_id; 4230 uint32_t result_shm_offset; 4231 uint32_t async; 4232 }; 4233 4234 COMPILE_ASSERT(sizeof(ReadPixels) == 48, Sizeof_ReadPixels_is_not_48); 4235 COMPILE_ASSERT(offsetof(ReadPixels, header) == 0, 4236 OffsetOf_ReadPixels_header_not_0); 4237 COMPILE_ASSERT(offsetof(ReadPixels, x) == 4, OffsetOf_ReadPixels_x_not_4); 4238 COMPILE_ASSERT(offsetof(ReadPixels, y) == 8, OffsetOf_ReadPixels_y_not_8); 4239 COMPILE_ASSERT(offsetof(ReadPixels, width) == 12, 4240 OffsetOf_ReadPixels_width_not_12); 4241 COMPILE_ASSERT(offsetof(ReadPixels, height) == 16, 4242 OffsetOf_ReadPixels_height_not_16); 4243 COMPILE_ASSERT(offsetof(ReadPixels, format) == 20, 4244 OffsetOf_ReadPixels_format_not_20); 4245 COMPILE_ASSERT(offsetof(ReadPixels, type) == 24, 4246 OffsetOf_ReadPixels_type_not_24); 4247 COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_id) == 28, 4248 OffsetOf_ReadPixels_pixels_shm_id_not_28); 4249 COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_offset) == 32, 4250 OffsetOf_ReadPixels_pixels_shm_offset_not_32); 4251 COMPILE_ASSERT(offsetof(ReadPixels, result_shm_id) == 36, 4252 OffsetOf_ReadPixels_result_shm_id_not_36); 4253 COMPILE_ASSERT(offsetof(ReadPixels, result_shm_offset) == 40, 4254 OffsetOf_ReadPixels_result_shm_offset_not_40); 4255 COMPILE_ASSERT(offsetof(ReadPixels, async) == 44, 4256 OffsetOf_ReadPixels_async_not_44); 4257 4258 struct ReleaseShaderCompiler { 4259 typedef ReleaseShaderCompiler ValueType; 4260 static const CommandId kCmdId = kReleaseShaderCompiler; 4261 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4262 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4263 4264 static uint32_t ComputeSize() { 4265 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4266 } 4267 4268 void SetHeader() { header.SetCmd<ValueType>(); } 4269 4270 void Init() { SetHeader(); } 4271 4272 void* Set(void* cmd) { 4273 static_cast<ValueType*>(cmd)->Init(); 4274 return NextCmdAddress<ValueType>(cmd); 4275 } 4276 4277 gpu::CommandHeader header; 4278 }; 4279 4280 COMPILE_ASSERT(sizeof(ReleaseShaderCompiler) == 4, 4281 Sizeof_ReleaseShaderCompiler_is_not_4); 4282 COMPILE_ASSERT(offsetof(ReleaseShaderCompiler, header) == 0, 4283 OffsetOf_ReleaseShaderCompiler_header_not_0); 4284 4285 struct RenderbufferStorage { 4286 typedef RenderbufferStorage ValueType; 4287 static const CommandId kCmdId = kRenderbufferStorage; 4288 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4289 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4290 4291 static uint32_t ComputeSize() { 4292 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4293 } 4294 4295 void SetHeader() { header.SetCmd<ValueType>(); } 4296 4297 void Init(GLenum _target, 4298 GLenum _internalformat, 4299 GLsizei _width, 4300 GLsizei _height) { 4301 SetHeader(); 4302 target = _target; 4303 internalformat = _internalformat; 4304 width = _width; 4305 height = _height; 4306 } 4307 4308 void* Set(void* cmd, 4309 GLenum _target, 4310 GLenum _internalformat, 4311 GLsizei _width, 4312 GLsizei _height) { 4313 static_cast<ValueType*>(cmd) 4314 ->Init(_target, _internalformat, _width, _height); 4315 return NextCmdAddress<ValueType>(cmd); 4316 } 4317 4318 gpu::CommandHeader header; 4319 uint32_t target; 4320 uint32_t internalformat; 4321 int32_t width; 4322 int32_t height; 4323 }; 4324 4325 COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20, 4326 Sizeof_RenderbufferStorage_is_not_20); 4327 COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0, 4328 OffsetOf_RenderbufferStorage_header_not_0); 4329 COMPILE_ASSERT(offsetof(RenderbufferStorage, target) == 4, 4330 OffsetOf_RenderbufferStorage_target_not_4); 4331 COMPILE_ASSERT(offsetof(RenderbufferStorage, internalformat) == 8, 4332 OffsetOf_RenderbufferStorage_internalformat_not_8); 4333 COMPILE_ASSERT(offsetof(RenderbufferStorage, width) == 12, 4334 OffsetOf_RenderbufferStorage_width_not_12); 4335 COMPILE_ASSERT(offsetof(RenderbufferStorage, height) == 16, 4336 OffsetOf_RenderbufferStorage_height_not_16); 4337 4338 struct SampleCoverage { 4339 typedef SampleCoverage ValueType; 4340 static const CommandId kCmdId = kSampleCoverage; 4341 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4342 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4343 4344 static uint32_t ComputeSize() { 4345 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4346 } 4347 4348 void SetHeader() { header.SetCmd<ValueType>(); } 4349 4350 void Init(GLclampf _value, GLboolean _invert) { 4351 SetHeader(); 4352 value = _value; 4353 invert = _invert; 4354 } 4355 4356 void* Set(void* cmd, GLclampf _value, GLboolean _invert) { 4357 static_cast<ValueType*>(cmd)->Init(_value, _invert); 4358 return NextCmdAddress<ValueType>(cmd); 4359 } 4360 4361 gpu::CommandHeader header; 4362 float value; 4363 uint32_t invert; 4364 }; 4365 4366 COMPILE_ASSERT(sizeof(SampleCoverage) == 12, Sizeof_SampleCoverage_is_not_12); 4367 COMPILE_ASSERT(offsetof(SampleCoverage, header) == 0, 4368 OffsetOf_SampleCoverage_header_not_0); 4369 COMPILE_ASSERT(offsetof(SampleCoverage, value) == 4, 4370 OffsetOf_SampleCoverage_value_not_4); 4371 COMPILE_ASSERT(offsetof(SampleCoverage, invert) == 8, 4372 OffsetOf_SampleCoverage_invert_not_8); 4373 4374 struct Scissor { 4375 typedef Scissor ValueType; 4376 static const CommandId kCmdId = kScissor; 4377 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4378 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4379 4380 static uint32_t ComputeSize() { 4381 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4382 } 4383 4384 void SetHeader() { header.SetCmd<ValueType>(); } 4385 4386 void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { 4387 SetHeader(); 4388 x = _x; 4389 y = _y; 4390 width = _width; 4391 height = _height; 4392 } 4393 4394 void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { 4395 static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height); 4396 return NextCmdAddress<ValueType>(cmd); 4397 } 4398 4399 gpu::CommandHeader header; 4400 int32_t x; 4401 int32_t y; 4402 int32_t width; 4403 int32_t height; 4404 }; 4405 4406 COMPILE_ASSERT(sizeof(Scissor) == 20, Sizeof_Scissor_is_not_20); 4407 COMPILE_ASSERT(offsetof(Scissor, header) == 0, OffsetOf_Scissor_header_not_0); 4408 COMPILE_ASSERT(offsetof(Scissor, x) == 4, OffsetOf_Scissor_x_not_4); 4409 COMPILE_ASSERT(offsetof(Scissor, y) == 8, OffsetOf_Scissor_y_not_8); 4410 COMPILE_ASSERT(offsetof(Scissor, width) == 12, OffsetOf_Scissor_width_not_12); 4411 COMPILE_ASSERT(offsetof(Scissor, height) == 16, OffsetOf_Scissor_height_not_16); 4412 4413 struct ShaderBinary { 4414 typedef ShaderBinary ValueType; 4415 static const CommandId kCmdId = kShaderBinary; 4416 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4417 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4418 4419 static uint32_t ComputeSize() { 4420 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4421 } 4422 4423 void SetHeader() { header.SetCmd<ValueType>(); } 4424 4425 void Init(GLsizei _n, 4426 uint32_t _shaders_shm_id, 4427 uint32_t _shaders_shm_offset, 4428 GLenum _binaryformat, 4429 uint32_t _binary_shm_id, 4430 uint32_t _binary_shm_offset, 4431 GLsizei _length) { 4432 SetHeader(); 4433 n = _n; 4434 shaders_shm_id = _shaders_shm_id; 4435 shaders_shm_offset = _shaders_shm_offset; 4436 binaryformat = _binaryformat; 4437 binary_shm_id = _binary_shm_id; 4438 binary_shm_offset = _binary_shm_offset; 4439 length = _length; 4440 } 4441 4442 void* Set(void* cmd, 4443 GLsizei _n, 4444 uint32_t _shaders_shm_id, 4445 uint32_t _shaders_shm_offset, 4446 GLenum _binaryformat, 4447 uint32_t _binary_shm_id, 4448 uint32_t _binary_shm_offset, 4449 GLsizei _length) { 4450 static_cast<ValueType*>(cmd)->Init(_n, 4451 _shaders_shm_id, 4452 _shaders_shm_offset, 4453 _binaryformat, 4454 _binary_shm_id, 4455 _binary_shm_offset, 4456 _length); 4457 return NextCmdAddress<ValueType>(cmd); 4458 } 4459 4460 gpu::CommandHeader header; 4461 int32_t n; 4462 uint32_t shaders_shm_id; 4463 uint32_t shaders_shm_offset; 4464 uint32_t binaryformat; 4465 uint32_t binary_shm_id; 4466 uint32_t binary_shm_offset; 4467 int32_t length; 4468 }; 4469 4470 COMPILE_ASSERT(sizeof(ShaderBinary) == 32, Sizeof_ShaderBinary_is_not_32); 4471 COMPILE_ASSERT(offsetof(ShaderBinary, header) == 0, 4472 OffsetOf_ShaderBinary_header_not_0); 4473 COMPILE_ASSERT(offsetof(ShaderBinary, n) == 4, OffsetOf_ShaderBinary_n_not_4); 4474 COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_id) == 8, 4475 OffsetOf_ShaderBinary_shaders_shm_id_not_8); 4476 COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_offset) == 12, 4477 OffsetOf_ShaderBinary_shaders_shm_offset_not_12); 4478 COMPILE_ASSERT(offsetof(ShaderBinary, binaryformat) == 16, 4479 OffsetOf_ShaderBinary_binaryformat_not_16); 4480 COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_id) == 20, 4481 OffsetOf_ShaderBinary_binary_shm_id_not_20); 4482 COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_offset) == 24, 4483 OffsetOf_ShaderBinary_binary_shm_offset_not_24); 4484 COMPILE_ASSERT(offsetof(ShaderBinary, length) == 28, 4485 OffsetOf_ShaderBinary_length_not_28); 4486 4487 struct ShaderSourceBucket { 4488 typedef ShaderSourceBucket ValueType; 4489 static const CommandId kCmdId = kShaderSourceBucket; 4490 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4491 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4492 4493 static uint32_t ComputeSize() { 4494 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4495 } 4496 4497 void SetHeader() { header.SetCmd<ValueType>(); } 4498 4499 void Init(GLuint _shader, uint32_t _data_bucket_id) { 4500 SetHeader(); 4501 shader = _shader; 4502 data_bucket_id = _data_bucket_id; 4503 } 4504 4505 void* Set(void* cmd, GLuint _shader, uint32_t _data_bucket_id) { 4506 static_cast<ValueType*>(cmd)->Init(_shader, _data_bucket_id); 4507 return NextCmdAddress<ValueType>(cmd); 4508 } 4509 4510 gpu::CommandHeader header; 4511 uint32_t shader; 4512 uint32_t data_bucket_id; 4513 }; 4514 4515 COMPILE_ASSERT(sizeof(ShaderSourceBucket) == 12, 4516 Sizeof_ShaderSourceBucket_is_not_12); 4517 COMPILE_ASSERT(offsetof(ShaderSourceBucket, header) == 0, 4518 OffsetOf_ShaderSourceBucket_header_not_0); 4519 COMPILE_ASSERT(offsetof(ShaderSourceBucket, shader) == 4, 4520 OffsetOf_ShaderSourceBucket_shader_not_4); 4521 COMPILE_ASSERT(offsetof(ShaderSourceBucket, data_bucket_id) == 8, 4522 OffsetOf_ShaderSourceBucket_data_bucket_id_not_8); 4523 4524 struct StencilFunc { 4525 typedef StencilFunc ValueType; 4526 static const CommandId kCmdId = kStencilFunc; 4527 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4528 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4529 4530 static uint32_t ComputeSize() { 4531 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4532 } 4533 4534 void SetHeader() { header.SetCmd<ValueType>(); } 4535 4536 void Init(GLenum _func, GLint _ref, GLuint _mask) { 4537 SetHeader(); 4538 func = _func; 4539 ref = _ref; 4540 mask = _mask; 4541 } 4542 4543 void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) { 4544 static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask); 4545 return NextCmdAddress<ValueType>(cmd); 4546 } 4547 4548 gpu::CommandHeader header; 4549 uint32_t func; 4550 int32_t ref; 4551 uint32_t mask; 4552 }; 4553 4554 COMPILE_ASSERT(sizeof(StencilFunc) == 16, Sizeof_StencilFunc_is_not_16); 4555 COMPILE_ASSERT(offsetof(StencilFunc, header) == 0, 4556 OffsetOf_StencilFunc_header_not_0); 4557 COMPILE_ASSERT(offsetof(StencilFunc, func) == 4, 4558 OffsetOf_StencilFunc_func_not_4); 4559 COMPILE_ASSERT(offsetof(StencilFunc, ref) == 8, OffsetOf_StencilFunc_ref_not_8); 4560 COMPILE_ASSERT(offsetof(StencilFunc, mask) == 12, 4561 OffsetOf_StencilFunc_mask_not_12); 4562 4563 struct StencilFuncSeparate { 4564 typedef StencilFuncSeparate ValueType; 4565 static const CommandId kCmdId = kStencilFuncSeparate; 4566 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4567 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4568 4569 static uint32_t ComputeSize() { 4570 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4571 } 4572 4573 void SetHeader() { header.SetCmd<ValueType>(); } 4574 4575 void Init(GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { 4576 SetHeader(); 4577 face = _face; 4578 func = _func; 4579 ref = _ref; 4580 mask = _mask; 4581 } 4582 4583 void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { 4584 static_cast<ValueType*>(cmd)->Init(_face, _func, _ref, _mask); 4585 return NextCmdAddress<ValueType>(cmd); 4586 } 4587 4588 gpu::CommandHeader header; 4589 uint32_t face; 4590 uint32_t func; 4591 int32_t ref; 4592 uint32_t mask; 4593 }; 4594 4595 COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20, 4596 Sizeof_StencilFuncSeparate_is_not_20); 4597 COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0, 4598 OffsetOf_StencilFuncSeparate_header_not_0); 4599 COMPILE_ASSERT(offsetof(StencilFuncSeparate, face) == 4, 4600 OffsetOf_StencilFuncSeparate_face_not_4); 4601 COMPILE_ASSERT(offsetof(StencilFuncSeparate, func) == 8, 4602 OffsetOf_StencilFuncSeparate_func_not_8); 4603 COMPILE_ASSERT(offsetof(StencilFuncSeparate, ref) == 12, 4604 OffsetOf_StencilFuncSeparate_ref_not_12); 4605 COMPILE_ASSERT(offsetof(StencilFuncSeparate, mask) == 16, 4606 OffsetOf_StencilFuncSeparate_mask_not_16); 4607 4608 struct StencilMask { 4609 typedef StencilMask ValueType; 4610 static const CommandId kCmdId = kStencilMask; 4611 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4612 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4613 4614 static uint32_t ComputeSize() { 4615 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4616 } 4617 4618 void SetHeader() { header.SetCmd<ValueType>(); } 4619 4620 void Init(GLuint _mask) { 4621 SetHeader(); 4622 mask = _mask; 4623 } 4624 4625 void* Set(void* cmd, GLuint _mask) { 4626 static_cast<ValueType*>(cmd)->Init(_mask); 4627 return NextCmdAddress<ValueType>(cmd); 4628 } 4629 4630 gpu::CommandHeader header; 4631 uint32_t mask; 4632 }; 4633 4634 COMPILE_ASSERT(sizeof(StencilMask) == 8, Sizeof_StencilMask_is_not_8); 4635 COMPILE_ASSERT(offsetof(StencilMask, header) == 0, 4636 OffsetOf_StencilMask_header_not_0); 4637 COMPILE_ASSERT(offsetof(StencilMask, mask) == 4, 4638 OffsetOf_StencilMask_mask_not_4); 4639 4640 struct StencilMaskSeparate { 4641 typedef StencilMaskSeparate ValueType; 4642 static const CommandId kCmdId = kStencilMaskSeparate; 4643 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4644 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4645 4646 static uint32_t ComputeSize() { 4647 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4648 } 4649 4650 void SetHeader() { header.SetCmd<ValueType>(); } 4651 4652 void Init(GLenum _face, GLuint _mask) { 4653 SetHeader(); 4654 face = _face; 4655 mask = _mask; 4656 } 4657 4658 void* Set(void* cmd, GLenum _face, GLuint _mask) { 4659 static_cast<ValueType*>(cmd)->Init(_face, _mask); 4660 return NextCmdAddress<ValueType>(cmd); 4661 } 4662 4663 gpu::CommandHeader header; 4664 uint32_t face; 4665 uint32_t mask; 4666 }; 4667 4668 COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12, 4669 Sizeof_StencilMaskSeparate_is_not_12); 4670 COMPILE_ASSERT(offsetof(StencilMaskSeparate, header) == 0, 4671 OffsetOf_StencilMaskSeparate_header_not_0); 4672 COMPILE_ASSERT(offsetof(StencilMaskSeparate, face) == 4, 4673 OffsetOf_StencilMaskSeparate_face_not_4); 4674 COMPILE_ASSERT(offsetof(StencilMaskSeparate, mask) == 8, 4675 OffsetOf_StencilMaskSeparate_mask_not_8); 4676 4677 struct StencilOp { 4678 typedef StencilOp ValueType; 4679 static const CommandId kCmdId = kStencilOp; 4680 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4681 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4682 4683 static uint32_t ComputeSize() { 4684 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4685 } 4686 4687 void SetHeader() { header.SetCmd<ValueType>(); } 4688 4689 void Init(GLenum _fail, GLenum _zfail, GLenum _zpass) { 4690 SetHeader(); 4691 fail = _fail; 4692 zfail = _zfail; 4693 zpass = _zpass; 4694 } 4695 4696 void* Set(void* cmd, GLenum _fail, GLenum _zfail, GLenum _zpass) { 4697 static_cast<ValueType*>(cmd)->Init(_fail, _zfail, _zpass); 4698 return NextCmdAddress<ValueType>(cmd); 4699 } 4700 4701 gpu::CommandHeader header; 4702 uint32_t fail; 4703 uint32_t zfail; 4704 uint32_t zpass; 4705 }; 4706 4707 COMPILE_ASSERT(sizeof(StencilOp) == 16, Sizeof_StencilOp_is_not_16); 4708 COMPILE_ASSERT(offsetof(StencilOp, header) == 0, 4709 OffsetOf_StencilOp_header_not_0); 4710 COMPILE_ASSERT(offsetof(StencilOp, fail) == 4, OffsetOf_StencilOp_fail_not_4); 4711 COMPILE_ASSERT(offsetof(StencilOp, zfail) == 8, OffsetOf_StencilOp_zfail_not_8); 4712 COMPILE_ASSERT(offsetof(StencilOp, zpass) == 12, 4713 OffsetOf_StencilOp_zpass_not_12); 4714 4715 struct StencilOpSeparate { 4716 typedef StencilOpSeparate ValueType; 4717 static const CommandId kCmdId = kStencilOpSeparate; 4718 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4719 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4720 4721 static uint32_t ComputeSize() { 4722 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4723 } 4724 4725 void SetHeader() { header.SetCmd<ValueType>(); } 4726 4727 void Init(GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) { 4728 SetHeader(); 4729 face = _face; 4730 fail = _fail; 4731 zfail = _zfail; 4732 zpass = _zpass; 4733 } 4734 4735 void* Set(void* cmd, 4736 GLenum _face, 4737 GLenum _fail, 4738 GLenum _zfail, 4739 GLenum _zpass) { 4740 static_cast<ValueType*>(cmd)->Init(_face, _fail, _zfail, _zpass); 4741 return NextCmdAddress<ValueType>(cmd); 4742 } 4743 4744 gpu::CommandHeader header; 4745 uint32_t face; 4746 uint32_t fail; 4747 uint32_t zfail; 4748 uint32_t zpass; 4749 }; 4750 4751 COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20, 4752 Sizeof_StencilOpSeparate_is_not_20); 4753 COMPILE_ASSERT(offsetof(StencilOpSeparate, header) == 0, 4754 OffsetOf_StencilOpSeparate_header_not_0); 4755 COMPILE_ASSERT(offsetof(StencilOpSeparate, face) == 4, 4756 OffsetOf_StencilOpSeparate_face_not_4); 4757 COMPILE_ASSERT(offsetof(StencilOpSeparate, fail) == 8, 4758 OffsetOf_StencilOpSeparate_fail_not_8); 4759 COMPILE_ASSERT(offsetof(StencilOpSeparate, zfail) == 12, 4760 OffsetOf_StencilOpSeparate_zfail_not_12); 4761 COMPILE_ASSERT(offsetof(StencilOpSeparate, zpass) == 16, 4762 OffsetOf_StencilOpSeparate_zpass_not_16); 4763 4764 struct TexImage2D { 4765 typedef TexImage2D ValueType; 4766 static const CommandId kCmdId = kTexImage2D; 4767 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4768 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4769 4770 static uint32_t ComputeSize() { 4771 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4772 } 4773 4774 void SetHeader() { header.SetCmd<ValueType>(); } 4775 4776 void Init(GLenum _target, 4777 GLint _level, 4778 GLint _internalformat, 4779 GLsizei _width, 4780 GLsizei _height, 4781 GLenum _format, 4782 GLenum _type, 4783 uint32_t _pixels_shm_id, 4784 uint32_t _pixels_shm_offset) { 4785 SetHeader(); 4786 target = _target; 4787 level = _level; 4788 internalformat = _internalformat; 4789 width = _width; 4790 height = _height; 4791 format = _format; 4792 type = _type; 4793 pixels_shm_id = _pixels_shm_id; 4794 pixels_shm_offset = _pixels_shm_offset; 4795 } 4796 4797 void* Set(void* cmd, 4798 GLenum _target, 4799 GLint _level, 4800 GLint _internalformat, 4801 GLsizei _width, 4802 GLsizei _height, 4803 GLenum _format, 4804 GLenum _type, 4805 uint32_t _pixels_shm_id, 4806 uint32_t _pixels_shm_offset) { 4807 static_cast<ValueType*>(cmd)->Init(_target, 4808 _level, 4809 _internalformat, 4810 _width, 4811 _height, 4812 _format, 4813 _type, 4814 _pixels_shm_id, 4815 _pixels_shm_offset); 4816 return NextCmdAddress<ValueType>(cmd); 4817 } 4818 4819 gpu::CommandHeader header; 4820 uint32_t target; 4821 int32_t level; 4822 int32_t internalformat; 4823 int32_t width; 4824 int32_t height; 4825 uint32_t format; 4826 uint32_t type; 4827 uint32_t pixels_shm_id; 4828 uint32_t pixels_shm_offset; 4829 static const int32_t border = 0; 4830 }; 4831 4832 COMPILE_ASSERT(sizeof(TexImage2D) == 40, Sizeof_TexImage2D_is_not_40); 4833 COMPILE_ASSERT(offsetof(TexImage2D, header) == 0, 4834 OffsetOf_TexImage2D_header_not_0); 4835 COMPILE_ASSERT(offsetof(TexImage2D, target) == 4, 4836 OffsetOf_TexImage2D_target_not_4); 4837 COMPILE_ASSERT(offsetof(TexImage2D, level) == 8, 4838 OffsetOf_TexImage2D_level_not_8); 4839 COMPILE_ASSERT(offsetof(TexImage2D, internalformat) == 12, 4840 OffsetOf_TexImage2D_internalformat_not_12); 4841 COMPILE_ASSERT(offsetof(TexImage2D, width) == 16, 4842 OffsetOf_TexImage2D_width_not_16); 4843 COMPILE_ASSERT(offsetof(TexImage2D, height) == 20, 4844 OffsetOf_TexImage2D_height_not_20); 4845 COMPILE_ASSERT(offsetof(TexImage2D, format) == 24, 4846 OffsetOf_TexImage2D_format_not_24); 4847 COMPILE_ASSERT(offsetof(TexImage2D, type) == 28, 4848 OffsetOf_TexImage2D_type_not_28); 4849 COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 32, 4850 OffsetOf_TexImage2D_pixels_shm_id_not_32); 4851 COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 36, 4852 OffsetOf_TexImage2D_pixels_shm_offset_not_36); 4853 4854 struct TexParameterf { 4855 typedef TexParameterf ValueType; 4856 static const CommandId kCmdId = kTexParameterf; 4857 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4858 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4859 4860 static uint32_t ComputeSize() { 4861 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4862 } 4863 4864 void SetHeader() { header.SetCmd<ValueType>(); } 4865 4866 void Init(GLenum _target, GLenum _pname, GLfloat _param) { 4867 SetHeader(); 4868 target = _target; 4869 pname = _pname; 4870 param = _param; 4871 } 4872 4873 void* Set(void* cmd, GLenum _target, GLenum _pname, GLfloat _param) { 4874 static_cast<ValueType*>(cmd)->Init(_target, _pname, _param); 4875 return NextCmdAddress<ValueType>(cmd); 4876 } 4877 4878 gpu::CommandHeader header; 4879 uint32_t target; 4880 uint32_t pname; 4881 float param; 4882 }; 4883 4884 COMPILE_ASSERT(sizeof(TexParameterf) == 16, Sizeof_TexParameterf_is_not_16); 4885 COMPILE_ASSERT(offsetof(TexParameterf, header) == 0, 4886 OffsetOf_TexParameterf_header_not_0); 4887 COMPILE_ASSERT(offsetof(TexParameterf, target) == 4, 4888 OffsetOf_TexParameterf_target_not_4); 4889 COMPILE_ASSERT(offsetof(TexParameterf, pname) == 8, 4890 OffsetOf_TexParameterf_pname_not_8); 4891 COMPILE_ASSERT(offsetof(TexParameterf, param) == 12, 4892 OffsetOf_TexParameterf_param_not_12); 4893 4894 struct TexParameterfvImmediate { 4895 typedef TexParameterfvImmediate ValueType; 4896 static const CommandId kCmdId = kTexParameterfvImmediate; 4897 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 4898 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4899 4900 static uint32_t ComputeDataSize() { 4901 return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT 4902 } 4903 4904 static uint32_t ComputeSize() { 4905 return static_cast<uint32_t>(sizeof(ValueType) + 4906 ComputeDataSize()); // NOLINT 4907 } 4908 4909 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 4910 4911 void Init(GLenum _target, GLenum _pname, const GLfloat* _params) { 4912 SetHeader(); 4913 target = _target; 4914 pname = _pname; 4915 memcpy(ImmediateDataAddress(this), _params, ComputeDataSize()); 4916 } 4917 4918 void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) { 4919 static_cast<ValueType*>(cmd)->Init(_target, _pname, _params); 4920 const uint32_t size = ComputeSize(); 4921 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 4922 } 4923 4924 gpu::CommandHeader header; 4925 uint32_t target; 4926 uint32_t pname; 4927 }; 4928 4929 COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12, 4930 Sizeof_TexParameterfvImmediate_is_not_12); 4931 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, header) == 0, 4932 OffsetOf_TexParameterfvImmediate_header_not_0); 4933 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, target) == 4, 4934 OffsetOf_TexParameterfvImmediate_target_not_4); 4935 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, pname) == 8, 4936 OffsetOf_TexParameterfvImmediate_pname_not_8); 4937 4938 struct TexParameteri { 4939 typedef TexParameteri ValueType; 4940 static const CommandId kCmdId = kTexParameteri; 4941 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 4942 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4943 4944 static uint32_t ComputeSize() { 4945 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 4946 } 4947 4948 void SetHeader() { header.SetCmd<ValueType>(); } 4949 4950 void Init(GLenum _target, GLenum _pname, GLint _param) { 4951 SetHeader(); 4952 target = _target; 4953 pname = _pname; 4954 param = _param; 4955 } 4956 4957 void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) { 4958 static_cast<ValueType*>(cmd)->Init(_target, _pname, _param); 4959 return NextCmdAddress<ValueType>(cmd); 4960 } 4961 4962 gpu::CommandHeader header; 4963 uint32_t target; 4964 uint32_t pname; 4965 int32_t param; 4966 }; 4967 4968 COMPILE_ASSERT(sizeof(TexParameteri) == 16, Sizeof_TexParameteri_is_not_16); 4969 COMPILE_ASSERT(offsetof(TexParameteri, header) == 0, 4970 OffsetOf_TexParameteri_header_not_0); 4971 COMPILE_ASSERT(offsetof(TexParameteri, target) == 4, 4972 OffsetOf_TexParameteri_target_not_4); 4973 COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8, 4974 OffsetOf_TexParameteri_pname_not_8); 4975 COMPILE_ASSERT(offsetof(TexParameteri, param) == 12, 4976 OffsetOf_TexParameteri_param_not_12); 4977 4978 struct TexParameterivImmediate { 4979 typedef TexParameterivImmediate ValueType; 4980 static const CommandId kCmdId = kTexParameterivImmediate; 4981 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 4982 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 4983 4984 static uint32_t ComputeDataSize() { 4985 return static_cast<uint32_t>(sizeof(GLint) * 1); // NOLINT 4986 } 4987 4988 static uint32_t ComputeSize() { 4989 return static_cast<uint32_t>(sizeof(ValueType) + 4990 ComputeDataSize()); // NOLINT 4991 } 4992 4993 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 4994 4995 void Init(GLenum _target, GLenum _pname, const GLint* _params) { 4996 SetHeader(); 4997 target = _target; 4998 pname = _pname; 4999 memcpy(ImmediateDataAddress(this), _params, ComputeDataSize()); 5000 } 5001 5002 void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) { 5003 static_cast<ValueType*>(cmd)->Init(_target, _pname, _params); 5004 const uint32_t size = ComputeSize(); 5005 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5006 } 5007 5008 gpu::CommandHeader header; 5009 uint32_t target; 5010 uint32_t pname; 5011 }; 5012 5013 COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12, 5014 Sizeof_TexParameterivImmediate_is_not_12); 5015 COMPILE_ASSERT(offsetof(TexParameterivImmediate, header) == 0, 5016 OffsetOf_TexParameterivImmediate_header_not_0); 5017 COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4, 5018 OffsetOf_TexParameterivImmediate_target_not_4); 5019 COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8, 5020 OffsetOf_TexParameterivImmediate_pname_not_8); 5021 5022 struct TexSubImage2D { 5023 typedef TexSubImage2D ValueType; 5024 static const CommandId kCmdId = kTexSubImage2D; 5025 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5026 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5027 5028 static uint32_t ComputeSize() { 5029 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5030 } 5031 5032 void SetHeader() { header.SetCmd<ValueType>(); } 5033 5034 void Init(GLenum _target, 5035 GLint _level, 5036 GLint _xoffset, 5037 GLint _yoffset, 5038 GLsizei _width, 5039 GLsizei _height, 5040 GLenum _format, 5041 GLenum _type, 5042 uint32_t _pixels_shm_id, 5043 uint32_t _pixels_shm_offset, 5044 GLboolean _internal) { 5045 SetHeader(); 5046 target = _target; 5047 level = _level; 5048 xoffset = _xoffset; 5049 yoffset = _yoffset; 5050 width = _width; 5051 height = _height; 5052 format = _format; 5053 type = _type; 5054 pixels_shm_id = _pixels_shm_id; 5055 pixels_shm_offset = _pixels_shm_offset; 5056 internal = _internal; 5057 } 5058 5059 void* Set(void* cmd, 5060 GLenum _target, 5061 GLint _level, 5062 GLint _xoffset, 5063 GLint _yoffset, 5064 GLsizei _width, 5065 GLsizei _height, 5066 GLenum _format, 5067 GLenum _type, 5068 uint32_t _pixels_shm_id, 5069 uint32_t _pixels_shm_offset, 5070 GLboolean _internal) { 5071 static_cast<ValueType*>(cmd)->Init(_target, 5072 _level, 5073 _xoffset, 5074 _yoffset, 5075 _width, 5076 _height, 5077 _format, 5078 _type, 5079 _pixels_shm_id, 5080 _pixels_shm_offset, 5081 _internal); 5082 return NextCmdAddress<ValueType>(cmd); 5083 } 5084 5085 gpu::CommandHeader header; 5086 uint32_t target; 5087 int32_t level; 5088 int32_t xoffset; 5089 int32_t yoffset; 5090 int32_t width; 5091 int32_t height; 5092 uint32_t format; 5093 uint32_t type; 5094 uint32_t pixels_shm_id; 5095 uint32_t pixels_shm_offset; 5096 uint32_t internal; 5097 }; 5098 5099 COMPILE_ASSERT(sizeof(TexSubImage2D) == 48, Sizeof_TexSubImage2D_is_not_48); 5100 COMPILE_ASSERT(offsetof(TexSubImage2D, header) == 0, 5101 OffsetOf_TexSubImage2D_header_not_0); 5102 COMPILE_ASSERT(offsetof(TexSubImage2D, target) == 4, 5103 OffsetOf_TexSubImage2D_target_not_4); 5104 COMPILE_ASSERT(offsetof(TexSubImage2D, level) == 8, 5105 OffsetOf_TexSubImage2D_level_not_8); 5106 COMPILE_ASSERT(offsetof(TexSubImage2D, xoffset) == 12, 5107 OffsetOf_TexSubImage2D_xoffset_not_12); 5108 COMPILE_ASSERT(offsetof(TexSubImage2D, yoffset) == 16, 5109 OffsetOf_TexSubImage2D_yoffset_not_16); 5110 COMPILE_ASSERT(offsetof(TexSubImage2D, width) == 20, 5111 OffsetOf_TexSubImage2D_width_not_20); 5112 COMPILE_ASSERT(offsetof(TexSubImage2D, height) == 24, 5113 OffsetOf_TexSubImage2D_height_not_24); 5114 COMPILE_ASSERT(offsetof(TexSubImage2D, format) == 28, 5115 OffsetOf_TexSubImage2D_format_not_28); 5116 COMPILE_ASSERT(offsetof(TexSubImage2D, type) == 32, 5117 OffsetOf_TexSubImage2D_type_not_32); 5118 COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_id) == 36, 5119 OffsetOf_TexSubImage2D_pixels_shm_id_not_36); 5120 COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_offset) == 40, 5121 OffsetOf_TexSubImage2D_pixels_shm_offset_not_40); 5122 COMPILE_ASSERT(offsetof(TexSubImage2D, internal) == 44, 5123 OffsetOf_TexSubImage2D_internal_not_44); 5124 5125 struct Uniform1f { 5126 typedef Uniform1f ValueType; 5127 static const CommandId kCmdId = kUniform1f; 5128 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5129 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5130 5131 static uint32_t ComputeSize() { 5132 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5133 } 5134 5135 void SetHeader() { header.SetCmd<ValueType>(); } 5136 5137 void Init(GLint _location, GLfloat _x) { 5138 SetHeader(); 5139 location = _location; 5140 x = _x; 5141 } 5142 5143 void* Set(void* cmd, GLint _location, GLfloat _x) { 5144 static_cast<ValueType*>(cmd)->Init(_location, _x); 5145 return NextCmdAddress<ValueType>(cmd); 5146 } 5147 5148 gpu::CommandHeader header; 5149 int32_t location; 5150 float x; 5151 }; 5152 5153 COMPILE_ASSERT(sizeof(Uniform1f) == 12, Sizeof_Uniform1f_is_not_12); 5154 COMPILE_ASSERT(offsetof(Uniform1f, header) == 0, 5155 OffsetOf_Uniform1f_header_not_0); 5156 COMPILE_ASSERT(offsetof(Uniform1f, location) == 4, 5157 OffsetOf_Uniform1f_location_not_4); 5158 COMPILE_ASSERT(offsetof(Uniform1f, x) == 8, OffsetOf_Uniform1f_x_not_8); 5159 5160 struct Uniform1fvImmediate { 5161 typedef Uniform1fvImmediate ValueType; 5162 static const CommandId kCmdId = kUniform1fvImmediate; 5163 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5164 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5165 5166 static uint32_t ComputeDataSize(GLsizei count) { 5167 return static_cast<uint32_t>(sizeof(GLfloat) * 1 * count); // NOLINT 5168 } 5169 5170 static uint32_t ComputeSize(GLsizei count) { 5171 return static_cast<uint32_t>(sizeof(ValueType) + 5172 ComputeDataSize(count)); // NOLINT 5173 } 5174 5175 void SetHeader(GLsizei count) { 5176 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5177 } 5178 5179 void Init(GLint _location, GLsizei _count, const GLfloat* _v) { 5180 SetHeader(_count); 5181 location = _location; 5182 count = _count; 5183 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5184 } 5185 5186 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { 5187 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5188 const uint32_t size = ComputeSize(_count); 5189 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5190 } 5191 5192 gpu::CommandHeader header; 5193 int32_t location; 5194 int32_t count; 5195 }; 5196 5197 COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12, 5198 Sizeof_Uniform1fvImmediate_is_not_12); 5199 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0, 5200 OffsetOf_Uniform1fvImmediate_header_not_0); 5201 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4, 5202 OffsetOf_Uniform1fvImmediate_location_not_4); 5203 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, count) == 8, 5204 OffsetOf_Uniform1fvImmediate_count_not_8); 5205 5206 struct Uniform1i { 5207 typedef Uniform1i ValueType; 5208 static const CommandId kCmdId = kUniform1i; 5209 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5210 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5211 5212 static uint32_t ComputeSize() { 5213 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5214 } 5215 5216 void SetHeader() { header.SetCmd<ValueType>(); } 5217 5218 void Init(GLint _location, GLint _x) { 5219 SetHeader(); 5220 location = _location; 5221 x = _x; 5222 } 5223 5224 void* Set(void* cmd, GLint _location, GLint _x) { 5225 static_cast<ValueType*>(cmd)->Init(_location, _x); 5226 return NextCmdAddress<ValueType>(cmd); 5227 } 5228 5229 gpu::CommandHeader header; 5230 int32_t location; 5231 int32_t x; 5232 }; 5233 5234 COMPILE_ASSERT(sizeof(Uniform1i) == 12, Sizeof_Uniform1i_is_not_12); 5235 COMPILE_ASSERT(offsetof(Uniform1i, header) == 0, 5236 OffsetOf_Uniform1i_header_not_0); 5237 COMPILE_ASSERT(offsetof(Uniform1i, location) == 4, 5238 OffsetOf_Uniform1i_location_not_4); 5239 COMPILE_ASSERT(offsetof(Uniform1i, x) == 8, OffsetOf_Uniform1i_x_not_8); 5240 5241 struct Uniform1ivImmediate { 5242 typedef Uniform1ivImmediate ValueType; 5243 static const CommandId kCmdId = kUniform1ivImmediate; 5244 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5245 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5246 5247 static uint32_t ComputeDataSize(GLsizei count) { 5248 return static_cast<uint32_t>(sizeof(GLint) * 1 * count); // NOLINT 5249 } 5250 5251 static uint32_t ComputeSize(GLsizei count) { 5252 return static_cast<uint32_t>(sizeof(ValueType) + 5253 ComputeDataSize(count)); // NOLINT 5254 } 5255 5256 void SetHeader(GLsizei count) { 5257 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5258 } 5259 5260 void Init(GLint _location, GLsizei _count, const GLint* _v) { 5261 SetHeader(_count); 5262 location = _location; 5263 count = _count; 5264 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5265 } 5266 5267 void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { 5268 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5269 const uint32_t size = ComputeSize(_count); 5270 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5271 } 5272 5273 gpu::CommandHeader header; 5274 int32_t location; 5275 int32_t count; 5276 }; 5277 5278 COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12, 5279 Sizeof_Uniform1ivImmediate_is_not_12); 5280 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0, 5281 OffsetOf_Uniform1ivImmediate_header_not_0); 5282 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4, 5283 OffsetOf_Uniform1ivImmediate_location_not_4); 5284 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8, 5285 OffsetOf_Uniform1ivImmediate_count_not_8); 5286 5287 struct Uniform2f { 5288 typedef Uniform2f ValueType; 5289 static const CommandId kCmdId = kUniform2f; 5290 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5291 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5292 5293 static uint32_t ComputeSize() { 5294 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5295 } 5296 5297 void SetHeader() { header.SetCmd<ValueType>(); } 5298 5299 void Init(GLint _location, GLfloat _x, GLfloat _y) { 5300 SetHeader(); 5301 location = _location; 5302 x = _x; 5303 y = _y; 5304 } 5305 5306 void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) { 5307 static_cast<ValueType*>(cmd)->Init(_location, _x, _y); 5308 return NextCmdAddress<ValueType>(cmd); 5309 } 5310 5311 gpu::CommandHeader header; 5312 int32_t location; 5313 float x; 5314 float y; 5315 }; 5316 5317 COMPILE_ASSERT(sizeof(Uniform2f) == 16, Sizeof_Uniform2f_is_not_16); 5318 COMPILE_ASSERT(offsetof(Uniform2f, header) == 0, 5319 OffsetOf_Uniform2f_header_not_0); 5320 COMPILE_ASSERT(offsetof(Uniform2f, location) == 4, 5321 OffsetOf_Uniform2f_location_not_4); 5322 COMPILE_ASSERT(offsetof(Uniform2f, x) == 8, OffsetOf_Uniform2f_x_not_8); 5323 COMPILE_ASSERT(offsetof(Uniform2f, y) == 12, OffsetOf_Uniform2f_y_not_12); 5324 5325 struct Uniform2fvImmediate { 5326 typedef Uniform2fvImmediate ValueType; 5327 static const CommandId kCmdId = kUniform2fvImmediate; 5328 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5329 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5330 5331 static uint32_t ComputeDataSize(GLsizei count) { 5332 return static_cast<uint32_t>(sizeof(GLfloat) * 2 * count); // NOLINT 5333 } 5334 5335 static uint32_t ComputeSize(GLsizei count) { 5336 return static_cast<uint32_t>(sizeof(ValueType) + 5337 ComputeDataSize(count)); // NOLINT 5338 } 5339 5340 void SetHeader(GLsizei count) { 5341 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5342 } 5343 5344 void Init(GLint _location, GLsizei _count, const GLfloat* _v) { 5345 SetHeader(_count); 5346 location = _location; 5347 count = _count; 5348 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5349 } 5350 5351 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { 5352 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5353 const uint32_t size = ComputeSize(_count); 5354 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5355 } 5356 5357 gpu::CommandHeader header; 5358 int32_t location; 5359 int32_t count; 5360 }; 5361 5362 COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12, 5363 Sizeof_Uniform2fvImmediate_is_not_12); 5364 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0, 5365 OffsetOf_Uniform2fvImmediate_header_not_0); 5366 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4, 5367 OffsetOf_Uniform2fvImmediate_location_not_4); 5368 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, count) == 8, 5369 OffsetOf_Uniform2fvImmediate_count_not_8); 5370 5371 struct Uniform2i { 5372 typedef Uniform2i ValueType; 5373 static const CommandId kCmdId = kUniform2i; 5374 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5375 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5376 5377 static uint32_t ComputeSize() { 5378 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5379 } 5380 5381 void SetHeader() { header.SetCmd<ValueType>(); } 5382 5383 void Init(GLint _location, GLint _x, GLint _y) { 5384 SetHeader(); 5385 location = _location; 5386 x = _x; 5387 y = _y; 5388 } 5389 5390 void* Set(void* cmd, GLint _location, GLint _x, GLint _y) { 5391 static_cast<ValueType*>(cmd)->Init(_location, _x, _y); 5392 return NextCmdAddress<ValueType>(cmd); 5393 } 5394 5395 gpu::CommandHeader header; 5396 int32_t location; 5397 int32_t x; 5398 int32_t y; 5399 }; 5400 5401 COMPILE_ASSERT(sizeof(Uniform2i) == 16, Sizeof_Uniform2i_is_not_16); 5402 COMPILE_ASSERT(offsetof(Uniform2i, header) == 0, 5403 OffsetOf_Uniform2i_header_not_0); 5404 COMPILE_ASSERT(offsetof(Uniform2i, location) == 4, 5405 OffsetOf_Uniform2i_location_not_4); 5406 COMPILE_ASSERT(offsetof(Uniform2i, x) == 8, OffsetOf_Uniform2i_x_not_8); 5407 COMPILE_ASSERT(offsetof(Uniform2i, y) == 12, OffsetOf_Uniform2i_y_not_12); 5408 5409 struct Uniform2ivImmediate { 5410 typedef Uniform2ivImmediate ValueType; 5411 static const CommandId kCmdId = kUniform2ivImmediate; 5412 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5413 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5414 5415 static uint32_t ComputeDataSize(GLsizei count) { 5416 return static_cast<uint32_t>(sizeof(GLint) * 2 * count); // NOLINT 5417 } 5418 5419 static uint32_t ComputeSize(GLsizei count) { 5420 return static_cast<uint32_t>(sizeof(ValueType) + 5421 ComputeDataSize(count)); // NOLINT 5422 } 5423 5424 void SetHeader(GLsizei count) { 5425 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5426 } 5427 5428 void Init(GLint _location, GLsizei _count, const GLint* _v) { 5429 SetHeader(_count); 5430 location = _location; 5431 count = _count; 5432 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5433 } 5434 5435 void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { 5436 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5437 const uint32_t size = ComputeSize(_count); 5438 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5439 } 5440 5441 gpu::CommandHeader header; 5442 int32_t location; 5443 int32_t count; 5444 }; 5445 5446 COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12, 5447 Sizeof_Uniform2ivImmediate_is_not_12); 5448 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0, 5449 OffsetOf_Uniform2ivImmediate_header_not_0); 5450 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4, 5451 OffsetOf_Uniform2ivImmediate_location_not_4); 5452 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8, 5453 OffsetOf_Uniform2ivImmediate_count_not_8); 5454 5455 struct Uniform3f { 5456 typedef Uniform3f ValueType; 5457 static const CommandId kCmdId = kUniform3f; 5458 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5459 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5460 5461 static uint32_t ComputeSize() { 5462 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5463 } 5464 5465 void SetHeader() { header.SetCmd<ValueType>(); } 5466 5467 void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { 5468 SetHeader(); 5469 location = _location; 5470 x = _x; 5471 y = _y; 5472 z = _z; 5473 } 5474 5475 void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { 5476 static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z); 5477 return NextCmdAddress<ValueType>(cmd); 5478 } 5479 5480 gpu::CommandHeader header; 5481 int32_t location; 5482 float x; 5483 float y; 5484 float z; 5485 }; 5486 5487 COMPILE_ASSERT(sizeof(Uniform3f) == 20, Sizeof_Uniform3f_is_not_20); 5488 COMPILE_ASSERT(offsetof(Uniform3f, header) == 0, 5489 OffsetOf_Uniform3f_header_not_0); 5490 COMPILE_ASSERT(offsetof(Uniform3f, location) == 4, 5491 OffsetOf_Uniform3f_location_not_4); 5492 COMPILE_ASSERT(offsetof(Uniform3f, x) == 8, OffsetOf_Uniform3f_x_not_8); 5493 COMPILE_ASSERT(offsetof(Uniform3f, y) == 12, OffsetOf_Uniform3f_y_not_12); 5494 COMPILE_ASSERT(offsetof(Uniform3f, z) == 16, OffsetOf_Uniform3f_z_not_16); 5495 5496 struct Uniform3fvImmediate { 5497 typedef Uniform3fvImmediate ValueType; 5498 static const CommandId kCmdId = kUniform3fvImmediate; 5499 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5500 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5501 5502 static uint32_t ComputeDataSize(GLsizei count) { 5503 return static_cast<uint32_t>(sizeof(GLfloat) * 3 * count); // NOLINT 5504 } 5505 5506 static uint32_t ComputeSize(GLsizei count) { 5507 return static_cast<uint32_t>(sizeof(ValueType) + 5508 ComputeDataSize(count)); // NOLINT 5509 } 5510 5511 void SetHeader(GLsizei count) { 5512 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5513 } 5514 5515 void Init(GLint _location, GLsizei _count, const GLfloat* _v) { 5516 SetHeader(_count); 5517 location = _location; 5518 count = _count; 5519 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5520 } 5521 5522 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { 5523 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5524 const uint32_t size = ComputeSize(_count); 5525 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5526 } 5527 5528 gpu::CommandHeader header; 5529 int32_t location; 5530 int32_t count; 5531 }; 5532 5533 COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12, 5534 Sizeof_Uniform3fvImmediate_is_not_12); 5535 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0, 5536 OffsetOf_Uniform3fvImmediate_header_not_0); 5537 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4, 5538 OffsetOf_Uniform3fvImmediate_location_not_4); 5539 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, count) == 8, 5540 OffsetOf_Uniform3fvImmediate_count_not_8); 5541 5542 struct Uniform3i { 5543 typedef Uniform3i ValueType; 5544 static const CommandId kCmdId = kUniform3i; 5545 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5546 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5547 5548 static uint32_t ComputeSize() { 5549 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5550 } 5551 5552 void SetHeader() { header.SetCmd<ValueType>(); } 5553 5554 void Init(GLint _location, GLint _x, GLint _y, GLint _z) { 5555 SetHeader(); 5556 location = _location; 5557 x = _x; 5558 y = _y; 5559 z = _z; 5560 } 5561 5562 void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) { 5563 static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z); 5564 return NextCmdAddress<ValueType>(cmd); 5565 } 5566 5567 gpu::CommandHeader header; 5568 int32_t location; 5569 int32_t x; 5570 int32_t y; 5571 int32_t z; 5572 }; 5573 5574 COMPILE_ASSERT(sizeof(Uniform3i) == 20, Sizeof_Uniform3i_is_not_20); 5575 COMPILE_ASSERT(offsetof(Uniform3i, header) == 0, 5576 OffsetOf_Uniform3i_header_not_0); 5577 COMPILE_ASSERT(offsetof(Uniform3i, location) == 4, 5578 OffsetOf_Uniform3i_location_not_4); 5579 COMPILE_ASSERT(offsetof(Uniform3i, x) == 8, OffsetOf_Uniform3i_x_not_8); 5580 COMPILE_ASSERT(offsetof(Uniform3i, y) == 12, OffsetOf_Uniform3i_y_not_12); 5581 COMPILE_ASSERT(offsetof(Uniform3i, z) == 16, OffsetOf_Uniform3i_z_not_16); 5582 5583 struct Uniform3ivImmediate { 5584 typedef Uniform3ivImmediate ValueType; 5585 static const CommandId kCmdId = kUniform3ivImmediate; 5586 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5587 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5588 5589 static uint32_t ComputeDataSize(GLsizei count) { 5590 return static_cast<uint32_t>(sizeof(GLint) * 3 * count); // NOLINT 5591 } 5592 5593 static uint32_t ComputeSize(GLsizei count) { 5594 return static_cast<uint32_t>(sizeof(ValueType) + 5595 ComputeDataSize(count)); // NOLINT 5596 } 5597 5598 void SetHeader(GLsizei count) { 5599 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5600 } 5601 5602 void Init(GLint _location, GLsizei _count, const GLint* _v) { 5603 SetHeader(_count); 5604 location = _location; 5605 count = _count; 5606 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5607 } 5608 5609 void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { 5610 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5611 const uint32_t size = ComputeSize(_count); 5612 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5613 } 5614 5615 gpu::CommandHeader header; 5616 int32_t location; 5617 int32_t count; 5618 }; 5619 5620 COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12, 5621 Sizeof_Uniform3ivImmediate_is_not_12); 5622 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0, 5623 OffsetOf_Uniform3ivImmediate_header_not_0); 5624 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4, 5625 OffsetOf_Uniform3ivImmediate_location_not_4); 5626 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8, 5627 OffsetOf_Uniform3ivImmediate_count_not_8); 5628 5629 struct Uniform4f { 5630 typedef Uniform4f ValueType; 5631 static const CommandId kCmdId = kUniform4f; 5632 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5633 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5634 5635 static uint32_t ComputeSize() { 5636 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5637 } 5638 5639 void SetHeader() { header.SetCmd<ValueType>(); } 5640 5641 void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { 5642 SetHeader(); 5643 location = _location; 5644 x = _x; 5645 y = _y; 5646 z = _z; 5647 w = _w; 5648 } 5649 5650 void* Set(void* cmd, 5651 GLint _location, 5652 GLfloat _x, 5653 GLfloat _y, 5654 GLfloat _z, 5655 GLfloat _w) { 5656 static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w); 5657 return NextCmdAddress<ValueType>(cmd); 5658 } 5659 5660 gpu::CommandHeader header; 5661 int32_t location; 5662 float x; 5663 float y; 5664 float z; 5665 float w; 5666 }; 5667 5668 COMPILE_ASSERT(sizeof(Uniform4f) == 24, Sizeof_Uniform4f_is_not_24); 5669 COMPILE_ASSERT(offsetof(Uniform4f, header) == 0, 5670 OffsetOf_Uniform4f_header_not_0); 5671 COMPILE_ASSERT(offsetof(Uniform4f, location) == 4, 5672 OffsetOf_Uniform4f_location_not_4); 5673 COMPILE_ASSERT(offsetof(Uniform4f, x) == 8, OffsetOf_Uniform4f_x_not_8); 5674 COMPILE_ASSERT(offsetof(Uniform4f, y) == 12, OffsetOf_Uniform4f_y_not_12); 5675 COMPILE_ASSERT(offsetof(Uniform4f, z) == 16, OffsetOf_Uniform4f_z_not_16); 5676 COMPILE_ASSERT(offsetof(Uniform4f, w) == 20, OffsetOf_Uniform4f_w_not_20); 5677 5678 struct Uniform4fvImmediate { 5679 typedef Uniform4fvImmediate ValueType; 5680 static const CommandId kCmdId = kUniform4fvImmediate; 5681 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5682 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5683 5684 static uint32_t ComputeDataSize(GLsizei count) { 5685 return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count); // NOLINT 5686 } 5687 5688 static uint32_t ComputeSize(GLsizei count) { 5689 return static_cast<uint32_t>(sizeof(ValueType) + 5690 ComputeDataSize(count)); // NOLINT 5691 } 5692 5693 void SetHeader(GLsizei count) { 5694 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5695 } 5696 5697 void Init(GLint _location, GLsizei _count, const GLfloat* _v) { 5698 SetHeader(_count); 5699 location = _location; 5700 count = _count; 5701 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5702 } 5703 5704 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { 5705 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5706 const uint32_t size = ComputeSize(_count); 5707 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5708 } 5709 5710 gpu::CommandHeader header; 5711 int32_t location; 5712 int32_t count; 5713 }; 5714 5715 COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12, 5716 Sizeof_Uniform4fvImmediate_is_not_12); 5717 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0, 5718 OffsetOf_Uniform4fvImmediate_header_not_0); 5719 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4, 5720 OffsetOf_Uniform4fvImmediate_location_not_4); 5721 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, count) == 8, 5722 OffsetOf_Uniform4fvImmediate_count_not_8); 5723 5724 struct Uniform4i { 5725 typedef Uniform4i ValueType; 5726 static const CommandId kCmdId = kUniform4i; 5727 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5728 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5729 5730 static uint32_t ComputeSize() { 5731 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5732 } 5733 5734 void SetHeader() { header.SetCmd<ValueType>(); } 5735 5736 void Init(GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) { 5737 SetHeader(); 5738 location = _location; 5739 x = _x; 5740 y = _y; 5741 z = _z; 5742 w = _w; 5743 } 5744 5745 void* Set(void* cmd, 5746 GLint _location, 5747 GLint _x, 5748 GLint _y, 5749 GLint _z, 5750 GLint _w) { 5751 static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w); 5752 return NextCmdAddress<ValueType>(cmd); 5753 } 5754 5755 gpu::CommandHeader header; 5756 int32_t location; 5757 int32_t x; 5758 int32_t y; 5759 int32_t z; 5760 int32_t w; 5761 }; 5762 5763 COMPILE_ASSERT(sizeof(Uniform4i) == 24, Sizeof_Uniform4i_is_not_24); 5764 COMPILE_ASSERT(offsetof(Uniform4i, header) == 0, 5765 OffsetOf_Uniform4i_header_not_0); 5766 COMPILE_ASSERT(offsetof(Uniform4i, location) == 4, 5767 OffsetOf_Uniform4i_location_not_4); 5768 COMPILE_ASSERT(offsetof(Uniform4i, x) == 8, OffsetOf_Uniform4i_x_not_8); 5769 COMPILE_ASSERT(offsetof(Uniform4i, y) == 12, OffsetOf_Uniform4i_y_not_12); 5770 COMPILE_ASSERT(offsetof(Uniform4i, z) == 16, OffsetOf_Uniform4i_z_not_16); 5771 COMPILE_ASSERT(offsetof(Uniform4i, w) == 20, OffsetOf_Uniform4i_w_not_20); 5772 5773 struct Uniform4ivImmediate { 5774 typedef Uniform4ivImmediate ValueType; 5775 static const CommandId kCmdId = kUniform4ivImmediate; 5776 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5777 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5778 5779 static uint32_t ComputeDataSize(GLsizei count) { 5780 return static_cast<uint32_t>(sizeof(GLint) * 4 * count); // NOLINT 5781 } 5782 5783 static uint32_t ComputeSize(GLsizei count) { 5784 return static_cast<uint32_t>(sizeof(ValueType) + 5785 ComputeDataSize(count)); // NOLINT 5786 } 5787 5788 void SetHeader(GLsizei count) { 5789 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5790 } 5791 5792 void Init(GLint _location, GLsizei _count, const GLint* _v) { 5793 SetHeader(_count); 5794 location = _location; 5795 count = _count; 5796 memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count)); 5797 } 5798 5799 void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { 5800 static_cast<ValueType*>(cmd)->Init(_location, _count, _v); 5801 const uint32_t size = ComputeSize(_count); 5802 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5803 } 5804 5805 gpu::CommandHeader header; 5806 int32_t location; 5807 int32_t count; 5808 }; 5809 5810 COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12, 5811 Sizeof_Uniform4ivImmediate_is_not_12); 5812 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0, 5813 OffsetOf_Uniform4ivImmediate_header_not_0); 5814 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4, 5815 OffsetOf_Uniform4ivImmediate_location_not_4); 5816 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8, 5817 OffsetOf_Uniform4ivImmediate_count_not_8); 5818 5819 struct UniformMatrix2fvImmediate { 5820 typedef UniformMatrix2fvImmediate ValueType; 5821 static const CommandId kCmdId = kUniformMatrix2fvImmediate; 5822 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5823 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5824 5825 static uint32_t ComputeDataSize(GLsizei count) { 5826 return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count); // NOLINT 5827 } 5828 5829 static uint32_t ComputeSize(GLsizei count) { 5830 return static_cast<uint32_t>(sizeof(ValueType) + 5831 ComputeDataSize(count)); // NOLINT 5832 } 5833 5834 void SetHeader(GLsizei count) { 5835 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5836 } 5837 5838 void Init(GLint _location, GLsizei _count, const GLfloat* _value) { 5839 SetHeader(_count); 5840 location = _location; 5841 count = _count; 5842 memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); 5843 } 5844 5845 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) { 5846 static_cast<ValueType*>(cmd)->Init(_location, _count, _value); 5847 const uint32_t size = ComputeSize(_count); 5848 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5849 } 5850 5851 gpu::CommandHeader header; 5852 int32_t location; 5853 int32_t count; 5854 static const uint32_t transpose = false; 5855 }; 5856 5857 COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 12, 5858 Sizeof_UniformMatrix2fvImmediate_is_not_12); 5859 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0, 5860 OffsetOf_UniformMatrix2fvImmediate_header_not_0); 5861 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4, 5862 OffsetOf_UniformMatrix2fvImmediate_location_not_4); 5863 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8, 5864 OffsetOf_UniformMatrix2fvImmediate_count_not_8); 5865 5866 struct UniformMatrix3fvImmediate { 5867 typedef UniformMatrix3fvImmediate ValueType; 5868 static const CommandId kCmdId = kUniformMatrix3fvImmediate; 5869 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5870 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5871 5872 static uint32_t ComputeDataSize(GLsizei count) { 5873 return static_cast<uint32_t>(sizeof(GLfloat) * 9 * count); // NOLINT 5874 } 5875 5876 static uint32_t ComputeSize(GLsizei count) { 5877 return static_cast<uint32_t>(sizeof(ValueType) + 5878 ComputeDataSize(count)); // NOLINT 5879 } 5880 5881 void SetHeader(GLsizei count) { 5882 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5883 } 5884 5885 void Init(GLint _location, GLsizei _count, const GLfloat* _value) { 5886 SetHeader(_count); 5887 location = _location; 5888 count = _count; 5889 memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); 5890 } 5891 5892 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) { 5893 static_cast<ValueType*>(cmd)->Init(_location, _count, _value); 5894 const uint32_t size = ComputeSize(_count); 5895 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5896 } 5897 5898 gpu::CommandHeader header; 5899 int32_t location; 5900 int32_t count; 5901 static const uint32_t transpose = false; 5902 }; 5903 5904 COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 12, 5905 Sizeof_UniformMatrix3fvImmediate_is_not_12); 5906 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0, 5907 OffsetOf_UniformMatrix3fvImmediate_header_not_0); 5908 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4, 5909 OffsetOf_UniformMatrix3fvImmediate_location_not_4); 5910 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8, 5911 OffsetOf_UniformMatrix3fvImmediate_count_not_8); 5912 5913 struct UniformMatrix4fvImmediate { 5914 typedef UniformMatrix4fvImmediate ValueType; 5915 static const CommandId kCmdId = kUniformMatrix4fvImmediate; 5916 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 5917 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5918 5919 static uint32_t ComputeDataSize(GLsizei count) { 5920 return static_cast<uint32_t>(sizeof(GLfloat) * 16 * count); // NOLINT 5921 } 5922 5923 static uint32_t ComputeSize(GLsizei count) { 5924 return static_cast<uint32_t>(sizeof(ValueType) + 5925 ComputeDataSize(count)); // NOLINT 5926 } 5927 5928 void SetHeader(GLsizei count) { 5929 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 5930 } 5931 5932 void Init(GLint _location, GLsizei _count, const GLfloat* _value) { 5933 SetHeader(_count); 5934 location = _location; 5935 count = _count; 5936 memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count)); 5937 } 5938 5939 void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) { 5940 static_cast<ValueType*>(cmd)->Init(_location, _count, _value); 5941 const uint32_t size = ComputeSize(_count); 5942 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 5943 } 5944 5945 gpu::CommandHeader header; 5946 int32_t location; 5947 int32_t count; 5948 static const uint32_t transpose = false; 5949 }; 5950 5951 COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 12, 5952 Sizeof_UniformMatrix4fvImmediate_is_not_12); 5953 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0, 5954 OffsetOf_UniformMatrix4fvImmediate_header_not_0); 5955 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4, 5956 OffsetOf_UniformMatrix4fvImmediate_location_not_4); 5957 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8, 5958 OffsetOf_UniformMatrix4fvImmediate_count_not_8); 5959 5960 struct UseProgram { 5961 typedef UseProgram ValueType; 5962 static const CommandId kCmdId = kUseProgram; 5963 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5964 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5965 5966 static uint32_t ComputeSize() { 5967 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 5968 } 5969 5970 void SetHeader() { header.SetCmd<ValueType>(); } 5971 5972 void Init(GLuint _program) { 5973 SetHeader(); 5974 program = _program; 5975 } 5976 5977 void* Set(void* cmd, GLuint _program) { 5978 static_cast<ValueType*>(cmd)->Init(_program); 5979 return NextCmdAddress<ValueType>(cmd); 5980 } 5981 5982 gpu::CommandHeader header; 5983 uint32_t program; 5984 }; 5985 5986 COMPILE_ASSERT(sizeof(UseProgram) == 8, Sizeof_UseProgram_is_not_8); 5987 COMPILE_ASSERT(offsetof(UseProgram, header) == 0, 5988 OffsetOf_UseProgram_header_not_0); 5989 COMPILE_ASSERT(offsetof(UseProgram, program) == 4, 5990 OffsetOf_UseProgram_program_not_4); 5991 5992 struct ValidateProgram { 5993 typedef ValidateProgram ValueType; 5994 static const CommandId kCmdId = kValidateProgram; 5995 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 5996 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 5997 5998 static uint32_t ComputeSize() { 5999 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6000 } 6001 6002 void SetHeader() { header.SetCmd<ValueType>(); } 6003 6004 void Init(GLuint _program) { 6005 SetHeader(); 6006 program = _program; 6007 } 6008 6009 void* Set(void* cmd, GLuint _program) { 6010 static_cast<ValueType*>(cmd)->Init(_program); 6011 return NextCmdAddress<ValueType>(cmd); 6012 } 6013 6014 gpu::CommandHeader header; 6015 uint32_t program; 6016 }; 6017 6018 COMPILE_ASSERT(sizeof(ValidateProgram) == 8, Sizeof_ValidateProgram_is_not_8); 6019 COMPILE_ASSERT(offsetof(ValidateProgram, header) == 0, 6020 OffsetOf_ValidateProgram_header_not_0); 6021 COMPILE_ASSERT(offsetof(ValidateProgram, program) == 4, 6022 OffsetOf_ValidateProgram_program_not_4); 6023 6024 struct VertexAttrib1f { 6025 typedef VertexAttrib1f ValueType; 6026 static const CommandId kCmdId = kVertexAttrib1f; 6027 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6028 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6029 6030 static uint32_t ComputeSize() { 6031 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6032 } 6033 6034 void SetHeader() { header.SetCmd<ValueType>(); } 6035 6036 void Init(GLuint _indx, GLfloat _x) { 6037 SetHeader(); 6038 indx = _indx; 6039 x = _x; 6040 } 6041 6042 void* Set(void* cmd, GLuint _indx, GLfloat _x) { 6043 static_cast<ValueType*>(cmd)->Init(_indx, _x); 6044 return NextCmdAddress<ValueType>(cmd); 6045 } 6046 6047 gpu::CommandHeader header; 6048 uint32_t indx; 6049 float x; 6050 }; 6051 6052 COMPILE_ASSERT(sizeof(VertexAttrib1f) == 12, Sizeof_VertexAttrib1f_is_not_12); 6053 COMPILE_ASSERT(offsetof(VertexAttrib1f, header) == 0, 6054 OffsetOf_VertexAttrib1f_header_not_0); 6055 COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4, 6056 OffsetOf_VertexAttrib1f_indx_not_4); 6057 COMPILE_ASSERT(offsetof(VertexAttrib1f, x) == 8, 6058 OffsetOf_VertexAttrib1f_x_not_8); 6059 6060 struct VertexAttrib1fvImmediate { 6061 typedef VertexAttrib1fvImmediate ValueType; 6062 static const CommandId kCmdId = kVertexAttrib1fvImmediate; 6063 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6064 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6065 6066 static uint32_t ComputeDataSize() { 6067 return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT 6068 } 6069 6070 static uint32_t ComputeSize() { 6071 return static_cast<uint32_t>(sizeof(ValueType) + 6072 ComputeDataSize()); // NOLINT 6073 } 6074 6075 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 6076 6077 void Init(GLuint _indx, const GLfloat* _values) { 6078 SetHeader(); 6079 indx = _indx; 6080 memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); 6081 } 6082 6083 void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { 6084 static_cast<ValueType*>(cmd)->Init(_indx, _values); 6085 const uint32_t size = ComputeSize(); 6086 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6087 } 6088 6089 gpu::CommandHeader header; 6090 uint32_t indx; 6091 }; 6092 6093 COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8, 6094 Sizeof_VertexAttrib1fvImmediate_is_not_8); 6095 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, header) == 0, 6096 OffsetOf_VertexAttrib1fvImmediate_header_not_0); 6097 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, indx) == 4, 6098 OffsetOf_VertexAttrib1fvImmediate_indx_not_4); 6099 6100 struct VertexAttrib2f { 6101 typedef VertexAttrib2f ValueType; 6102 static const CommandId kCmdId = kVertexAttrib2f; 6103 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6104 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6105 6106 static uint32_t ComputeSize() { 6107 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6108 } 6109 6110 void SetHeader() { header.SetCmd<ValueType>(); } 6111 6112 void Init(GLuint _indx, GLfloat _x, GLfloat _y) { 6113 SetHeader(); 6114 indx = _indx; 6115 x = _x; 6116 y = _y; 6117 } 6118 6119 void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y) { 6120 static_cast<ValueType*>(cmd)->Init(_indx, _x, _y); 6121 return NextCmdAddress<ValueType>(cmd); 6122 } 6123 6124 gpu::CommandHeader header; 6125 uint32_t indx; 6126 float x; 6127 float y; 6128 }; 6129 6130 COMPILE_ASSERT(sizeof(VertexAttrib2f) == 16, Sizeof_VertexAttrib2f_is_not_16); 6131 COMPILE_ASSERT(offsetof(VertexAttrib2f, header) == 0, 6132 OffsetOf_VertexAttrib2f_header_not_0); 6133 COMPILE_ASSERT(offsetof(VertexAttrib2f, indx) == 4, 6134 OffsetOf_VertexAttrib2f_indx_not_4); 6135 COMPILE_ASSERT(offsetof(VertexAttrib2f, x) == 8, 6136 OffsetOf_VertexAttrib2f_x_not_8); 6137 COMPILE_ASSERT(offsetof(VertexAttrib2f, y) == 12, 6138 OffsetOf_VertexAttrib2f_y_not_12); 6139 6140 struct VertexAttrib2fvImmediate { 6141 typedef VertexAttrib2fvImmediate ValueType; 6142 static const CommandId kCmdId = kVertexAttrib2fvImmediate; 6143 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6144 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6145 6146 static uint32_t ComputeDataSize() { 6147 return static_cast<uint32_t>(sizeof(GLfloat) * 2); // NOLINT 6148 } 6149 6150 static uint32_t ComputeSize() { 6151 return static_cast<uint32_t>(sizeof(ValueType) + 6152 ComputeDataSize()); // NOLINT 6153 } 6154 6155 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 6156 6157 void Init(GLuint _indx, const GLfloat* _values) { 6158 SetHeader(); 6159 indx = _indx; 6160 memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); 6161 } 6162 6163 void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { 6164 static_cast<ValueType*>(cmd)->Init(_indx, _values); 6165 const uint32_t size = ComputeSize(); 6166 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6167 } 6168 6169 gpu::CommandHeader header; 6170 uint32_t indx; 6171 }; 6172 6173 COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8, 6174 Sizeof_VertexAttrib2fvImmediate_is_not_8); 6175 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, header) == 0, 6176 OffsetOf_VertexAttrib2fvImmediate_header_not_0); 6177 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, indx) == 4, 6178 OffsetOf_VertexAttrib2fvImmediate_indx_not_4); 6179 6180 struct VertexAttrib3f { 6181 typedef VertexAttrib3f ValueType; 6182 static const CommandId kCmdId = kVertexAttrib3f; 6183 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6184 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6185 6186 static uint32_t ComputeSize() { 6187 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6188 } 6189 6190 void SetHeader() { header.SetCmd<ValueType>(); } 6191 6192 void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { 6193 SetHeader(); 6194 indx = _indx; 6195 x = _x; 6196 y = _y; 6197 z = _z; 6198 } 6199 6200 void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { 6201 static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z); 6202 return NextCmdAddress<ValueType>(cmd); 6203 } 6204 6205 gpu::CommandHeader header; 6206 uint32_t indx; 6207 float x; 6208 float y; 6209 float z; 6210 }; 6211 6212 COMPILE_ASSERT(sizeof(VertexAttrib3f) == 20, Sizeof_VertexAttrib3f_is_not_20); 6213 COMPILE_ASSERT(offsetof(VertexAttrib3f, header) == 0, 6214 OffsetOf_VertexAttrib3f_header_not_0); 6215 COMPILE_ASSERT(offsetof(VertexAttrib3f, indx) == 4, 6216 OffsetOf_VertexAttrib3f_indx_not_4); 6217 COMPILE_ASSERT(offsetof(VertexAttrib3f, x) == 8, 6218 OffsetOf_VertexAttrib3f_x_not_8); 6219 COMPILE_ASSERT(offsetof(VertexAttrib3f, y) == 12, 6220 OffsetOf_VertexAttrib3f_y_not_12); 6221 COMPILE_ASSERT(offsetof(VertexAttrib3f, z) == 16, 6222 OffsetOf_VertexAttrib3f_z_not_16); 6223 6224 struct VertexAttrib3fvImmediate { 6225 typedef VertexAttrib3fvImmediate ValueType; 6226 static const CommandId kCmdId = kVertexAttrib3fvImmediate; 6227 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6228 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6229 6230 static uint32_t ComputeDataSize() { 6231 return static_cast<uint32_t>(sizeof(GLfloat) * 3); // NOLINT 6232 } 6233 6234 static uint32_t ComputeSize() { 6235 return static_cast<uint32_t>(sizeof(ValueType) + 6236 ComputeDataSize()); // NOLINT 6237 } 6238 6239 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 6240 6241 void Init(GLuint _indx, const GLfloat* _values) { 6242 SetHeader(); 6243 indx = _indx; 6244 memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); 6245 } 6246 6247 void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { 6248 static_cast<ValueType*>(cmd)->Init(_indx, _values); 6249 const uint32_t size = ComputeSize(); 6250 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6251 } 6252 6253 gpu::CommandHeader header; 6254 uint32_t indx; 6255 }; 6256 6257 COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8, 6258 Sizeof_VertexAttrib3fvImmediate_is_not_8); 6259 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, header) == 0, 6260 OffsetOf_VertexAttrib3fvImmediate_header_not_0); 6261 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, indx) == 4, 6262 OffsetOf_VertexAttrib3fvImmediate_indx_not_4); 6263 6264 struct VertexAttrib4f { 6265 typedef VertexAttrib4f ValueType; 6266 static const CommandId kCmdId = kVertexAttrib4f; 6267 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6268 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6269 6270 static uint32_t ComputeSize() { 6271 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6272 } 6273 6274 void SetHeader() { header.SetCmd<ValueType>(); } 6275 6276 void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { 6277 SetHeader(); 6278 indx = _indx; 6279 x = _x; 6280 y = _y; 6281 z = _z; 6282 w = _w; 6283 } 6284 6285 void* Set(void* cmd, 6286 GLuint _indx, 6287 GLfloat _x, 6288 GLfloat _y, 6289 GLfloat _z, 6290 GLfloat _w) { 6291 static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w); 6292 return NextCmdAddress<ValueType>(cmd); 6293 } 6294 6295 gpu::CommandHeader header; 6296 uint32_t indx; 6297 float x; 6298 float y; 6299 float z; 6300 float w; 6301 }; 6302 6303 COMPILE_ASSERT(sizeof(VertexAttrib4f) == 24, Sizeof_VertexAttrib4f_is_not_24); 6304 COMPILE_ASSERT(offsetof(VertexAttrib4f, header) == 0, 6305 OffsetOf_VertexAttrib4f_header_not_0); 6306 COMPILE_ASSERT(offsetof(VertexAttrib4f, indx) == 4, 6307 OffsetOf_VertexAttrib4f_indx_not_4); 6308 COMPILE_ASSERT(offsetof(VertexAttrib4f, x) == 8, 6309 OffsetOf_VertexAttrib4f_x_not_8); 6310 COMPILE_ASSERT(offsetof(VertexAttrib4f, y) == 12, 6311 OffsetOf_VertexAttrib4f_y_not_12); 6312 COMPILE_ASSERT(offsetof(VertexAttrib4f, z) == 16, 6313 OffsetOf_VertexAttrib4f_z_not_16); 6314 COMPILE_ASSERT(offsetof(VertexAttrib4f, w) == 20, 6315 OffsetOf_VertexAttrib4f_w_not_20); 6316 6317 struct VertexAttrib4fvImmediate { 6318 typedef VertexAttrib4fvImmediate ValueType; 6319 static const CommandId kCmdId = kVertexAttrib4fvImmediate; 6320 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6321 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6322 6323 static uint32_t ComputeDataSize() { 6324 return static_cast<uint32_t>(sizeof(GLfloat) * 4); // NOLINT 6325 } 6326 6327 static uint32_t ComputeSize() { 6328 return static_cast<uint32_t>(sizeof(ValueType) + 6329 ComputeDataSize()); // NOLINT 6330 } 6331 6332 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 6333 6334 void Init(GLuint _indx, const GLfloat* _values) { 6335 SetHeader(); 6336 indx = _indx; 6337 memcpy(ImmediateDataAddress(this), _values, ComputeDataSize()); 6338 } 6339 6340 void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { 6341 static_cast<ValueType*>(cmd)->Init(_indx, _values); 6342 const uint32_t size = ComputeSize(); 6343 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6344 } 6345 6346 gpu::CommandHeader header; 6347 uint32_t indx; 6348 }; 6349 6350 COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8, 6351 Sizeof_VertexAttrib4fvImmediate_is_not_8); 6352 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0, 6353 OffsetOf_VertexAttrib4fvImmediate_header_not_0); 6354 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4, 6355 OffsetOf_VertexAttrib4fvImmediate_indx_not_4); 6356 6357 struct VertexAttribPointer { 6358 typedef VertexAttribPointer ValueType; 6359 static const CommandId kCmdId = kVertexAttribPointer; 6360 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6361 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6362 6363 static uint32_t ComputeSize() { 6364 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6365 } 6366 6367 void SetHeader() { header.SetCmd<ValueType>(); } 6368 6369 void Init(GLuint _indx, 6370 GLint _size, 6371 GLenum _type, 6372 GLboolean _normalized, 6373 GLsizei _stride, 6374 GLuint _offset) { 6375 SetHeader(); 6376 indx = _indx; 6377 size = _size; 6378 type = _type; 6379 normalized = _normalized; 6380 stride = _stride; 6381 offset = _offset; 6382 } 6383 6384 void* Set(void* cmd, 6385 GLuint _indx, 6386 GLint _size, 6387 GLenum _type, 6388 GLboolean _normalized, 6389 GLsizei _stride, 6390 GLuint _offset) { 6391 static_cast<ValueType*>(cmd) 6392 ->Init(_indx, _size, _type, _normalized, _stride, _offset); 6393 return NextCmdAddress<ValueType>(cmd); 6394 } 6395 6396 gpu::CommandHeader header; 6397 uint32_t indx; 6398 int32_t size; 6399 uint32_t type; 6400 uint32_t normalized; 6401 int32_t stride; 6402 uint32_t offset; 6403 }; 6404 6405 COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28, 6406 Sizeof_VertexAttribPointer_is_not_28); 6407 COMPILE_ASSERT(offsetof(VertexAttribPointer, header) == 0, 6408 OffsetOf_VertexAttribPointer_header_not_0); 6409 COMPILE_ASSERT(offsetof(VertexAttribPointer, indx) == 4, 6410 OffsetOf_VertexAttribPointer_indx_not_4); 6411 COMPILE_ASSERT(offsetof(VertexAttribPointer, size) == 8, 6412 OffsetOf_VertexAttribPointer_size_not_8); 6413 COMPILE_ASSERT(offsetof(VertexAttribPointer, type) == 12, 6414 OffsetOf_VertexAttribPointer_type_not_12); 6415 COMPILE_ASSERT(offsetof(VertexAttribPointer, normalized) == 16, 6416 OffsetOf_VertexAttribPointer_normalized_not_16); 6417 COMPILE_ASSERT(offsetof(VertexAttribPointer, stride) == 20, 6418 OffsetOf_VertexAttribPointer_stride_not_20); 6419 COMPILE_ASSERT(offsetof(VertexAttribPointer, offset) == 24, 6420 OffsetOf_VertexAttribPointer_offset_not_24); 6421 6422 struct Viewport { 6423 typedef Viewport ValueType; 6424 static const CommandId kCmdId = kViewport; 6425 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6426 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6427 6428 static uint32_t ComputeSize() { 6429 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6430 } 6431 6432 void SetHeader() { header.SetCmd<ValueType>(); } 6433 6434 void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { 6435 SetHeader(); 6436 x = _x; 6437 y = _y; 6438 width = _width; 6439 height = _height; 6440 } 6441 6442 void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { 6443 static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height); 6444 return NextCmdAddress<ValueType>(cmd); 6445 } 6446 6447 gpu::CommandHeader header; 6448 int32_t x; 6449 int32_t y; 6450 int32_t width; 6451 int32_t height; 6452 }; 6453 6454 COMPILE_ASSERT(sizeof(Viewport) == 20, Sizeof_Viewport_is_not_20); 6455 COMPILE_ASSERT(offsetof(Viewport, header) == 0, OffsetOf_Viewport_header_not_0); 6456 COMPILE_ASSERT(offsetof(Viewport, x) == 4, OffsetOf_Viewport_x_not_4); 6457 COMPILE_ASSERT(offsetof(Viewport, y) == 8, OffsetOf_Viewport_y_not_8); 6458 COMPILE_ASSERT(offsetof(Viewport, width) == 12, OffsetOf_Viewport_width_not_12); 6459 COMPILE_ASSERT(offsetof(Viewport, height) == 16, 6460 OffsetOf_Viewport_height_not_16); 6461 6462 struct BlitFramebufferCHROMIUM { 6463 typedef BlitFramebufferCHROMIUM ValueType; 6464 static const CommandId kCmdId = kBlitFramebufferCHROMIUM; 6465 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6466 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 6467 6468 static uint32_t ComputeSize() { 6469 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6470 } 6471 6472 void SetHeader() { header.SetCmd<ValueType>(); } 6473 6474 void Init(GLint _srcX0, 6475 GLint _srcY0, 6476 GLint _srcX1, 6477 GLint _srcY1, 6478 GLint _dstX0, 6479 GLint _dstY0, 6480 GLint _dstX1, 6481 GLint _dstY1, 6482 GLbitfield _mask, 6483 GLenum _filter) { 6484 SetHeader(); 6485 srcX0 = _srcX0; 6486 srcY0 = _srcY0; 6487 srcX1 = _srcX1; 6488 srcY1 = _srcY1; 6489 dstX0 = _dstX0; 6490 dstY0 = _dstY0; 6491 dstX1 = _dstX1; 6492 dstY1 = _dstY1; 6493 mask = _mask; 6494 filter = _filter; 6495 } 6496 6497 void* Set(void* cmd, 6498 GLint _srcX0, 6499 GLint _srcY0, 6500 GLint _srcX1, 6501 GLint _srcY1, 6502 GLint _dstX0, 6503 GLint _dstY0, 6504 GLint _dstX1, 6505 GLint _dstY1, 6506 GLbitfield _mask, 6507 GLenum _filter) { 6508 static_cast<ValueType*>(cmd)->Init(_srcX0, 6509 _srcY0, 6510 _srcX1, 6511 _srcY1, 6512 _dstX0, 6513 _dstY0, 6514 _dstX1, 6515 _dstY1, 6516 _mask, 6517 _filter); 6518 return NextCmdAddress<ValueType>(cmd); 6519 } 6520 6521 gpu::CommandHeader header; 6522 int32_t srcX0; 6523 int32_t srcY0; 6524 int32_t srcX1; 6525 int32_t srcY1; 6526 int32_t dstX0; 6527 int32_t dstY0; 6528 int32_t dstX1; 6529 int32_t dstY1; 6530 uint32_t mask; 6531 uint32_t filter; 6532 }; 6533 6534 COMPILE_ASSERT(sizeof(BlitFramebufferCHROMIUM) == 44, 6535 Sizeof_BlitFramebufferCHROMIUM_is_not_44); 6536 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, header) == 0, 6537 OffsetOf_BlitFramebufferCHROMIUM_header_not_0); 6538 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcX0) == 4, 6539 OffsetOf_BlitFramebufferCHROMIUM_srcX0_not_4); 6540 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcY0) == 8, 6541 OffsetOf_BlitFramebufferCHROMIUM_srcY0_not_8); 6542 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcX1) == 12, 6543 OffsetOf_BlitFramebufferCHROMIUM_srcX1_not_12); 6544 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcY1) == 16, 6545 OffsetOf_BlitFramebufferCHROMIUM_srcY1_not_16); 6546 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstX0) == 20, 6547 OffsetOf_BlitFramebufferCHROMIUM_dstX0_not_20); 6548 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstY0) == 24, 6549 OffsetOf_BlitFramebufferCHROMIUM_dstY0_not_24); 6550 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstX1) == 28, 6551 OffsetOf_BlitFramebufferCHROMIUM_dstX1_not_28); 6552 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstY1) == 32, 6553 OffsetOf_BlitFramebufferCHROMIUM_dstY1_not_32); 6554 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, mask) == 36, 6555 OffsetOf_BlitFramebufferCHROMIUM_mask_not_36); 6556 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, filter) == 40, 6557 OffsetOf_BlitFramebufferCHROMIUM_filter_not_40); 6558 6559 // GL_CHROMIUM_framebuffer_multisample 6560 struct RenderbufferStorageMultisampleCHROMIUM { 6561 typedef RenderbufferStorageMultisampleCHROMIUM ValueType; 6562 static const CommandId kCmdId = kRenderbufferStorageMultisampleCHROMIUM; 6563 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6564 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6565 6566 static uint32_t ComputeSize() { 6567 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6568 } 6569 6570 void SetHeader() { header.SetCmd<ValueType>(); } 6571 6572 void Init(GLenum _target, 6573 GLsizei _samples, 6574 GLenum _internalformat, 6575 GLsizei _width, 6576 GLsizei _height) { 6577 SetHeader(); 6578 target = _target; 6579 samples = _samples; 6580 internalformat = _internalformat; 6581 width = _width; 6582 height = _height; 6583 } 6584 6585 void* Set(void* cmd, 6586 GLenum _target, 6587 GLsizei _samples, 6588 GLenum _internalformat, 6589 GLsizei _width, 6590 GLsizei _height) { 6591 static_cast<ValueType*>(cmd) 6592 ->Init(_target, _samples, _internalformat, _width, _height); 6593 return NextCmdAddress<ValueType>(cmd); 6594 } 6595 6596 gpu::CommandHeader header; 6597 uint32_t target; 6598 int32_t samples; 6599 uint32_t internalformat; 6600 int32_t width; 6601 int32_t height; 6602 }; 6603 6604 COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleCHROMIUM) == 24, 6605 Sizeof_RenderbufferStorageMultisampleCHROMIUM_is_not_24); 6606 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, header) == 0, 6607 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_header_not_0); 6608 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, target) == 4, 6609 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_target_not_4); 6610 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, samples) == 8, 6611 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_samples_not_8); 6612 COMPILE_ASSERT( 6613 offsetof(RenderbufferStorageMultisampleCHROMIUM, internalformat) == 12, 6614 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_internalformat_not_12); 6615 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, width) == 16, 6616 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_width_not_16); 6617 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, height) == 20, 6618 OffsetOf_RenderbufferStorageMultisampleCHROMIUM_height_not_20); 6619 6620 // GL_EXT_multisampled_render_to_texture 6621 struct RenderbufferStorageMultisampleEXT { 6622 typedef RenderbufferStorageMultisampleEXT ValueType; 6623 static const CommandId kCmdId = kRenderbufferStorageMultisampleEXT; 6624 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6625 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6626 6627 static uint32_t ComputeSize() { 6628 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6629 } 6630 6631 void SetHeader() { header.SetCmd<ValueType>(); } 6632 6633 void Init(GLenum _target, 6634 GLsizei _samples, 6635 GLenum _internalformat, 6636 GLsizei _width, 6637 GLsizei _height) { 6638 SetHeader(); 6639 target = _target; 6640 samples = _samples; 6641 internalformat = _internalformat; 6642 width = _width; 6643 height = _height; 6644 } 6645 6646 void* Set(void* cmd, 6647 GLenum _target, 6648 GLsizei _samples, 6649 GLenum _internalformat, 6650 GLsizei _width, 6651 GLsizei _height) { 6652 static_cast<ValueType*>(cmd) 6653 ->Init(_target, _samples, _internalformat, _width, _height); 6654 return NextCmdAddress<ValueType>(cmd); 6655 } 6656 6657 gpu::CommandHeader header; 6658 uint32_t target; 6659 int32_t samples; 6660 uint32_t internalformat; 6661 int32_t width; 6662 int32_t height; 6663 }; 6664 6665 COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleEXT) == 24, 6666 Sizeof_RenderbufferStorageMultisampleEXT_is_not_24); 6667 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, header) == 0, 6668 OffsetOf_RenderbufferStorageMultisampleEXT_header_not_0); 6669 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, target) == 4, 6670 OffsetOf_RenderbufferStorageMultisampleEXT_target_not_4); 6671 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, samples) == 8, 6672 OffsetOf_RenderbufferStorageMultisampleEXT_samples_not_8); 6673 COMPILE_ASSERT( 6674 offsetof(RenderbufferStorageMultisampleEXT, internalformat) == 12, 6675 OffsetOf_RenderbufferStorageMultisampleEXT_internalformat_not_12); 6676 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, width) == 16, 6677 OffsetOf_RenderbufferStorageMultisampleEXT_width_not_16); 6678 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, height) == 20, 6679 OffsetOf_RenderbufferStorageMultisampleEXT_height_not_20); 6680 6681 struct FramebufferTexture2DMultisampleEXT { 6682 typedef FramebufferTexture2DMultisampleEXT ValueType; 6683 static const CommandId kCmdId = kFramebufferTexture2DMultisampleEXT; 6684 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6685 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 6686 6687 static uint32_t ComputeSize() { 6688 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6689 } 6690 6691 void SetHeader() { header.SetCmd<ValueType>(); } 6692 6693 void Init(GLenum _target, 6694 GLenum _attachment, 6695 GLenum _textarget, 6696 GLuint _texture, 6697 GLsizei _samples) { 6698 SetHeader(); 6699 target = _target; 6700 attachment = _attachment; 6701 textarget = _textarget; 6702 texture = _texture; 6703 samples = _samples; 6704 } 6705 6706 void* Set(void* cmd, 6707 GLenum _target, 6708 GLenum _attachment, 6709 GLenum _textarget, 6710 GLuint _texture, 6711 GLsizei _samples) { 6712 static_cast<ValueType*>(cmd) 6713 ->Init(_target, _attachment, _textarget, _texture, _samples); 6714 return NextCmdAddress<ValueType>(cmd); 6715 } 6716 6717 gpu::CommandHeader header; 6718 uint32_t target; 6719 uint32_t attachment; 6720 uint32_t textarget; 6721 uint32_t texture; 6722 int32_t samples; 6723 static const int32_t level = 0; 6724 }; 6725 6726 COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 24, 6727 Sizeof_FramebufferTexture2DMultisampleEXT_is_not_24); 6728 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, header) == 0, 6729 OffsetOf_FramebufferTexture2DMultisampleEXT_header_not_0); 6730 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, target) == 4, 6731 OffsetOf_FramebufferTexture2DMultisampleEXT_target_not_4); 6732 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, attachment) == 8, 6733 OffsetOf_FramebufferTexture2DMultisampleEXT_attachment_not_8); 6734 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, textarget) == 12, 6735 OffsetOf_FramebufferTexture2DMultisampleEXT_textarget_not_12); 6736 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, texture) == 16, 6737 OffsetOf_FramebufferTexture2DMultisampleEXT_texture_not_16); 6738 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 20, 6739 OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_20); 6740 6741 struct TexStorage2DEXT { 6742 typedef TexStorage2DEXT ValueType; 6743 static const CommandId kCmdId = kTexStorage2DEXT; 6744 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6745 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6746 6747 static uint32_t ComputeSize() { 6748 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6749 } 6750 6751 void SetHeader() { header.SetCmd<ValueType>(); } 6752 6753 void Init(GLenum _target, 6754 GLsizei _levels, 6755 GLenum _internalFormat, 6756 GLsizei _width, 6757 GLsizei _height) { 6758 SetHeader(); 6759 target = _target; 6760 levels = _levels; 6761 internalFormat = _internalFormat; 6762 width = _width; 6763 height = _height; 6764 } 6765 6766 void* Set(void* cmd, 6767 GLenum _target, 6768 GLsizei _levels, 6769 GLenum _internalFormat, 6770 GLsizei _width, 6771 GLsizei _height) { 6772 static_cast<ValueType*>(cmd) 6773 ->Init(_target, _levels, _internalFormat, _width, _height); 6774 return NextCmdAddress<ValueType>(cmd); 6775 } 6776 6777 gpu::CommandHeader header; 6778 uint32_t target; 6779 int32_t levels; 6780 uint32_t internalFormat; 6781 int32_t width; 6782 int32_t height; 6783 }; 6784 6785 COMPILE_ASSERT(sizeof(TexStorage2DEXT) == 24, Sizeof_TexStorage2DEXT_is_not_24); 6786 COMPILE_ASSERT(offsetof(TexStorage2DEXT, header) == 0, 6787 OffsetOf_TexStorage2DEXT_header_not_0); 6788 COMPILE_ASSERT(offsetof(TexStorage2DEXT, target) == 4, 6789 OffsetOf_TexStorage2DEXT_target_not_4); 6790 COMPILE_ASSERT(offsetof(TexStorage2DEXT, levels) == 8, 6791 OffsetOf_TexStorage2DEXT_levels_not_8); 6792 COMPILE_ASSERT(offsetof(TexStorage2DEXT, internalFormat) == 12, 6793 OffsetOf_TexStorage2DEXT_internalFormat_not_12); 6794 COMPILE_ASSERT(offsetof(TexStorage2DEXT, width) == 16, 6795 OffsetOf_TexStorage2DEXT_width_not_16); 6796 COMPILE_ASSERT(offsetof(TexStorage2DEXT, height) == 20, 6797 OffsetOf_TexStorage2DEXT_height_not_20); 6798 6799 struct GenQueriesEXTImmediate { 6800 typedef GenQueriesEXTImmediate ValueType; 6801 static const CommandId kCmdId = kGenQueriesEXTImmediate; 6802 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6803 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6804 6805 static uint32_t ComputeDataSize(GLsizei n) { 6806 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 6807 } 6808 6809 static uint32_t ComputeSize(GLsizei n) { 6810 return static_cast<uint32_t>(sizeof(ValueType) + 6811 ComputeDataSize(n)); // NOLINT 6812 } 6813 6814 void SetHeader(GLsizei n) { 6815 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 6816 } 6817 6818 void Init(GLsizei _n, GLuint* _queries) { 6819 SetHeader(_n); 6820 n = _n; 6821 memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n)); 6822 } 6823 6824 void* Set(void* cmd, GLsizei _n, GLuint* _queries) { 6825 static_cast<ValueType*>(cmd)->Init(_n, _queries); 6826 const uint32_t size = ComputeSize(_n); 6827 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6828 } 6829 6830 gpu::CommandHeader header; 6831 int32_t n; 6832 }; 6833 6834 COMPILE_ASSERT(sizeof(GenQueriesEXTImmediate) == 8, 6835 Sizeof_GenQueriesEXTImmediate_is_not_8); 6836 COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, header) == 0, 6837 OffsetOf_GenQueriesEXTImmediate_header_not_0); 6838 COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, n) == 4, 6839 OffsetOf_GenQueriesEXTImmediate_n_not_4); 6840 6841 struct DeleteQueriesEXTImmediate { 6842 typedef DeleteQueriesEXTImmediate ValueType; 6843 static const CommandId kCmdId = kDeleteQueriesEXTImmediate; 6844 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 6845 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6846 6847 static uint32_t ComputeDataSize(GLsizei n) { 6848 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 6849 } 6850 6851 static uint32_t ComputeSize(GLsizei n) { 6852 return static_cast<uint32_t>(sizeof(ValueType) + 6853 ComputeDataSize(n)); // NOLINT 6854 } 6855 6856 void SetHeader(GLsizei n) { 6857 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 6858 } 6859 6860 void Init(GLsizei _n, const GLuint* _queries) { 6861 SetHeader(_n); 6862 n = _n; 6863 memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n)); 6864 } 6865 6866 void* Set(void* cmd, GLsizei _n, const GLuint* _queries) { 6867 static_cast<ValueType*>(cmd)->Init(_n, _queries); 6868 const uint32_t size = ComputeSize(_n); 6869 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 6870 } 6871 6872 gpu::CommandHeader header; 6873 int32_t n; 6874 }; 6875 6876 COMPILE_ASSERT(sizeof(DeleteQueriesEXTImmediate) == 8, 6877 Sizeof_DeleteQueriesEXTImmediate_is_not_8); 6878 COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, header) == 0, 6879 OffsetOf_DeleteQueriesEXTImmediate_header_not_0); 6880 COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, n) == 4, 6881 OffsetOf_DeleteQueriesEXTImmediate_n_not_4); 6882 6883 struct BeginQueryEXT { 6884 typedef BeginQueryEXT ValueType; 6885 static const CommandId kCmdId = kBeginQueryEXT; 6886 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6887 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6888 6889 static uint32_t ComputeSize() { 6890 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6891 } 6892 6893 void SetHeader() { header.SetCmd<ValueType>(); } 6894 6895 void Init(GLenum _target, 6896 GLuint _id, 6897 uint32_t _sync_data_shm_id, 6898 uint32_t _sync_data_shm_offset) { 6899 SetHeader(); 6900 target = _target; 6901 id = _id; 6902 sync_data_shm_id = _sync_data_shm_id; 6903 sync_data_shm_offset = _sync_data_shm_offset; 6904 } 6905 6906 void* Set(void* cmd, 6907 GLenum _target, 6908 GLuint _id, 6909 uint32_t _sync_data_shm_id, 6910 uint32_t _sync_data_shm_offset) { 6911 static_cast<ValueType*>(cmd) 6912 ->Init(_target, _id, _sync_data_shm_id, _sync_data_shm_offset); 6913 return NextCmdAddress<ValueType>(cmd); 6914 } 6915 6916 gpu::CommandHeader header; 6917 uint32_t target; 6918 uint32_t id; 6919 uint32_t sync_data_shm_id; 6920 uint32_t sync_data_shm_offset; 6921 }; 6922 6923 COMPILE_ASSERT(sizeof(BeginQueryEXT) == 20, Sizeof_BeginQueryEXT_is_not_20); 6924 COMPILE_ASSERT(offsetof(BeginQueryEXT, header) == 0, 6925 OffsetOf_BeginQueryEXT_header_not_0); 6926 COMPILE_ASSERT(offsetof(BeginQueryEXT, target) == 4, 6927 OffsetOf_BeginQueryEXT_target_not_4); 6928 COMPILE_ASSERT(offsetof(BeginQueryEXT, id) == 8, 6929 OffsetOf_BeginQueryEXT_id_not_8); 6930 COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_id) == 12, 6931 OffsetOf_BeginQueryEXT_sync_data_shm_id_not_12); 6932 COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_offset) == 16, 6933 OffsetOf_BeginQueryEXT_sync_data_shm_offset_not_16); 6934 6935 struct EndQueryEXT { 6936 typedef EndQueryEXT ValueType; 6937 static const CommandId kCmdId = kEndQueryEXT; 6938 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6939 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6940 6941 static uint32_t ComputeSize() { 6942 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6943 } 6944 6945 void SetHeader() { header.SetCmd<ValueType>(); } 6946 6947 void Init(GLenum _target, GLuint _submit_count) { 6948 SetHeader(); 6949 target = _target; 6950 submit_count = _submit_count; 6951 } 6952 6953 void* Set(void* cmd, GLenum _target, GLuint _submit_count) { 6954 static_cast<ValueType*>(cmd)->Init(_target, _submit_count); 6955 return NextCmdAddress<ValueType>(cmd); 6956 } 6957 6958 gpu::CommandHeader header; 6959 uint32_t target; 6960 uint32_t submit_count; 6961 }; 6962 6963 COMPILE_ASSERT(sizeof(EndQueryEXT) == 12, Sizeof_EndQueryEXT_is_not_12); 6964 COMPILE_ASSERT(offsetof(EndQueryEXT, header) == 0, 6965 OffsetOf_EndQueryEXT_header_not_0); 6966 COMPILE_ASSERT(offsetof(EndQueryEXT, target) == 4, 6967 OffsetOf_EndQueryEXT_target_not_4); 6968 COMPILE_ASSERT(offsetof(EndQueryEXT, submit_count) == 8, 6969 OffsetOf_EndQueryEXT_submit_count_not_8); 6970 6971 struct InsertEventMarkerEXT { 6972 typedef InsertEventMarkerEXT ValueType; 6973 static const CommandId kCmdId = kInsertEventMarkerEXT; 6974 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 6975 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 6976 6977 static uint32_t ComputeSize() { 6978 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 6979 } 6980 6981 void SetHeader() { header.SetCmd<ValueType>(); } 6982 6983 void Init(GLuint _bucket_id) { 6984 SetHeader(); 6985 bucket_id = _bucket_id; 6986 } 6987 6988 void* Set(void* cmd, GLuint _bucket_id) { 6989 static_cast<ValueType*>(cmd)->Init(_bucket_id); 6990 return NextCmdAddress<ValueType>(cmd); 6991 } 6992 6993 gpu::CommandHeader header; 6994 uint32_t bucket_id; 6995 }; 6996 6997 COMPILE_ASSERT(sizeof(InsertEventMarkerEXT) == 8, 6998 Sizeof_InsertEventMarkerEXT_is_not_8); 6999 COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, header) == 0, 7000 OffsetOf_InsertEventMarkerEXT_header_not_0); 7001 COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, bucket_id) == 4, 7002 OffsetOf_InsertEventMarkerEXT_bucket_id_not_4); 7003 7004 struct PushGroupMarkerEXT { 7005 typedef PushGroupMarkerEXT ValueType; 7006 static const CommandId kCmdId = kPushGroupMarkerEXT; 7007 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7008 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7009 7010 static uint32_t ComputeSize() { 7011 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7012 } 7013 7014 void SetHeader() { header.SetCmd<ValueType>(); } 7015 7016 void Init(GLuint _bucket_id) { 7017 SetHeader(); 7018 bucket_id = _bucket_id; 7019 } 7020 7021 void* Set(void* cmd, GLuint _bucket_id) { 7022 static_cast<ValueType*>(cmd)->Init(_bucket_id); 7023 return NextCmdAddress<ValueType>(cmd); 7024 } 7025 7026 gpu::CommandHeader header; 7027 uint32_t bucket_id; 7028 }; 7029 7030 COMPILE_ASSERT(sizeof(PushGroupMarkerEXT) == 8, 7031 Sizeof_PushGroupMarkerEXT_is_not_8); 7032 COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, header) == 0, 7033 OffsetOf_PushGroupMarkerEXT_header_not_0); 7034 COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, bucket_id) == 4, 7035 OffsetOf_PushGroupMarkerEXT_bucket_id_not_4); 7036 7037 struct PopGroupMarkerEXT { 7038 typedef PopGroupMarkerEXT ValueType; 7039 static const CommandId kCmdId = kPopGroupMarkerEXT; 7040 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7041 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7042 7043 static uint32_t ComputeSize() { 7044 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7045 } 7046 7047 void SetHeader() { header.SetCmd<ValueType>(); } 7048 7049 void Init() { SetHeader(); } 7050 7051 void* Set(void* cmd) { 7052 static_cast<ValueType*>(cmd)->Init(); 7053 return NextCmdAddress<ValueType>(cmd); 7054 } 7055 7056 gpu::CommandHeader header; 7057 }; 7058 7059 COMPILE_ASSERT(sizeof(PopGroupMarkerEXT) == 4, 7060 Sizeof_PopGroupMarkerEXT_is_not_4); 7061 COMPILE_ASSERT(offsetof(PopGroupMarkerEXT, header) == 0, 7062 OffsetOf_PopGroupMarkerEXT_header_not_0); 7063 7064 struct GenVertexArraysOESImmediate { 7065 typedef GenVertexArraysOESImmediate ValueType; 7066 static const CommandId kCmdId = kGenVertexArraysOESImmediate; 7067 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 7068 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7069 7070 static uint32_t ComputeDataSize(GLsizei n) { 7071 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 7072 } 7073 7074 static uint32_t ComputeSize(GLsizei n) { 7075 return static_cast<uint32_t>(sizeof(ValueType) + 7076 ComputeDataSize(n)); // NOLINT 7077 } 7078 7079 void SetHeader(GLsizei n) { 7080 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 7081 } 7082 7083 void Init(GLsizei _n, GLuint* _arrays) { 7084 SetHeader(_n); 7085 n = _n; 7086 memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n)); 7087 } 7088 7089 void* Set(void* cmd, GLsizei _n, GLuint* _arrays) { 7090 static_cast<ValueType*>(cmd)->Init(_n, _arrays); 7091 const uint32_t size = ComputeSize(_n); 7092 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 7093 } 7094 7095 gpu::CommandHeader header; 7096 int32_t n; 7097 }; 7098 7099 COMPILE_ASSERT(sizeof(GenVertexArraysOESImmediate) == 8, 7100 Sizeof_GenVertexArraysOESImmediate_is_not_8); 7101 COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, header) == 0, 7102 OffsetOf_GenVertexArraysOESImmediate_header_not_0); 7103 COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, n) == 4, 7104 OffsetOf_GenVertexArraysOESImmediate_n_not_4); 7105 7106 struct DeleteVertexArraysOESImmediate { 7107 typedef DeleteVertexArraysOESImmediate ValueType; 7108 static const CommandId kCmdId = kDeleteVertexArraysOESImmediate; 7109 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 7110 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7111 7112 static uint32_t ComputeDataSize(GLsizei n) { 7113 return static_cast<uint32_t>(sizeof(GLuint) * n); // NOLINT 7114 } 7115 7116 static uint32_t ComputeSize(GLsizei n) { 7117 return static_cast<uint32_t>(sizeof(ValueType) + 7118 ComputeDataSize(n)); // NOLINT 7119 } 7120 7121 void SetHeader(GLsizei n) { 7122 header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); 7123 } 7124 7125 void Init(GLsizei _n, const GLuint* _arrays) { 7126 SetHeader(_n); 7127 n = _n; 7128 memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n)); 7129 } 7130 7131 void* Set(void* cmd, GLsizei _n, const GLuint* _arrays) { 7132 static_cast<ValueType*>(cmd)->Init(_n, _arrays); 7133 const uint32_t size = ComputeSize(_n); 7134 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 7135 } 7136 7137 gpu::CommandHeader header; 7138 int32_t n; 7139 }; 7140 7141 COMPILE_ASSERT(sizeof(DeleteVertexArraysOESImmediate) == 8, 7142 Sizeof_DeleteVertexArraysOESImmediate_is_not_8); 7143 COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, header) == 0, 7144 OffsetOf_DeleteVertexArraysOESImmediate_header_not_0); 7145 COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, n) == 4, 7146 OffsetOf_DeleteVertexArraysOESImmediate_n_not_4); 7147 7148 struct IsVertexArrayOES { 7149 typedef IsVertexArrayOES ValueType; 7150 static const CommandId kCmdId = kIsVertexArrayOES; 7151 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7152 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7153 7154 typedef uint32_t Result; 7155 7156 static uint32_t ComputeSize() { 7157 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7158 } 7159 7160 void SetHeader() { header.SetCmd<ValueType>(); } 7161 7162 void Init(GLuint _array, 7163 uint32_t _result_shm_id, 7164 uint32_t _result_shm_offset) { 7165 SetHeader(); 7166 array = _array; 7167 result_shm_id = _result_shm_id; 7168 result_shm_offset = _result_shm_offset; 7169 } 7170 7171 void* Set(void* cmd, 7172 GLuint _array, 7173 uint32_t _result_shm_id, 7174 uint32_t _result_shm_offset) { 7175 static_cast<ValueType*>(cmd) 7176 ->Init(_array, _result_shm_id, _result_shm_offset); 7177 return NextCmdAddress<ValueType>(cmd); 7178 } 7179 7180 gpu::CommandHeader header; 7181 uint32_t array; 7182 uint32_t result_shm_id; 7183 uint32_t result_shm_offset; 7184 }; 7185 7186 COMPILE_ASSERT(sizeof(IsVertexArrayOES) == 16, 7187 Sizeof_IsVertexArrayOES_is_not_16); 7188 COMPILE_ASSERT(offsetof(IsVertexArrayOES, header) == 0, 7189 OffsetOf_IsVertexArrayOES_header_not_0); 7190 COMPILE_ASSERT(offsetof(IsVertexArrayOES, array) == 4, 7191 OffsetOf_IsVertexArrayOES_array_not_4); 7192 COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_id) == 8, 7193 OffsetOf_IsVertexArrayOES_result_shm_id_not_8); 7194 COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_offset) == 12, 7195 OffsetOf_IsVertexArrayOES_result_shm_offset_not_12); 7196 7197 struct BindVertexArrayOES { 7198 typedef BindVertexArrayOES ValueType; 7199 static const CommandId kCmdId = kBindVertexArrayOES; 7200 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7201 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7202 7203 static uint32_t ComputeSize() { 7204 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7205 } 7206 7207 void SetHeader() { header.SetCmd<ValueType>(); } 7208 7209 void Init(GLuint _array) { 7210 SetHeader(); 7211 array = _array; 7212 } 7213 7214 void* Set(void* cmd, GLuint _array) { 7215 static_cast<ValueType*>(cmd)->Init(_array); 7216 return NextCmdAddress<ValueType>(cmd); 7217 } 7218 7219 gpu::CommandHeader header; 7220 uint32_t array; 7221 }; 7222 7223 COMPILE_ASSERT(sizeof(BindVertexArrayOES) == 8, 7224 Sizeof_BindVertexArrayOES_is_not_8); 7225 COMPILE_ASSERT(offsetof(BindVertexArrayOES, header) == 0, 7226 OffsetOf_BindVertexArrayOES_header_not_0); 7227 COMPILE_ASSERT(offsetof(BindVertexArrayOES, array) == 4, 7228 OffsetOf_BindVertexArrayOES_array_not_4); 7229 7230 struct SwapBuffers { 7231 typedef SwapBuffers ValueType; 7232 static const CommandId kCmdId = kSwapBuffers; 7233 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7234 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 7235 7236 static uint32_t ComputeSize() { 7237 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7238 } 7239 7240 void SetHeader() { header.SetCmd<ValueType>(); } 7241 7242 void Init() { SetHeader(); } 7243 7244 void* Set(void* cmd) { 7245 static_cast<ValueType*>(cmd)->Init(); 7246 return NextCmdAddress<ValueType>(cmd); 7247 } 7248 7249 gpu::CommandHeader header; 7250 }; 7251 7252 COMPILE_ASSERT(sizeof(SwapBuffers) == 4, Sizeof_SwapBuffers_is_not_4); 7253 COMPILE_ASSERT(offsetof(SwapBuffers, header) == 0, 7254 OffsetOf_SwapBuffers_header_not_0); 7255 7256 struct GetMaxValueInBufferCHROMIUM { 7257 typedef GetMaxValueInBufferCHROMIUM ValueType; 7258 static const CommandId kCmdId = kGetMaxValueInBufferCHROMIUM; 7259 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7260 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7261 7262 typedef GLuint Result; 7263 7264 static uint32_t ComputeSize() { 7265 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7266 } 7267 7268 void SetHeader() { header.SetCmd<ValueType>(); } 7269 7270 void Init(GLuint _buffer_id, 7271 GLsizei _count, 7272 GLenum _type, 7273 GLuint _offset, 7274 uint32_t _result_shm_id, 7275 uint32_t _result_shm_offset) { 7276 SetHeader(); 7277 buffer_id = _buffer_id; 7278 count = _count; 7279 type = _type; 7280 offset = _offset; 7281 result_shm_id = _result_shm_id; 7282 result_shm_offset = _result_shm_offset; 7283 } 7284 7285 void* Set(void* cmd, 7286 GLuint _buffer_id, 7287 GLsizei _count, 7288 GLenum _type, 7289 GLuint _offset, 7290 uint32_t _result_shm_id, 7291 uint32_t _result_shm_offset) { 7292 static_cast<ValueType*>(cmd)->Init( 7293 _buffer_id, _count, _type, _offset, _result_shm_id, _result_shm_offset); 7294 return NextCmdAddress<ValueType>(cmd); 7295 } 7296 7297 gpu::CommandHeader header; 7298 uint32_t buffer_id; 7299 int32_t count; 7300 uint32_t type; 7301 uint32_t offset; 7302 uint32_t result_shm_id; 7303 uint32_t result_shm_offset; 7304 }; 7305 7306 COMPILE_ASSERT(sizeof(GetMaxValueInBufferCHROMIUM) == 28, 7307 Sizeof_GetMaxValueInBufferCHROMIUM_is_not_28); 7308 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, header) == 0, 7309 OffsetOf_GetMaxValueInBufferCHROMIUM_header_not_0); 7310 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, buffer_id) == 4, 7311 OffsetOf_GetMaxValueInBufferCHROMIUM_buffer_id_not_4); 7312 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, count) == 8, 7313 OffsetOf_GetMaxValueInBufferCHROMIUM_count_not_8); 7314 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, type) == 12, 7315 OffsetOf_GetMaxValueInBufferCHROMIUM_type_not_12); 7316 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, offset) == 16, 7317 OffsetOf_GetMaxValueInBufferCHROMIUM_offset_not_16); 7318 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_id) == 20, 7319 OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_id_not_20); 7320 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_offset) == 24, 7321 OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_offset_not_24); 7322 7323 struct GenSharedIdsCHROMIUM { 7324 typedef GenSharedIdsCHROMIUM ValueType; 7325 static const CommandId kCmdId = kGenSharedIdsCHROMIUM; 7326 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7327 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7328 7329 static uint32_t ComputeSize() { 7330 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7331 } 7332 7333 void SetHeader() { header.SetCmd<ValueType>(); } 7334 7335 void Init(GLuint _namespace_id, 7336 GLuint _id_offset, 7337 GLsizei _n, 7338 uint32_t _ids_shm_id, 7339 uint32_t _ids_shm_offset) { 7340 SetHeader(); 7341 namespace_id = _namespace_id; 7342 id_offset = _id_offset; 7343 n = _n; 7344 ids_shm_id = _ids_shm_id; 7345 ids_shm_offset = _ids_shm_offset; 7346 } 7347 7348 void* Set(void* cmd, 7349 GLuint _namespace_id, 7350 GLuint _id_offset, 7351 GLsizei _n, 7352 uint32_t _ids_shm_id, 7353 uint32_t _ids_shm_offset) { 7354 static_cast<ValueType*>(cmd) 7355 ->Init(_namespace_id, _id_offset, _n, _ids_shm_id, _ids_shm_offset); 7356 return NextCmdAddress<ValueType>(cmd); 7357 } 7358 7359 gpu::CommandHeader header; 7360 uint32_t namespace_id; 7361 uint32_t id_offset; 7362 int32_t n; 7363 uint32_t ids_shm_id; 7364 uint32_t ids_shm_offset; 7365 }; 7366 7367 COMPILE_ASSERT(sizeof(GenSharedIdsCHROMIUM) == 24, 7368 Sizeof_GenSharedIdsCHROMIUM_is_not_24); 7369 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, header) == 0, 7370 OffsetOf_GenSharedIdsCHROMIUM_header_not_0); 7371 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, namespace_id) == 4, 7372 OffsetOf_GenSharedIdsCHROMIUM_namespace_id_not_4); 7373 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, id_offset) == 8, 7374 OffsetOf_GenSharedIdsCHROMIUM_id_offset_not_8); 7375 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, n) == 12, 7376 OffsetOf_GenSharedIdsCHROMIUM_n_not_12); 7377 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, ids_shm_id) == 16, 7378 OffsetOf_GenSharedIdsCHROMIUM_ids_shm_id_not_16); 7379 COMPILE_ASSERT(offsetof(GenSharedIdsCHROMIUM, ids_shm_offset) == 20, 7380 OffsetOf_GenSharedIdsCHROMIUM_ids_shm_offset_not_20); 7381 7382 struct DeleteSharedIdsCHROMIUM { 7383 typedef DeleteSharedIdsCHROMIUM ValueType; 7384 static const CommandId kCmdId = kDeleteSharedIdsCHROMIUM; 7385 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7386 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7387 7388 static uint32_t ComputeSize() { 7389 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7390 } 7391 7392 void SetHeader() { header.SetCmd<ValueType>(); } 7393 7394 void Init(GLuint _namespace_id, 7395 GLsizei _n, 7396 uint32_t _ids_shm_id, 7397 uint32_t _ids_shm_offset) { 7398 SetHeader(); 7399 namespace_id = _namespace_id; 7400 n = _n; 7401 ids_shm_id = _ids_shm_id; 7402 ids_shm_offset = _ids_shm_offset; 7403 } 7404 7405 void* Set(void* cmd, 7406 GLuint _namespace_id, 7407 GLsizei _n, 7408 uint32_t _ids_shm_id, 7409 uint32_t _ids_shm_offset) { 7410 static_cast<ValueType*>(cmd) 7411 ->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset); 7412 return NextCmdAddress<ValueType>(cmd); 7413 } 7414 7415 gpu::CommandHeader header; 7416 uint32_t namespace_id; 7417 int32_t n; 7418 uint32_t ids_shm_id; 7419 uint32_t ids_shm_offset; 7420 }; 7421 7422 COMPILE_ASSERT(sizeof(DeleteSharedIdsCHROMIUM) == 20, 7423 Sizeof_DeleteSharedIdsCHROMIUM_is_not_20); 7424 COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, header) == 0, 7425 OffsetOf_DeleteSharedIdsCHROMIUM_header_not_0); 7426 COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, namespace_id) == 4, 7427 OffsetOf_DeleteSharedIdsCHROMIUM_namespace_id_not_4); 7428 COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, n) == 8, 7429 OffsetOf_DeleteSharedIdsCHROMIUM_n_not_8); 7430 COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, ids_shm_id) == 12, 7431 OffsetOf_DeleteSharedIdsCHROMIUM_ids_shm_id_not_12); 7432 COMPILE_ASSERT(offsetof(DeleteSharedIdsCHROMIUM, ids_shm_offset) == 16, 7433 OffsetOf_DeleteSharedIdsCHROMIUM_ids_shm_offset_not_16); 7434 7435 struct RegisterSharedIdsCHROMIUM { 7436 typedef RegisterSharedIdsCHROMIUM ValueType; 7437 static const CommandId kCmdId = kRegisterSharedIdsCHROMIUM; 7438 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7439 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7440 7441 static uint32_t ComputeSize() { 7442 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7443 } 7444 7445 void SetHeader() { header.SetCmd<ValueType>(); } 7446 7447 void Init(GLuint _namespace_id, 7448 GLsizei _n, 7449 uint32_t _ids_shm_id, 7450 uint32_t _ids_shm_offset) { 7451 SetHeader(); 7452 namespace_id = _namespace_id; 7453 n = _n; 7454 ids_shm_id = _ids_shm_id; 7455 ids_shm_offset = _ids_shm_offset; 7456 } 7457 7458 void* Set(void* cmd, 7459 GLuint _namespace_id, 7460 GLsizei _n, 7461 uint32_t _ids_shm_id, 7462 uint32_t _ids_shm_offset) { 7463 static_cast<ValueType*>(cmd) 7464 ->Init(_namespace_id, _n, _ids_shm_id, _ids_shm_offset); 7465 return NextCmdAddress<ValueType>(cmd); 7466 } 7467 7468 gpu::CommandHeader header; 7469 uint32_t namespace_id; 7470 int32_t n; 7471 uint32_t ids_shm_id; 7472 uint32_t ids_shm_offset; 7473 }; 7474 7475 COMPILE_ASSERT(sizeof(RegisterSharedIdsCHROMIUM) == 20, 7476 Sizeof_RegisterSharedIdsCHROMIUM_is_not_20); 7477 COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, header) == 0, 7478 OffsetOf_RegisterSharedIdsCHROMIUM_header_not_0); 7479 COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, namespace_id) == 4, 7480 OffsetOf_RegisterSharedIdsCHROMIUM_namespace_id_not_4); 7481 COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, n) == 8, 7482 OffsetOf_RegisterSharedIdsCHROMIUM_n_not_8); 7483 COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, ids_shm_id) == 12, 7484 OffsetOf_RegisterSharedIdsCHROMIUM_ids_shm_id_not_12); 7485 COMPILE_ASSERT(offsetof(RegisterSharedIdsCHROMIUM, ids_shm_offset) == 16, 7486 OffsetOf_RegisterSharedIdsCHROMIUM_ids_shm_offset_not_16); 7487 7488 struct EnableFeatureCHROMIUM { 7489 typedef EnableFeatureCHROMIUM ValueType; 7490 static const CommandId kCmdId = kEnableFeatureCHROMIUM; 7491 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7492 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7493 7494 typedef GLint Result; 7495 7496 static uint32_t ComputeSize() { 7497 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7498 } 7499 7500 void SetHeader() { header.SetCmd<ValueType>(); } 7501 7502 void Init(GLuint _bucket_id, 7503 uint32_t _result_shm_id, 7504 uint32_t _result_shm_offset) { 7505 SetHeader(); 7506 bucket_id = _bucket_id; 7507 result_shm_id = _result_shm_id; 7508 result_shm_offset = _result_shm_offset; 7509 } 7510 7511 void* Set(void* cmd, 7512 GLuint _bucket_id, 7513 uint32_t _result_shm_id, 7514 uint32_t _result_shm_offset) { 7515 static_cast<ValueType*>(cmd) 7516 ->Init(_bucket_id, _result_shm_id, _result_shm_offset); 7517 return NextCmdAddress<ValueType>(cmd); 7518 } 7519 7520 gpu::CommandHeader header; 7521 uint32_t bucket_id; 7522 uint32_t result_shm_id; 7523 uint32_t result_shm_offset; 7524 }; 7525 7526 COMPILE_ASSERT(sizeof(EnableFeatureCHROMIUM) == 16, 7527 Sizeof_EnableFeatureCHROMIUM_is_not_16); 7528 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, header) == 0, 7529 OffsetOf_EnableFeatureCHROMIUM_header_not_0); 7530 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, bucket_id) == 4, 7531 OffsetOf_EnableFeatureCHROMIUM_bucket_id_not_4); 7532 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_id) == 8, 7533 OffsetOf_EnableFeatureCHROMIUM_result_shm_id_not_8); 7534 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_offset) == 12, 7535 OffsetOf_EnableFeatureCHROMIUM_result_shm_offset_not_12); 7536 7537 struct ResizeCHROMIUM { 7538 typedef ResizeCHROMIUM ValueType; 7539 static const CommandId kCmdId = kResizeCHROMIUM; 7540 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7541 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7542 7543 static uint32_t ComputeSize() { 7544 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7545 } 7546 7547 void SetHeader() { header.SetCmd<ValueType>(); } 7548 7549 void Init(GLuint _width, GLuint _height, GLfloat _scale_factor) { 7550 SetHeader(); 7551 width = _width; 7552 height = _height; 7553 scale_factor = _scale_factor; 7554 } 7555 7556 void* Set(void* cmd, GLuint _width, GLuint _height, GLfloat _scale_factor) { 7557 static_cast<ValueType*>(cmd)->Init(_width, _height, _scale_factor); 7558 return NextCmdAddress<ValueType>(cmd); 7559 } 7560 7561 gpu::CommandHeader header; 7562 uint32_t width; 7563 uint32_t height; 7564 float scale_factor; 7565 }; 7566 7567 COMPILE_ASSERT(sizeof(ResizeCHROMIUM) == 16, Sizeof_ResizeCHROMIUM_is_not_16); 7568 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, header) == 0, 7569 OffsetOf_ResizeCHROMIUM_header_not_0); 7570 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, width) == 4, 7571 OffsetOf_ResizeCHROMIUM_width_not_4); 7572 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, height) == 8, 7573 OffsetOf_ResizeCHROMIUM_height_not_8); 7574 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, scale_factor) == 12, 7575 OffsetOf_ResizeCHROMIUM_scale_factor_not_12); 7576 7577 struct GetRequestableExtensionsCHROMIUM { 7578 typedef GetRequestableExtensionsCHROMIUM ValueType; 7579 static const CommandId kCmdId = kGetRequestableExtensionsCHROMIUM; 7580 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7581 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7582 7583 static uint32_t ComputeSize() { 7584 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7585 } 7586 7587 void SetHeader() { header.SetCmd<ValueType>(); } 7588 7589 void Init(uint32_t _bucket_id) { 7590 SetHeader(); 7591 bucket_id = _bucket_id; 7592 } 7593 7594 void* Set(void* cmd, uint32_t _bucket_id) { 7595 static_cast<ValueType*>(cmd)->Init(_bucket_id); 7596 return NextCmdAddress<ValueType>(cmd); 7597 } 7598 7599 gpu::CommandHeader header; 7600 uint32_t bucket_id; 7601 }; 7602 7603 COMPILE_ASSERT(sizeof(GetRequestableExtensionsCHROMIUM) == 8, 7604 Sizeof_GetRequestableExtensionsCHROMIUM_is_not_8); 7605 COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, header) == 0, 7606 OffsetOf_GetRequestableExtensionsCHROMIUM_header_not_0); 7607 COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, bucket_id) == 4, 7608 OffsetOf_GetRequestableExtensionsCHROMIUM_bucket_id_not_4); 7609 7610 struct RequestExtensionCHROMIUM { 7611 typedef RequestExtensionCHROMIUM ValueType; 7612 static const CommandId kCmdId = kRequestExtensionCHROMIUM; 7613 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7614 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7615 7616 static uint32_t ComputeSize() { 7617 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7618 } 7619 7620 void SetHeader() { header.SetCmd<ValueType>(); } 7621 7622 void Init(uint32_t _bucket_id) { 7623 SetHeader(); 7624 bucket_id = _bucket_id; 7625 } 7626 7627 void* Set(void* cmd, uint32_t _bucket_id) { 7628 static_cast<ValueType*>(cmd)->Init(_bucket_id); 7629 return NextCmdAddress<ValueType>(cmd); 7630 } 7631 7632 gpu::CommandHeader header; 7633 uint32_t bucket_id; 7634 }; 7635 7636 COMPILE_ASSERT(sizeof(RequestExtensionCHROMIUM) == 8, 7637 Sizeof_RequestExtensionCHROMIUM_is_not_8); 7638 COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, header) == 0, 7639 OffsetOf_RequestExtensionCHROMIUM_header_not_0); 7640 COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, bucket_id) == 4, 7641 OffsetOf_RequestExtensionCHROMIUM_bucket_id_not_4); 7642 7643 struct GetMultipleIntegervCHROMIUM { 7644 typedef GetMultipleIntegervCHROMIUM ValueType; 7645 static const CommandId kCmdId = kGetMultipleIntegervCHROMIUM; 7646 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7647 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7648 7649 static uint32_t ComputeSize() { 7650 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7651 } 7652 7653 void SetHeader() { header.SetCmd<ValueType>(); } 7654 7655 void Init(uint32_t _pnames_shm_id, 7656 uint32_t _pnames_shm_offset, 7657 GLuint _count, 7658 uint32_t _results_shm_id, 7659 uint32_t _results_shm_offset, 7660 GLsizeiptr _size) { 7661 SetHeader(); 7662 pnames_shm_id = _pnames_shm_id; 7663 pnames_shm_offset = _pnames_shm_offset; 7664 count = _count; 7665 results_shm_id = _results_shm_id; 7666 results_shm_offset = _results_shm_offset; 7667 size = _size; 7668 } 7669 7670 void* Set(void* cmd, 7671 uint32_t _pnames_shm_id, 7672 uint32_t _pnames_shm_offset, 7673 GLuint _count, 7674 uint32_t _results_shm_id, 7675 uint32_t _results_shm_offset, 7676 GLsizeiptr _size) { 7677 static_cast<ValueType*>(cmd)->Init(_pnames_shm_id, 7678 _pnames_shm_offset, 7679 _count, 7680 _results_shm_id, 7681 _results_shm_offset, 7682 _size); 7683 return NextCmdAddress<ValueType>(cmd); 7684 } 7685 7686 gpu::CommandHeader header; 7687 uint32_t pnames_shm_id; 7688 uint32_t pnames_shm_offset; 7689 uint32_t count; 7690 uint32_t results_shm_id; 7691 uint32_t results_shm_offset; 7692 int32_t size; 7693 }; 7694 7695 COMPILE_ASSERT(sizeof(GetMultipleIntegervCHROMIUM) == 28, 7696 Sizeof_GetMultipleIntegervCHROMIUM_is_not_28); 7697 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, header) == 0, 7698 OffsetOf_GetMultipleIntegervCHROMIUM_header_not_0); 7699 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_id) == 4, 7700 OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_id_not_4); 7701 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_offset) == 8, 7702 OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_offset_not_8); 7703 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, count) == 12, 7704 OffsetOf_GetMultipleIntegervCHROMIUM_count_not_12); 7705 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_id) == 16, 7706 OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_id_not_16); 7707 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_offset) == 20, 7708 OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_offset_not_20); 7709 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, size) == 24, 7710 OffsetOf_GetMultipleIntegervCHROMIUM_size_not_24); 7711 7712 struct GetProgramInfoCHROMIUM { 7713 typedef GetProgramInfoCHROMIUM ValueType; 7714 static const CommandId kCmdId = kGetProgramInfoCHROMIUM; 7715 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7716 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7717 7718 struct Result { 7719 uint32_t link_status; 7720 uint32_t num_attribs; 7721 uint32_t num_uniforms; 7722 }; 7723 7724 static uint32_t ComputeSize() { 7725 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7726 } 7727 7728 void SetHeader() { header.SetCmd<ValueType>(); } 7729 7730 void Init(GLuint _program, uint32_t _bucket_id) { 7731 SetHeader(); 7732 program = _program; 7733 bucket_id = _bucket_id; 7734 } 7735 7736 void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) { 7737 static_cast<ValueType*>(cmd)->Init(_program, _bucket_id); 7738 return NextCmdAddress<ValueType>(cmd); 7739 } 7740 7741 gpu::CommandHeader header; 7742 uint32_t program; 7743 uint32_t bucket_id; 7744 }; 7745 7746 COMPILE_ASSERT(sizeof(GetProgramInfoCHROMIUM) == 12, 7747 Sizeof_GetProgramInfoCHROMIUM_is_not_12); 7748 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, header) == 0, 7749 OffsetOf_GetProgramInfoCHROMIUM_header_not_0); 7750 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, program) == 4, 7751 OffsetOf_GetProgramInfoCHROMIUM_program_not_4); 7752 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, bucket_id) == 8, 7753 OffsetOf_GetProgramInfoCHROMIUM_bucket_id_not_8); 7754 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, link_status) == 0, 7755 OffsetOf_GetProgramInfoCHROMIUM_Result_link_status_not_0); 7756 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_attribs) == 4, 7757 OffsetOf_GetProgramInfoCHROMIUM_Result_num_attribs_not_4); 7758 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_uniforms) == 8, 7759 OffsetOf_GetProgramInfoCHROMIUM_Result_num_uniforms_not_8); 7760 7761 struct GetTranslatedShaderSourceANGLE { 7762 typedef GetTranslatedShaderSourceANGLE ValueType; 7763 static const CommandId kCmdId = kGetTranslatedShaderSourceANGLE; 7764 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7765 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7766 7767 static uint32_t ComputeSize() { 7768 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7769 } 7770 7771 void SetHeader() { header.SetCmd<ValueType>(); } 7772 7773 void Init(GLuint _shader, uint32_t _bucket_id) { 7774 SetHeader(); 7775 shader = _shader; 7776 bucket_id = _bucket_id; 7777 } 7778 7779 void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) { 7780 static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id); 7781 return NextCmdAddress<ValueType>(cmd); 7782 } 7783 7784 gpu::CommandHeader header; 7785 uint32_t shader; 7786 uint32_t bucket_id; 7787 }; 7788 7789 COMPILE_ASSERT(sizeof(GetTranslatedShaderSourceANGLE) == 12, 7790 Sizeof_GetTranslatedShaderSourceANGLE_is_not_12); 7791 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, header) == 0, 7792 OffsetOf_GetTranslatedShaderSourceANGLE_header_not_0); 7793 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, shader) == 4, 7794 OffsetOf_GetTranslatedShaderSourceANGLE_shader_not_4); 7795 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, bucket_id) == 8, 7796 OffsetOf_GetTranslatedShaderSourceANGLE_bucket_id_not_8); 7797 7798 struct PostSubBufferCHROMIUM { 7799 typedef PostSubBufferCHROMIUM ValueType; 7800 static const CommandId kCmdId = kPostSubBufferCHROMIUM; 7801 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7802 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7803 7804 static uint32_t ComputeSize() { 7805 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7806 } 7807 7808 void SetHeader() { header.SetCmd<ValueType>(); } 7809 7810 void Init(GLint _x, GLint _y, GLint _width, GLint _height) { 7811 SetHeader(); 7812 x = _x; 7813 y = _y; 7814 width = _width; 7815 height = _height; 7816 } 7817 7818 void* Set(void* cmd, GLint _x, GLint _y, GLint _width, GLint _height) { 7819 static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height); 7820 return NextCmdAddress<ValueType>(cmd); 7821 } 7822 7823 gpu::CommandHeader header; 7824 int32_t x; 7825 int32_t y; 7826 int32_t width; 7827 int32_t height; 7828 }; 7829 7830 COMPILE_ASSERT(sizeof(PostSubBufferCHROMIUM) == 20, 7831 Sizeof_PostSubBufferCHROMIUM_is_not_20); 7832 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, header) == 0, 7833 OffsetOf_PostSubBufferCHROMIUM_header_not_0); 7834 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, x) == 4, 7835 OffsetOf_PostSubBufferCHROMIUM_x_not_4); 7836 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, y) == 8, 7837 OffsetOf_PostSubBufferCHROMIUM_y_not_8); 7838 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, width) == 12, 7839 OffsetOf_PostSubBufferCHROMIUM_width_not_12); 7840 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, height) == 16, 7841 OffsetOf_PostSubBufferCHROMIUM_height_not_16); 7842 7843 struct TexImageIOSurface2DCHROMIUM { 7844 typedef TexImageIOSurface2DCHROMIUM ValueType; 7845 static const CommandId kCmdId = kTexImageIOSurface2DCHROMIUM; 7846 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7847 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7848 7849 static uint32_t ComputeSize() { 7850 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7851 } 7852 7853 void SetHeader() { header.SetCmd<ValueType>(); } 7854 7855 void Init(GLenum _target, 7856 GLsizei _width, 7857 GLsizei _height, 7858 GLuint _ioSurfaceId, 7859 GLuint _plane) { 7860 SetHeader(); 7861 target = _target; 7862 width = _width; 7863 height = _height; 7864 ioSurfaceId = _ioSurfaceId; 7865 plane = _plane; 7866 } 7867 7868 void* Set(void* cmd, 7869 GLenum _target, 7870 GLsizei _width, 7871 GLsizei _height, 7872 GLuint _ioSurfaceId, 7873 GLuint _plane) { 7874 static_cast<ValueType*>(cmd) 7875 ->Init(_target, _width, _height, _ioSurfaceId, _plane); 7876 return NextCmdAddress<ValueType>(cmd); 7877 } 7878 7879 gpu::CommandHeader header; 7880 uint32_t target; 7881 int32_t width; 7882 int32_t height; 7883 uint32_t ioSurfaceId; 7884 uint32_t plane; 7885 }; 7886 7887 COMPILE_ASSERT(sizeof(TexImageIOSurface2DCHROMIUM) == 24, 7888 Sizeof_TexImageIOSurface2DCHROMIUM_is_not_24); 7889 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, header) == 0, 7890 OffsetOf_TexImageIOSurface2DCHROMIUM_header_not_0); 7891 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, target) == 4, 7892 OffsetOf_TexImageIOSurface2DCHROMIUM_target_not_4); 7893 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, width) == 8, 7894 OffsetOf_TexImageIOSurface2DCHROMIUM_width_not_8); 7895 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, height) == 12, 7896 OffsetOf_TexImageIOSurface2DCHROMIUM_height_not_12); 7897 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, ioSurfaceId) == 16, 7898 OffsetOf_TexImageIOSurface2DCHROMIUM_ioSurfaceId_not_16); 7899 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, plane) == 20, 7900 OffsetOf_TexImageIOSurface2DCHROMIUM_plane_not_20); 7901 7902 struct CopyTextureCHROMIUM { 7903 typedef CopyTextureCHROMIUM ValueType; 7904 static const CommandId kCmdId = kCopyTextureCHROMIUM; 7905 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7906 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7907 7908 static uint32_t ComputeSize() { 7909 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7910 } 7911 7912 void SetHeader() { header.SetCmd<ValueType>(); } 7913 7914 void Init(GLenum _target, 7915 GLenum _source_id, 7916 GLenum _dest_id, 7917 GLint _level, 7918 GLint _internalformat, 7919 GLenum _dest_type) { 7920 SetHeader(); 7921 target = _target; 7922 source_id = _source_id; 7923 dest_id = _dest_id; 7924 level = _level; 7925 internalformat = _internalformat; 7926 dest_type = _dest_type; 7927 } 7928 7929 void* Set(void* cmd, 7930 GLenum _target, 7931 GLenum _source_id, 7932 GLenum _dest_id, 7933 GLint _level, 7934 GLint _internalformat, 7935 GLenum _dest_type) { 7936 static_cast<ValueType*>(cmd)->Init( 7937 _target, _source_id, _dest_id, _level, _internalformat, _dest_type); 7938 return NextCmdAddress<ValueType>(cmd); 7939 } 7940 7941 gpu::CommandHeader header; 7942 uint32_t target; 7943 uint32_t source_id; 7944 uint32_t dest_id; 7945 int32_t level; 7946 int32_t internalformat; 7947 uint32_t dest_type; 7948 }; 7949 7950 COMPILE_ASSERT(sizeof(CopyTextureCHROMIUM) == 28, 7951 Sizeof_CopyTextureCHROMIUM_is_not_28); 7952 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, header) == 0, 7953 OffsetOf_CopyTextureCHROMIUM_header_not_0); 7954 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, target) == 4, 7955 OffsetOf_CopyTextureCHROMIUM_target_not_4); 7956 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, source_id) == 8, 7957 OffsetOf_CopyTextureCHROMIUM_source_id_not_8); 7958 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_id) == 12, 7959 OffsetOf_CopyTextureCHROMIUM_dest_id_not_12); 7960 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, level) == 16, 7961 OffsetOf_CopyTextureCHROMIUM_level_not_16); 7962 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, internalformat) == 20, 7963 OffsetOf_CopyTextureCHROMIUM_internalformat_not_20); 7964 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_type) == 24, 7965 OffsetOf_CopyTextureCHROMIUM_dest_type_not_24); 7966 7967 struct DrawArraysInstancedANGLE { 7968 typedef DrawArraysInstancedANGLE ValueType; 7969 static const CommandId kCmdId = kDrawArraysInstancedANGLE; 7970 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 7971 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 7972 7973 static uint32_t ComputeSize() { 7974 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 7975 } 7976 7977 void SetHeader() { header.SetCmd<ValueType>(); } 7978 7979 void Init(GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount) { 7980 SetHeader(); 7981 mode = _mode; 7982 first = _first; 7983 count = _count; 7984 primcount = _primcount; 7985 } 7986 7987 void* Set(void* cmd, 7988 GLenum _mode, 7989 GLint _first, 7990 GLsizei _count, 7991 GLsizei _primcount) { 7992 static_cast<ValueType*>(cmd)->Init(_mode, _first, _count, _primcount); 7993 return NextCmdAddress<ValueType>(cmd); 7994 } 7995 7996 gpu::CommandHeader header; 7997 uint32_t mode; 7998 int32_t first; 7999 int32_t count; 8000 int32_t primcount; 8001 }; 8002 8003 COMPILE_ASSERT(sizeof(DrawArraysInstancedANGLE) == 20, 8004 Sizeof_DrawArraysInstancedANGLE_is_not_20); 8005 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, header) == 0, 8006 OffsetOf_DrawArraysInstancedANGLE_header_not_0); 8007 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, mode) == 4, 8008 OffsetOf_DrawArraysInstancedANGLE_mode_not_4); 8009 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, first) == 8, 8010 OffsetOf_DrawArraysInstancedANGLE_first_not_8); 8011 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, count) == 12, 8012 OffsetOf_DrawArraysInstancedANGLE_count_not_12); 8013 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, primcount) == 16, 8014 OffsetOf_DrawArraysInstancedANGLE_primcount_not_16); 8015 8016 struct DrawElementsInstancedANGLE { 8017 typedef DrawElementsInstancedANGLE ValueType; 8018 static const CommandId kCmdId = kDrawElementsInstancedANGLE; 8019 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8020 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8021 8022 static uint32_t ComputeSize() { 8023 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8024 } 8025 8026 void SetHeader() { header.SetCmd<ValueType>(); } 8027 8028 void Init(GLenum _mode, 8029 GLsizei _count, 8030 GLenum _type, 8031 GLuint _index_offset, 8032 GLsizei _primcount) { 8033 SetHeader(); 8034 mode = _mode; 8035 count = _count; 8036 type = _type; 8037 index_offset = _index_offset; 8038 primcount = _primcount; 8039 } 8040 8041 void* Set(void* cmd, 8042 GLenum _mode, 8043 GLsizei _count, 8044 GLenum _type, 8045 GLuint _index_offset, 8046 GLsizei _primcount) { 8047 static_cast<ValueType*>(cmd) 8048 ->Init(_mode, _count, _type, _index_offset, _primcount); 8049 return NextCmdAddress<ValueType>(cmd); 8050 } 8051 8052 gpu::CommandHeader header; 8053 uint32_t mode; 8054 int32_t count; 8055 uint32_t type; 8056 uint32_t index_offset; 8057 int32_t primcount; 8058 }; 8059 8060 COMPILE_ASSERT(sizeof(DrawElementsInstancedANGLE) == 24, 8061 Sizeof_DrawElementsInstancedANGLE_is_not_24); 8062 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, header) == 0, 8063 OffsetOf_DrawElementsInstancedANGLE_header_not_0); 8064 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, mode) == 4, 8065 OffsetOf_DrawElementsInstancedANGLE_mode_not_4); 8066 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, count) == 8, 8067 OffsetOf_DrawElementsInstancedANGLE_count_not_8); 8068 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, type) == 12, 8069 OffsetOf_DrawElementsInstancedANGLE_type_not_12); 8070 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, index_offset) == 16, 8071 OffsetOf_DrawElementsInstancedANGLE_index_offset_not_16); 8072 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, primcount) == 20, 8073 OffsetOf_DrawElementsInstancedANGLE_primcount_not_20); 8074 8075 struct VertexAttribDivisorANGLE { 8076 typedef VertexAttribDivisorANGLE ValueType; 8077 static const CommandId kCmdId = kVertexAttribDivisorANGLE; 8078 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8079 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8080 8081 static uint32_t ComputeSize() { 8082 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8083 } 8084 8085 void SetHeader() { header.SetCmd<ValueType>(); } 8086 8087 void Init(GLuint _index, GLuint _divisor) { 8088 SetHeader(); 8089 index = _index; 8090 divisor = _divisor; 8091 } 8092 8093 void* Set(void* cmd, GLuint _index, GLuint _divisor) { 8094 static_cast<ValueType*>(cmd)->Init(_index, _divisor); 8095 return NextCmdAddress<ValueType>(cmd); 8096 } 8097 8098 gpu::CommandHeader header; 8099 uint32_t index; 8100 uint32_t divisor; 8101 }; 8102 8103 COMPILE_ASSERT(sizeof(VertexAttribDivisorANGLE) == 12, 8104 Sizeof_VertexAttribDivisorANGLE_is_not_12); 8105 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, header) == 0, 8106 OffsetOf_VertexAttribDivisorANGLE_header_not_0); 8107 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, index) == 4, 8108 OffsetOf_VertexAttribDivisorANGLE_index_not_4); 8109 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, divisor) == 8, 8110 OffsetOf_VertexAttribDivisorANGLE_divisor_not_8); 8111 8112 struct ProduceTextureCHROMIUMImmediate { 8113 typedef ProduceTextureCHROMIUMImmediate ValueType; 8114 static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate; 8115 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 8116 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 8117 8118 static uint32_t ComputeDataSize() { 8119 return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT 8120 } 8121 8122 static uint32_t ComputeSize() { 8123 return static_cast<uint32_t>(sizeof(ValueType) + 8124 ComputeDataSize()); // NOLINT 8125 } 8126 8127 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 8128 8129 void Init(GLenum _target, const GLbyte* _mailbox) { 8130 SetHeader(); 8131 target = _target; 8132 memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize()); 8133 } 8134 8135 void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) { 8136 static_cast<ValueType*>(cmd)->Init(_target, _mailbox); 8137 const uint32_t size = ComputeSize(); 8138 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 8139 } 8140 8141 gpu::CommandHeader header; 8142 uint32_t target; 8143 }; 8144 8145 COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUMImmediate) == 8, 8146 Sizeof_ProduceTextureCHROMIUMImmediate_is_not_8); 8147 COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, header) == 0, 8148 OffsetOf_ProduceTextureCHROMIUMImmediate_header_not_0); 8149 COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, target) == 4, 8150 OffsetOf_ProduceTextureCHROMIUMImmediate_target_not_4); 8151 8152 struct ProduceTextureDirectCHROMIUMImmediate { 8153 typedef ProduceTextureDirectCHROMIUMImmediate ValueType; 8154 static const CommandId kCmdId = kProduceTextureDirectCHROMIUMImmediate; 8155 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 8156 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 8157 8158 static uint32_t ComputeDataSize() { 8159 return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT 8160 } 8161 8162 static uint32_t ComputeSize() { 8163 return static_cast<uint32_t>(sizeof(ValueType) + 8164 ComputeDataSize()); // NOLINT 8165 } 8166 8167 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 8168 8169 void Init(GLuint _texture, GLenum _target, const GLbyte* _mailbox) { 8170 SetHeader(); 8171 texture = _texture; 8172 target = _target; 8173 memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize()); 8174 } 8175 8176 void* Set(void* cmd, 8177 GLuint _texture, 8178 GLenum _target, 8179 const GLbyte* _mailbox) { 8180 static_cast<ValueType*>(cmd)->Init(_texture, _target, _mailbox); 8181 const uint32_t size = ComputeSize(); 8182 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 8183 } 8184 8185 gpu::CommandHeader header; 8186 uint32_t texture; 8187 uint32_t target; 8188 }; 8189 8190 COMPILE_ASSERT(sizeof(ProduceTextureDirectCHROMIUMImmediate) == 12, 8191 Sizeof_ProduceTextureDirectCHROMIUMImmediate_is_not_12); 8192 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, header) == 0, 8193 OffsetOf_ProduceTextureDirectCHROMIUMImmediate_header_not_0); 8194 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, texture) == 4, 8195 OffsetOf_ProduceTextureDirectCHROMIUMImmediate_texture_not_4); 8196 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, target) == 8, 8197 OffsetOf_ProduceTextureDirectCHROMIUMImmediate_target_not_8); 8198 8199 struct ConsumeTextureCHROMIUMImmediate { 8200 typedef ConsumeTextureCHROMIUMImmediate ValueType; 8201 static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate; 8202 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 8203 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 8204 8205 static uint32_t ComputeDataSize() { 8206 return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT 8207 } 8208 8209 static uint32_t ComputeSize() { 8210 return static_cast<uint32_t>(sizeof(ValueType) + 8211 ComputeDataSize()); // NOLINT 8212 } 8213 8214 void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); } 8215 8216 void Init(GLenum _target, const GLbyte* _mailbox) { 8217 SetHeader(); 8218 target = _target; 8219 memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize()); 8220 } 8221 8222 void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) { 8223 static_cast<ValueType*>(cmd)->Init(_target, _mailbox); 8224 const uint32_t size = ComputeSize(); 8225 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 8226 } 8227 8228 gpu::CommandHeader header; 8229 uint32_t target; 8230 }; 8231 8232 COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUMImmediate) == 8, 8233 Sizeof_ConsumeTextureCHROMIUMImmediate_is_not_8); 8234 COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, header) == 0, 8235 OffsetOf_ConsumeTextureCHROMIUMImmediate_header_not_0); 8236 COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, target) == 4, 8237 OffsetOf_ConsumeTextureCHROMIUMImmediate_target_not_4); 8238 8239 struct BindUniformLocationCHROMIUMBucket { 8240 typedef BindUniformLocationCHROMIUMBucket ValueType; 8241 static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket; 8242 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8243 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8244 8245 static uint32_t ComputeSize() { 8246 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8247 } 8248 8249 void SetHeader() { header.SetCmd<ValueType>(); } 8250 8251 void Init(GLuint _program, GLint _location, uint32_t _name_bucket_id) { 8252 SetHeader(); 8253 program = _program; 8254 location = _location; 8255 name_bucket_id = _name_bucket_id; 8256 } 8257 8258 void* Set(void* cmd, 8259 GLuint _program, 8260 GLint _location, 8261 uint32_t _name_bucket_id) { 8262 static_cast<ValueType*>(cmd)->Init(_program, _location, _name_bucket_id); 8263 return NextCmdAddress<ValueType>(cmd); 8264 } 8265 8266 gpu::CommandHeader header; 8267 uint32_t program; 8268 int32_t location; 8269 uint32_t name_bucket_id; 8270 }; 8271 8272 COMPILE_ASSERT(sizeof(BindUniformLocationCHROMIUMBucket) == 16, 8273 Sizeof_BindUniformLocationCHROMIUMBucket_is_not_16); 8274 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, header) == 0, 8275 OffsetOf_BindUniformLocationCHROMIUMBucket_header_not_0); 8276 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, program) == 4, 8277 OffsetOf_BindUniformLocationCHROMIUMBucket_program_not_4); 8278 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, location) == 8, 8279 OffsetOf_BindUniformLocationCHROMIUMBucket_location_not_8); 8280 COMPILE_ASSERT( 8281 offsetof(BindUniformLocationCHROMIUMBucket, name_bucket_id) == 12, 8282 OffsetOf_BindUniformLocationCHROMIUMBucket_name_bucket_id_not_12); 8283 8284 struct BindTexImage2DCHROMIUM { 8285 typedef BindTexImage2DCHROMIUM ValueType; 8286 static const CommandId kCmdId = kBindTexImage2DCHROMIUM; 8287 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8288 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8289 8290 static uint32_t ComputeSize() { 8291 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8292 } 8293 8294 void SetHeader() { header.SetCmd<ValueType>(); } 8295 8296 void Init(GLenum _target, GLint _imageId) { 8297 SetHeader(); 8298 target = _target; 8299 imageId = _imageId; 8300 } 8301 8302 void* Set(void* cmd, GLenum _target, GLint _imageId) { 8303 static_cast<ValueType*>(cmd)->Init(_target, _imageId); 8304 return NextCmdAddress<ValueType>(cmd); 8305 } 8306 8307 gpu::CommandHeader header; 8308 uint32_t target; 8309 int32_t imageId; 8310 }; 8311 8312 COMPILE_ASSERT(sizeof(BindTexImage2DCHROMIUM) == 12, 8313 Sizeof_BindTexImage2DCHROMIUM_is_not_12); 8314 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, header) == 0, 8315 OffsetOf_BindTexImage2DCHROMIUM_header_not_0); 8316 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, target) == 4, 8317 OffsetOf_BindTexImage2DCHROMIUM_target_not_4); 8318 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, imageId) == 8, 8319 OffsetOf_BindTexImage2DCHROMIUM_imageId_not_8); 8320 8321 struct ReleaseTexImage2DCHROMIUM { 8322 typedef ReleaseTexImage2DCHROMIUM ValueType; 8323 static const CommandId kCmdId = kReleaseTexImage2DCHROMIUM; 8324 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8325 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8326 8327 static uint32_t ComputeSize() { 8328 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8329 } 8330 8331 void SetHeader() { header.SetCmd<ValueType>(); } 8332 8333 void Init(GLenum _target, GLint _imageId) { 8334 SetHeader(); 8335 target = _target; 8336 imageId = _imageId; 8337 } 8338 8339 void* Set(void* cmd, GLenum _target, GLint _imageId) { 8340 static_cast<ValueType*>(cmd)->Init(_target, _imageId); 8341 return NextCmdAddress<ValueType>(cmd); 8342 } 8343 8344 gpu::CommandHeader header; 8345 uint32_t target; 8346 int32_t imageId; 8347 }; 8348 8349 COMPILE_ASSERT(sizeof(ReleaseTexImage2DCHROMIUM) == 12, 8350 Sizeof_ReleaseTexImage2DCHROMIUM_is_not_12); 8351 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, header) == 0, 8352 OffsetOf_ReleaseTexImage2DCHROMIUM_header_not_0); 8353 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, target) == 4, 8354 OffsetOf_ReleaseTexImage2DCHROMIUM_target_not_4); 8355 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, imageId) == 8, 8356 OffsetOf_ReleaseTexImage2DCHROMIUM_imageId_not_8); 8357 8358 struct TraceBeginCHROMIUM { 8359 typedef TraceBeginCHROMIUM ValueType; 8360 static const CommandId kCmdId = kTraceBeginCHROMIUM; 8361 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8362 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8363 8364 static uint32_t ComputeSize() { 8365 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8366 } 8367 8368 void SetHeader() { header.SetCmd<ValueType>(); } 8369 8370 void Init(GLuint _bucket_id) { 8371 SetHeader(); 8372 bucket_id = _bucket_id; 8373 } 8374 8375 void* Set(void* cmd, GLuint _bucket_id) { 8376 static_cast<ValueType*>(cmd)->Init(_bucket_id); 8377 return NextCmdAddress<ValueType>(cmd); 8378 } 8379 8380 gpu::CommandHeader header; 8381 uint32_t bucket_id; 8382 }; 8383 8384 COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 8, 8385 Sizeof_TraceBeginCHROMIUM_is_not_8); 8386 COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, header) == 0, 8387 OffsetOf_TraceBeginCHROMIUM_header_not_0); 8388 COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, bucket_id) == 4, 8389 OffsetOf_TraceBeginCHROMIUM_bucket_id_not_4); 8390 8391 struct TraceEndCHROMIUM { 8392 typedef TraceEndCHROMIUM ValueType; 8393 static const CommandId kCmdId = kTraceEndCHROMIUM; 8394 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8395 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8396 8397 static uint32_t ComputeSize() { 8398 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8399 } 8400 8401 void SetHeader() { header.SetCmd<ValueType>(); } 8402 8403 void Init() { SetHeader(); } 8404 8405 void* Set(void* cmd) { 8406 static_cast<ValueType*>(cmd)->Init(); 8407 return NextCmdAddress<ValueType>(cmd); 8408 } 8409 8410 gpu::CommandHeader header; 8411 }; 8412 8413 COMPILE_ASSERT(sizeof(TraceEndCHROMIUM) == 4, Sizeof_TraceEndCHROMIUM_is_not_4); 8414 COMPILE_ASSERT(offsetof(TraceEndCHROMIUM, header) == 0, 8415 OffsetOf_TraceEndCHROMIUM_header_not_0); 8416 8417 struct AsyncTexSubImage2DCHROMIUM { 8418 typedef AsyncTexSubImage2DCHROMIUM ValueType; 8419 static const CommandId kCmdId = kAsyncTexSubImage2DCHROMIUM; 8420 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8421 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8422 8423 static uint32_t ComputeSize() { 8424 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8425 } 8426 8427 void SetHeader() { header.SetCmd<ValueType>(); } 8428 8429 void Init(GLenum _target, 8430 GLint _level, 8431 GLint _xoffset, 8432 GLint _yoffset, 8433 GLsizei _width, 8434 GLsizei _height, 8435 GLenum _format, 8436 GLenum _type, 8437 uint32_t _data_shm_id, 8438 uint32_t _data_shm_offset, 8439 uint32_t _async_upload_token, 8440 uint32_t _sync_data_shm_id, 8441 uint32_t _sync_data_shm_offset) { 8442 SetHeader(); 8443 target = _target; 8444 level = _level; 8445 xoffset = _xoffset; 8446 yoffset = _yoffset; 8447 width = _width; 8448 height = _height; 8449 format = _format; 8450 type = _type; 8451 data_shm_id = _data_shm_id; 8452 data_shm_offset = _data_shm_offset; 8453 async_upload_token = _async_upload_token; 8454 sync_data_shm_id = _sync_data_shm_id; 8455 sync_data_shm_offset = _sync_data_shm_offset; 8456 } 8457 8458 void* Set(void* cmd, 8459 GLenum _target, 8460 GLint _level, 8461 GLint _xoffset, 8462 GLint _yoffset, 8463 GLsizei _width, 8464 GLsizei _height, 8465 GLenum _format, 8466 GLenum _type, 8467 uint32_t _data_shm_id, 8468 uint32_t _data_shm_offset, 8469 uint32_t _async_upload_token, 8470 uint32_t _sync_data_shm_id, 8471 uint32_t _sync_data_shm_offset) { 8472 static_cast<ValueType*>(cmd)->Init(_target, 8473 _level, 8474 _xoffset, 8475 _yoffset, 8476 _width, 8477 _height, 8478 _format, 8479 _type, 8480 _data_shm_id, 8481 _data_shm_offset, 8482 _async_upload_token, 8483 _sync_data_shm_id, 8484 _sync_data_shm_offset); 8485 return NextCmdAddress<ValueType>(cmd); 8486 } 8487 8488 gpu::CommandHeader header; 8489 uint32_t target; 8490 int32_t level; 8491 int32_t xoffset; 8492 int32_t yoffset; 8493 int32_t width; 8494 int32_t height; 8495 uint32_t format; 8496 uint32_t type; 8497 uint32_t data_shm_id; 8498 uint32_t data_shm_offset; 8499 uint32_t async_upload_token; 8500 uint32_t sync_data_shm_id; 8501 uint32_t sync_data_shm_offset; 8502 }; 8503 8504 COMPILE_ASSERT(sizeof(AsyncTexSubImage2DCHROMIUM) == 56, 8505 Sizeof_AsyncTexSubImage2DCHROMIUM_is_not_56); 8506 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, header) == 0, 8507 OffsetOf_AsyncTexSubImage2DCHROMIUM_header_not_0); 8508 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, target) == 4, 8509 OffsetOf_AsyncTexSubImage2DCHROMIUM_target_not_4); 8510 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, level) == 8, 8511 OffsetOf_AsyncTexSubImage2DCHROMIUM_level_not_8); 8512 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, xoffset) == 12, 8513 OffsetOf_AsyncTexSubImage2DCHROMIUM_xoffset_not_12); 8514 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, yoffset) == 16, 8515 OffsetOf_AsyncTexSubImage2DCHROMIUM_yoffset_not_16); 8516 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, width) == 20, 8517 OffsetOf_AsyncTexSubImage2DCHROMIUM_width_not_20); 8518 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, height) == 24, 8519 OffsetOf_AsyncTexSubImage2DCHROMIUM_height_not_24); 8520 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, format) == 28, 8521 OffsetOf_AsyncTexSubImage2DCHROMIUM_format_not_28); 8522 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, type) == 32, 8523 OffsetOf_AsyncTexSubImage2DCHROMIUM_type_not_32); 8524 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_id) == 36, 8525 OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_id_not_36); 8526 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_offset) == 40, 8527 OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_offset_not_40); 8528 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, async_upload_token) == 44, 8529 OffsetOf_AsyncTexSubImage2DCHROMIUM_async_upload_token_not_44); 8530 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_id) == 48, 8531 OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_id_not_48); 8532 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_offset) == 52, 8533 OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_offset_not_52); 8534 8535 struct AsyncTexImage2DCHROMIUM { 8536 typedef AsyncTexImage2DCHROMIUM ValueType; 8537 static const CommandId kCmdId = kAsyncTexImage2DCHROMIUM; 8538 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8539 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8540 8541 static uint32_t ComputeSize() { 8542 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8543 } 8544 8545 void SetHeader() { header.SetCmd<ValueType>(); } 8546 8547 void Init(GLenum _target, 8548 GLint _level, 8549 GLint _internalformat, 8550 GLsizei _width, 8551 GLsizei _height, 8552 GLenum _format, 8553 GLenum _type, 8554 uint32_t _pixels_shm_id, 8555 uint32_t _pixels_shm_offset, 8556 uint32_t _async_upload_token, 8557 uint32_t _sync_data_shm_id, 8558 uint32_t _sync_data_shm_offset) { 8559 SetHeader(); 8560 target = _target; 8561 level = _level; 8562 internalformat = _internalformat; 8563 width = _width; 8564 height = _height; 8565 format = _format; 8566 type = _type; 8567 pixels_shm_id = _pixels_shm_id; 8568 pixels_shm_offset = _pixels_shm_offset; 8569 async_upload_token = _async_upload_token; 8570 sync_data_shm_id = _sync_data_shm_id; 8571 sync_data_shm_offset = _sync_data_shm_offset; 8572 } 8573 8574 void* Set(void* cmd, 8575 GLenum _target, 8576 GLint _level, 8577 GLint _internalformat, 8578 GLsizei _width, 8579 GLsizei _height, 8580 GLenum _format, 8581 GLenum _type, 8582 uint32_t _pixels_shm_id, 8583 uint32_t _pixels_shm_offset, 8584 uint32_t _async_upload_token, 8585 uint32_t _sync_data_shm_id, 8586 uint32_t _sync_data_shm_offset) { 8587 static_cast<ValueType*>(cmd)->Init(_target, 8588 _level, 8589 _internalformat, 8590 _width, 8591 _height, 8592 _format, 8593 _type, 8594 _pixels_shm_id, 8595 _pixels_shm_offset, 8596 _async_upload_token, 8597 _sync_data_shm_id, 8598 _sync_data_shm_offset); 8599 return NextCmdAddress<ValueType>(cmd); 8600 } 8601 8602 gpu::CommandHeader header; 8603 uint32_t target; 8604 int32_t level; 8605 int32_t internalformat; 8606 int32_t width; 8607 int32_t height; 8608 uint32_t format; 8609 uint32_t type; 8610 uint32_t pixels_shm_id; 8611 uint32_t pixels_shm_offset; 8612 uint32_t async_upload_token; 8613 uint32_t sync_data_shm_id; 8614 uint32_t sync_data_shm_offset; 8615 static const int32_t border = 0; 8616 }; 8617 8618 COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 52, 8619 Sizeof_AsyncTexImage2DCHROMIUM_is_not_52); 8620 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, header) == 0, 8621 OffsetOf_AsyncTexImage2DCHROMIUM_header_not_0); 8622 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, target) == 4, 8623 OffsetOf_AsyncTexImage2DCHROMIUM_target_not_4); 8624 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, level) == 8, 8625 OffsetOf_AsyncTexImage2DCHROMIUM_level_not_8); 8626 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, internalformat) == 12, 8627 OffsetOf_AsyncTexImage2DCHROMIUM_internalformat_not_12); 8628 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, width) == 16, 8629 OffsetOf_AsyncTexImage2DCHROMIUM_width_not_16); 8630 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, height) == 20, 8631 OffsetOf_AsyncTexImage2DCHROMIUM_height_not_20); 8632 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 24, 8633 OffsetOf_AsyncTexImage2DCHROMIUM_format_not_24); 8634 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 28, 8635 OffsetOf_AsyncTexImage2DCHROMIUM_type_not_28); 8636 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 32, 8637 OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_32); 8638 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 36, 8639 OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_36); 8640 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 40, 8641 OffsetOf_AsyncTexImage2DCHROMIUM_async_upload_token_not_40); 8642 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 44, 8643 OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_id_not_44); 8644 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 48, 8645 OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_offset_not_48); 8646 8647 struct WaitAsyncTexImage2DCHROMIUM { 8648 typedef WaitAsyncTexImage2DCHROMIUM ValueType; 8649 static const CommandId kCmdId = kWaitAsyncTexImage2DCHROMIUM; 8650 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8651 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8652 8653 static uint32_t ComputeSize() { 8654 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8655 } 8656 8657 void SetHeader() { header.SetCmd<ValueType>(); } 8658 8659 void Init(GLenum _target) { 8660 SetHeader(); 8661 target = _target; 8662 } 8663 8664 void* Set(void* cmd, GLenum _target) { 8665 static_cast<ValueType*>(cmd)->Init(_target); 8666 return NextCmdAddress<ValueType>(cmd); 8667 } 8668 8669 gpu::CommandHeader header; 8670 uint32_t target; 8671 }; 8672 8673 COMPILE_ASSERT(sizeof(WaitAsyncTexImage2DCHROMIUM) == 8, 8674 Sizeof_WaitAsyncTexImage2DCHROMIUM_is_not_8); 8675 COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, header) == 0, 8676 OffsetOf_WaitAsyncTexImage2DCHROMIUM_header_not_0); 8677 COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, target) == 4, 8678 OffsetOf_WaitAsyncTexImage2DCHROMIUM_target_not_4); 8679 8680 struct WaitAllAsyncTexImage2DCHROMIUM { 8681 typedef WaitAllAsyncTexImage2DCHROMIUM ValueType; 8682 static const CommandId kCmdId = kWaitAllAsyncTexImage2DCHROMIUM; 8683 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8684 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8685 8686 static uint32_t ComputeSize() { 8687 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8688 } 8689 8690 void SetHeader() { header.SetCmd<ValueType>(); } 8691 8692 void Init() { SetHeader(); } 8693 8694 void* Set(void* cmd) { 8695 static_cast<ValueType*>(cmd)->Init(); 8696 return NextCmdAddress<ValueType>(cmd); 8697 } 8698 8699 gpu::CommandHeader header; 8700 }; 8701 8702 COMPILE_ASSERT(sizeof(WaitAllAsyncTexImage2DCHROMIUM) == 4, 8703 Sizeof_WaitAllAsyncTexImage2DCHROMIUM_is_not_4); 8704 COMPILE_ASSERT(offsetof(WaitAllAsyncTexImage2DCHROMIUM, header) == 0, 8705 OffsetOf_WaitAllAsyncTexImage2DCHROMIUM_header_not_0); 8706 8707 struct DiscardFramebufferEXTImmediate { 8708 typedef DiscardFramebufferEXTImmediate ValueType; 8709 static const CommandId kCmdId = kDiscardFramebufferEXTImmediate; 8710 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 8711 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8712 8713 static uint32_t ComputeDataSize(GLsizei count) { 8714 return static_cast<uint32_t>(sizeof(GLenum) * 1 * count); // NOLINT 8715 } 8716 8717 static uint32_t ComputeSize(GLsizei count) { 8718 return static_cast<uint32_t>(sizeof(ValueType) + 8719 ComputeDataSize(count)); // NOLINT 8720 } 8721 8722 void SetHeader(GLsizei count) { 8723 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 8724 } 8725 8726 void Init(GLenum _target, GLsizei _count, const GLenum* _attachments) { 8727 SetHeader(_count); 8728 target = _target; 8729 count = _count; 8730 memcpy(ImmediateDataAddress(this), _attachments, ComputeDataSize(_count)); 8731 } 8732 8733 void* Set(void* cmd, 8734 GLenum _target, 8735 GLsizei _count, 8736 const GLenum* _attachments) { 8737 static_cast<ValueType*>(cmd)->Init(_target, _count, _attachments); 8738 const uint32_t size = ComputeSize(_count); 8739 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 8740 } 8741 8742 gpu::CommandHeader header; 8743 uint32_t target; 8744 int32_t count; 8745 }; 8746 8747 COMPILE_ASSERT(sizeof(DiscardFramebufferEXTImmediate) == 12, 8748 Sizeof_DiscardFramebufferEXTImmediate_is_not_12); 8749 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, header) == 0, 8750 OffsetOf_DiscardFramebufferEXTImmediate_header_not_0); 8751 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, target) == 4, 8752 OffsetOf_DiscardFramebufferEXTImmediate_target_not_4); 8753 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, count) == 8, 8754 OffsetOf_DiscardFramebufferEXTImmediate_count_not_8); 8755 8756 struct LoseContextCHROMIUM { 8757 typedef LoseContextCHROMIUM ValueType; 8758 static const CommandId kCmdId = kLoseContextCHROMIUM; 8759 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8760 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8761 8762 static uint32_t ComputeSize() { 8763 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8764 } 8765 8766 void SetHeader() { header.SetCmd<ValueType>(); } 8767 8768 void Init(GLenum _current, GLenum _other) { 8769 SetHeader(); 8770 current = _current; 8771 other = _other; 8772 } 8773 8774 void* Set(void* cmd, GLenum _current, GLenum _other) { 8775 static_cast<ValueType*>(cmd)->Init(_current, _other); 8776 return NextCmdAddress<ValueType>(cmd); 8777 } 8778 8779 gpu::CommandHeader header; 8780 uint32_t current; 8781 uint32_t other; 8782 }; 8783 8784 COMPILE_ASSERT(sizeof(LoseContextCHROMIUM) == 12, 8785 Sizeof_LoseContextCHROMIUM_is_not_12); 8786 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, header) == 0, 8787 OffsetOf_LoseContextCHROMIUM_header_not_0); 8788 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, current) == 4, 8789 OffsetOf_LoseContextCHROMIUM_current_not_4); 8790 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, other) == 8, 8791 OffsetOf_LoseContextCHROMIUM_other_not_8); 8792 8793 struct WaitSyncPointCHROMIUM { 8794 typedef WaitSyncPointCHROMIUM ValueType; 8795 static const CommandId kCmdId = kWaitSyncPointCHROMIUM; 8796 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8797 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1); 8798 8799 static uint32_t ComputeSize() { 8800 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8801 } 8802 8803 void SetHeader() { header.SetCmd<ValueType>(); } 8804 8805 void Init(GLuint _sync_point) { 8806 SetHeader(); 8807 sync_point = _sync_point; 8808 } 8809 8810 void* Set(void* cmd, GLuint _sync_point) { 8811 static_cast<ValueType*>(cmd)->Init(_sync_point); 8812 return NextCmdAddress<ValueType>(cmd); 8813 } 8814 8815 gpu::CommandHeader header; 8816 uint32_t sync_point; 8817 }; 8818 8819 COMPILE_ASSERT(sizeof(WaitSyncPointCHROMIUM) == 8, 8820 Sizeof_WaitSyncPointCHROMIUM_is_not_8); 8821 COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, header) == 0, 8822 OffsetOf_WaitSyncPointCHROMIUM_header_not_0); 8823 COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, sync_point) == 4, 8824 OffsetOf_WaitSyncPointCHROMIUM_sync_point_not_4); 8825 8826 struct DrawBuffersEXTImmediate { 8827 typedef DrawBuffersEXTImmediate ValueType; 8828 static const CommandId kCmdId = kDrawBuffersEXTImmediate; 8829 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 8830 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8831 8832 static uint32_t ComputeDataSize(GLsizei count) { 8833 return static_cast<uint32_t>(sizeof(GLenum) * 1 * count); // NOLINT 8834 } 8835 8836 static uint32_t ComputeSize(GLsizei count) { 8837 return static_cast<uint32_t>(sizeof(ValueType) + 8838 ComputeDataSize(count)); // NOLINT 8839 } 8840 8841 void SetHeader(GLsizei count) { 8842 header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); 8843 } 8844 8845 void Init(GLsizei _count, const GLenum* _bufs) { 8846 SetHeader(_count); 8847 count = _count; 8848 memcpy(ImmediateDataAddress(this), _bufs, ComputeDataSize(_count)); 8849 } 8850 8851 void* Set(void* cmd, GLsizei _count, const GLenum* _bufs) { 8852 static_cast<ValueType*>(cmd)->Init(_count, _bufs); 8853 const uint32_t size = ComputeSize(_count); 8854 return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); 8855 } 8856 8857 gpu::CommandHeader header; 8858 int32_t count; 8859 }; 8860 8861 COMPILE_ASSERT(sizeof(DrawBuffersEXTImmediate) == 8, 8862 Sizeof_DrawBuffersEXTImmediate_is_not_8); 8863 COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, header) == 0, 8864 OffsetOf_DrawBuffersEXTImmediate_header_not_0); 8865 COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, count) == 4, 8866 OffsetOf_DrawBuffersEXTImmediate_count_not_4); 8867 8868 struct DiscardBackbufferCHROMIUM { 8869 typedef DiscardBackbufferCHROMIUM ValueType; 8870 static const CommandId kCmdId = kDiscardBackbufferCHROMIUM; 8871 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8872 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8873 8874 static uint32_t ComputeSize() { 8875 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8876 } 8877 8878 void SetHeader() { header.SetCmd<ValueType>(); } 8879 8880 void Init() { SetHeader(); } 8881 8882 void* Set(void* cmd) { 8883 static_cast<ValueType*>(cmd)->Init(); 8884 return NextCmdAddress<ValueType>(cmd); 8885 } 8886 8887 gpu::CommandHeader header; 8888 }; 8889 8890 COMPILE_ASSERT(sizeof(DiscardBackbufferCHROMIUM) == 4, 8891 Sizeof_DiscardBackbufferCHROMIUM_is_not_4); 8892 COMPILE_ASSERT(offsetof(DiscardBackbufferCHROMIUM, header) == 0, 8893 OffsetOf_DiscardBackbufferCHROMIUM_header_not_0); 8894 8895 struct ScheduleOverlayPlaneCHROMIUM { 8896 typedef ScheduleOverlayPlaneCHROMIUM ValueType; 8897 static const CommandId kCmdId = kScheduleOverlayPlaneCHROMIUM; 8898 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 8899 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); 8900 8901 static uint32_t ComputeSize() { 8902 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT 8903 } 8904 8905 void SetHeader() { header.SetCmd<ValueType>(); } 8906 8907 void Init(GLint _plane_z_order, 8908 GLenum _plane_transform, 8909 GLuint _overlay_texture_id, 8910 GLint _bounds_x, 8911 GLint _bounds_y, 8912 GLint _bounds_width, 8913 GLint _bounds_height, 8914 GLfloat _uv_x, 8915 GLfloat _uv_y, 8916 GLfloat _uv_width, 8917 GLfloat _uv_height) { 8918 SetHeader(); 8919 plane_z_order = _plane_z_order; 8920 plane_transform = _plane_transform; 8921 overlay_texture_id = _overlay_texture_id; 8922 bounds_x = _bounds_x; 8923 bounds_y = _bounds_y; 8924 bounds_width = _bounds_width; 8925 bounds_height = _bounds_height; 8926 uv_x = _uv_x; 8927 uv_y = _uv_y; 8928 uv_width = _uv_width; 8929 uv_height = _uv_height; 8930 } 8931 8932 void* Set(void* cmd, 8933 GLint _plane_z_order, 8934 GLenum _plane_transform, 8935 GLuint _overlay_texture_id, 8936 GLint _bounds_x, 8937 GLint _bounds_y, 8938 GLint _bounds_width, 8939 GLint _bounds_height, 8940 GLfloat _uv_x, 8941 GLfloat _uv_y, 8942 GLfloat _uv_width, 8943 GLfloat _uv_height) { 8944 static_cast<ValueType*>(cmd)->Init(_plane_z_order, 8945 _plane_transform, 8946 _overlay_texture_id, 8947 _bounds_x, 8948 _bounds_y, 8949 _bounds_width, 8950 _bounds_height, 8951 _uv_x, 8952 _uv_y, 8953 _uv_width, 8954 _uv_height); 8955 return NextCmdAddress<ValueType>(cmd); 8956 } 8957 8958 gpu::CommandHeader header; 8959 int32_t plane_z_order; 8960 uint32_t plane_transform; 8961 uint32_t overlay_texture_id; 8962 int32_t bounds_x; 8963 int32_t bounds_y; 8964 int32_t bounds_width; 8965 int32_t bounds_height; 8966 float uv_x; 8967 float uv_y; 8968 float uv_width; 8969 float uv_height; 8970 }; 8971 8972 COMPILE_ASSERT(sizeof(ScheduleOverlayPlaneCHROMIUM) == 48, 8973 Sizeof_ScheduleOverlayPlaneCHROMIUM_is_not_48); 8974 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, header) == 0, 8975 OffsetOf_ScheduleOverlayPlaneCHROMIUM_header_not_0); 8976 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_z_order) == 4, 8977 OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_z_order_not_4); 8978 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_transform) == 8, 8979 OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_transform_not_8); 8980 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, overlay_texture_id) == 12, 8981 OffsetOf_ScheduleOverlayPlaneCHROMIUM_overlay_texture_id_not_12); 8982 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_x) == 16, 8983 OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_x_not_16); 8984 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_y) == 20, 8985 OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_y_not_20); 8986 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_width) == 24, 8987 OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_width_not_24); 8988 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_height) == 28, 8989 OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_height_not_28); 8990 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_x) == 32, 8991 OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_x_not_32); 8992 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_y) == 36, 8993 OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_y_not_36); 8994 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_width) == 40, 8995 OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_width_not_40); 8996 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_height) == 44, 8997 OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_height_not_44); 8998 8999 #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ 9000
