statetable.h

Go to the documentation of this file.

#ifndef ION_GFX_STATETABLE_H_
#define ION_GFX_STATETABLE_H_

#include <bitset>

#include "base/integral_types.h"
#include "ion/base/referent.h"
#include "ion/math/range.h"
#include "ion/math/vector.h"

namespace ion {
namespace gfx {

class ION_API StateTable : public base::Referent {
 public:


  enum Capability {
    kBlend,                   // Corresponds to GL_BLEND.
    kCullFace,                // Corresponds to GL_CULL_FACE.
    kDebugOutputSynchronous,  // Corresponds to GL_DEBUG_OUTPUT_SYNCHRONOUS
    kDepthTest,               // Corresponds to GL_DEPTH_TEST.
    kDither,                  // Corresponds to GL_DITHER.
    kMultisample,             // Corresponds to GL_MULTISAMPLE.
    kPolygonOffsetFill,       // Corresponds to GL_POLYGON_OFFSET_FILL.
    kSampleAlphaToCoverage,   // Corresponds to GL_SAMPLE_ALPHA_TO_COVERAGE.
    kSampleCoverage,          // Corresponds to GL_SAMPLE_COVERAGE.
    kScissorTest,             // Corresponds to GL_SCISSOR_TEST.
    kStencilTest,             // Corresponds to GL_STENCIL_TEST.
    kNumCapabilities,         // The number of supported capabilities.
  };

  enum Value {
    kBlendColorValue,
    kBlendEquationsValue,
    kBlendFunctionsValue,
    kClearColorValue,
    kClearDepthValue,
    kClearStencilValue,
    kColorWriteMasksValue,
    kCullFaceModeValue,
    kFrontFaceModeValue,
    kDepthFunctionValue,
    kDepthRangeValue,
    kDepthWriteMaskValue,
    kDrawBufferValue,
    kHintsValue,
    kLineWidthValue,
    kPolygonOffsetValue,
    kSampleCoverageValue,
    kScissorBoxValue,
    kStencilFunctionsValue,
    kStencilOperationsValue,
    kStencilWriteMasksValue,
    kViewportValue,
    kNumValues,
  };



  enum BlendEquation {
    kAdd,                    // Corresponds to GL_FUNC_ADD.
    kReverseSubtract,        // Corresponds to GL_FUNC_REVERSE_SUBTRACT.
    kSubtract,               // Corresponds to GL_FUNC_SUBTRACT
  };

  enum BlendFunctionFactor {
    kConstantAlpha,          // Corresponds to GL_CONSTANT_ALPHA.
    kConstantColor,          // Corresponds to GL_CONSTANT_COLOR.
    kDstAlpha,               // Corresponds to GL_DST_ALPHA.
    kDstColor,               // Corresponds to GL_DST_COLOR.
    kOne,                    // Corresponds to GL_ONE.
    kOneMinusConstantAlpha,  // Corresponds to GL_ONE_MINUS_CONSTANT_ALPHA.
    kOneMinusConstantColor,  // Corresponds to GL_ONE_MINUS_CONSTANT_COLOR.
    kOneMinusDstAlpha,       // Corresponds to GL_ONE_MINUS_DST_ALPHA.
    kOneMinusDstColor,       // Corresponds to GL_ONE_MINUS_DST_COLOR.
    kOneMinusSrcAlpha,       // Corresponds to GL_ONE_MINUS_SRC_ALPHA.
    kOneMinusSrcColor,       // Corresponds to GL_ONE_MINUS_SRC_COLOR.
    kSrcAlpha,               // Corresponds to GL_SRC_ALPHA.
    kSrcAlphaSaturate,       // Corresponds to GL_SRC_ALPHA_SATURATE.
    kSrcColor,               // Corresponds to GL_SRC_COLOR.
    kZero,                   // Corresponds to GL_ZERO.
  };

  enum ClearMaskBit {
    kClearColorBufferBit,    // Corresponds to GL_COLOR_BUFFER_BIT.
    kClearDepthBufferBit,    // Corresponds to GL_DEPTH_BUFFER_BIT.
    kClearStencilBufferBit,  // Corresponds to GL_STENCIL_BUFFER_BIT.
  };

  enum CullFaceMode {
    kCullFront,              // Corresponds to GL_FRONT.
    kCullBack,               // Corresponds to GL_BACK.
    kCullFrontAndBack,       // Corresponds to GL_FRONT_AND_BACK.
  };

