Change command buffer client code to use structures....

command_buffer/samples/bubble/bubble_module.cc

 /*
  * 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 20 matching lines @@
 
 
 // This is the Soap Bubble sample / demo. It runs as a native client NPAPI
 // plug-in.
 
 #include <math.h>
 #include <stdint.h>
 #ifdef __native_demo__
 #include <sys/nacl_syscalls.h>
 #else
-#include "native_client/service_runtime/nrd_xfer_lib/nrd_all_modules.h"
+#include "native_client/src/shared/imc/nacl_imc.h"
 #endif
 #include "command_buffer/common/cross/gapi_interface.h"
 #include "command_buffer/common/cross/rpc_imc.h"
 #include "command_buffer/client/cross/cmd_buffer_helper.h"
 #include "command_buffer/client/cross/buffer_sync_proxy.h"
 #include "command_buffer/client/cross/fenced_allocator.h"
 #include "command_buffer/samples/bubble/utils.h"
 #include "command_buffer/samples/bubble/iridescence_texture.h"
 #include "command_buffer/samples/bubble/perlin_noise.h"
 #include "third_party/vectormath/files/vectormathlibrary/include/vectormath/scalar/cpp/vectormath_aos.h"  // NOLINT
 
-#include "native_client/intermodule_comm/nacl_imc.h"
-#include "native_client/tools/npapi_runtime/nacl_npapi.h"
+#include "native_client/src/shared/npruntime/nacl_npapi.h"
 
 // Cube map data is hard-coded in cubemap.cc as a byte array.
 // Format is 64x64xBRGA, D3D face ordering (+X, -X, +Y, -Y, +Z, -Z).
 extern unsigned char g_cubemap_data[];
 const unsigned int kCubeMapWidth = 64;
 const unsigned int kCubeMapHeight = 64;
 const unsigned int kCubeMapFaceSize = kCubeMapWidth * kCubeMapHeight * 4;
 
 // Define this to debug command buffers: it will call Finish() and check for a
 // parse error. If there was one, it will warn about it in the console window.
 // #define DEBUG_CMD
 #ifdef DEBUG_CMD
 #define CHECK_ERROR(HELPER) do {                                        \
     HELPER->Finish();                                                   \
     BufferSyncInterface::ParseError error =                             \
         HELPER->interface()->GetParseError();                           \
-    if (error != BufferSyncInterface::PARSE_NO_ERROR) {                 \
+    if (error != BufferSyncInterface::kParseNoError) {                 \
       printf("CMD error %d at %s:%d\n", error, __FILE__, __LINE__);     \
     }                                                                   \
   } while (false)
 #else
 #define CHECK_ERROR(HELPER) do { } while (false)
 #endif
 
 namespace Vectormath {
 namespace Aos {
 
@@ skipping 33 matching lines @@
               float depth,
               unsigned int stencil) {
   CommandBufferEntry args[7];
   args[0].value_uint32 = buffers;
   args[1].value_float = color.red;
   args[2].value_float = color.green;
   args[3].value_float = color.blue;
   args[4].value_float = color.alpha;
   args[5].value_float = depth;
   args[6].value_uint32 = stencil;
-  cmd_buffer->AddCommand(command_buffer::CLEAR, 7, args);
+  cmd_buffer->AddCommand(command_buffer::kClear, 7, args);
   CHECK_ERROR(cmd_buffer);
 }
 
 // Adds a SetViewport command into the buffer.
 // Parameters:
 //   cmd_buffer: the command buffer helper.
 //   x, y, width, height: the dimensions of the Viewport.
 //   z_near, z_far: the near and far clip plane distances.
 void SetViewportCmd(CommandBufferHelper *cmd_buffer,
                     unsigned int x,
                     unsigned int y,
                     unsigned int width,
                     unsigned int height,
                     float z_near,
                     float z_far) {
   CommandBufferEntry args[6];
   args[0].value_uint32 = x;
   args[1].value_uint32 = y;
   args[2].value_uint32 = width;
   args[3].value_uint32 = height;
   args[4].value_float = z_near;
   args[5].value_float = z_far;
-  cmd_buffer->AddCommand(command_buffer::SET_VIEWPORT, 6, args);
+  cmd_buffer->AddCommand(command_buffer::kSetViewport, 6, args);
   CHECK_ERROR(cmd_buffer);
 }
 
 // Copy a data buffer to args, for IMMEDIATE commands. Returns the number of
 // args used.
 unsigned int CopyToArgs(CommandBufferEntry *args,
                         const void *data,
                         size_t size) {
   memcpy(args, data, size);
   const unsigned int arg_size = sizeof(args[0]);
@@ skipping 145 matching lines @@
       *texture++ = value;
       *texture++ = value;
       *texture++ = value;
       *texture++ = value;
     }
   }
 }
 
 // Gets current time in microseconds.
 uint64_t GetTimeUsec() {
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-  return tv.tv_sec * 1000000ULL + tv.tv_usec;
+  return 0ULL;
+//  struct timeval tv;
+//  gettimeofday(&tv, NULL);
+//  return tv.tv_sec * 1000000ULL + tv.tv_usec;
 }
 
 class BubbleDemo {
  public:
   BubbleDemo();
   ~BubbleDemo() {}
 
   // Creates the socket pair for the connection.
   nacl::HtpHandle CreateSockets();
 
@@ skipping 151 matching lines @@
   MakeIridescenceTexture(kTexWidth, kTexHeight, kRefractionIndex,
                          kRedWavelength, iridescence_texture_);
 
   // Clear the buffers.
   RGBA color = {0.f, 0.f, 0.f, 1.f};
   ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
            1.f, 0);
 
   // AddCommand copies the args, so it is safe to re-use args across various
   // calls.
-  // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices).
+  // 20 is the largest command we use (SetParamDataImmediate for matrices).
   CommandBufferEntry args[20];
 
   // Create geometry arrays and structures
   args[0].value_uint32 = vertex_buffer_id_;
   args[1].value_uint32 = kVertexBufferSize;  // size
   args[2].value_uint32 = 0;  // flags
-  helper_->AddCommand(CREATE_VERTEX_BUFFER, 3, args);
+  helper_->AddCommand(CreateVertexBuffer, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = vertex_buffer_id_;
   args[1].value_uint32 = 0;  // offset in VB
   args[2].value_uint32 = kVertexBufferSize;  // size
   args[3].value_uint32 = shm_id_;  // shm
   args[4].value_uint32 = allocator_->GetOffset(vertices_);  // offset in shm
-  helper_->AddCommand(SET_VERTEX_BUFFER_DATA, 5, args);
+  helper_->AddCommand(SetVertexBufferData, 5, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = index_buffer_id_;
   args[1].value_uint32 = kIndexBufferSize;  // size
   args[2].value_uint32 = index_buffer::INDEX_32BIT;  // flags
-  helper_->AddCommand(CREATE_INDEX_BUFFER, 3, args);
+  helper_->AddCommand(CreateIndexBuffer, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = index_buffer_id_;
   args[1].value_uint32 = 0;  // offset in IB
   args[2].value_uint32 = kIndexBufferSize;  // size
   args[3].value_uint32 = shm_id_;  // shm
   args[4].value_uint32 = allocator_->GetOffset(indices_);  // offset in shm
-  helper_->AddCommand(SET_INDEX_BUFFER_DATA, 5, args);
+  helper_->AddCommand(SetIndexBufferData, 5, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = vertex_struct_id_;
   args[1].value_uint32 = 3;  // input count
-  helper_->AddCommand(CREATE_VERTEX_STRUCT, 2, args);
+  helper_->AddCommand(CreateVertexStruct, 2, args);
   CHECK_ERROR(helper_);
 
   // Set POSITION input stream
   args[0].value_uint32 = vertex_struct_id_;
   args[1].value_uint32 = 0;                               // input
   args[2].value_uint32 = vertex_buffer_id_;               // buffer
   args[3].value_uint32 = 0;                               // offset
   args[4].value_uint32 =
       set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) |
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::POSITION) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Set NORMAL input stream
   args[1].value_uint32 = 1;                               // input
   args[3].value_uint32 = 12;                              // offset
   args[4].value_uint32 =
       set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) |
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::NORMAL) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Set TEXCOORD0 input stream
   args[1].value_uint32 = 2;                               // input
   args[3].value_uint32 = 24;                              // offset
   args[4].value_uint32 =
       set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) |
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT2) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::TEX_COORD) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Create a 2D texture.
   args[0].value_uint32 = noise_texture_id_;
   args[1].value_uint32 =
       create_texture_2d_cmd::Width::MakeValue(kTexWidth) |
       create_texture_2d_cmd::Height::MakeValue(kTexHeight);
   args[2].value_uint32 =
       create_texture_2d_cmd::Levels::MakeValue(0) |
       create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_2d_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_2D, 3, args);
+  helper_->AddCommand(CreateTexture2d, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_texture_id_;
   args[1].value_uint32 =
       set_texture_data_cmd::X::MakeValue(0) |
       set_texture_data_cmd::Y::MakeValue(0);
   args[2].value_uint32 =
       set_texture_data_cmd::Width::MakeValue(kTexWidth) |
       set_texture_data_cmd::Height::MakeValue(kTexHeight);
   args[3].value_uint32 =
       set_texture_data_cmd::Z::MakeValue(0) |
       set_texture_data_cmd::Depth::MakeValue(1);
   args[4].value_uint32 = set_texture_data_cmd::Level::MakeValue(0);
   args[5].value_uint32 = kTexWidth * 4;  // row_pitch
   args[6].value_uint32 = 0;  // slice_pitch
   args[7].value_uint32 = kTexSize;  // size
   args[8].value_uint32 = shm_id_;
   args[9].value_uint32 = allocator_->GetOffset(noise_texture_);
-  helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+  helper_->AddCommand(SetTextureData, 10, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
   args[1].value_uint32 = noise_texture_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
   args[1].value_uint32 =
       set_sampler_states::AddressingU::MakeValue(sampler::WRAP) |
       set_sampler_states::AddressingV::MakeValue(sampler::WRAP) |
       set_sampler_states::AddressingW::MakeValue(sampler::WRAP) |
       set_sampler_states::MagFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create a 2D texture.
   args[0].value_uint32 = iridescence_texture_id_;
   args[1].value_uint32 =
       create_texture_2d_cmd::Width::MakeValue(kTexWidth) |
       create_texture_2d_cmd::Height::MakeValue(kTexHeight);
   args[2].value_uint32 =
       create_texture_2d_cmd::Levels::MakeValue(0) |
       create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_2d_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_2D, 3, args);
+  helper_->AddCommand(CreateTexture2d, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_texture_id_;
   args[1].value_uint32 =
       set_texture_data_cmd::X::MakeValue(0) |
       set_texture_data_cmd::Y::MakeValue(0);
   args[2].value_uint32 =
       set_texture_data_cmd::Width::MakeValue(kTexWidth) |
       set_texture_data_cmd::Height::MakeValue(kTexHeight);
   args[3].value_uint32 =
       set_texture_data_cmd::Z::MakeValue(0) |
       set_texture_data_cmd::Depth::MakeValue(1);
   args[4].value_uint32 = set_texture_data_cmd::Level::MakeValue(0);
   args[5].value_uint32 = kTexWidth * 4;  // row_pitch
   args[6].value_uint32 = 0;  // slice_pitch
   args[7].value_uint32 = kTexSize;  // size
   args[8].value_uint32 = shm_id_;
   args[9].value_uint32 = allocator_->GetOffset(iridescence_texture_);
-  helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+  helper_->AddCommand(SetTextureData, 10, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
   args[1].value_uint32 = iridescence_texture_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
   args[1].value_uint32 =
       set_sampler_states::AddressingU::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::AddressingV::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::AddressingW::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::MagFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create a Cubemap texture.
   args[0].value_uint32 = cubemap_id_;
   args[1].value_uint32 =
       create_texture_cube_cmd::Side::MakeValue(kCubeMapWidth);
   args[2].value_uint32 =
       create_texture_cube_cmd::Levels::MakeValue(0) |
       create_texture_cube_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_cube_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_CUBE, 3, args);
+  helper_->AddCommand(CreateTextureCube, 3, args);
   CHECK_ERROR(helper_);
 
   for (unsigned int face = 0; face < 6; ++face) {
     void *data = allocator_->Alloc(kCubeMapFaceSize);
     memcpy(data, g_cubemap_data + face*kCubeMapFaceSize, kCubeMapFaceSize);
     args[0].value_uint32 = cubemap_id_;
     args[1].value_uint32 =
         set_texture_data_cmd::X::MakeValue(0) |
         set_texture_data_cmd::Y::MakeValue(0);
     args[2].value_uint32 =
         set_texture_data_cmd::Width::MakeValue(kCubeMapWidth) |
         set_texture_data_cmd::Height::MakeValue(kCubeMapHeight);
     args[3].value_uint32 =
         set_texture_data_cmd::Z::MakeValue(0) |
         set_texture_data_cmd::Depth::MakeValue(1);
     args[4].value_uint32 =
         set_texture_data_cmd::Level::MakeValue(0) |
         set_texture_data_cmd::Face::MakeValue(face);
     args[5].value_uint32 = kCubeMapWidth * 4;  // row_pitch
     args[6].value_uint32 = 0;  // slice_pitch
     args[7].value_uint32 = kCubeMapFaceSize;  // size
     args[8].value_uint32 = shm_id_;
     args[9].value_uint32 = allocator_->GetOffset(data);
-    helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+    helper_->AddCommand(SetTextureData, 10, args);
     CHECK_ERROR(helper_);
     allocator_->FreePendingToken(data, helper_->InsertToken());
   }
 
   args[0].value_uint32 = cubemap_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_id_;
   args[1].value_uint32 = cubemap_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_id_;
   args[1].value_uint32 =
       set_sampler_states::AddressingU::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::AddressingV::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::AddressingW::MakeValue(sampler::CLAMP_TO_EDGE) |
       set_sampler_states::MagFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create the effect, and parameters.
   void *data = allocator_->Alloc(sizeof(effect_data));
   memcpy(data, effect_data, sizeof(effect_data));
   args[0].value_uint32 = effect_id_;
   args[1].value_uint32 = sizeof(effect_data);  // size
   args[2].value_uint32 = shm_id_;  // shm
   args[3].value_uint32 = allocator_->GetOffset(data);  // offset in shm
-  helper_->AddCommand(CREATE_EFFECT, 4, args);
+  helper_->AddCommand(CreateEffect, 4, args);
   CHECK_ERROR(helper_);
   allocator_->FreePendingToken(data, helper_->InsertToken());
 
   {
     const char param_name[] = "noise_sampler";
     args[0].value_uint32 = noise_sampler_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "iridescence_sampler";
     args[0].value_uint32 = iridescence_sampler_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "env_sampler";
     args[0].value_uint32 = cubemap_sampler_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "worldViewProj";
     args[0].value_uint32 = mvp_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "world";
     args[0].value_uint32 = world_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "worldIT";
     args[0].value_uint32 = worldIT_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "eye";
     args[0].value_uint32 = eye_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   {
     const char param_name[] = "thickness_params";
     args[0].value_uint32 = thickness_param_id_;
     args[1].value_uint32 = effect_id_;
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
   // Bind textures to the parameters
   args[0].value_uint32 = noise_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = noise_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = iridescence_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = cubemap_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   // Create our random bubbles.
   for (unsigned int i = 0; i < kBubbleCount; ++i) {
     Bubble bubble;
     bubble.position = math::Point3(Randf(-6.f, 6.f, &seed_),
                                    Randf(-6.f, 6.f, &seed_),
                                    Randf(-6.f, 6.f, &seed_));
     bubble.rotation_speed = math::Vector3(Randf(-.1f, .1f, &seed_),
                                           Randf(-.1f, .1f, &seed_),
@@ skipping 45 matching lines @@
   math::Matrix4 model =
       math::Matrix4::translation(math::Vector3(bubble.position)) *
       math::Matrix4::scale(math::Vector3(bubble.scale, bubble.scale,
                                          bubble.scale)) *
       math::Matrix4::rotationZYX(rotation);
   math::Matrix4 modelIT = math::inverse(math::transpose(model));
   math::Matrix4 mvp = proj * view * model;
 
   // AddCommand copies the args, so it is safe to re-use args across various
   // calls.
-  // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices).
+  // 20 is the largest command we use (SetParamDataImmediate for matrices).
   CommandBufferEntry args[20];
 
   args[0].value_uint32 = vertex_struct_id_;
-  helper_->AddCommand(SET_VERTEX_STRUCT, 1, args);
+  helper_->AddCommand(SetVertexStruct, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = mvp_param_id_;
   args[1].value_uint32 = sizeof(mvp);
   unsigned int arg_count = CopyToArgs(args + 2, &mvp, sizeof(mvp));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = world_param_id_;
   args[1].value_uint32 = sizeof(model);
   arg_count = CopyToArgs(args + 2, &model, sizeof(model));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = worldIT_param_id_;
   args[1].value_uint32 = sizeof(modelIT);
   arg_count = CopyToArgs(args + 2, &modelIT, sizeof(modelIT));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = eye_param_id_;
   args[1].value_uint32 = sizeof(eye);
   arg_count = CopyToArgs(args + 2, &eye, sizeof(eye));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 =
       set_blending::ColorSrcFunc::MakeValue(GAPIInterface::BLEND_FUNC_ONE) |
       set_blending::ColorDstFunc::MakeValue(
           GAPIInterface::BLEND_FUNC_SRC_ALPHA) |
       set_blending::ColorEq::MakeValue(GAPIInterface::BLEND_EQ_ADD) |
       set_blending::SeparateAlpha::MakeValue(0) |
       set_blending::Enable::MakeValue(1);
-  helper_->AddCommand(SET_BLENDING, 1, args);
+  helper_->AddCommand(SetBlending, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = effect_id_;
-  helper_->AddCommand(SET_EFFECT, 1, args);
+  helper_->AddCommand(SetEffect, 1, args);
   CHECK_ERROR(helper_);
 
   // Draw back faces first.
   args[0].value_uint32 =
       set_polygon_raster::FillMode::MakeValue(
           GAPIInterface::POLYGON_MODE_FILL) |
       set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CCW);
-  helper_->AddCommand(SET_POLYGON_RASTER, 1, args);
+  helper_->AddCommand(SetPolygonRaster, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = thickness_param_id_;
   args[1].value_uint32 = 4*sizeof(float);  // NOLINT
   args[2].value_float = bubble.thickness_falloff;
   args[3].value_float = bubble.base_thickness;
   args[4].value_float = bubble.noise_ratio;
   args[5].value_float = .5f;  // back face attenuation
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args);
+  helper_->AddCommand(SetParamDataImmediate, 6, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = GAPIInterface::TRIANGLES;
   args[1].value_uint32 = index_buffer_id_;
   args[2].value_uint32 = 0;  // first
   args[3].value_uint32 = kIndexCount/3;  // primitive count
   args[4].value_uint32 = 0;  // min index
   args[5].value_uint32 = kVertexCount-1;  // max index
-  helper_->AddCommand(DRAW_INDEXED, 6, args);
+  helper_->AddCommand(DrawIndexed, 6, args);
   CHECK_ERROR(helper_);
 
   // Then front faces.
   args[0].value_uint32 =
       set_polygon_raster::FillMode::MakeValue(
           GAPIInterface::POLYGON_MODE_FILL) |
       set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CW);
-  helper_->AddCommand(SET_POLYGON_RASTER, 1, args);
+  helper_->AddCommand(SetPolygonRaster, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = thickness_param_id_;
   args[1].value_uint32 = 4*sizeof(float);  // NOLINT
   args[2].value_float = bubble.thickness_falloff;
   args[3].value_float = bubble.base_thickness;
   args[4].value_float = bubble.noise_ratio;
   args[5].value_float = 1.f;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args);
+  helper_->AddCommand(SetParamDataImmediate, 6, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = GAPIInterface::TRIANGLES;
   args[1].value_uint32 = index_buffer_id_;
   args[2].value_uint32 = 0;  // first
   args[3].value_uint32 = kIndexCount/3;  // primitive count
   args[4].value_uint32 = 0;  // min index
   args[5].value_uint32 = kVertexCount-1;  // max index
-  helper_->AddCommand(DRAW_INDEXED, 6, args);
+  helper_->AddCommand(DrawIndexed, 6, args);
   CHECK_ERROR(helper_);
 }
 
 void BubbleDemo::Render() {
   uint64_t time_usec = GetTimeUsec() - start_time_;
   time_ = time_usec * 1.e-6f;
   // Camera path
   float r = 20.f;
   float theta = time_ / 4.f;
   float phi = 2 * theta;
   math::Point3 eye(r * cosf(theta), r / 3.f * sinf(phi), r * sinf(theta));
   math::Point3 target(0.f, 0.f, 0.f);
   math::Vector3 up(0.f, 1.f, 0.f);
   math::Matrix4 proj =
       math::CreatePerspectiveMatrix(kPi / 4.f, 1.f, .1f, 10000.f);
   math::Matrix4 view = math::Matrix4::lookAt(eye, target, up);
 
-  helper_->AddCommand(BEGIN_FRAME, 0 , NULL);
+  helper_->AddCommand(BeginFrame, 0 , NULL);
   CHECK_ERROR(helper_);
   RGBA color = {0.2f, 0.2f, 0.2f, 1.f};
   ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
            1.f, 0);
 
   // Sort bubbles back-to-front.
   std::sort(bubbles_.begin(), bubbles_.end(), BubbleSorter(view));
   // Then render them all.
   for (unsigned int i = 0; i < bubbles_.size(); ++i) {
     const Bubble &bubble = bubbles_[i];
     DrawBubble(view, proj, bubble, time_ * 2.f * kPi * bubble.rotation_speed);
   }
 
-  helper_->AddCommand(END_FRAME, 0 , NULL);
+  helper_->AddCommand(EndFrame, 0 , NULL);
   CHECK_ERROR(helper_);
   helper_->Flush();
 }
 
 }  // namespace command_buffer
 }  // namespace o3d
 
 // Scriptable object for the plug-in, provides the glue with the browser.
 // Creates a BubbleDemo object and delegates calls to it.
 class Plugin : public NPObject {
@@ skipping 217 matching lines @@
   }
   return NPERR_GENERIC_ERROR;
 }
 
 int main(int argc, char **argv) {
   printf("Bubble demo\n");
   NaClNP_Init(&argc, argv);
   NaClNP_MainLoop(0);
   return 0;
 }