move all O3D specific command buffer stuff to command_buffer::o3d...

command_buffer/common/cross/o3d_cmd_format.h

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 46 matching lines @@
 // use other POD types or intrinsics as members.
 
 #ifndef O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_
 #define O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_
 
 #include "command_buffer/common/cross/cmd_buffer_common.h"
 #include "command_buffer/common/cross/resource.h"
 
 namespace o3d {
 namespace command_buffer {
+namespace o3d {
 
 // This macro is used to safely and convienently expand the list of commnad
 // buffer commands in to various lists and never have them get out of sync. To
 // add a new command, add it this list, create the corresponding structure below
 // and then add a function in gapi_decoder.cc called Handle_COMMAND_NAME where
 // COMMAND_NAME is the name of your command structure.
 //
 // NOTE: THE ORDER OF THESE MUST NOT CHANGE (their id is derived by order)
 #define O3D_COMMAND_BUFFER_CMDS(OP) \
   OP(Noop)                          /* 1024 */ \
@@ skipping 156 matching lines @@
   kBlendFuncDstAlpha,
   kBlendFuncInvDstAlpha,
   kBlendFuncDstColor,
   kBlendFuncInvDstColor,
   kBlendFuncSrcAlphaSaturate,
   kBlendFuncBlendColor,
   kBlendFuncInvBlendColor,
   kNumBlendFunc
 };
 
-namespace cmd {
-
 const char* GetCommandName(CommandId id);
 
 // Make sure the compiler does not add extra padding to any of the command
 // structures.
 O3D_PUSH_STRUCTURE_PACKING_1;
 
 struct Noop {
   typedef Noop ValueType;
-  static const CommandId kCmdId = command_buffer::kNoop;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kNoop;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 skip_count) {
     header.Init(kCmdId, skip_count + 1);
   }
 
   void Init(uint32 skip_count) {
     SetHeader(skip_count);
   }
 
   static void* Set(void* cmd, uint32 skip_count) {
     static_cast<ValueType*>(cmd)->Init(skip_count);
     return NextImmediateCmdAddress<ValueType>(
         cmd, skip_count * sizeof(CommandBufferEntry));  // NOLINT
   }
 
   CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(Noop) == 4, Sizeof_Noop_is_not_4);
 COMPILE_ASSERT(offsetof(Noop, header) == 0, Offsetof_Noop_header_not_0);
 
 struct SetToken {
   typedef SetToken ValueType;
-  static const CommandId kCmdId = command_buffer::kSetToken;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetToken;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(uint32 _token) {
     SetHeader();
     token = _token;
   }
   static void* Set(void* cmd, uint32 token) {
     static_cast<ValueType*>(cmd)->Init(token);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   uint32 token;
 };
 
 COMPILE_ASSERT(sizeof(SetToken) == 8, Sizeof_SetToken_is_not_8);
 COMPILE_ASSERT(offsetof(SetToken, header) == 0,
                Offsetof_SetToken_header_not_0);
 COMPILE_ASSERT(offsetof(SetToken, token) == 4,
                Offsetof_SetToken_token_not_4);
 
 struct BeginFrame {
   typedef BeginFrame ValueType;
-  static const CommandId kCmdId = command_buffer::kBeginFrame;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kBeginFrame;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init() {
     SetHeader();
   }
   static void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(BeginFrame) == 4, Sizeof_BeginFrame_is_not_4);
 COMPILE_ASSERT(offsetof(BeginFrame, header) == 0,
                OffsetOf_BeginFrame_header_not_0);
 
 struct EndFrame {
   typedef EndFrame ValueType;
-  static const CommandId kCmdId = command_buffer::kEndFrame;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kEndFrame;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init() {
     SetHeader();
   }
   static void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(EndFrame) == 4, Sizeof_EndFrame_is_not_4);
 COMPILE_ASSERT(offsetof(EndFrame, header) == 0,
                OffsetOf_EndFrame_header_not_0);
 
 struct Clear {
   typedef Clear ValueType;
-  static const CommandId kCmdId = command_buffer::kClear;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kClear;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(uint32 _buffers, float _red, float _green, float _blue,
             float _alpha, float _depth, uint32 _stencil) {
     SetHeader();
     buffers = _buffers;
     red = _red;
@@ skipping 36 matching lines @@
                OffsetOf_Clear_blue_not_16);
 COMPILE_ASSERT(offsetof(Clear, alpha) == 20,
                OffsetOf_Clear_alpha_not_20);
 COMPILE_ASSERT(offsetof(Clear, depth) == 24,
                OffsetOf_Clear_depth_not_24);
 COMPILE_ASSERT(offsetof(Clear, stencil) == 28,
                OffsetOf_Clear_stencil_not_28);
 
 struct SetViewport {
   typedef SetViewport ValueType;
-  static const CommandId kCmdId = command_buffer::kSetViewport;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetViewport;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(
       uint32 _left,
       uint32 _top,
       uint32 _width,
       uint32 _height,
@@ skipping 45 matching lines @@
                OffsetOf_SetViewport_width_not_12);
 COMPILE_ASSERT(offsetof(SetViewport, height) == 16,
                OffsetOf_SetViewport_height_not_16);
 COMPILE_ASSERT(offsetof(SetViewport, z_min) == 20,
                OffsetOf_SetViewport_z_min_not_20);
 COMPILE_ASSERT(offsetof(SetViewport, z_max) == 24,
                OffsetOf_SetViewport_z_max_not_24);
 
 struct CreateVertexBuffer {
   typedef CreateVertexBuffer ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateVertexBuffer;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateVertexBuffer;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_buffer_id, uint32 _size,
             vertex_buffer::Flags _flags) {
     SetHeader();
     vertex_buffer_id = _vertex_buffer_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_CreateVertexBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(CreateVertexBuffer, vertex_buffer_id) == 4,
                OffsetOf_CreateVertexBuffer_vertex_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(CreateVertexBuffer, size) == 8,
                OffsetOf_CreateVertexBuffer_size_not_8);
 COMPILE_ASSERT(offsetof(CreateVertexBuffer, flags) == 12,
                OffsetOf_CreateVertexBuffer_flags_not_12);
 
 struct DestroyVertexBuffer {
   typedef DestroyVertexBuffer ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyVertexBuffer;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyVertexBuffer;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_buffer_id) {
     SetHeader();
     vertex_buffer_id = _vertex_buffer_id;
   }
 
   static void* Set(void* cmd, ResourceId vertex_buffer_id) {
     static_cast<ValueType*>(cmd)->Init(vertex_buffer_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId vertex_buffer_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyVertexBuffer) == 8,
                Sizeof_DestroyVertexBuffer_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyVertexBuffer, header) == 0,
                OffsetOf_DestroyVertexBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyVertexBuffer, vertex_buffer_id) == 4,
                OffsetOf_DestroyVertexBuffer_vertex_buffer_id_not_4);
 
 struct SetVertexBufferDataImmediate {
   typedef SetVertexBufferDataImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kSetVertexBufferDataImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kSetVertexBufferDataImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 size) {
     header.SetCmdBySize<ValueType>(size);
   }
 
   void Init(ResourceId _vertex_buffer_id, uint32 _offset,
             const void* data, uint32 size) {
     SetHeader(size);
     vertex_buffer_id = _vertex_buffer_id;
     offset = _offset;
@@ skipping 15 matching lines @@
                Sizeof_SetVertexBufferDataImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, header) == 0,
                OffsetOf_SetVertexBufferDataImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, vertex_buffer_id) == 4,
                OffsetOf_SetVertexBufferDataImmediate_vertex_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, offset) == 8,
                OffsetOf_SetVertexBufferDataImmediate_offset_not_8);
 
 struct SetVertexBufferData {
   typedef SetVertexBufferData ValueType;
-  static const CommandId kCmdId = command_buffer::kSetVertexBufferData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetVertexBufferData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_buffer_id, uint32 _offset, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     vertex_buffer_id = _vertex_buffer_id;
     offset = _offset;
@@ skipping 24 matching lines @@
                OffsetOf_SetVertexBufferData_vertex_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(SetVertexBufferData, offset) == 8,
                OffsetOf_SetVertexBufferData_offset_not_8);
 COMPILE_ASSERT(offsetof(SetVertexBufferData, size) == 12,
                OffsetOf_SetVertexBufferData_size_not_12);
 COMPILE_ASSERT(offsetof(SetVertexBufferData, shared_memory) == 16,
                OffsetOf_SetVertexBufferData_shared_memory_not_16);
 
 struct GetVertexBufferData {
   typedef GetVertexBufferData ValueType;
-  static const CommandId kCmdId = command_buffer::kGetVertexBufferData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetVertexBufferData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_buffer_id, uint32 _offset, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     vertex_buffer_id = _vertex_buffer_id;
     offset = _offset;
@@ skipping 24 matching lines @@
                OffsetOf_GetVertexBufferData_vertex_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(GetVertexBufferData, offset) == 8,
                OffsetOf_GetVertexBufferData_offset_not_8);
 COMPILE_ASSERT(offsetof(GetVertexBufferData, size) == 12,
                OffsetOf_GetVertexBufferData_size_not_12);
 COMPILE_ASSERT(offsetof(GetVertexBufferData, shared_memory) == 16,
                OffsetOf_GetVertexBufferData_shared_memory_not_16);
 
 struct CreateIndexBuffer {
   typedef CreateIndexBuffer ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateIndexBuffer;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateIndexBuffer;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _index_buffer_id, uint32 _size,
             index_buffer::Flags _flags) {
     SetHeader();
     index_buffer_id = _index_buffer_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_CreateIndexBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(CreateIndexBuffer, index_buffer_id) == 4,
                OffsetOf_CreateIndexBuffer_index_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(CreateIndexBuffer, size) == 8,
                OffsetOf_CreateIndexBuffer_size_not_8);
 COMPILE_ASSERT(offsetof(CreateIndexBuffer, flags) == 12,
                OffsetOf_CreateIndexBuffer_flags_not_12);
 
 struct DestroyIndexBuffer {
   typedef DestroyIndexBuffer ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyIndexBuffer;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyIndexBuffer;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _index_buffer_id) {
     SetHeader();
     index_buffer_id = _index_buffer_id;
   }
 
   static void* Set(void* cmd, ResourceId index_buffer_id) {
     static_cast<ValueType*>(cmd)->Init(index_buffer_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId index_buffer_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyIndexBuffer) == 8,
                Sizeof_DestroyIndexBuffer_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyIndexBuffer, header) == 0,
                OffsetOf_DestroyIndexBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyIndexBuffer, index_buffer_id) == 4,
                OffsetOf_DestroyIndexBuffer_index_buffer_id_not_4);
 
 struct SetIndexBufferDataImmediate {
   typedef SetIndexBufferDataImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kSetIndexBufferDataImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kSetIndexBufferDataImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 size) {
     header.SetCmdBySize<ValueType>(size);
   }
 
   void Init(ResourceId _index_buffer_id, uint32 _offset,
             const void* data, uint32 size) {
     SetHeader(size);
     index_buffer_id = _index_buffer_id;
     offset = _offset;
@@ skipping 15 matching lines @@
                Sizeof_SetIndexBufferDataImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, header) == 0,
                OffsetOf_SetIndexBufferDataImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, index_buffer_id) == 4,
                OffsetOf_SetIndexBufferDataImmediate_index_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, offset) == 8,
                OffsetOf_SetIndexBufferDataImmediate_offset_not_8);
 
 struct SetIndexBufferData {
   typedef SetIndexBufferData ValueType;
-  static const CommandId kCmdId = command_buffer::kSetIndexBufferData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetIndexBufferData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _index_buffer_id, uint32 _offset, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     index_buffer_id = _index_buffer_id;
     offset = _offset;
@@ skipping 24 matching lines @@
                OffsetOf_SetIndexBufferData_index_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(SetIndexBufferData, offset) == 8,
                OffsetOf_SetIndexBufferData_offset_not_8);
 COMPILE_ASSERT(offsetof(SetIndexBufferData, size) == 12,
                OffsetOf_SetIndexBufferData_size_not_12);
 COMPILE_ASSERT(offsetof(SetIndexBufferData, shared_memory) == 16,
                OffsetOf_SetIndexBufferData_shared_memory_not_16);
 
 struct GetIndexBufferData {
   typedef GetIndexBufferData ValueType;
-  static const CommandId kCmdId = command_buffer::kGetIndexBufferData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetIndexBufferData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _index_buffer_id, uint32 _offset, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     index_buffer_id = _index_buffer_id;
     offset = _offset;
@@ skipping 24 matching lines @@
                OffsetOf_GetIndexBufferData_index_buffer_id_not_4);
 COMPILE_ASSERT(offsetof(GetIndexBufferData, offset) == 8,
                OffsetOf_GetIndexBufferData_offset_not_8);
 COMPILE_ASSERT(offsetof(GetIndexBufferData, size) == 12,
                OffsetOf_GetIndexBufferData_size_not_12);
 COMPILE_ASSERT(offsetof(GetIndexBufferData, shared_memory) == 16,
                OffsetOf_GetIndexBufferData_shared_memory_not_16);
 
 struct CreateVertexStruct {
   typedef CreateVertexStruct ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateVertexStruct;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateVertexStruct;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_struct_id, uint32 _input_count) {
     SetHeader();
     vertex_struct_id = _vertex_struct_id;
     input_count = _input_count;
   }