  enum DepthFunction {
    kDepthAlways,            // Corresponds to GL_ALWAYS.
    kDepthEqual,             // Corresponds to GL_EQUAL.
    kDepthGreater,           // Corresponds to GL_GREATER.
    kDepthGreaterOrEqual,    // Corresponds to GL_GEQUAL.
    kDepthLess,              // Corresponds to GL_LESS.
    kDepthLessOrEqual,       // Corresponds to GL_LEQUAL.
    kDepthNever,             // Corresponds to GL_NEVER.
    kDepthNotEqual,          // Corresponds to GL_NOTEQUAL.
  };

  enum DrawBuffer {
    kBack,          // Corresponds to GL_BACK.
    kBackLeft,      // Corresponds to GL_BACK_LEFT.
    kBackRight,     // Corresponds to GL_BACK_RIGHT.
    kFront,         // Corresponds to GL_FRONT.
    kFrontAndBack,  // Corresponds to GL_FRONT_AND_BACK.
    kFrontLeft,     // Corresponds to GL_FRONT_LEFT.
    kFrontRight,    // Corresponds to GL_FRONT_RIGHT.
    kLeft,          // Corresponds to GL_LEFT.
    kNone,          // Corresponds to GL_NONE.
    kRight,         // Corresponds to GL_RIGHT.
};

  enum FrontFaceMode {
    kClockwise,              // Corresponds to GL_CW.
    kCounterClockwise,       // Corresponds to GL_CCW.
  };

  enum HintMode {
    kHintFastest,            // Corresponds to GL_FASTEST.
    kHintNicest,             // Corresponds to GL_NICEST.
    kHintDontCare,           // Corresponds to GL_DONT_CARE.
  };

  enum HintTarget {
    kGenerateMipmapHint,     // Corresponds to GL_GENERATE_MIPMAP_HINT.
  };

  enum StencilFunction {
    kStencilAlways,          // Corresponds to GL_ALWAYS.
    kStencilEqual,           // Corresponds to GL_EQUAL.
    kStencilGreater,         // Corresponds to GL_GREATER.
    kStencilGreaterOrEqual,  // Corresponds to GL_GEQUAL.
    kStencilLess,            // Corresponds to GL_LESS.
    kStencilLessOrEqual,     // Corresponds to GL_LEQUAL.
    kStencilNever,           // Corresponds to GL_NEVER.
    kStencilNotEqual,        // Corresponds to GL_NOTEQUAL.
  };

  enum StencilOperation {
    kStencilDecrement,         // Corresponds to GL_DECR.
    kStencilDecrementAndWrap,  // Corresponds to GL_DECR_WRAP.
    kStencilIncrement,         // Corresponds to GL_INCR.
    kStencilIncrementAndWrap,  // Corresponds to GL_INCR_WRAP.
    kStencilInvert,            // Corresponds to GL_INVERT.
    kStencilKeep,              // Corresponds to GL_KEEP.
    kStencilReplace,           // Corresponds to GL_REPLACE.
    kStencilZero,              // Corresponds to GL_ZERO.
  };



  StateTable()
      : default_width_(0),
        default_height_(0) {
    Reset();
  }
  StateTable(int default_width, int default_height)
      : default_width_(default_width),
        default_height_(default_height) {
    Reset();
  }

  void Reset();

  void ResetSetState() {
    data_.capabilities_set.reset();
    data_.values_set.reset();
  }

  void MarkAllSet() {
    data_.capabilities_set.set();
    data_.values_set.set();
  }

  void CopyFrom(const StateTable& other);

  void MergeValuesFrom(const StateTable& other,
                       const StateTable& state_to_test);

  void MergeNonClearValuesFrom(const StateTable& other,
                               const StateTable& state_to_test);




  void Enable(Capability capability, bool is_enabled) {
    data_.capabilities.set(capability, is_enabled);
    data_.capabilities_set.set(capability);
  }

  bool IsEnabled(Capability capability) const {
    return data_.capabilities.test(capability);
  }

  size_t GetEnabledCount() const {
    return data_.capabilities.count();
  }

  void ResetCapability(Capability capability) {
    if (capability == kDither)
      data_.capabilities.set(capability);
    else
      data_.capabilities.reset(capability);
    data_.capabilities_set.reset(capability);
  }

  bool IsCapabilitySet(Capability capability) const {
    return data_.capabilities_set.test(capability);
  }

  size_t GetSetCapabilityCount() const {
    return data_.capabilities_set.count();
  }

