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

command_buffer/service/cross/gl/states_gl.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 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 // This file implements the render state-related GAPI functions on GL.
 
-#include "command_buffer/common/cross/cmd_buffer_format.h"
+#include "command_buffer/common/cross/o3d_cmd_format.h"
 #include "command_buffer/service/cross/gl/gapi_gl.h"
 
 namespace o3d {
 namespace command_buffer {
+namespace o3d {
 
 namespace {
 
 GLenum kGLPolygonModes[] = {
   GL_POINT,
   GL_LINE,
   GL_FILL,
 };
-COMPILE_ASSERT(command_buffer::kNumPolygonMode == arraysize(kGLPolygonModes),
+COMPILE_ASSERT(o3d::kNumPolygonMode == arraysize(kGLPolygonModes),
                kGLPolygonModes_does_not_match_command_buffer_PolygonMode);
 
 GLenum kGLComparison[] = {
   GL_NEVER,
   GL_LESS,
   GL_EQUAL,
   GL_LEQUAL,
   GL_GREATER,
   GL_NOTEQUAL,
   GL_GEQUAL,
   GL_ALWAYS,
 };
-COMPILE_ASSERT(command_buffer::kNumComparison == arraysize(kGLComparison),
+COMPILE_ASSERT(o3d::kNumComparison == arraysize(kGLComparison),
                kGLComparison_does_not_match_command_buffer_Comparison);
 
 GLenum kGLBlendFunc[] = {
   GL_ZERO,
   GL_ONE,
   GL_SRC_COLOR,
   GL_ONE_MINUS_SRC_COLOR,
   GL_SRC_ALPHA,
   GL_ONE_MINUS_SRC_ALPHA,
   GL_DST_ALPHA,
   GL_ONE_MINUS_DST_ALPHA,
   GL_DST_COLOR,
   GL_ONE_MINUS_DST_COLOR,
   GL_SRC_ALPHA_SATURATE,
   GL_CONSTANT_COLOR,
   GL_ONE_MINUS_CONSTANT_COLOR,
 };
-COMPILE_ASSERT(command_buffer::kNumBlendFunc == arraysize(kGLBlendFunc),
+COMPILE_ASSERT(o3d::kNumBlendFunc == arraysize(kGLBlendFunc),
                kGLBlendFunc_does_not_match_command_buffer_BlendFunc);
 
 GLenum kGLBlendEq[] = {
   GL_FUNC_ADD,
   GL_FUNC_SUBTRACT,
   GL_FUNC_REVERSE_SUBTRACT,
   GL_MIN,
   GL_MAX,
 };
-COMPILE_ASSERT(command_buffer::kNumBlendEq == arraysize(kGLBlendEq),
+COMPILE_ASSERT(o3d::kNumBlendEq == arraysize(kGLBlendEq),
                kGLBlendEq_does_not_match_command_buffer_BlendEq);
 
 GLenum kGLStencilOp[] = {
   GL_KEEP,
   GL_ZERO,
   GL_REPLACE,
   GL_INCR,
   GL_DECR,
   GL_INVERT,
   GL_INCR_WRAP,
   GL_DECR_WRAP,
 };
-COMPILE_ASSERT(command_buffer::kNumStencilOp == arraysize(kGLStencilOp),
+COMPILE_ASSERT(o3d::kNumStencilOp == arraysize(kGLStencilOp),
                kGLStencilOp_does_not_match_command_buffer_StencilOp);
 
 // Check that the definition of the counter-clockwise func/ops match the
 // clockwise ones, just shifted by 16 bits, so that we can use
 // DecodeStencilFuncOps on both of them.
 #define CHECK_CCW_MATCHES_CW(FIELD)                                       \
-  COMPILE_ASSERT(cmd::SetStencilTest::CW ## FIELD::kLength ==             \
-                 cmd::SetStencilTest::CCW ## FIELD::kLength,              \
+  COMPILE_ASSERT(o3d::SetStencilTest::CW ## FIELD::kLength ==             \
+                 o3d::SetStencilTest::CCW ## FIELD::kLength,              \
                  CCW ## FIELD ## _length_does_not_match_ ## CW ## FIELD); \
-  COMPILE_ASSERT(cmd::SetStencilTest::CW ## FIELD::kShift + 16 ==         \
-                 cmd::SetStencilTest::CCW ## FIELD::kShift,               \
+  COMPILE_ASSERT(o3d::SetStencilTest::CW ## FIELD::kShift + 16 ==         \
+                 o3d::SetStencilTest::CCW ## FIELD::kShift,               \
                  CCW ## FIELD ## _shift_does_not_match_ ## CW ## FIELD)
 
 CHECK_CCW_MATCHES_CW(Func);
 CHECK_CCW_MATCHES_CW(PassOp);
 CHECK_CCW_MATCHES_CW(FailOp);
 CHECK_CCW_MATCHES_CW(ZFailOp);
 
 #undef CHECK_CCW_MATCHES_CW
 
 // Decodes stencil test function and operations from the bitfield.
 void DecodeStencilFuncOps(Uint32 params,
                           GLenum *func,
                           GLenum *pass,
                           GLenum *fail,
                           GLenum *zfail) {
   // Sanity check. The value has already been tested in
   // GAPIDecoder::DecodeSetStencilTest in gapi_decoder.cc.
-  DCHECK_EQ(cmd::SetStencilTest::Unused1::Get(params), 0);
+  DCHECK_EQ(o3d::SetStencilTest::Unused1::Get(params), 0);
   // Check that the bitmask get cannot generate values outside of the allowed
   // range.
-  COMPILE_ASSERT(cmd::SetStencilTest::CWFunc::kMask <
-                 command_buffer::kNumComparison,
+  COMPILE_ASSERT(o3d::SetStencilTest::CWFunc::kMask <
+                 o3d::kNumComparison,
                  set_stencil_test_CWFunc_may_produce_invalid_values);
-  *func = kGLComparison[cmd::SetStencilTest::CWFunc::Get(params)];
+  *func = kGLComparison[o3d::SetStencilTest::CWFunc::Get(params)];
 
-  COMPILE_ASSERT(cmd::SetStencilTest::CWPassOp::kMask <
-                 command_buffer::kNumStencilOp,
+  COMPILE_ASSERT(o3d::SetStencilTest::CWPassOp::kMask <
+                 o3d::kNumStencilOp,
                  set_stencil_test_CWPassOp_may_produce_invalid_values);
-  *pass = kGLStencilOp[cmd::SetStencilTest::CWPassOp::Get(params)];
+  *pass = kGLStencilOp[o3d::SetStencilTest::CWPassOp::Get(params)];
 
-  COMPILE_ASSERT(cmd::SetStencilTest::CWFailOp::kMask <
-                 command_buffer::kNumStencilOp,
+  COMPILE_ASSERT(o3d::SetStencilTest::CWFailOp::kMask <
+                 o3d::kNumStencilOp,
                  set_stencil_test_CWFailOp_may_produce_invalid_values);
-  *fail = kGLStencilOp[cmd::SetStencilTest::CWFailOp::Get(params)];
+  *fail = kGLStencilOp[o3d::SetStencilTest::CWFailOp::Get(params)];
 
-  COMPILE_ASSERT(cmd::SetStencilTest::CWZFailOp::kMask <
-                 command_buffer::kNumStencilOp,
+  COMPILE_ASSERT(o3d::SetStencilTest::CWZFailOp::kMask <
+                 o3d::kNumStencilOp,
                  set_stencil_test_CWZFailOp_may_produce_invalid_values);
-  *zfail = kGLStencilOp[cmd::SetStencilTest::CWZFailOp::Get(params)];
+  *zfail = kGLStencilOp[o3d::SetStencilTest::CWZFailOp::Get(params)];
 }
 
 }  // anonymous namespace
 
 void GAPIGL::SetViewport(unsigned int x,
                          unsigned int y,
                          unsigned int width,
                          unsigned int height,
                          float z_min,
                          float z_max) {
@@ skipping 37 matching lines @@
     glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE);
     glDisable(GL_POINT_SPRITE);
   }
   glPointSize(point_size);
 }
 
 void GAPIGL::SetPolygonOffset(float slope_factor, float units) {
   glPolygonOffset(slope_factor, units);
 }
 
-void GAPIGL::SetPolygonRaster(PolygonMode fill_mode,
-                              FaceCullMode cull_mode) {
+void GAPIGL::SetPolygonRaster(o3d::PolygonMode fill_mode,
+                              o3d::FaceCullMode cull_mode) {
   DCHECK_LT(fill_mode, kNumPolygonMode);
   glPolygonMode(GL_FRONT_AND_BACK, kGLPolygonModes[fill_mode]);
   DCHECK_LT(cull_mode, kNumFaceCullMode);
   switch (cull_mode) {
     case kCullCW:
       glEnable(GL_CULL_FACE);
       glCullFace(GL_BACK);
       break;
     case kCullCCW:
       glEnable(GL_CULL_FACE);
       glCullFace(GL_FRONT);
       break;
     default:
       glDisable(GL_CULL_FACE);
       break;
   }
 }
 
 void GAPIGL::SetAlphaTest(bool enable,
                           float reference,
-                          Comparison comp) {
+                          o3d::Comparison comp) {
   DCHECK_LT(comp, kNumComparison);
   if (enable) {
     glEnable(GL_ALPHA_TEST);
     glAlphaFunc(kGLComparison[comp], reference);
   } else {
     glDisable(GL_ALPHA_TEST);
   }
 }
 
 void GAPIGL::SetDepthTest(bool enable,
                           bool write_enable,
-                          Comparison comp) {
+                          o3d::Comparison comp) {
   DCHECK_LT(comp, kNumComparison);
   if (enable) {
     glEnable(GL_DEPTH_TEST);
     glDepthFunc(kGLComparison[comp]);
   } else {
     glDisable(GL_DEPTH_TEST);
   }
   glDepthMask(write_enable);
 }
 
@@ skipping 79 matching lines @@
     }
   } else {
     glDisable(GL_BLEND);
   }
 }
 
 void GAPIGL::SetBlendingColor(const RGBA &color) {
   glBlendColor(color.red, color.green, color.blue, color.alpha);
 }
 
+}  // namespace o3d
 }  // namespace command_buffer
 }  // namespace o3d