More work in Command Buffers...

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 27 matching lines @@
 namespace o3d {
 namespace command_buffer {
 
 namespace {
 
 GLenum kGLPolygonModes[] = {
   GL_POINT,
   GL_LINE,
   GL_FILL,
 };
-COMPILE_ASSERT(GAPIInterface::NUM_POLYGON_MODE == arraysize(kGLPolygonModes),
-               kGLPolygonModes_does_not_match_GAPIInterface_PolygonMode);
+COMPILE_ASSERT(command_buffer::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(GAPIInterface::NUM_COMPARISON == arraysize(kGLComparison),
-               kGLComparison_does_not_match_GAPIInterface_Comparison);
+COMPILE_ASSERT(command_buffer::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(GAPIInterface::NUM_BLEND_FUNC == arraysize(kGLBlendFunc),
-               kGLBlendFunc_does_not_match_GAPIInterface_BlendFunc);
+COMPILE_ASSERT(command_buffer::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(GAPIInterface::NUM_BLEND_EQ == arraysize(kGLBlendEq),
-               kGLBlendEq_does_not_match_GAPIInterface_BlendEq);
+COMPILE_ASSERT(command_buffer::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(GAPIInterface::NUM_STENCIL_OP == arraysize(kGLStencilOp),
-               kGLStencilOp_does_not_match_GAPIInterface_StencilOp);
+COMPILE_ASSERT(command_buffer::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(set_stencil_test::CW ## FIELD::kLength ==                \
-                 set_stencil_test::CCW ## FIELD::kLength,                 \
+  COMPILE_ASSERT(cmd::SetStencilTest::CW ## FIELD::kLength ==             \
+                 cmd::SetStencilTest::CCW ## FIELD::kLength,              \
                  CCW ## FIELD ## _length_does_not_match_ ## CW ## FIELD); \
-  COMPILE_ASSERT(set_stencil_test::CW ## FIELD::kShift + 16 ==            \
-                 set_stencil_test::CCW ## FIELD::kShift,                  \
+  COMPILE_ASSERT(cmd::SetStencilTest::CW ## FIELD::kShift + 16 ==         \
+                 cmd::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) {
-  namespace cmd = set_stencil_test;
   // Sanity check. The value has already been tested in
   // GAPIDecoder::DecodeSetStencilTest in gapi_decoder.cc.
-  DCHECK_EQ(cmd::Unused1::Get(params), 0);
+  DCHECK_EQ(cmd::SetStencilTest::Unused1::Get(params), 0);
   // Check that the bitmask get cannot generate values outside of the allowed
   // range.
-  COMPILE_ASSERT(cmd::CWFunc::kMask < GAPIInterface::NUM_COMPARISON,
+  COMPILE_ASSERT(cmd::SetStencilTest::CWFunc::kMask <
+                 command_buffer::kNumComparison,
                  set_stencil_test_CWFunc_may_produce_invalid_values);
-  *func = kGLComparison[cmd::CWFunc::Get(params)];
+  *func = kGLComparison[cmd::SetStencilTest::CWFunc::Get(params)];
 
-  COMPILE_ASSERT(cmd::CWPassOp::kMask < GAPIInterface::NUM_STENCIL_OP,
+  COMPILE_ASSERT(cmd::SetStencilTest::CWPassOp::kMask <
+                 command_buffer::kNumStencilOp,
                  set_stencil_test_CWPassOp_may_produce_invalid_values);
-  *pass = kGLStencilOp[cmd::CWPassOp::Get(params)];
+  *pass = kGLStencilOp[cmd::SetStencilTest::CWPassOp::Get(params)];
 
-  COMPILE_ASSERT(cmd::CWFailOp::kMask < GAPIInterface::NUM_STENCIL_OP,
+  COMPILE_ASSERT(cmd::SetStencilTest::CWFailOp::kMask <
+                 command_buffer::kNumStencilOp,
                  set_stencil_test_CWFailOp_may_produce_invalid_values);
-  *fail = kGLStencilOp[cmd::CWFailOp::Get(params)];
+  *fail = kGLStencilOp[cmd::SetStencilTest::CWFailOp::Get(params)];
 
-  COMPILE_ASSERT(cmd::CWZFailOp::kMask < GAPIInterface::NUM_STENCIL_OP,
+  COMPILE_ASSERT(cmd::SetStencilTest::CWZFailOp::kMask <
+                 command_buffer::kNumStencilOp,
                  set_stencil_test_CWZFailOp_may_produce_invalid_values);
-  *zfail = kGLStencilOp[cmd::CWZFailOp::Get(params)];
+  *zfail = kGLStencilOp[cmd::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 39 matching lines @@
   }
   glPointSize(point_size);
 }
 
 void GAPIGL::SetPolygonOffset(float slope_factor, float units) {
   glPolygonOffset(slope_factor, units);
 }
 
 void GAPIGL::SetPolygonRaster(PolygonMode fill_mode,
                               FaceCullMode cull_mode) {
-  DCHECK_LT(fill_mode, NUM_POLYGON_MODE);
+  DCHECK_LT(fill_mode, kNumPolygonMode);
   glPolygonMode(GL_FRONT_AND_BACK, kGLPolygonModes[fill_mode]);
-  DCHECK_LT(cull_mode, NUM_FACE_CULL_MODE);
+  DCHECK_LT(cull_mode, kNumFaceCullMode);
   switch (cull_mode) {
-    case CULL_CW:
+    case kCullCW:
       glEnable(GL_CULL_FACE);
       glCullFace(GL_BACK);
       break;
-    case CULL_CCW:
+    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) {
-  DCHECK_LT(comp, NUM_COMPARISON);
+  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) {
-  DCHECK_LT(comp, NUM_COMPARISON);
+  DCHECK_LT(comp, kNumComparison);
   if (enable) {
     glEnable(GL_DEPTH_TEST);
     glDepthFunc(kGLComparison[comp]);
   } else {
     glDisable(GL_DEPTH_TEST);
   }
   glDepthMask(write_enable);
 }
 
 void GAPIGL::SetStencilTest(bool enable,
@@ skipping 47 matching lines @@
 }
 
 void GAPIGL::SetBlending(bool enable,
                          bool separate_alpha,
                          BlendEq color_eq,
                          BlendFunc color_src_func,
                          BlendFunc color_dst_func,
                          BlendEq alpha_eq,
                          BlendFunc alpha_src_func,
                          BlendFunc alpha_dst_func) {
-  DCHECK_LT(color_eq, NUM_BLEND_EQ);
-  DCHECK_LT(color_src_func, NUM_BLEND_FUNC);
-  DCHECK_LT(color_dst_func, NUM_BLEND_FUNC);
-  DCHECK_LT(alpha_eq, NUM_BLEND_EQ);
-  DCHECK_LT(alpha_src_func, NUM_BLEND_FUNC);
-  DCHECK_LT(alpha_dst_func, NUM_BLEND_FUNC);
+  DCHECK_LT(color_eq, kNumBlendEq);
+  DCHECK_LT(color_src_func, kNumBlendFunc);
+  DCHECK_LT(color_dst_func, kNumBlendFunc);
+  DCHECK_LT(alpha_eq, kNumBlendEq);
+  DCHECK_LT(alpha_src_func, kNumBlendFunc);
+  DCHECK_LT(alpha_dst_func, kNumBlendFunc);
   if (enable) {
     glEnable(GL_BLEND);
     GLenum gl_color_eq = kGLBlendEq[color_eq];
     GLenum gl_color_src_func = kGLBlendFunc[color_src_func];
     GLenum gl_color_dst_func = kGLBlendFunc[color_dst_func];
     if (separate_alpha) {
       GLenum gl_alpha_eq = kGLBlendEq[alpha_eq];
       GLenum gl_alpha_src_func = kGLBlendFunc[alpha_src_func];
       GLenum gl_alpha_dst_func = kGLBlendFunc[alpha_dst_func];
       glBlendFuncSeparate(gl_color_src_func, gl_color_dst_func,
                           gl_alpha_src_func, gl_alpha_dst_func);
       glBlendEquationSeparate(gl_color_eq, gl_alpha_eq);
     } else {
       glBlendFunc(gl_color_src_func, gl_color_dst_func);
       glBlendEquation(gl_color_eq);
     }
   } else {
     glDisable(GL_BLEND);
   }
 }
 
 void GAPIGL::SetBlendingColor(const RGBA &color) {
   glBlendColor(color.red, color.green, color.blue, color.alpha);
 }
 
 }  // namespace command_buffer
 }  // namespace o3d