openglobjects.h

Go to the documentation of this file.

#ifndef ION_GFX_OPENGLOBJECTS_H_
#define ION_GFX_OPENGLOBJECTS_H_

#include <vector>

#include "ion/base/variant.h"
#include "ion/math/matrix.h"
#include "ion/math/vector.h"
#include "ion/portgfx/glheaders.h"

namespace ion {
namespace gfx {

template <typename T>
struct ArrayInfo : T {
  struct Attribute {
    Attribute()
        : buffer(0U),
          enabled(GL_FALSE),
          size(4U),
          stride(0U),
          type(GL_FLOAT),
          normalized(GL_FALSE),
          pointer(NULL),
          value(0.f, 0.f, 0.f, 1.f),
          divisor(0U) {}
    GLuint buffer;
    GLboolean enabled;
    GLuint size;
    GLuint stride;
    GLenum type;
    GLboolean normalized;
    GLvoid* pointer;
    math::Vector4f value;
    GLuint divisor;
  };
  std::vector<Attribute> attributes;
};

template <typename T>
struct BufferInfo : T {
  BufferInfo()
      : size(-1),
        usage(0),
        mapped_data(NULL) {}
  GLsizeiptr size;
  GLenum usage;
  GLvoid* mapped_data;
};

template <typename T>
struct FramebufferInfo : T {
  struct Attachment {
    Attachment() : type(GL_NONE), value(0), level(0), cube_face(0) {}
    GLenum type;
    GLuint value;
    GLuint level;
    GLenum cube_face;
  };
  FramebufferInfo() {}
  Attachment color0;
  Attachment depth;
  Attachment stencil;
};

template <typename T>
struct ProgramInfo : T {
  struct Attribute {
    Attribute() : index(0), type(GL_NONE), size(0U) {}
    GLint index;
    std::vector<GLint> array_indices;
    GLenum type;
    GLint size;
    std::string name;
  };
  struct Uniform {
    typedef base::Variant<
        int, uint32, float,
        math::VectorBase2f, math::VectorBase3f, math::VectorBase4f,
        math::VectorBase2i, math::VectorBase3i, math::VectorBase4i,
        math::VectorBase2ui, math::VectorBase3ui, math::VectorBase4ui,
        math::Matrix2f, math::Matrix3f, math::Matrix4f> ValueType;
    Uniform() : index(0U), type(GL_FLOAT), size(0U) {}
    GLint index;
    std::vector<GLint> array_indices;
    GLenum type;
    GLint size;
    ValueType value;
    std::string name;
  };
  struct Varying {
    Varying() : index(0), type(GL_NONE), size(0U) {}
    GLint index;
    std::vector<GLint> array_indices;
    GLenum type;
    GLint size;
    std::string name;
  };
  ProgramInfo()
      : vertex_shader(0U),
        fragment_shader(0U),
        delete_status(GL_FALSE),
        link_status(GL_FALSE),
        validate_status(GL_FALSE) {}
  GLuint vertex_shader;
  GLuint fragment_shader;
  std::vector<Attribute> attributes;
  std::vector<Uniform> uniforms;
  std::vector<Varying> varyings;
  GLboolean delete_status;
  GLboolean link_status;
  GLboolean validate_status;
  std::string info_log;
};

template <typename T>
struct RenderbufferInfo : T {
  RenderbufferInfo()
      : width(0),
        height(0),
        internal_format(GL_RGBA4),
        red_size(0),
        green_size(0),
        blue_size(0),
        alpha_size(0),
        depth_size(0),
        stencil_size(0),
        multisample_samples(0) {}
  GLsizei width;
  GLsizei height;
  GLenum internal_format;
  GLsizei red_size;
  GLsizei green_size;
  GLsizei blue_size;
  GLsizei alpha_size;
  GLsizei depth_size;
  GLsizei stencil_size;
  GLsizei multisample_samples;
};

template <typename T>
struct SamplerInfo : T {
  SamplerInfo()
      : compare_func(GL_LESS),
        compare_mode(GL_NONE),
        max_anisotropy(1.f),
        min_lod(-1000.f),
        max_lod(1000.f),
        min_filter(GL_NEAREST_MIPMAP_LINEAR),
        mag_filter(GL_LINEAR),
        wrap_r(GL_REPEAT),
        wrap_s(GL_REPEAT),
        wrap_t(GL_REPEAT) {}
  GLenum compare_func;
  GLenum compare_mode;
  GLfloat max_anisotropy;
  GLfloat min_lod;
  GLfloat max_lod;
  GLenum min_filter;
  GLenum mag_filter;
  GLenum wrap_r;
  GLenum wrap_s;
  GLenum wrap_t;
};

template <typename T>
struct ShaderInfo : T {
  ShaderInfo()
      : type(static_cast<GLenum>(-1)),
        delete_status(GL_FALSE),
        compile_status(GL_FALSE) {}
  GLenum type;
  GLboolean delete_status;
  GLboolean compile_status;
  std::string source;
  std::string info_log;
};

template <typename T>
struct SyncInfo : T {
  SyncInfo()
      : type(static_cast<GLenum>(-1)),
        status(static_cast<GLenum>(-1)),
        condition(static_cast<GLenum>(-1)),
        flags(0) {}
  GLenum type;
  GLenum status;
  GLenum condition;
  GLbitfield flags;
};

template <typename T>
struct TransformFeedbackInfo : T {
  TransformFeedbackInfo()
      : target(GL_TRANSFORM_FEEDBACK_BUFFER),
        varyings(nullptr),
        status(static_cast<GLenum>(-1)),
        primitive_count(0) {}
  GLenum target;
  const char** varyings;
  GLenum status;
  GLuint primitive_count;
};

template <typename T>
struct TextureInfo : T {
  TextureInfo()
      : base_level(0),
        max_level(1000),
        compare_func(GL_LESS),
        compare_mode(GL_NONE),
        max_anisotropy(1.f),
        min_lod(-1000.f),
        max_lod(1000.f),
        min_filter(GL_NEAREST_MIPMAP_LINEAR),
        mag_filter(GL_LINEAR),
        samples(0),
        fixed_sample_locations(true),
        swizzle_r(GL_RED),
        swizzle_g(GL_GREEN),
        swizzle_b(GL_BLUE),
        swizzle_a(GL_ALPHA),
        wrap_r(GL_REPEAT),
        wrap_s(GL_REPEAT),
        wrap_t(GL_REPEAT),
        target(static_cast<GLenum>(-1))
  {}
  GLint base_level;
  GLint max_level;
  GLenum compare_func;
  GLenum compare_mode;
  GLfloat max_anisotropy;
  GLfloat min_lod;
  GLfloat max_lod;
  GLenum min_filter;
  GLenum mag_filter;
  GLuint samples;
  GLboolean fixed_sample_locations;
  GLenum swizzle_r;
  GLenum swizzle_g;
  GLenum swizzle_b;
  GLenum swizzle_a;
  GLenum wrap_r;
  GLenum wrap_s;
  GLenum wrap_t;
  GLenum target;
};

template <typename T>
struct TimerInfo : T {
  TimerInfo()
      : mode(kNone),
        timestamp(0),
        duration(0),
        deleted(false),
        is_data_available(false) {}
  enum Mode {
    kNone,
    kIsQueryCounter,
    kIsBeginEndQuery,
  };
  Mode mode;
  uint64 timestamp;
  uint64 duration;
  bool deleted;
  bool is_data_available;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_OPENGLOBJECTS_H_