More work in Command Buffers...

core/cross/command_buffer/states_cb.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 24 matching lines @@
 
 #include "core/cross/precompile.h"
 #include "core/cross/state.h"
 #include "core/cross/command_buffer/renderer_cb.h"
 #include "core/cross/command_buffer/states_cb.h"
 #include "command_buffer/common/cross/gapi_interface.h"
 
 namespace o3d {
 using command_buffer::CommandBufferEntry;
 using command_buffer::CommandBufferHelper;
-using command_buffer::GAPIInterface;
 
 namespace {
 
 // Converts values meant to represent a Cull Mode to the corresponding
 // command-buffer value.
 // Default: CULL_NONE.
-GAPIInterface::FaceCullMode CullModeToCB(int cull) {
+command_buffer::FaceCullMode CullModeToCB(int cull) {
   switch (cull) {
     default:
     case State::CULL_NONE:
-      return GAPIInterface::CULL_NONE;
+      return command_buffer::kCullNone;
     case State::CULL_CW:
-      return GAPIInterface::CULL_CW;
+      return command_buffer::kCullCW;
     case State::CULL_CCW:
-      return GAPIInterface::CULL_CCW;
+      return command_buffer::kCullCCW;
   }
 }
 
 // Converts values meant to represent a Polygon Fill Mode to the corresponding
 // command-buffer value.
-// Default: POLYGON_MODE_FILL.
-GAPIInterface::PolygonMode FillModeToCB(int fill) {
+// Default: kPolygonModeFill.
+command_buffer::PolygonMode FillModeToCB(int fill) {
   switch (fill) {
     case State::POINT:
-      return GAPIInterface::POLYGON_MODE_POINTS;
+      return command_buffer::kPolygonModePoints;
     case State::WIREFRAME:
-      return GAPIInterface::POLYGON_MODE_LINES;
+      return command_buffer::kPolygonModeLines;
     default:
     case State::SOLID:
-      return GAPIInterface::POLYGON_MODE_FILL;
+      return command_buffer::kPolygonModeFill;
   }
 }
 
 // Converts values meant to represent a Comparison Function to the corresponding
 // command-buffer value.
-// Default: ALWAYS.
-GAPIInterface::Comparison ComparisonToCB(int comparison) {
+// Default: kAlways.
+command_buffer::Comparison ComparisonToCB(int comparison) {
   switch (comparison) {
     case State::CMP_NEVER:
-      return GAPIInterface::NEVER;
+      return command_buffer::kNever;
     case State::CMP_LESS:
-      return GAPIInterface::LESS;
+      return command_buffer::kLess;
     case State::CMP_EQUAL:
-      return GAPIInterface::EQUAL;
+      return command_buffer::kEqual;
     case State::CMP_LEQUAL:
-      return GAPIInterface::LEQUAL;
+      return command_buffer::kLEqual;
     case State::CMP_GREATER:
-      return GAPIInterface::GREATER;
+      return command_buffer::kGreater;
     case State::CMP_NOTEQUAL:
-      return GAPIInterface::NOT_EQUAL;
+      return command_buffer::kNotEqual;
     case State::CMP_GEQUAL:
-      return GAPIInterface::GEQUAL;
+      return command_buffer::kGEqual;
     case State::CMP_ALWAYS:
     default:
-      return GAPIInterface::ALWAYS;
+      return command_buffer::kAlways;
   }
 }
 
 // Converts values meant to represent a Stencil Operation to the corresponding
 // command-buffer value.
-// Default: KEEP.
-GAPIInterface::StencilOp StencilOpToCB(int op) {
+// Default: kKeep.
+command_buffer::StencilOp StencilOpToCB(int op) {
   switch (op) {
     default:
     case State::STENCIL_KEEP:
-      return GAPIInterface::KEEP;
+      return command_buffer::kKeep;
     case State::STENCIL_ZERO:
-      return GAPIInterface::ZERO;
+      return command_buffer::kZero;
     case State::STENCIL_REPLACE:
-      return GAPIInterface::REPLACE;
+      return command_buffer::kReplace;
     case State::STENCIL_INCREMENT_SATURATE:
-      return GAPIInterface::INC_NO_WRAP;
+      return command_buffer::kIncNoWrap;
     case State::STENCIL_DECREMENT_SATURATE:
-      return GAPIInterface::DEC_NO_WRAP;
+      return command_buffer::kDecNoWrap;
     case State::STENCIL_INVERT:
-      return GAPIInterface::INVERT;
+      return command_buffer::kInvert;
     case State::STENCIL_INCREMENT:
-      return GAPIInterface::INC_WRAP;
+      return command_buffer::kIncWrap;
     case State::STENCIL_DECREMENT:
-      return GAPIInterface::DEC_WRAP;
+      return command_buffer::kDecWrap;
   }
 }
 
 // Converts values meant to represent a Blending Function to the corresponding
 // command-buffer value.
-// Default: BLEND_FUNC_ONE.
-GAPIInterface::BlendFunc BlendFuncToCB(int func) {
+// Default: kBlendFuncOne.
+command_buffer::BlendFunc BlendFuncToCB(int func) {
   switch (func) {
     case State::BLENDFUNC_ZERO:
-      return GAPIInterface::BLEND_FUNC_ZERO;
+      return command_buffer::kBlendFuncZero;
     default:
     case State::BLENDFUNC_ONE:
-      return GAPIInterface::BLEND_FUNC_ONE;
+      return command_buffer::kBlendFuncOne;
     case State::BLENDFUNC_SOURCE_COLOR:
-      return GAPIInterface::BLEND_FUNC_SRC_COLOR;
+      return command_buffer::kBlendFuncSrcColor;
     case State::BLENDFUNC_INVERSE_SOURCE_COLOR:
-      return GAPIInterface::BLEND_FUNC_INV_SRC_COLOR;
+      return command_buffer::kBlendFuncInvSrcColor;
     case State::BLENDFUNC_SOURCE_ALPHA:
-      return GAPIInterface::BLEND_FUNC_SRC_ALPHA;
+      return command_buffer::kBlendFuncSrcAlpha;
     case State::BLENDFUNC_INVERSE_SOURCE_ALPHA:
-      return GAPIInterface::BLEND_FUNC_INV_SRC_ALPHA;
+      return command_buffer::kBlendFuncInvSrcAlpha;
     case State::BLENDFUNC_DESTINATION_ALPHA:
-      return GAPIInterface::BLEND_FUNC_DST_ALPHA;
+      return command_buffer::kBlendFuncDstAlpha;
     case State::BLENDFUNC_INVERSE_DESTINATION_ALPHA:
-      return GAPIInterface::BLEND_FUNC_INV_DST_ALPHA;
+      return command_buffer::kBlendFuncInvDstAlpha;
     case State::BLENDFUNC_DESTINATION_COLOR:
-      return GAPIInterface::BLEND_FUNC_DST_COLOR;
+      return command_buffer::kBlendFuncDstColor;
     case State::BLENDFUNC_INVERSE_DESTINATION_COLOR:
-      return GAPIInterface::BLEND_FUNC_INV_DST_COLOR;
+      return command_buffer::kBlendFuncInvDstColor;
     case State::BLENDFUNC_SOURCE_ALPHA_SATUTRATE:
-      return GAPIInterface::BLEND_FUNC_SRC_ALPHA_SATUTRATE;
+      return command_buffer::kBlendFuncSrcAlphaSaturate;
   }
 }
 
 // Converts values meant to represent a Blending Equation to the corresponding
 // command-buffer value.
-// Default: BLEND_EQ_ADD.
-GAPIInterface::BlendEq BlendEqToCB(int eq) {
+// Default: kBlendEqAdd.
+command_buffer::BlendEq BlendEqToCB(int eq) {
   switch (eq) {
     default:
     case State::BLEND_ADD:
-      return GAPIInterface::BLEND_EQ_ADD;
+      return command_buffer::kBlendEqAdd;
     case State::BLEND_SUBTRACT:
-      return GAPIInterface::BLEND_EQ_SUB;
+      return command_buffer::kBlendEqSub;
     case State::BLEND_REVERSE_SUBTRACT:
-      return GAPIInterface::BLEND_EQ_REV_SUB;
+      return command_buffer::kBlendEqRevSub;
     case State::BLEND_MIN:
-      return GAPIInterface::BLEND_EQ_MIN;
+      return command_buffer::kBlendEqMin;
     case State::BLEND_MAX:
-      return GAPIInterface::BLEND_EQ_MAX;
+      return command_buffer::kBlendEqMax;
   }
 }
 
 }  // anonymous namespace
 
 // This class wraps StateHandler to make it type-safe.
 template <typename T>
 class TypedStateHandler : public RendererCB::StateHandler {
  public:
   // Override this function to set a specific state.
@@ skipping 72 matching lines @@
 // A handler for the color write state.
 class ColorWriteStateHandler : public TypedStateHandler<ParamInteger> {
  public:
   ColorWriteStateHandler(uint32 *value, bool *dirty)
       : value_(value),
         dirty_(dirty) {
   }
 
   virtual void SetStateFromTypedParam(RendererCB* renderer,
                                       ParamInteger* param) const {
+    using command_buffer::cmd::SetColorWrite;
     int mask = param->value();
-    o3d::command_buffer::set_color_write::AllColorsMask::Set(value_, mask);
+    SetColorWrite::AllColorsMask::Set(value_, mask);
     renderer->SetWriteMask(mask);
     *dirty_ = true;
   }
  private:
   uint32 *value_;
   bool *dirty_;
 };
 
 // A template that generates a handler for full-size values (uint32, int32,
 // float).
@@ skipping 27 matching lines @@
 //   dirty: a pointer to the dirty bit.
 class CullModeStateHandler : public TypedStateHandler<ParamInteger> {
  public:
   CullModeStateHandler(uint32 *value, bool *dirty)
       : value_(value),
         dirty_(dirty) {
   }
 
   virtual void SetStateFromTypedParam(RendererCB* renderer,
                                       ParamInteger* param) const {
-    using command_buffer::set_polygon_raster::CullMode;
-    CullMode::Set(value_, CullModeToCB(param->value()));
+    using command_buffer::cmd::SetPolygonRaster;
+    SetPolygonRaster::CullMode::Set(value_, CullModeToCB(param->value()));
     *dirty_ = true;
   }
  private:
   uint32 *value_;
   bool *dirty_;
 };
 
 // Handler for Polygon Fill Mode.
 // Parameters:
 //   value: a pointer to the argument value as an uint32.
 //   dirty: a pointer to the dirty bit.
 class FillModeStateHandler : public TypedStateHandler<ParamInteger> {
  public:
   FillModeStateHandler(uint32 *value, bool *dirty)
       : value_(value),
         dirty_(dirty) {
   }
 
   virtual void SetStateFromTypedParam(RendererCB* renderer,
                                       ParamInteger* param) const {
-    using command_buffer::set_polygon_raster::FillMode;
-    FillMode::Set(value_, FillModeToCB(param->value()));
+    using command_buffer::cmd::SetPolygonRaster;
+    SetPolygonRaster::FillMode::Set(value_, FillModeToCB(param->value()));
     *dirty_ = true;
   }
  private:
   uint32 *value_;
   bool *dirty_;
 };
 
 // A template that generates a handler for comparison functions.
 // Template Parameters:
 //   bit_field: the BitField type to access the proper bits.
@@ skipping 89 matching lines @@
   uint32 *value_;
   bool *dirty_;
 };
 
 // Adds all the state handlers for all the states. The list of handlers must
 // match in names and types the list in Renderer::AddDefaultStates()
 // (in renderer.cc).
 void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
   // Point/Line raster
   {
-    using command_buffer::set_point_line_raster::LineSmoothEnable;
-    using command_buffer::set_point_line_raster::PointSpriteEnable;
     bool *dirty = point_line_helper_.dirty_ptr();
-    command_buffer::cmd::SetPointLineRaster& cmd =
-        point_line_helper_.command();
+    using command_buffer::cmd::SetPointLineRaster;
+    SetPointLineRaster& cmd = point_line_helper_.command();
     renderer->AddStateHandler(
         State::kLineSmoothEnableParamName,
-        new EnableStateHandler<LineSmoothEnable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<
+            SetPointLineRaster::LineSmoothEnable>(&cmd.enables, dirty));
     renderer->AddStateHandler(
         State::kPointSpriteEnableParamName,
-        new EnableStateHandler<PointSpriteEnable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<
+            SetPointLineRaster::PointSpriteEnable>(&cmd.enables, dirty));
     renderer->AddStateHandler(State::kPointSizeParamName,
                               new ValueStateHandler<ParamFloat>(
                                   &cmd.point_size, dirty));
   }
 
   // Polygon Raster
   {
     bool *dirty = poly_raster_helper_.dirty_ptr();
-    command_buffer::cmd::SetPolygonRaster& cmd =
-        poly_raster_helper_.command();
+    using command_buffer::cmd::SetPolygonRaster;
+    SetPolygonRaster& cmd = poly_raster_helper_.command();
     renderer->AddStateHandler(State::kCullModeParamName,
-                              new CullModeStateHandler(&cmd.fixme0, dirty));
+                              new CullModeStateHandler(&cmd.fill_cull, dirty));
     renderer->AddStateHandler(State::kFillModeParamName,
-                              new FillModeStateHandler(&cmd.fixme0, dirty));
+                              new FillModeStateHandler(&cmd.fill_cull, dirty));
   }
 
   // Polygon Offset
   {
     bool *dirty = poly_offset_helper_.dirty_ptr();
     command_buffer::cmd::SetPolygonOffset& cmd =
         poly_offset_helper_.command();
     renderer->AddStateHandler(
         State::kPolygonOffset1ParamName,
         new ValueStateHandler<ParamFloat>(&cmd.slope_factor, dirty));
     renderer->AddStateHandler(
         State::kPolygonOffset2ParamName,
         new ValueStateHandler<ParamFloat>(&cmd.units, dirty));
   }
 
   // Alpha test
   {
-    using command_buffer::set_alpha_test::Enable;
-    using command_buffer::set_alpha_test::Func;
-    command_buffer::cmd::SetAlphaTest& cmd = alpha_test_helper_.command();
+    using command_buffer::cmd::SetAlphaTest;
+    SetAlphaTest& cmd = alpha_test_helper_.command();
     bool *dirty = alpha_test_helper_.dirty_ptr();
     renderer->AddStateHandler(
         State::kAlphaTestEnableParamName,
-        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetAlphaTest::Enable>(&cmd.func_enable, dirty));
     renderer->AddStateHandler(
         State::kAlphaComparisonFunctionParamName,
-        new ComparisonStateHandler<Func>(&cmd.fixme0, dirty));
+        new ComparisonStateHandler<SetAlphaTest::Func>(&cmd.func_enable, dirty));
     renderer->AddStateHandler(
         State::kAlphaReferenceParamName,
         new ValueStateHandler<ParamFloat>(&cmd.value, dirty));
   }
 
   // Depth Test
   {
-    using command_buffer::set_depth_test::Enable;
-    using command_buffer::set_depth_test::WriteEnable;
-    using command_buffer::set_depth_test::Func;
     bool *dirty = depth_test_helper_.dirty_ptr();
-    command_buffer::cmd::SetDepthTest& cmd = depth_test_helper_.command();
+    using command_buffer::cmd::SetDepthTest;
+    SetDepthTest& cmd = depth_test_helper_.command();
     renderer->AddStateHandler(
         State::kZWriteEnableParamName,
-        new EnableStateHandler<WriteEnable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetDepthTest::WriteEnable>(&cmd.func_enable, dirty));
     renderer->AddStateHandler(
         State::kZEnableParamName,
-        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetDepthTest::Enable>(&cmd.func_enable, dirty));
     renderer->AddStateHandler(
         State::kZComparisonFunctionParamName,
-        new ComparisonStateHandler<Func>(&cmd.fixme0, dirty));
+        new ComparisonStateHandler<SetDepthTest::Func>(&cmd.func_enable, dirty));
   }
 
   // Stencil Test
   {
-    using command_buffer::set_stencil_test::Enable;
-    using command_buffer::set_stencil_test::SeparateCCW;
-    using command_buffer::set_stencil_test::WriteMask;
-    using command_buffer::set_stencil_test::CompareMask;
-    using command_buffer::set_stencil_test::ReferenceValue;
-    using command_buffer::set_stencil_test::CWFunc;
-    using command_buffer::set_stencil_test::CWPassOp;
-    using command_buffer::set_stencil_test::CWFailOp;
-    using command_buffer::set_stencil_test::CWZFailOp;
-    using command_buffer::set_stencil_test::CCWFunc;
-    using command_buffer::set_stencil_test::CCWPassOp;
-    using command_buffer::set_stencil_test::CCWFailOp;
-    using command_buffer::set_stencil_test::CCWZFailOp;
     bool *dirty = stencil_test_helper_.dirty_ptr();
-    command_buffer::cmd::SetStencilTest& cmd = stencil_test_helper_.command();
+    using command_buffer::cmd::SetStencilTest;
+    SetStencilTest& cmd = stencil_test_helper_.command();
     renderer->AddStateHandler(
         State::kStencilEnableParamName,
-        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetStencilTest::Enable>(&cmd.stencil_args0, dirty));
     renderer->AddStateHandler(
         State::kTwoSidedStencilEnableParamName,
-        new EnableStateHandler<SeparateCCW>(&cmd.fixme0, dirty));
+        new EnableStateHandler<
+            SetStencilTest::SeparateCCW>(&cmd.stencil_args0, dirty));
     renderer->AddStateHandler(
         State::kStencilReferenceParamName,
-        new BitFieldStateHandler<ReferenceValue>(&cmd.fixme0, dirty));
+        new BitFieldStateHandler<
+            SetStencilTest::ReferenceValue>(&cmd.stencil_args0, dirty));
     renderer->AddStateHandler(
         State::kStencilMaskParamName,
-        new BitFieldStateHandler<CompareMask>(&cmd.fixme0, dirty));
+        new BitFieldStateHandler<
+            SetStencilTest::CompareMask>(&cmd.stencil_args0, dirty));
     renderer->AddStateHandler(
         State::kStencilWriteMaskParamName,
-        new BitFieldStateHandler<WriteMask>(&cmd.fixme0, dirty));
+        new BitFieldStateHandler<
+            SetStencilTest::WriteMask>(&cmd.stencil_args0, dirty));
 
     renderer->AddStateHandler(
         State::kStencilComparisonFunctionParamName,
-        new ComparisonStateHandler<CWFunc>(&cmd.fixme1, dirty));
+        new ComparisonStateHandler<
+            SetStencilTest::CWFunc>(&cmd.stencil_args1, dirty));
     renderer->AddStateHandler(
         State::kStencilPassOperationParamName,
-        new StencilOpStateHandler<CWPassOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CWPassOp>(&cmd.stencil_args1, dirty));
     renderer->AddStateHandler(
         State::kStencilFailOperationParamName,
-        new StencilOpStateHandler<CWFailOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CWFailOp>(&cmd.stencil_args1, dirty));
     renderer->AddStateHandler(
         State::kStencilZFailOperationParamName,
-        new StencilOpStateHandler<CWZFailOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CWZFailOp>(&cmd.stencil_args1, dirty));
 
     renderer->AddStateHandler(
         State::kCCWStencilComparisonFunctionParamName,
-        new ComparisonStateHandler<CCWFunc>(&cmd.fixme1, dirty));
+        new ComparisonStateHandler<
+            SetStencilTest::CCWFunc>(&cmd.stencil_args1, dirty));
 
     renderer->AddStateHandler(
         State::kCCWStencilPassOperationParamName,
-        new StencilOpStateHandler<CCWPassOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CCWPassOp>(&cmd.stencil_args1, dirty));
     renderer->AddStateHandler(
         State::kCCWStencilFailOperationParamName,
-        new StencilOpStateHandler<CCWFailOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CCWFailOp>(&cmd.stencil_args1, dirty));
     renderer->AddStateHandler(
         State::kCCWStencilZFailOperationParamName,
-        new StencilOpStateHandler<CCWZFailOp>(&cmd.fixme1, dirty));
+        new StencilOpStateHandler<
+            SetStencilTest::CCWZFailOp>(&cmd.stencil_args1, dirty));
   }
 
   // Blending
   {
-    using command_buffer::set_blending::Enable;
-    using command_buffer::set_blending::SeparateAlpha;
-    using command_buffer::set_blending::ColorEq;
-    using command_buffer::set_blending::ColorSrcFunc;
-    using command_buffer::set_blending::ColorDstFunc;
-    using command_buffer::set_blending::AlphaEq;
-    using command_buffer::set_blending::AlphaSrcFunc;
-    using command_buffer::set_blending::AlphaDstFunc;
     bool *dirty = blending_helper_.dirty_ptr();
-    command_buffer::cmd::SetBlending& cmd = blending_helper_.command();
+    using command_buffer::cmd::SetBlending;
+    SetBlending& cmd = blending_helper_.command();
     renderer->AddStateHandler(
         State::kAlphaBlendEnableParamName,
-        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetBlending::Enable>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kSeparateAlphaBlendEnableParamName,
-        new EnableStateHandler<SeparateAlpha>(&cmd.fixme0, dirty));
+        new EnableStateHandler<SetBlending::SeparateAlpha>(&cmd.blend_settings, dirty));
 
     renderer->AddStateHandler(
         State::kSourceBlendFunctionParamName,
-        new BlendFuncStateHandler<ColorSrcFunc>(&cmd.fixme0, dirty));
+        new BlendFuncStateHandler<
+            SetBlending::ColorSrcFunc>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kDestinationBlendFunctionParamName,
-        new BlendFuncStateHandler<ColorDstFunc>(&cmd.fixme0, dirty));
+        new BlendFuncStateHandler<
+            SetBlending::ColorDstFunc>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kBlendEquationParamName,
-        new BlendEqStateHandler<ColorEq>(&cmd.fixme0, dirty));
+        new BlendEqStateHandler<
+            SetBlending::ColorEq>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kSourceBlendAlphaFunctionParamName,
-        new BlendFuncStateHandler<AlphaSrcFunc>(&cmd.fixme0, dirty));
+        new BlendFuncStateHandler<
+            SetBlending::AlphaSrcFunc>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kDestinationBlendAlphaFunctionParamName,
-        new BlendFuncStateHandler<AlphaDstFunc>(&cmd.fixme0, dirty));
+        new BlendFuncStateHandler<
+            SetBlending::AlphaDstFunc>(&cmd.blend_settings, dirty));
     renderer->AddStateHandler(
         State::kBlendAlphaEquationParamName,
-        new BlendEqStateHandler<AlphaEq>(&cmd.fixme0, dirty));
+        new BlendEqStateHandler<
+            SetBlending::AlphaEq>(&cmd.blend_settings, dirty));
   }
 
   // Color Write
   {
-    using command_buffer::set_color_write::DitherEnable;
-    using command_buffer::set_color_write::AllColorsMask;
     bool *dirty = color_write_helper_.dirty_ptr();
-    command_buffer::cmd::SetColorWrite& cmd = color_write_helper_.command();
+    using command_buffer::cmd::SetColorWrite;
+    SetColorWrite& cmd = color_write_helper_.command();
     renderer->AddStateHandler(
         State::kDitherEnableParamName,
-        new EnableStateHandler<DitherEnable>(&cmd.flags, dirty));
+        new EnableStateHandler<SetColorWrite::DitherEnable>(&cmd.flags, dirty));
     renderer->AddStateHandler(
         State::kColorWriteEnableParamName,
         new ColorWriteStateHandler(&cmd.flags, dirty));
   }
 }
 
 void RendererCB::StateManager::ValidateStates(CommandBufferHelper *helper) {
   point_line_helper_.Validate(helper);
   poly_offset_helper_.Validate(helper);
   poly_raster_helper_.Validate(helper);
   alpha_test_helper_.Validate(helper);
   depth_test_helper_.Validate(helper);
   stencil_test_helper_.Validate(helper);
   color_write_helper_.Validate(helper);
   blending_helper_.Validate(helper);
 }
 
 }  // namespace o3d