  static bool AreCapabilitiesSame(const StateTable& st0,
                                  const StateTable& st1) {
    return st0.data_.capabilities == st1.data_.capabilities;
  }

  static int GetCapabilityCount() { return kNumCapabilities; }



  void ResetValue(Value value);

  bool IsValueSet(Value value) const {
    return data_.values_set.test(value);
  }

  size_t GetSetValueCount() const {
    return data_.values_set.count();
  }

  static int GetValueCount() { return kNumValues; }


  void SetEnforceSettings(bool enforced) { data_.is_enforced = enforced; }
  bool AreSettingsEnforced() const { return data_.is_enforced; }



  void SetBlendColor(const math::Vector4f& color);
  const math::Vector4f& GetBlendColor() const { return data_.blend_color; }

  void SetBlendEquations(BlendEquation rgb_eq, BlendEquation alpha_eq);
  BlendEquation GetRgbBlendEquation() const { return data_.rgb_blend_equation; }
  BlendEquation GetAlphaBlendEquation() const {
    return data_.alpha_blend_equation;
  }

  void SetBlendFunctions(BlendFunctionFactor rgb_source_factor,
                         BlendFunctionFactor rgb_destination_factor,
                         BlendFunctionFactor alpha_source_factor,
                         BlendFunctionFactor alpha_destination_factor);
  BlendFunctionFactor GetRgbBlendFunctionSourceFactor() const {
    return data_.rgb_blend_source_factor;
  }
  BlendFunctionFactor GetRgbBlendFunctionDestinationFactor() const {
    return data_.rgb_blend_destination_factor;
  }
  BlendFunctionFactor GetAlphaBlendFunctionSourceFactor() const {
    return data_.alpha_blend_source_factor;
  }
  BlendFunctionFactor GetAlphaBlendFunctionDestinationFactor() const {
    return data_.alpha_blend_destination_factor;
  }



  void SetClearColor(const math::Vector4f& color);
  const math::Vector4f& GetClearColor() const { return data_.clear_color; }

  void SetClearDepthValue(float value);
  float GetClearDepthValue() const { return data_.clear_depth_value; }

  void SetClearStencilValue(int value);
  int GetClearStencilValue() const { return data_.clear_stencil_value; }



  void SetColorWriteMasks(bool red, bool green, bool blue, bool alpha);
  bool GetRedColorWriteMask() const { return data_.color_write_masks[0]; }
  bool GetGreenColorWriteMask() const { return data_.color_write_masks[1]; }
  bool GetBlueColorWriteMask() const { return data_.color_write_masks[2]; }
  bool GetAlphaColorWriteMask() const { return data_.color_write_masks[3]; }



  void SetCullFaceMode(CullFaceMode mode);
  CullFaceMode GetCullFaceMode() const { return data_.cull_face_mode; }

  void SetFrontFaceMode(FrontFaceMode mode);
  FrontFaceMode GetFrontFaceMode() const { return data_.front_face_mode; }



  void SetDepthFunction(DepthFunction func);
  DepthFunction GetDepthFunction() const { return data_.depth_function; }

  void SetDepthRange(const math::Range1f& range);
  const math::Range1f& GetDepthRange() const { return data_.depth_range; }

  void SetDepthWriteMask(bool mask);
  bool GetDepthWriteMask() const { return data_.depth_write_mask; }



  void SetDrawBuffer(DrawBuffer draw_buffer);
  DrawBuffer GetDrawBuffer() const { return data_.draw_buffer; }



  void SetHint(HintTarget target, HintMode mode);
  HintMode GetHint(HintTarget target) const { return data_.hints[target]; }



  void SetLineWidth(float width);
  float GetLineWidth() const { return data_.line_width; }



  void SetPolygonOffset(float factor, float units);
  float GetPolygonOffsetFactor() const { return data_.polygon_offset_factor; }
  float GetPolygonOffsetUnits() const { return data_.polygon_offset_units; }



  void SetSampleCoverage(float value, bool is_inverted);
  float GetSampleCoverageValue() const { return data_.sample_coverage_value; }
  bool IsSampleCoverageInverted() const {
    return data_.sample_coverage_inverted;
  }



  void SetScissorBox(const math::Range2i& box);
  const math::Range2i& GetScissorBox() const { return data_.scissor_box; }