@@ skipping 12 matching lines @@
                Sizeof_CreateVertexStruct_is_not_12);
 COMPILE_ASSERT(offsetof(CreateVertexStruct, header) == 0,
                OffsetOf_CreateVertexStruct_header_not_0);
 COMPILE_ASSERT(offsetof(CreateVertexStruct, vertex_struct_id) == 4,
                OffsetOf_CreateVertexStruct_vertex_struct_id_not_4);
 COMPILE_ASSERT(offsetof(CreateVertexStruct, input_count) == 8,
                OffsetOf_CreateVertexStruct_input_count_not_8);
 
 struct DestroyVertexStruct {
   typedef DestroyVertexStruct ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyVertexStruct;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyVertexStruct;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_struct_id) {
     SetHeader();
     vertex_struct_id = _vertex_struct_id;
   }
 
   static void* Set(void* cmd, ResourceId vertex_struct_id) {
     static_cast<ValueType*>(cmd)->Init(vertex_struct_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId vertex_struct_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyVertexStruct) == 8,
                Sizeof_DestroyVertexStruct_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyVertexStruct, header) == 0,
                OffsetOf_DestroyVertexStruct_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyVertexStruct, vertex_struct_id) == 4,
                OffsetOf_DestroyVertexStruct_vertex_struct_id_not_4);
 
 struct SetVertexInput {
   typedef SetVertexInput ValueType;
-  static const CommandId kCmdId = command_buffer::kSetVertexInput;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetVertexInput;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // type_stride_semantic field.
   typedef BitField<0, 4> SemanticIndex;
   typedef BitField<4, 4> Semantic;
   typedef BitField<8, 8> Type;
   typedef BitField<16, 16> Stride;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
@@ skipping 58 matching lines @@
                OffsetOf_SetVertexInput_input_index_not_8);
 COMPILE_ASSERT(offsetof(SetVertexInput, vertex_buffer_id) == 12,
                OffsetOf_SetVertexInput_vertex_buffer_id_not_12);
 COMPILE_ASSERT(offsetof(SetVertexInput, offset) == 16,
                OffsetOf_SetVertexInput_offset_not_16);
 COMPILE_ASSERT(offsetof(SetVertexInput, type_stride_semantic) == 20,
                OffsetOf_SetVertexInput_type_stride_semantic_not_20);
 
 struct SetVertexStruct {
   typedef SetVertexStruct ValueType;
-  static const CommandId kCmdId = command_buffer::kSetVertexStruct;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetVertexStruct;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _vertex_struct_id) {
     SetHeader();
     vertex_struct_id = _vertex_struct_id;
   }
 
   static void* Set(void* cmd, ResourceId vertex_struct_id) {
     static_cast<ValueType*>(cmd)->Init(vertex_struct_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId vertex_struct_id;
 };
 
 COMPILE_ASSERT(sizeof(SetVertexStruct) == 8,
                Sizeof_SetVertexStruct_is_not_8);
 COMPILE_ASSERT(offsetof(SetVertexStruct, header) == 0,
                OffsetOf_SetVertexStruct_header_not_0);
 COMPILE_ASSERT(offsetof(SetVertexStruct, vertex_struct_id) == 4,
                OffsetOf_SetVertexStruct_vertex_struct_id_not_4);
 
 struct Draw {
   typedef Draw ValueType;
-  static const CommandId kCmdId = command_buffer::kDraw;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDraw;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(PrimitiveType _primitive_type, uint32 _first, uint32 _count) {
     SetHeader();
     primitive_type = _primitive_type;
     first = _first;
     count = _count;
@@ skipping 16 matching lines @@
                OffsetOf_Draw_header_not_0);
 COMPILE_ASSERT(offsetof(Draw, primitive_type) == 4,
                OffsetOf_Draw_primitive_type_not_4);
 COMPILE_ASSERT(offsetof(Draw, first) == 8,
                OffsetOf_Draw_first_not_8);
 COMPILE_ASSERT(offsetof(Draw, count) == 12,
                OffsetOf_Draw_count_not_12);
 
 struct DrawIndexed {
   typedef DrawIndexed ValueType;
-  static const CommandId kCmdId = command_buffer::kDrawIndexed;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDrawIndexed;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(
       PrimitiveType _primitive_type,
       ResourceId _index_buffer_id,
       uint32 _first,
       uint32 _count,
@@ skipping 45 matching lines @@
                OffsetOf_DrawIndexed_first_not_12);
 COMPILE_ASSERT(offsetof(DrawIndexed, count) == 16,
                OffsetOf_DrawIndexed_count_not_16);
 COMPILE_ASSERT(offsetof(DrawIndexed, min_index) == 20,
                OffsetOf_DrawIndexed_min_index_not_20);
 COMPILE_ASSERT(offsetof(DrawIndexed, max_index) == 24,
                OffsetOf_DrawIndexed_max_index_not_24);
 
 struct CreateEffect {
   typedef CreateEffect ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateEffect;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateEffect;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     effect_id = _effect_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_CreateEffect_header_not_0);
 COMPILE_ASSERT(offsetof(CreateEffect, effect_id) == 4,
                OffsetOf_CreateEffect_effect_id_not_4);
 COMPILE_ASSERT(offsetof(CreateEffect, size) == 8,
                OffsetOf_CreateEffect_size_not_8);
 COMPILE_ASSERT(offsetof(CreateEffect, shared_memory) == 12,
                OffsetOf_CreateEffect_shared_memory_not_12);
 
 struct CreateEffectImmediate {
   typedef CreateEffectImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateEffectImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kCreateEffectImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 size) {
     header.SetCmdBySize<ValueType>(size);
   }
 
   void Init(ResourceId _effect_id, uint32 _size, const void* data) {
     SetHeader(_size);
     effect_id = _effect_id;
     size = _size;
   }
@@ skipping 13 matching lines @@
                Sizeof_CreateEffectImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(CreateEffectImmediate, header) == 0,
                OffsetOf_CreateEffectImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(CreateEffectImmediate, effect_id) == 4,
                OffsetOf_CreateEffectImmediate_effect_id_not_4);
 COMPILE_ASSERT(offsetof(CreateEffectImmediate, size) == 8,
                OffsetOf_CreateEffectImmediate_size_not_8);
 
 struct DestroyEffect {
   typedef DestroyEffect ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyEffect;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyEffect;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id) {
     SetHeader();
     effect_id = _effect_id;
   }
 
   static void* Set(void* cmd, ResourceId effect_id) {
     static_cast<ValueType*>(cmd)->Init(effect_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId effect_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyEffect) == 8, Sizeof_DestroyEffect_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyEffect, header) == 0,
                OffsetOf_DestroyEffect_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyEffect, effect_id) == 4,
                OffsetOf_DestroyEffect_effect_id_not_4);
 
 struct SetEffect {
   typedef SetEffect ValueType;
-  static const CommandId kCmdId = command_buffer::kSetEffect;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetEffect;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id) {
     SetHeader();
     effect_id = _effect_id;
   }
 
   static void* Set(void* cmd, ResourceId effect_id) {
     static_cast<ValueType*>(cmd)->Init(effect_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId effect_id;
 };
 
 COMPILE_ASSERT(sizeof(SetEffect) == 8, Sizeof_SetEffect_is_not_8);
 COMPILE_ASSERT(offsetof(SetEffect, header) == 0,
                OffsetOf_SetEffect_header_not_0);
 COMPILE_ASSERT(offsetof(SetEffect, effect_id) == 4,
                OffsetOf_SetEffect_effect_id_not_4);
 
 struct GetParamCount {
   typedef GetParamCount ValueType;
-  static const CommandId kCmdId = command_buffer::kGetParamCount;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetParamCount;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     effect_id = _effect_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_GetParamCount_header_not_0);
 COMPILE_ASSERT(offsetof(GetParamCount, effect_id) == 4,
                OffsetOf_GetParamCount_effect_id_not_4);
 COMPILE_ASSERT(offsetof(GetParamCount, size) == 8,
                OffsetOf_GetParamCount_size_not_8);
 COMPILE_ASSERT(offsetof(GetParamCount, shared_memory) == 12,
                OffsetOf_GetParamCount_shared_memory_not_12);
 
 struct CreateParam {
   typedef CreateParam ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateParam;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateParam;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _param_id, ResourceId _effect_id, uint32 _index) {
     SetHeader();
     param_id = _param_id;
     effect_id = _effect_id;
     index = _index;
@@ skipping 16 matching lines @@
                OffsetOf_CreateParam_header_not_0);
 COMPILE_ASSERT(offsetof(CreateParam, param_id) == 4,
                OffsetOf_CreateParam_param_id_not_4);
 COMPILE_ASSERT(offsetof(CreateParam, effect_id) == 8,
                OffsetOf_CreateParam_effect_id_not_8);
 COMPILE_ASSERT(offsetof(CreateParam, index) == 12,
                OffsetOf_CreateParam_index_not_12);
 
 struct CreateParamByName {
   typedef CreateParamByName ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateParamByName;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateParamByName;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _param_id, ResourceId _effect_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     param_id = _param_id;
     effect_id = _effect_id;
@@ skipping 24 matching lines @@
                OffsetOf_CreateParamByName_param_id_not_4);
 COMPILE_ASSERT(offsetof(CreateParamByName, effect_id) == 8,
                OffsetOf_CreateParamByName_effect_id_not_8);
 COMPILE_ASSERT(offsetof(CreateParamByName, size) == 12,
                OffsetOf_CreateParamByName_size_not_12);
 COMPILE_ASSERT(offsetof(CreateParamByName, shared_memory) == 16,
                OffsetOf_CreateParamByName_shared_memory_not_16);
 
 struct CreateParamByNameImmediate {
   typedef CreateParamByNameImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateParamByNameImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kCreateParamByNameImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 size) {
     header.SetCmdBySize<ValueType>(size);
   }
 
   void Init(ResourceId _param_id, ResourceId _effect_id, uint32 _size,
             const void* data) {
     SetHeader(_size);
     param_id = _param_id;
     effect_id = _effect_id;
@@ skipping 19 matching lines @@
                OffsetOf_CreateParamByNameImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, param_id) == 4,
                OffsetOf_CreateParamByNameImmediate_param_id_not_4);
 COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, effect_id) == 8,
                OffsetOf_CreateParamByNameImmediate_effect_id_not_8);
 COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, size) == 12,
                OffsetOf_CreateParamByNameImmediate_size_not_12);
 
 struct DestroyParam {
   typedef DestroyParam ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyParam;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyParam;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _param_id) {
     SetHeader();
     param_id = _param_id;
   }
 
   static void* Set(void* cmd, ResourceId param_id) {
     static_cast<ValueType*>(cmd)->Init(param_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId param_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyParam) == 8, Sizeof_DestroyParam_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyParam, header) == 0,
                OffsetOf_DestroyParam_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyParam, param_id) == 4,
                OffsetOf_DestroyParam_param_id_not_4);
 
 struct SetParamData {
   typedef SetParamData ValueType;
-  static const CommandId kCmdId = command_buffer::kSetParamData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetParamData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _param_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     param_id = _param_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_SetParamData_header_not_0);
 COMPILE_ASSERT(offsetof(SetParamData, param_id) == 4,
                OffsetOf_SetParamData_param_id_not_4);
 COMPILE_ASSERT(offsetof(SetParamData, size) == 8,
                OffsetOf_SetParamData_size_not_8);
 COMPILE_ASSERT(offsetof(SetParamData, shared_memory) == 12,
                OffsetOf_SetParamData_shared_memory_not_12);
 
 struct SetParamDataImmediate {
   typedef SetParamDataImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kSetParamDataImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kSetParamDataImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   void SetHeader(uint32 size) {
     header.SetCmdBySize<ValueType>(size);
   }
 
   void Init(ResourceId _param_id, uint32 _size, const void* data) {
     SetHeader(_size);
     param_id = _param_id;
     size = _size;
     memcpy(ImmediateDataAddress(this), data, _size);
@@ skipping 14 matching lines @@
                Sizeof_SetParamDataImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(SetParamDataImmediate, header) == 0,
                OffsetOf_SetParamDataImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(SetParamDataImmediate, param_id) == 4,
                OffsetOf_SetParamDataImmediate_param_id_not_4);
 COMPILE_ASSERT(offsetof(SetParamDataImmediate, size) == 8,
                OffsetOf_SetParamDataImmediate_size_not_8);
 
 struct GetParamDesc {
   typedef GetParamDesc ValueType;
-  static const CommandId kCmdId = command_buffer::kGetParamDesc;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetParamDesc;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _param_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     param_id = _param_id;
     size = _size;
@@ skipping 18 matching lines @@
                OffsetOf_GetParamDesc_header_not_0);
 COMPILE_ASSERT(offsetof(GetParamDesc, param_id) == 4,
                OffsetOf_GetParamDesc_id_not_4);
 COMPILE_ASSERT(offsetof(GetParamDesc, size) == 8,
                OffsetOf_GetParamDesc_size_not_8);
 COMPILE_ASSERT(offsetof(GetParamDesc, shared_memory) == 12,
                OffsetOf_GetParamDesc_shared_memory_not_12);
 
 struct GetStreamCount {
   typedef GetStreamCount ValueType;
-  static const CommandId kCmdId = command_buffer::kGetStreamCount;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetStreamCount;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     effect_id = _effect_id;
     size = _size;
@@ skipping 19 matching lines @@
                OffsetOf_GetStreamCount_header_not_0);
 COMPILE_ASSERT(offsetof(GetStreamCount, effect_id) == 4,
                OffsetOf_GetStreamCount_effect_id_not_4);
 COMPILE_ASSERT(offsetof(GetStreamCount, size) == 8,
                OffsetOf_GetStreamCount_size_not_8);
 COMPILE_ASSERT(offsetof(GetStreamCount, shared_memory) == 12,
                OffsetOf_GetStreamCount_shared_memory_not_12);
 
 struct GetStreamDesc {
   typedef GetStreamDesc ValueType;
-  static const CommandId kCmdId = command_buffer::kGetStreamDesc;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetStreamDesc;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _effect_id, uint32 _index, uint32 _size,
             uint32 shared_memory_id, uint32 shared_memory_offset) {
     SetHeader();
     effect_id = _effect_id;
     index = _index;
@@ skipping 22 matching lines @@
                OffsetOf_GetStreamDesc_effect_id_not_4);
 COMPILE_ASSERT(offsetof(GetStreamDesc, index) == 8,
                OffsetOf_GetStreamDesc_index_not_8);
 COMPILE_ASSERT(offsetof(GetStreamDesc, size) == 12,
                OffsetOf_GetStreamDesc_size_not_12);
 COMPILE_ASSERT(offsetof(GetStreamDesc, shared_memory) == 16,
                OffsetOf_GetStreamDesc_shared_memory_not_16);
 
 struct DestroyTexture {
   typedef DestroyTexture ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyTexture;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyTexture;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _texture_id) {
     SetHeader();
     texture_id = _texture_id;
   }
 
   static void* Set(void* cmd, ResourceId texture_id) {
     static_cast<ValueType*>(cmd)->Init(texture_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId texture_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyTexture) == 8, Sizeof_DestroyTexture_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyTexture, header) == 0,
                OffsetOf_DestroyTexture_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyTexture, texture_id) == 4,
                OffsetOf_DestroyTexture_texture_id_not_4);
 
 struct CreateTexture2d {
   typedef CreateTexture2d ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateTexture2d;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateTexture2d;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 2
   typedef BitField<0, 4> Levels;
   typedef BitField<4, 4> Unused;
   typedef BitField<8, 8> Format;
   typedef BitField<16, 16> Flags;
 
@@ skipping 37 matching lines @@
                OffsetOf_CreateTexture2d_header_not_0);
 COMPILE_ASSERT(offsetof(CreateTexture2d, texture_id) == 4,
                OffsetOf_CreateTexture2d_texture_id_not_4);
 COMPILE_ASSERT(offsetof(CreateTexture2d, width_height) == 8,
                OffsetOf_CreateTexture2d_width_height_not_8);
 COMPILE_ASSERT(offsetof(CreateTexture2d, levels_format_flags) == 12,
                OffsetOf_CreateTexture2d_levels_format_flags_not_12);
 
 struct CreateTexture3d {
   typedef CreateTexture3d ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateTexture3d;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateTexture3d;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 2
   typedef BitField<0, 16> Depth;
   typedef BitField<16, 16> Unused1;
   // argument 3
   typedef BitField<0, 4> Levels;
   typedef BitField<4, 4> Unused2;
@@ skipping 45 matching lines @@
                OffsetOf_CreateTexture3d_texture_id_not_4);
 COMPILE_ASSERT(offsetof(CreateTexture3d, width_height) == 8,
                OffsetOf_CreateTexture3d_width_height_not_8);
 COMPILE_ASSERT(offsetof(CreateTexture3d, depth_unused) == 12,
                OffsetOf_CreateTexture3d_depth_unused_not_12);
 COMPILE_ASSERT(offsetof(CreateTexture3d, levels_format_flags) == 16,
                OffsetOf_CreateTexture3d_levels_format_flags_not_16);
 
 struct CreateTextureCube {
   typedef CreateTextureCube ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateTextureCube;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateTextureCube;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> Side;
   typedef BitField<16, 16> Unused1;
   // argument 2
   typedef BitField<0, 4> Levels;
   typedef BitField<4, 4> Unused2;
   typedef BitField<8, 8> Format;
   typedef BitField<16, 16> Flags;
 
@@ skipping 35 matching lines @@
                OffsetOf_CreateTextureCube_header_not_0);
 COMPILE_ASSERT(offsetof(CreateTextureCube, texture_id) == 4,
                OffsetOf_CreateTextureCube_texture_id_not_4);
 COMPILE_ASSERT(offsetof(CreateTextureCube, edge_length) == 8,
                OffsetOf_CreateTextureCube_edge_length_not_8);
 COMPILE_ASSERT(offsetof(CreateTextureCube, levels_format_flags) == 12,
                OffsetOf_CreateTextureCube_levels_format_flags_not_12);
 
 struct SetTextureData {
   typedef SetTextureData ValueType;
-  static const CommandId kCmdId = command_buffer::kSetTextureData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetTextureData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> X;
   typedef BitField<16, 16> Y;
   // argument 2
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 3
   typedef BitField<0, 16> Z;
   typedef BitField<16, 16> Depth;
@@ skipping 98 matching lines @@
                OffsetOf_SetTextureData_row_pitch_not_24);
 COMPILE_ASSERT(offsetof(SetTextureData, slice_pitch) == 28,
                OffsetOf_SetTextureData_slice_pitch_not_28);
 COMPILE_ASSERT(offsetof(SetTextureData, size) == 32,
                OffsetOf_SetTextureData_size_not_32);
 COMPILE_ASSERT(offsetof(SetTextureData, shared_memory) == 36,
                OffsetOf_SetTextureData_shared_memory_not_36);
 
 struct SetTextureDataImmediate {
   typedef SetTextureDataImmediate ValueType;
-  static const CommandId kCmdId = command_buffer::kSetTextureDataImmediate;
-  static const ArgFlags kArgFlags = kAtLeastN;
+  static const CommandId kCmdId = kSetTextureDataImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 
   // argument 1
   typedef BitField<0, 16> X;
   typedef BitField<16, 16> Y;
   // argument 2
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 3
   typedef BitField<0, 16> Z;
   typedef BitField<16, 16> Depth;
@@ skipping 92 matching lines @@
                OffsetOf_SetTextureDataImmediate_level_face_not_20);
 COMPILE_ASSERT(offsetof(SetTextureDataImmediate, row_pitch) == 24,
                OffsetOf_SetTextureDataImmediate_row_pitch_not_24);
 COMPILE_ASSERT(offsetof(SetTextureDataImmediate, slice_pitch) == 28,
                OffsetOf_SetTextureDataImmediate_slice_pitch_not_28);
 COMPILE_ASSERT(offsetof(SetTextureDataImmediate, size) == 32,
                OffsetOf_SetTextureDataImmediate_size_not_32);
 
 struct GetTextureData {
   typedef GetTextureData ValueType;
-  static const CommandId kCmdId = command_buffer::kGetTextureData;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kGetTextureData;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> X;
   typedef BitField<16, 16> Y;
   // argument 2
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 3
   typedef BitField<0, 16> Z;
   typedef BitField<16, 16> Depth;
@@ skipping 98 matching lines @@
                OffsetOf_GetTextureData_row_pitch_not_24);
 COMPILE_ASSERT(offsetof(GetTextureData, slice_pitch) == 28,
                OffsetOf_GetTextureData_slice_pitch_not_28);
 COMPILE_ASSERT(offsetof(GetTextureData, size) == 32,
                OffsetOf_GetTextureData_size_not_32);
 COMPILE_ASSERT(offsetof(GetTextureData, shared_memory) == 36,
                OffsetOf_GetTextureData_shared_memory_not_36);
 
 struct CreateSampler {
   typedef CreateSampler ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateSampler;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateSampler;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _sampler_id) {
     SetHeader();
     sampler_id = _sampler_id;
   }
 
   static void* Set(void* cmd, ResourceId sampler_id) {
     static_cast<ValueType*>(cmd)->Init(sampler_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId sampler_id;
 };
 
 COMPILE_ASSERT(sizeof(CreateSampler) == 8, Sizeof_CreateSampler_is_not_8);
 COMPILE_ASSERT(offsetof(CreateSampler, header) == 0,
                OffsetOf_CreateSampler_header_not_0);
 COMPILE_ASSERT(offsetof(CreateSampler, sampler_id) == 4,
                OffsetOf_CreateSampler_sampler_id_not_4);
 
 struct DestroySampler {
   typedef DestroySampler ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroySampler;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroySampler;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _sampler_id) {
     SetHeader();
     sampler_id = _sampler_id;
   }
 
   static void* Set(void* cmd, ResourceId sampler_id) {
     static_cast<ValueType*>(cmd)->Init(sampler_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId sampler_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroySampler) == 8, Sizeof_DestroySampler_is_not_8);
 COMPILE_ASSERT(offsetof(DestroySampler, header) == 0,
                OffsetOf_DestroySampler_header_not_0);
 COMPILE_ASSERT(offsetof(DestroySampler, sampler_id) == 4,
                OffsetOf_DestroySampler_sampler_id_not_4);
 
 struct SetSamplerStates {
   typedef SetSamplerStates ValueType;
-  static const CommandId kCmdId = command_buffer::kSetSamplerStates;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetSamplerStates;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 2
   typedef BitField<0, 3> AddressingU;
   typedef BitField<3, 3> AddressingV;
   typedef BitField<6, 3> AddressingW;
   typedef BitField<9, 3> MagFilter;
   typedef BitField<12, 3> MinFilter;
   typedef BitField<15, 3> MipFilter;
   typedef BitField<18, 6> Unused;
   typedef BitField<24, 8> MaxAnisotropy;
@@ skipping 54 matching lines @@
                Sizeof_SetSamplerStates_is_not_12);
 COMPILE_ASSERT(offsetof(SetSamplerStates, header) == 0,
                OffsetOf_SetSamplerStates_header_not_0);
 COMPILE_ASSERT(offsetof(SetSamplerStates, sampler_id) == 4,
                OffsetOf_SetSamplerStates_sampler_id_not_4);
 COMPILE_ASSERT(offsetof(SetSamplerStates, sampler_states) == 8,
                OffsetOf_SetSamplerStates_sampler_states_not_8);
 
 struct SetSamplerBorderColor {
   typedef SetSamplerBorderColor ValueType;
-  static const CommandId kCmdId = command_buffer::kSetSamplerBorderColor;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetSamplerBorderColor;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _sampler_id,
             float _red, float _green, float _blue, float _alpha) {
     SetHeader();
     sampler_id = _sampler_id;
     red = _red;
@@ skipping 26 matching lines @@
                OffsetOf_SetSamplerBorderColor_red_not_8);
 COMPILE_ASSERT(offsetof(SetSamplerBorderColor, blue) == 12,
                OffsetOf_SetSamplerBorderColor_blue_not_12);
 COMPILE_ASSERT(offsetof(SetSamplerBorderColor, green) == 16,
                OffsetOf_SetSamplerBorderColor_green_not_16);
 COMPILE_ASSERT(offsetof(SetSamplerBorderColor, alpha) == 20,
                OffsetOf_SetSamplerBorderColor_alpha_not_20);
 
 struct SetSamplerTexture {
   typedef SetSamplerTexture ValueType;
-  static const CommandId kCmdId = command_buffer::kSetSamplerTexture;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetSamplerTexture;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _sampler_id, ResourceId _texture_id) {
     SetHeader();
     sampler_id = _sampler_id;
     texture_id = _texture_id;
   }
@@ skipping 12 matching lines @@
                Sizeof_SetSamplerTexture_is_not_12);
 COMPILE_ASSERT(offsetof(SetSamplerTexture, header) == 0,
                OffsetOf_SetSamplerTexture_header_not_0);
 COMPILE_ASSERT(offsetof(SetSamplerTexture, sampler_id) == 4,
                OffsetOf_SetSamplerTexture_sampler_id_not_4);
 COMPILE_ASSERT(offsetof(SetSamplerTexture, texture_id) == 8,
                OffsetOf_SetSamplerTexture_texture_id_not_8);
 
 struct SetScissor {
   typedef SetScissor ValueType;
-  static const CommandId kCmdId = command_buffer::kSetScissor;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetScissor;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 15> X;
   typedef BitField<15, 1> Unused;
   typedef BitField<16, 15> Y;
   typedef BitField<31, 1> Enable;
   // argument 1
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
 
@@ skipping 39 matching lines @@
 COMPILE_ASSERT(sizeof(SetScissor) == 12, Sizeof_SetScissor_is_not_12);
 COMPILE_ASSERT(offsetof(SetScissor, header) == 0,
                OffsetOf_SetScissor_header_not_0);
 COMPILE_ASSERT(offsetof(SetScissor, x_y_enable) == 4,
                OffsetOf_SetScissor_x_y_enable_not_4);
 COMPILE_ASSERT(offsetof(SetScissor, width_height) == 8,
                OffsetOf_SetScissor_width_height_not_8);
 
 struct SetPolygonOffset {
   typedef SetPolygonOffset ValueType;
-  static const CommandId kCmdId = command_buffer::kSetPolygonOffset;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetPolygonOffset;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(float _slope_factor, float _units) {
     SetHeader();
     slope_factor = _slope_factor;
     units = _units;
   }
@@ skipping 12 matching lines @@
                Sizeof_SetPolygonOffset_is_not_12);
 COMPILE_ASSERT(offsetof(SetPolygonOffset, header) == 0,
                OffsetOf_SetPolygonOffset_header_not_0);
 COMPILE_ASSERT(offsetof(SetPolygonOffset, slope_factor) == 4,
                OffsetOf_SetPolygonOffset_slope_factor_not_4);
 COMPILE_ASSERT(offsetof(SetPolygonOffset, units) == 8,
                OffsetOf_SetPolygonOffset_units_not_8);
 
 struct SetPointLineRaster {
   typedef SetPointLineRaster ValueType;
-  static const CommandId kCmdId = command_buffer::kSetPointLineRaster;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetPointLineRaster;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 1> LineSmoothEnable;
   typedef BitField<1, 1> PointSpriteEnable;
   typedef BitField<2, 30> Unused;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
@@ skipping 23 matching lines @@
                Sizeof_SetPointLineRaster_is_not_12);
 COMPILE_ASSERT(offsetof(SetPointLineRaster, header) == 0,
                OffsetOf_SetPointLineRaster_header_not_0);
 COMPILE_ASSERT(offsetof(SetPointLineRaster, enables) == 4,
                OffsetOf_SetPointLineRaster_enables_not_4);
 COMPILE_ASSERT(offsetof(SetPointLineRaster, point_size) == 8,
                OffsetOf_SetPointLineRaster_point_size_not_8);
 
 struct SetPolygonRaster {
   typedef SetPolygonRaster ValueType;
-  static const CommandId kCmdId = command_buffer::kSetPolygonRaster;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetPolygonRaster;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 2> FillMode;
   typedef BitField<2, 2> CullMode;
   typedef BitField<4, 28> Unused;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
@@ skipping 15 matching lines @@
 
 COMPILE_ASSERT(sizeof(SetPolygonRaster) == 8,
                Sizeof_SetPolygonRaster_is_not_8);
 COMPILE_ASSERT(offsetof(SetPolygonRaster, header) == 0,
                OffsetOf_SetPolygonRaster_header_not_0);
 COMPILE_ASSERT(offsetof(SetPolygonRaster, fill_cull) == 4,
                OffsetOf_SetPolygonRaster_fill_cull_not_4);
 
 struct SetAlphaTest {
   typedef SetAlphaTest ValueType;
-  static const CommandId kCmdId = command_buffer::kSetAlphaTest;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetAlphaTest;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 3> Func;
   typedef BitField<3, 28> Unused;
   typedef BitField<31, 1> Enable;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
@@ skipping 17 matching lines @@
 COMPILE_ASSERT(sizeof(SetAlphaTest) == 12, Sizeof_SetAlphaTest_is_not_12);
 COMPILE_ASSERT(offsetof(SetAlphaTest, header) == 0,
                OffsetOf_SetAlphaTest_header_not_0);
 COMPILE_ASSERT(offsetof(SetAlphaTest, func_enable) == 4,
                OffsetOf_SetAlphaTest_func_enable_not_4);
 COMPILE_ASSERT(offsetof(SetAlphaTest, value) == 8,
                OffsetOf_SetAlphaTest_value_not_8);
 
 struct SetDepthTest {
   typedef SetDepthTest ValueType;
-  static const CommandId kCmdId = command_buffer::kSetDepthTest;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetDepthTest;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 3> Func;
   typedef BitField<3, 27> Unused;
   typedef BitField<30, 1> WriteEnable;
   typedef BitField<31, 1> Enable;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
@@ skipping 18 matching lines @@
 };
 
 COMPILE_ASSERT(sizeof(SetDepthTest) == 8, Sizeof_SetDepthTest_is_not_8);
 COMPILE_ASSERT(offsetof(SetDepthTest, header) == 0,
                OffsetOf_SetDepthTest_header_not_0);
 COMPILE_ASSERT(offsetof(SetDepthTest, func_enable) == 4,
                OffsetOf_SetDepthTest_func_enable_not_4);
 
 struct SetStencilTest {
   typedef SetStencilTest ValueType;
-  static const CommandId kCmdId = command_buffer::kSetStencilTest;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetStencilTest;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 8> WriteMask;
   typedef BitField<8, 8> CompareMask;
   typedef BitField<16, 8> ReferenceValue;
   typedef BitField<24, 6> Unused0;
   typedef BitField<30, 1> SeparateCCW;
   typedef BitField<31, 1> Enable;
   // argument 1
   typedef BitField<0, 3> CWFunc;
@@ skipping 84 matching lines @@
                Sizeof_SetStencilTest_is_not_12);
 COMPILE_ASSERT(offsetof(SetStencilTest, header) == 0,
                OffsetOf_SetStencilTest_header_not_0);
 COMPILE_ASSERT(offsetof(SetStencilTest, stencil_args0) == 4,
                OffsetOf_SetStencilTest_stencil_args0_not_4);
 COMPILE_ASSERT(offsetof(SetStencilTest, stencil_args1) == 8,
                OffsetOf_SetStencilTest_stencil_args1_not_8);
 
 struct SetColorWrite {
   typedef SetColorWrite ValueType;
-  static const CommandId kCmdId = command_buffer::kSetColorWrite;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetColorWrite;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 1> RedMask;
   typedef BitField<1, 1> GreenMask;
   typedef BitField<2, 1> BlueMask;
   typedef BitField<3, 1> AlphaMask;
   typedef BitField<0, 4> AllColorsMask;  // alias for RGBA
   typedef BitField<4, 27> Unused;
   typedef BitField<31, 1> DitherEnable;
 
@@ skipping 21 matching lines @@
 };
 
 COMPILE_ASSERT(sizeof(SetColorWrite) == 8, Sizeof_SetColorWrite_is_not_8);
 COMPILE_ASSERT(offsetof(SetColorWrite, header) == 0,
                OffsetOf_SetColorWrite_header_not_0);
 COMPILE_ASSERT(offsetof(SetColorWrite, flags) == 4,
                OffsetOf_SetColorWrite_flags_not_4);
 
 struct SetBlending {
   typedef SetBlending ValueType;
-  static const CommandId kCmdId = command_buffer::kSetBlending;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetBlending;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 0
   typedef BitField<0, 4> ColorSrcFunc;
   typedef BitField<4, 4> ColorDstFunc;
   typedef BitField<8, 3> ColorEq;
   typedef BitField<11, 5> Unused0;
   typedef BitField<16, 4> AlphaSrcFunc;
   typedef BitField<20, 4> AlphaDstFunc;
   typedef BitField<24, 3> AlphaEq;
   typedef BitField<27, 3> Unused1;
@@ skipping 53 matching lines @@
 };
 
 COMPILE_ASSERT(sizeof(SetBlending) == 8, Sizeof_SetBlending_is_not_8);
 COMPILE_ASSERT(offsetof(SetBlending, header) == 0,
                OffsetOf_SetBlending_header_not_0);
 COMPILE_ASSERT(offsetof(SetBlending, blend_settings) == 4,
                OffsetOf_SetBlending_blend_settings_not_4);
 
 struct SetBlendingColor {
   typedef SetBlendingColor ValueType;
-  static const CommandId kCmdId = command_buffer::kSetBlendingColor;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetBlendingColor;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(float _red, float _green, float _blue, float _alpha) {
     SetHeader();
     red = _red;
     green = _green;
     blue = _blue;
@@ skipping 21 matching lines @@
                OffsetOf_SetBlendingColor_red_not_4);
 COMPILE_ASSERT(offsetof(SetBlendingColor, blue) == 8,
                OffsetOf_SetBlendingColor_blue_not_8);
 COMPILE_ASSERT(offsetof(SetBlendingColor, green) == 12,
                OffsetOf_SetBlendingColor_green_not_12);
 COMPILE_ASSERT(offsetof(SetBlendingColor, alpha) == 16,
                OffsetOf_SetBlendingColor_alpha_not_16);
 
 struct CreateRenderSurface {
   typedef CreateRenderSurface ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateRenderSurface;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateRenderSurface;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
   // argument 2 may refer to side or depth
   typedef BitField<0, 16> Levels;
   typedef BitField<16, 16> Side;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
@@ skipping 37 matching lines @@
                OffsetOf_CreateRenderSurface_render_surface_id_not_4);
 COMPILE_ASSERT(offsetof(CreateRenderSurface, width_height) == 8,
                OffsetOf_CreateRenderSurface_width_height_not_8);
 COMPILE_ASSERT(offsetof(CreateRenderSurface, levels_side) == 12,
                OffsetOf_CreateRenderSurface_levels_side_not_12);
 COMPILE_ASSERT(offsetof(CreateRenderSurface, texture_id) == 16,
                OffsetOf_CreateRenderSurface_texture_id_not_16);
 
 struct DestroyRenderSurface {
   typedef DestroyRenderSurface ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyRenderSurface;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyRenderSurface;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _render_surface_id) {
     SetHeader();
     render_surface_id = _render_surface_id;
   }
 
   static void* Set(void* cmd, ResourceId render_surface_id) {
     static_cast<ValueType*>(cmd)->Init(render_surface_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId render_surface_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyRenderSurface) == 8,
                Sizeof_DestroyRenderSurface_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyRenderSurface, header) == 0,
                OffsetOf_DestroyRenderSurface_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyRenderSurface, render_surface_id) == 4,
                OffsetOf_DestroyRenderSurface_render_surface_id_not_4);
 
 struct CreateDepthSurface {
   typedef CreateDepthSurface ValueType;
-  static const CommandId kCmdId = command_buffer::kCreateDepthSurface;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kCreateDepthSurface;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   // argument 1
   typedef BitField<0, 16> Width;
   typedef BitField<16, 16> Height;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _depth_surface_id, uint32 _width, uint32 _height) {
@@ skipping 18 matching lines @@
                Sizeof_CreateDepthSurface_is_not_12);
 COMPILE_ASSERT(offsetof(CreateDepthSurface, header) == 0,
                OffsetOf_CreateDepthSurface_header_not_0);
 COMPILE_ASSERT(offsetof(CreateDepthSurface, depth_surface_id) == 4,
                OffsetOf_CreateDepthSurface_depth_surface_id_not_4);
 COMPILE_ASSERT(offsetof(CreateDepthSurface, width_height) == 8,
                OffsetOf_CreateDepthSurface_width_height_not_8);
 
 struct DestroyDepthSurface {
   typedef DestroyDepthSurface ValueType;
-  static const CommandId kCmdId = command_buffer::kDestroyDepthSurface;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kDestroyDepthSurface;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _depth_surface_id) {
     SetHeader();
     depth_surface_id = _depth_surface_id;
   }
 
   static void* Set(void* cmd, ResourceId depth_surface_id) {
     static_cast<ValueType*>(cmd)->Init(depth_surface_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
   ResourceId depth_surface_id;
 };
 
 COMPILE_ASSERT(sizeof(DestroyDepthSurface) == 8,
                Sizeof_DestroyDepthSurface_is_not_8);
 COMPILE_ASSERT(offsetof(DestroyDepthSurface, header) == 0,
                OffsetOf_DestroyDepthSurface_header_not_0);
 COMPILE_ASSERT(offsetof(DestroyDepthSurface, depth_surface_id) == 4,
                OffsetOf_DestroyDepthdepth_surface_id_not_4);
 
 struct SetRenderSurface {
   typedef SetRenderSurface ValueType;
-  static const CommandId kCmdId = command_buffer::kSetRenderSurface;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetRenderSurface;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(ResourceId _render_surface_id, ResourceId _depth_surface_id) {
     SetHeader();
     render_surface_id = _render_surface_id;
     depth_surface_id = _depth_surface_id;
   }
@@ skipping 13 matching lines @@
                Sizeof_SetRenderSurface_is_not_12);
 COMPILE_ASSERT(offsetof(SetRenderSurface, header) == 0,
                OffsetOf_SetRenderSurface_header_not_0);
 COMPILE_ASSERT(offsetof(SetRenderSurface, render_surface_id) == 4,
                OffsetOf_SetRenderSurface_render_surface_id_not_4);
 COMPILE_ASSERT(offsetof(SetRenderSurface, depth_surface_id) == 8,
                OffsetOf_SetRenderSurface_depth_surface_id_not_8);
 
 struct SetBackSurfaces {
   typedef SetBackSurfaces ValueType;
-  static const CommandId kCmdId = command_buffer::kSetBackSurfaces;
-  static const ArgFlags kArgFlags = kFixed;
+  static const CommandId kCmdId = kSetBackSurfaces;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init() {
     SetHeader();
   }
 
   static void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(SetBackSurfaces) == 4,
                Sizeof_SetBackSurfaces_is_not_4);
 COMPILE_ASSERT(offsetof(SetBackSurfaces, header) == 0,
                OffsetOf_SetBackSurfaces_header_not_0);
 
 O3D_POP_STRUCTURE_PACKING;
 
 }  // namespace o3d
 }  // namespace command_buffer
 }  // namespace o3d
 
 #endif  // O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_