statetable.cc

Go to the documentation of this file.

#include "ion/gfx/statetable.h"

#include "ion/base/argcount.h"
#include "ion/base/enumhelper.h"
#include "ion/base/logging.h"
#include "ion/base/static_assert.h"
#include "ion/portgfx/glheaders.h"

namespace ion {
namespace gfx {

StateTable::~StateTable() {
}

void StateTable::Reset() {
  data_ = GetDefaultData();

  const math::Point2i max_point(default_width_, default_height_);
  data_.scissor_box.SetMaxPoint(max_point);
  data_.viewport.SetMaxPoint(max_point);
}

void StateTable::CopyFrom(const StateTable& other) {
  default_width_ = other.default_width_;
  default_height_ = other.default_height_;
  data_ = other.data_;
}

#define ION_UPDATE_VALUE1(n) data_.n = other.data_.n
#define ION_UPDATE_VALUE2(n1, n2) \
  ION_UPDATE_VALUE1(n1);          \
  data_.n2 = other.data_.n2
#define ION_UPDATE_VALUE3(n1, n2, n3) \
  ION_UPDATE_VALUE2(n1, n2);          \
  data_.n3 = other.data_.n3
#define ION_UPDATE_VALUE4(n1, n2, n3, n4) \
  ION_UPDATE_VALUE3(n1, n2, n3);          \
  data_.n4 = other.data_.n4
#define ION_UPDATE_VALUE5(n1, n2, n3, n4, n5) \
  ION_UPDATE_VALUE4(n1, n2, n3, n4);          \
  data_.n5 = other.data_.n5
#define ION_UPDATE_VALUE6(n1, n2, n3, n4, n5, n6) \
  ION_UPDATE_VALUE5(n1, n2, n3, n4, n5);          \
  data_.n6 = other.data_.n6
#define ION_UPDATE_VALUE_(UPDATE_VALUE_MACRO, ...) \
  UPDATE_VALUE_MACRO(__VA_ARGS__)

#define ION_UPDATE_VALUE(enum_name, ...)                                   \
  if (state_to_test.IsValueSet(enum_name)) {                               \
    data_.values_set.set(enum_name);                                       \
    ION_UPDATE_VALUE_(                                                     \
        ION_ARGCOUNT_XCONCAT(ION_UPDATE_VALUE, ION_ARGCOUNT(__VA_ARGS__)), \
        __VA_ARGS__);                                                      \
  }

void StateTable::MergeValuesFrom(const StateTable& other,
                                 const StateTable& state_to_test) {
  MergeNonClearValuesFrom(other, state_to_test);

  if (state_to_test.GetSetValueCount()) {
    ION_UPDATE_VALUE(kClearColorValue, clear_color)
    ION_UPDATE_VALUE(kClearDepthValue, clear_depth_value)
    ION_UPDATE_VALUE(kClearStencilValue, clear_stencil_value)
  }
}

void StateTable::MergeNonClearValuesFrom(const StateTable& other,
                                         const StateTable& state_to_test) {
  if (state_to_test.GetSetCapabilityCount() &&
      (!AreCapabilitiesSame(*this, other) ||
       state_to_test.AreSettingsEnforced())) {
    const size_t num_capabilities = data_.capabilities_set.size();
    for (size_t i = 0; i < num_capabilities; ++i) {
      if (state_to_test.data_.capabilities_set.test(i)) {
        data_.capabilities.set(i, other.data_.capabilities.test(i));
        data_.capabilities_set.set(i);
      }
    }
  }

  if (state_to_test.GetSetValueCount()) {
    ION_UPDATE_VALUE(kBlendColorValue, blend_color)
    ION_UPDATE_VALUE(kBlendEquationsValue, rgb_blend_equation,
                     alpha_blend_equation)
    ION_UPDATE_VALUE(kBlendFunctionsValue,
                     rgb_blend_source_factor,
                     rgb_blend_destination_factor,
                     alpha_blend_source_factor,
                     alpha_blend_destination_factor)
    ION_UPDATE_VALUE(kColorWriteMasksValue,
                     color_write_masks[0],
                     color_write_masks[1],
                     color_write_masks[2],
                     color_write_masks[3])
    ION_UPDATE_VALUE(kCullFaceModeValue, cull_face_mode)
    ION_UPDATE_VALUE(kDepthWriteMaskValue, depth_write_mask)
    ION_UPDATE_VALUE(kFrontFaceModeValue, front_face_mode)
    ION_UPDATE_VALUE(kDepthFunctionValue, depth_function)
    ION_UPDATE_VALUE(kDepthRangeValue, depth_range)
    ION_UPDATE_VALUE(kDrawBufferValue, draw_buffer);
    if (other.IsValueSet(StateTable::kHintsValue)) {
      for (int i = 0; i < kNumHints; ++i)
        data_.hints[i] = other.data_.hints[i];
    }
    ION_UPDATE_VALUE(kLineWidthValue, line_width)
    ION_UPDATE_VALUE(
        kPolygonOffsetValue, polygon_offset_factor, polygon_offset_units)
    ION_UPDATE_VALUE(
        kSampleCoverageValue, sample_coverage_value, sample_coverage_inverted)
    ION_UPDATE_VALUE(kStencilFunctionsValue,
                     front_stencil_function,
                     back_stencil_function,
                     front_stencil_reference_value,
                     back_stencil_reference_value,
                     front_stencil_mask,
                     back_stencil_mask)
    ION_UPDATE_VALUE(kStencilOperationsValue,
                     front_stencil_fail_op,
                     front_stencil_depth_fail_op,
                     front_stencil_pass_op,
                     back_stencil_fail_op,
                     back_stencil_depth_fail_op,
                     back_stencil_pass_op)
    ION_UPDATE_VALUE(kViewportValue, viewport)
    ION_UPDATE_VALUE(kScissorBoxValue, scissor_box)
    ION_UPDATE_VALUE(kStencilWriteMasksValue,
                     front_stencil_write_mask,
                     back_stencil_write_mask)
  }
}

#undef ION_UPDATE_VALUE
#undef ION_UPDATE_VALUE_
#undef ION_UPDATE_VALUE1
#undef ION_UPDATE_VALUE2
#undef ION_UPDATE_VALUE3
#undef ION_UPDATE_VALUE4
#undef ION_UPDATE_VALUE5
#undef ION_UPDATE_VALUE6


void StateTable::ResetValue(Value value) {
#define ION_COPY_VAL(var) data_.var = default_data.var

  const Data& default_data = GetDefaultData();

  switch (value) {
    case kBlendColorValue:
      ION_COPY_VAL(blend_color);
      break;
    case kBlendEquationsValue:
      ION_COPY_VAL(rgb_blend_equation);
      ION_COPY_VAL(alpha_blend_equation);
      break;
    case kBlendFunctionsValue:
      ION_COPY_VAL(rgb_blend_source_factor);
      ION_COPY_VAL(rgb_blend_destination_factor);
      ION_COPY_VAL(alpha_blend_source_factor);
      ION_COPY_VAL(alpha_blend_destination_factor);
      break;
    case kClearColorValue:
      ION_COPY_VAL(clear_color);
      break;
    case kColorWriteMasksValue:
      for (int i = 0; i < 4; ++i) {
        ION_COPY_VAL(color_write_masks[i]);
      }
      break;
    case kCullFaceModeValue:
      ION_COPY_VAL(cull_face_mode);
      break;
    case kFrontFaceModeValue:
      ION_COPY_VAL(front_face_mode);
      break;
    case kClearDepthValue:
      ION_COPY_VAL(clear_depth_value);
      break;
    case kDepthFunctionValue:
      ION_COPY_VAL(depth_function);
      break;
    case kDepthRangeValue:
      ION_COPY_VAL(depth_range);
      break;
    case kDepthWriteMaskValue:
      ION_COPY_VAL(depth_write_mask);
      break;
    case kDrawBufferValue:
      ION_COPY_VAL(draw_buffer);
      break;
    case kHintsValue:
      for (int i = 0; i < kNumHints; ++i) {
        ION_COPY_VAL(hints[i]);
      }
      break;
    case kLineWidthValue:
      ION_COPY_VAL(line_width);
      break;
    case kPolygonOffsetValue:
      ION_COPY_VAL(polygon_offset_factor);
      ION_COPY_VAL(polygon_offset_units);
      break;
    case kSampleCoverageValue:
      ION_COPY_VAL(sample_coverage_value);
      ION_COPY_VAL(sample_coverage_inverted);
      break;
    case kScissorBoxValue:
      data_.scissor_box.SetWithSize(
          default_data.scissor_box.GetMinPoint(),
          math::Vector2i(default_width_, default_height_));
      break;
    case kStencilFunctionsValue:
      ION_COPY_VAL(front_stencil_function);
      ION_COPY_VAL(back_stencil_function);
      ION_COPY_VAL(front_stencil_reference_value);
      ION_COPY_VAL(back_stencil_reference_value);
      ION_COPY_VAL(front_stencil_mask);
      ION_COPY_VAL(back_stencil_mask);
      break;
    case kStencilOperationsValue:
      ION_COPY_VAL(front_stencil_fail_op);
      ION_COPY_VAL(front_stencil_depth_fail_op);
      ION_COPY_VAL(front_stencil_pass_op);
      ION_COPY_VAL(back_stencil_fail_op);
      ION_COPY_VAL(back_stencil_depth_fail_op);
      ION_COPY_VAL(back_stencil_pass_op);
      break;
    case kClearStencilValue:
      ION_COPY_VAL(clear_stencil_value);
      break;
    case kStencilWriteMasksValue:
      ION_COPY_VAL(front_stencil_write_mask);
      ION_COPY_VAL(back_stencil_write_mask);
      break;
    case kViewportValue:
      data_.viewport.SetWithSize(
          default_data.viewport.GetMinPoint(),
          math::Vector2i(default_width_, default_height_));
      break;
    default:
      DCHECK(false) << "Invalid Value type";
      return;
  }

  data_.values_set.reset(value);

#undef ION_COPY_VAL
}



void StateTable::SetBlendColor(const math::Vector4f& color) {
  data_.blend_color = color;
  data_.values_set.set(kBlendColorValue);
}

void StateTable::SetBlendEquations(BlendEquation rgb_eq,
                                   BlendEquation alpha_eq) {
  data_.rgb_blend_equation = rgb_eq;
  data_.alpha_blend_equation = alpha_eq;
  data_.values_set.set(kBlendEquationsValue);
}

void StateTable::SetBlendFunctions(
    BlendFunctionFactor rgb_source_factor,
    BlendFunctionFactor rgb_destination_factor,
    BlendFunctionFactor alpha_source_factor,
    BlendFunctionFactor alpha_destination_factor) {
  data_.rgb_blend_source_factor = rgb_source_factor;
  data_.rgb_blend_destination_factor = rgb_destination_factor;
  data_.alpha_blend_source_factor = alpha_source_factor;
  data_.alpha_blend_destination_factor = alpha_destination_factor;
  data_.values_set.set(kBlendFunctionsValue);
}



void StateTable::SetClearColor(const math::Vector4f& color) {
  data_.clear_color = color;
  data_.values_set.set(kClearColorValue);
}

void StateTable::SetColorWriteMasks(bool red, bool green,
                                    bool blue, bool alpha) {
  data_.color_write_masks[0] = red;
  data_.color_write_masks[1] = green;
  data_.color_write_masks[2] = blue;
  data_.color_write_masks[3] = alpha;
  data_.values_set.set(kColorWriteMasksValue);
}



void StateTable::SetCullFaceMode(CullFaceMode mode) {
  data_.cull_face_mode = mode;
  data_.values_set.set(kCullFaceModeValue);
}

void StateTable::SetFrontFaceMode(FrontFaceMode mode) {
  data_.front_face_mode = mode;
  data_.values_set.set(kFrontFaceModeValue);
}



void StateTable::SetClearDepthValue(float value) {
  data_.clear_depth_value = value;
  data_.values_set.set(kClearDepthValue);
}

void StateTable::SetDepthFunction(DepthFunction func) {
  data_.depth_function = func;
  data_.values_set.set(kDepthFunctionValue);
}

void StateTable::SetDepthRange(const math::Range1f& range) {
  data_.depth_range = range;
  data_.values_set.set(kDepthRangeValue);
}

void StateTable::SetDepthWriteMask(bool mask) {
  data_.depth_write_mask = mask;
  data_.values_set.set(kDepthWriteMaskValue);
}



void StateTable::SetDrawBuffer(DrawBuffer draw_buffer) {
  data_.draw_buffer = draw_buffer;
  data_.values_set.set(kDrawBufferValue);
}



void StateTable::SetHint(HintTarget target, HintMode mode) {
  data_.hints[target] = mode;
  data_.values_set.set(kHintsValue);
}



void StateTable::SetLineWidth(float width) {
  data_.line_width = width;
  data_.values_set.set(kLineWidthValue);
}



void StateTable::SetPolygonOffset(float factor, float units) {
  data_.polygon_offset_factor = factor;
  data_.polygon_offset_units = units;
  data_.values_set.set(kPolygonOffsetValue);
}



void StateTable::SetSampleCoverage(float value, bool is_inverted) {
  data_.sample_coverage_value = value;
  data_.sample_coverage_inverted = is_inverted;
  data_.values_set.set(kSampleCoverageValue);
}



void StateTable::SetScissorBox(const math::Range2i& box) {
  data_.scissor_box = box;
  data_.values_set.set(kScissorBoxValue);
}



void StateTable::SetStencilFunctions(
    StencilFunction front_func, int front_reference_value, uint32 front_mask,
    StencilFunction back_func, int back_reference_value, uint32 back_mask) {
  data_.front_stencil_function = front_func;
  data_.front_stencil_reference_value = front_reference_value;
  data_.front_stencil_mask = front_mask;
  data_.back_stencil_function = back_func;
  data_.back_stencil_reference_value = back_reference_value;
  data_.back_stencil_mask = back_mask;
  data_.values_set.set(kStencilFunctionsValue);
}

void StateTable::SetStencilOperations(StencilOperation front_stencil_fail,
                                      StencilOperation front_depth_fail,
                                      StencilOperation front_pass,
                                      StencilOperation back_stencil_fail,
                                      StencilOperation back_depth_fail,
                                      StencilOperation back_pass) {
  data_.front_stencil_fail_op = front_stencil_fail;
  data_.front_stencil_depth_fail_op = front_depth_fail;
  data_.front_stencil_pass_op = front_pass;
  data_.back_stencil_fail_op = back_stencil_fail;
  data_.back_stencil_depth_fail_op = back_depth_fail;
  data_.back_stencil_pass_op = back_pass;
  data_.values_set.set(kStencilOperationsValue);
}

void StateTable::SetClearStencilValue(int value) {
  data_.clear_stencil_value = value;
  data_.values_set.set(kClearStencilValue);
}

void StateTable::SetStencilWriteMasks(uint32 front_mask, uint32 back_mask) {
  data_.front_stencil_write_mask = front_mask;
  data_.back_stencil_write_mask = back_mask;
  data_.values_set.set(kStencilWriteMasksValue);
}



void StateTable::SetViewport(const math::Range2i& rect) {
  data_.viewport = rect;
  data_.values_set.set(kViewportValue);
}

void StateTable::SetViewport(int left, int bottom, int width, int height) {
  SetViewport(math::Range2i::BuildWithSize(math::Point2i(left, bottom),
                                           math::Vector2i(width, height)));
}



#define ION_INSTANTIATE_GETENUMSTRING(type) \
  template <> ION_API const char* StateTable::GetEnumString(type value) { \
    return base::EnumHelper::GetString(value); \
  }

ION_INSTANTIATE_GETENUMSTRING(Capability);
ION_INSTANTIATE_GETENUMSTRING(BlendEquation);
ION_INSTANTIATE_GETENUMSTRING(BlendFunctionFactor);
ION_INSTANTIATE_GETENUMSTRING(CullFaceMode);
ION_INSTANTIATE_GETENUMSTRING(DepthFunction);
ION_INSTANTIATE_GETENUMSTRING(FrontFaceMode);
ION_INSTANTIATE_GETENUMSTRING(HintMode);
ION_INSTANTIATE_GETENUMSTRING(StencilFunction);
ION_INSTANTIATE_GETENUMSTRING(StencilOperation);

#undef ION_INSTANTIATE_GETENUMSTRING

}  // namespace gfx



namespace base {

using gfx::StateTable;

#define ION_CHECK_ARRAYS(enums, strings)                        \
  ION_STATIC_ASSERT(ARRAYSIZE(enums) == ARRAYSIZE(strings),     \
                    "Wrong size for " #strings)


template <> ION_API const EnumHelper::EnumData<StateTable::Capability>
EnumHelper::GetEnumData() {
  static const GLenum kCapabilities[] = {
      GL_BLEND,
      GL_CULL_FACE,
      GL_DEBUG_OUTPUT_SYNCHRONOUS,
      GL_DEPTH_TEST,
      GL_DITHER,
      GL_MULTISAMPLE,
      GL_POLYGON_OFFSET_FILL,
      GL_SAMPLE_ALPHA_TO_COVERAGE,
      GL_SAMPLE_COVERAGE,
      GL_SCISSOR_TEST,
      GL_STENCIL_TEST,
  };
  static const char* kCapabilityStrings[] = {
      "Blend",
      "CullFace",
      "DebugOutputSynchronous",
      "DepthTest",
      "Dither",
      "Multisample",
      "PolygonOffsetFill",
      "SampleAlphaToCoverage",
      "SampleCoverage",
      "ScissorTest",
      "StencilTest",
  };
  ION_CHECK_ARRAYS(kCapabilities, kCapabilityStrings);
  return EnumData<StateTable::Capability>(
      base::IndexMap<StateTable::Capability, GLenum>(
          kCapabilities, ARRAYSIZE(kCapabilities)),
      kCapabilityStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::BlendEquation>
EnumHelper::GetEnumData() {
  static const GLenum kBlendEquations[] = {
    GL_FUNC_ADD, GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT
  };
  static const char* kBlendEquationStrings[] = {
    "Add", "ReverseSubtract", "Subtract",
  };
  ION_CHECK_ARRAYS(kBlendEquations, kBlendEquationStrings);
  return EnumData<StateTable::BlendEquation>(
      base::IndexMap<StateTable::BlendEquation, GLenum>(
          kBlendEquations, ARRAYSIZE(kBlendEquations)),
      kBlendEquationStrings);
}

template <> ION_API
const EnumHelper::EnumData<StateTable::BlendFunctionFactor>
EnumHelper::GetEnumData() {
  static const GLenum kBlendFunctionFactors[] = {
    GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR, GL_DST_ALPHA, GL_DST_COLOR, GL_ONE,
    GL_ONE_MINUS_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_COLOR,
    GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA,
    GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA_SATURATE, GL_SRC_COLOR,
    GL_ZERO
  };
  static const char* kBlendFunctionFactorStrings[] = {
    "ConstantAlpha", "ConstantColor", "DstAlpha", "DstColor", "One",
    "OneMinusConstantAlpha", "OneMinusConstantColor", "OneMinusDstAlpha",
    "OneMinusDstColor", "OneMinusSrcAlpha", "OneMinusSrcColor", "SrcAlpha",
    "SrcAlphaSaturate", "SrcColor", "Zero"
  };
  ION_CHECK_ARRAYS(kBlendFunctionFactors, kBlendFunctionFactorStrings);
  return EnumData<StateTable::BlendFunctionFactor>(
      base::IndexMap<StateTable::BlendFunctionFactor, GLenum>(
          kBlendFunctionFactors, ARRAYSIZE(kBlendFunctionFactors)),
      kBlendFunctionFactorStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::CullFaceMode>
EnumHelper::GetEnumData() {
  static const GLenum kCullFaceModes[] = {
    GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
  };
  static const char* kCullFaceModeStrings[] = {
    "CullFront", "CullBack", "CullFrontAndBack",
  };
  ION_CHECK_ARRAYS(kCullFaceModes, kCullFaceModeStrings);
  return EnumData<StateTable::CullFaceMode>(
      base::IndexMap<StateTable::CullFaceMode, GLenum>(
          kCullFaceModes, ARRAYSIZE(kCullFaceModes)),
      kCullFaceModeStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::DepthFunction>
EnumHelper::GetEnumData() {
  static const GLenum kDepthFunctions[] = {
    GL_ALWAYS, GL_EQUAL, GL_GREATER, GL_GEQUAL,
    GL_LESS, GL_LEQUAL, GL_NEVER, GL_NOTEQUAL
  };
  static const char* kDepthFunctionStrings[] = {
    "DepthAlways", "DepthEqual", "DepthGreater", "DepthGreaterOrEqual",
    "DepthLess", "DepthLessOrEqual", "DepthNever", "DepthNotEqual"
  };
  ION_CHECK_ARRAYS(kDepthFunctions, kDepthFunctionStrings);
  return EnumData<StateTable::DepthFunction>(
      base::IndexMap<StateTable::DepthFunction, GLenum>(
          kDepthFunctions, ARRAYSIZE(kDepthFunctions)),
      kDepthFunctionStrings);
}

template <>
ION_API const EnumHelper::EnumData<StateTable::DrawBuffer>
EnumHelper::GetEnumData() {
  static const GLenum kDrawBuffers[] = {
    GL_BACK, GL_BACK_LEFT, GL_BACK_RIGHT, GL_FRONT, GL_FRONT_AND_BACK,
    GL_FRONT_LEFT, GL_FRONT_RIGHT, GL_LEFT, GL_NONE, GL_RIGHT};
  static const char* kDrawBufferStrings[] = {
    "Back", "BackLeft", "BackRight", "Front", "FrontAndBack",
    "FrontLeft", "FrontRight", "Left", "None", "Right"};
  ION_CHECK_ARRAYS(kDrawBuffers, kDrawBufferStrings);
  return EnumData<StateTable::DrawBuffer>(
      base::IndexMap<StateTable::DrawBuffer, GLenum>(kDrawBuffers,
                                                     ARRAYSIZE(kDrawBuffers)),
      kDrawBufferStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::FrontFaceMode>
EnumHelper::GetEnumData() {
  static const GLenum kFrontFaceModes[] = { GL_CW, GL_CCW };
  static const char* kFrontFaceModeStrings[] = {
    "Clockwise", "CounterClockwise"
  };
  ION_CHECK_ARRAYS(kFrontFaceModes, kFrontFaceModeStrings);
  return EnumData<StateTable::FrontFaceMode>(
      base::IndexMap<StateTable::FrontFaceMode, GLenum>(
          kFrontFaceModes, ARRAYSIZE(kFrontFaceModes)),
      kFrontFaceModeStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::HintMode>
EnumHelper::GetEnumData() {
  static const GLenum kHintModes[] = { GL_FASTEST, GL_NICEST, GL_DONT_CARE };
  static const char* kHintModeStrings[] = {
    "HintFastest", "HintNicest", "HintDontCare"
  };
  ION_CHECK_ARRAYS(kHintModes, kHintModeStrings);
  return EnumData<StateTable::HintMode>(
      base::IndexMap<StateTable::HintMode, GLenum>(
          kHintModes, ARRAYSIZE(kHintModes)),
      kHintModeStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::StencilFunction>
EnumHelper::GetEnumData() {
  static const GLenum kStencilFunctions[] = {
    GL_ALWAYS, GL_EQUAL, GL_GREATER, GL_GEQUAL,
    GL_LESS, GL_LEQUAL, GL_NEVER, GL_NOTEQUAL
  };
  static const char* kStencilFunctionStrings[] = {
    "StencilAlways", "StencilEqual", "StencilGreater", "StencilGreaterOrEqual",
    "StencilLess", "StencilLessOrEqual", "StencilNever", "StencilNotEqual"
  };
  ION_CHECK_ARRAYS(kStencilFunctions, kStencilFunctionStrings);
  return EnumData<StateTable::StencilFunction>(
      base::IndexMap<StateTable::StencilFunction, GLenum>(
          kStencilFunctions, ARRAYSIZE(kStencilFunctions)),
      kStencilFunctionStrings);
}

template <> ION_API const EnumHelper::EnumData<StateTable::StencilOperation>
EnumHelper::GetEnumData() {
  static const GLenum kStencilOperations[] = {
    GL_DECR, GL_DECR_WRAP, GL_INCR, GL_INCR_WRAP,
    GL_INVERT, GL_KEEP, GL_REPLACE, GL_ZERO
  };
  static const char* kStencilOperationStrings[] = {
    "StencilDecrement", "StencilDecrementAndWrap", "StencilIncrement",
    "StencilIncrementAndWrap", "StencilInvert", "StencilKeep",
    "StencilReplace", "StencilZero"
  };
  ION_CHECK_ARRAYS(kStencilOperations, kStencilOperationStrings);
  return EnumData<StateTable::StencilOperation>(
      base::IndexMap<StateTable::StencilOperation, GLenum>(
          kStencilOperations, ARRAYSIZE(kStencilOperations)),
      kStencilOperationStrings);
}

#undef ION_CHECK_ARRAYS

}  // namespace base

namespace gfx {



const StateTable::Data& StateTable::GetDefaultData() {
  static const StateTable::Data default_data(true);
  return default_data;
}

StateTable::Data::Data(bool unused) {
  capabilities.reset();
  capabilities.set(kDither);

  capabilities_set.reset();
  values_set.reset();

  is_enforced = false;

  blend_color.Set(0.0f, 0.0f, 0.0f, 0.0f);
  rgb_blend_equation = alpha_blend_equation = kAdd;
  rgb_blend_source_factor = alpha_blend_source_factor = kOne;
  rgb_blend_destination_factor = alpha_blend_destination_factor = kZero;
  clear_color.Set(0.0f, 0.0f, 0.0f, 0.0f);
  color_write_masks[0] = color_write_masks[1] =
      color_write_masks[2] = color_write_masks[3] = true;
  cull_face_mode = kCullBack;
  front_face_mode = kCounterClockwise;
  clear_depth_value = 1.0f;
  depth_function = kDepthLess;
  depth_range.Set(0.0f, 1.0f);
  depth_write_mask = true;
  draw_buffer = kBack;
  hints[kGenerateMipmapHint] = kHintDontCare;
  line_width = 1.0f;
  polygon_offset_factor = 0.0f;
  polygon_offset_units = 0.0f;
  sample_coverage_value = 1.0f;
  sample_coverage_inverted = false;
  scissor_box.Set(math::Point2i::Zero(), math::Point2i::Zero());
  front_stencil_function = back_stencil_function = kStencilAlways;
  front_stencil_reference_value = back_stencil_reference_value = 0;
  front_stencil_mask = back_stencil_mask = 0xffffffff;
  front_stencil_fail_op = front_stencil_depth_fail_op =
      front_stencil_pass_op = back_stencil_fail_op =
      back_stencil_depth_fail_op = back_stencil_pass_op = kStencilKeep;
  clear_stencil_value = 0;
  front_stencil_write_mask = back_stencil_write_mask = 0xffffffff;
  viewport.Set(math::Point2i::Zero(), math::Point2i::Zero());
}

}  // namespace gfx
}  // namespace ion