shape.h

Go to the documentation of this file.

#ifndef ION_GFX_SHAPE_H_
#define ION_GFX_SHAPE_H_

#include <string>

#include "ion/base/referent.h"
#include "ion/gfx/attributearray.h"
#include "ion/gfx/indexbuffer.h"
#include "ion/math/range.h"

namespace ion {
namespace gfx {

class ION_API Shape : public base::Referent {
 public:
  enum PrimitiveType {
    kLines,
    kLineLoop,
    kLineStrip,
    kPoints,
    kTriangles,  // Default.
    kTriangleFan,
    kTriangleStrip,
  };

  Shape();

  const std::string& GetLabel() const { return label_; }
  void SetLabel(const std::string& label) { label_ = label; }

  void SetPrimitiveType(PrimitiveType type) { primitive_type_ = type; }
  PrimitiveType GetPrimitiveType() const { return primitive_type_; }

  void SetAttributeArray(const AttributeArrayPtr& attribute_array) {
    attribute_array_ = attribute_array;
  }
  const AttributeArrayPtr& GetAttributeArray() const {
    return attribute_array_;
  }

  void SetIndexBuffer(const IndexBufferPtr& index_buffer) {
    index_buffer_ = index_buffer;
  }
  const IndexBufferPtr& GetIndexBuffer() const {
    return index_buffer_;
  }

  size_t AddVertexRange(const math::Range1i& range);
  void SetVertexRange(size_t i, const math::Range1i& range);
  void ClearVertexRanges() { vertex_ranges_.clear(); }
  const math::Range1i GetVertexRange(size_t i) const;
  size_t GetVertexRangeCount() const { return vertex_ranges_.size(); }
  void EnableVertexRange(size_t i, bool enable);
  bool IsVertexRangeEnabled(size_t i) const;

  void SetInstanceCount(int count) { instance_count_ = count; }
  int GetInstanceCount() const { return instance_count_; }

  void SetVertexRangeInstanceCount(size_t i, int instance_count);
  int GetVertexRangeInstanceCount(size_t i) const;

 protected:
  ~Shape() override;

 private:
  struct VertexRange {
    VertexRange() : is_enabled(false), instance_count(0) {}  // For STL only.
    VertexRange(const math::Range1i& range_in, bool is_enabled_in,
                int instance_count_in)
        : range(range_in),
          is_enabled(is_enabled_in),
          instance_count(instance_count_in) {}
    math::Range1i range;
    bool is_enabled;
    int instance_count;
  };

  bool CheckRangeIndex(size_t i, const char* name) const;

  PrimitiveType primitive_type_;
  AttributeArrayPtr attribute_array_;
  IndexBufferPtr index_buffer_;
  base::AllocVector<VertexRange> vertex_ranges_;
  int instance_count_;
  std::string label_;
};

typedef base::ReferentPtr<Shape>::Type ShapePtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_SHAPE_H_