  void SetStencilFunctions(
      StencilFunction front_func, int front_reference_value, uint32 front_mask,
      StencilFunction back_func, int back_reference_value, uint32 back_mask);
  StencilFunction GetFrontStencilFunction() const {
    return data_.front_stencil_function;
  }
  StencilFunction GetBackStencilFunction() const {
    return data_.back_stencil_function;
  }
  int GetFrontStencilReferenceValue() const {
    return data_.front_stencil_reference_value;
  }
  int GetBackStencilReferenceValue() const {
    return data_.back_stencil_reference_value;
  }
  uint32 GetFrontStencilMask() const { return data_.front_stencil_mask; }
  uint32 GetBackStencilMask() const { return data_.back_stencil_mask; }

  void SetStencilOperations(StencilOperation front_stencil_fail,
                            StencilOperation front_depth_fail,
                            StencilOperation front_pass,
                            StencilOperation back_stencil_fail,
                            StencilOperation back_depth_fail,
                            StencilOperation back_pass);
  StencilOperation GetFrontStencilFailOperation() const {
    return data_.front_stencil_fail_op;
  }
  StencilOperation GetFrontStencilDepthFailOperation() const {
    return data_.front_stencil_depth_fail_op;
  }
  StencilOperation GetFrontStencilPassOperation() const {
    return data_.front_stencil_pass_op;
  }
  StencilOperation GetBackStencilFailOperation() const {
    return data_.back_stencil_fail_op;
  }
  StencilOperation GetBackStencilDepthFailOperation() const {
    return data_.back_stencil_depth_fail_op;
  }
  StencilOperation GetBackStencilPassOperation() const {
    return data_.back_stencil_pass_op;
  }

  void SetStencilWriteMasks(uint32 front_mask, uint32 back_mask);
  uint32 GetFrontStencilWriteMask() const {
    return data_.front_stencil_write_mask;
  }
  uint32 GetBackStencilWriteMask() const {
    return data_.back_stencil_write_mask;
  }



  void SetViewport(const math::Range2i& rect);
  void SetViewport(int left, int bottom, int width, int height);
  const math::Range2i& GetViewport() const { return data_.viewport; }


  template <typename EnumType> static const char* GetEnumString(EnumType value);

 protected:
  ~StateTable() override;

 private:
  static const int kNumStateValues = kViewportValue + 1;

  static const int kNumClearMaskBits = kClearStencilBufferBit + 1;

  static const int kNumHints = kGenerateMipmapHint + 1;

  struct Data {
    Data() {}

    explicit Data(bool unused);

    std::bitset<kNumCapabilities> capabilities_set;

    std::bitset<kNumStateValues> values_set;

    std::bitset<kNumCapabilities> capabilities;

    bool is_enforced;

    math::Vector4f blend_color;
    BlendEquation rgb_blend_equation;
    BlendEquation alpha_blend_equation;
    BlendFunctionFactor rgb_blend_source_factor;
    BlendFunctionFactor rgb_blend_destination_factor;
    BlendFunctionFactor alpha_blend_source_factor;
    BlendFunctionFactor alpha_blend_destination_factor;

    math::Vector4f clear_color;
    float clear_depth_value;
    int clear_stencil_value;

    bool color_write_masks[4];  // Red, green, blue, alpha.

    CullFaceMode cull_face_mode;
    FrontFaceMode front_face_mode;

    DepthFunction depth_function;
    math::Range1f depth_range;
    bool depth_write_mask;

    DrawBuffer draw_buffer;

    HintMode hints[kNumHints];

    float line_width;

    float polygon_offset_factor;
    float polygon_offset_units;

    float sample_coverage_value;
    bool sample_coverage_inverted;

    math::Range2i scissor_box;

    StencilFunction front_stencil_function;
    StencilFunction back_stencil_function;
    int front_stencil_reference_value;
    int back_stencil_reference_value;
    uint32 front_stencil_mask;
    uint32 back_stencil_mask;
    StencilOperation front_stencil_fail_op;
    StencilOperation front_stencil_depth_fail_op;
    StencilOperation front_stencil_pass_op;
    StencilOperation back_stencil_fail_op;
    StencilOperation back_stencil_depth_fail_op;
    StencilOperation back_stencil_pass_op;
    uint32 front_stencil_write_mask;
    uint32 back_stencil_write_mask;

    math::Range2i viewport;
  };

  static const Data& GetDefaultData();

  int default_width_;
  int default_height_;

  Data data_;
};

typedef base::ReferentPtr<StateTable>::Type StateTablePtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_STATETABLE_H_