geometry_resource.hpp

// Copyright [2015] Albert Huang

#ifndef SCENEVIEW_GEOMETRY_RESOURCE_HPP__
#define SCENEVIEW_GEOMETRY_RESOURCE_HPP__

#include <cstdint>
#include <memory>
#include <vector>

#include <QString>
#include <QVector2D>
#include <QVector3D>
#include <QVector4D>
#include <QOpenGLBuffer>

#include <sceneview/axis_aligned_box.hpp>

namespace sv {

class Drawable;

struct GeometryData {
  std::vector<QVector3D> vertices;

  std::vector<QVector3D> normals;

  std::vector<QVector4D> diffuse;

  std::vector<QVector4D> specular;

  std::vector<float> shininess;

  std::vector<QVector2D> tex_coords_0;

  std::vector<uint32_t> indices;

  GLenum gl_mode;
};

class GeometryResource {
  public:
    typedef std::shared_ptr<GeometryResource> Ptr;

    ~GeometryResource();

    void Load(const GeometryData& data);

    QOpenGLBuffer* VBO() { return &vbo_; }

    QOpenGLBuffer* IndexBuffer();

    int VertexOffset() const { return vertex_offset_; }

    int NumVertices() const { return num_vertices_; }

    int NormalOffset() const { return normal_offset_; }

    int NumNormals() const { return num_normals_; }

    int DiffuseOffset() const { return diffuse_offset_; }

    int NumDiffuse() const { return num_diffuse_; }

    int NumSpecular() const { return num_specular_; }

    int SpecularOffset() const { return specular_offset_; }

    int NumShininess() const { return num_shininess_; }

    int ShininessOffset() const { return shininess_offset_; }

    int TexCoords0Offset() const { return tex_coords_0_offset_; }

    int NumTexCoords0() const { return num_tex_coords_0_; }

    int NumIndices() const { return num_indices_; }

    GLenum IndexType() const { return index_type_; }

    GLenum GLMode() const { return gl_mode_; }

    const AxisAlignedBox& BoundingBox() const { return bounding_box_; }

  private:
    friend class ResourceManager;

    friend class Drawable;

    explicit GeometryResource(const QString& name);

    void AddListener(Drawable* drawable);

    void RemoveListener(Drawable* drawable);

    const QString name_;

    // Vertex buffer to hold the data in graphics memory
    bool created_vbo_;
    QOpenGLBuffer vbo_;
    QOpenGLBuffer index_buffer_;

    int vertex_offset_;
    int normal_offset_;
    int diffuse_offset_;
    int specular_offset_;
    int shininess_offset_;
    int tex_coords_0_offset_;

    int num_vertices_;
    int num_normals_;
    int num_diffuse_;
    int num_specular_;
    int num_shininess_;
    int num_tex_coords_0_;

    int num_indices_;

    GLenum gl_mode_;
    GLenum index_type_;

    AxisAlignedBox bounding_box_;

    std::vector<Drawable*> listeners_;
};

}  // namespace sv

#endif  // SCENEVIEW_GEOMETRY_RESOURCE_HPP__