TVertexArray.h

Go to the documentation of this file.

#pragma once
#include "Matrix.h"
 
#include <QOpenGLBuffer>
#include <QOpenGLTexture>
#include <misc/gen/TVector.h>
#include <xgl/ShaderProgram.h>
#include <xgl/Types.h>
#include <xgl/VertexArrayBase.h>
 
namespace sf::xgl
{
 
template<VertexArrayBase::VertexMember VertexMembers>
class TVertexArray : public VertexArrayBase
{
  public:
    explicit TVertexArray(ShaderProgram* sp);
 
    ~TVertexArray() override;
 
    ShaderProgram* shaderProgram();
 
    void draw() final;
 
    void paint() final;
 
    bool hasColor() const final;
 
    bool hasTexture() const final;
 
    void setTexture(QOpenGLTexture* texture);
 
    NormalsDataType getNormalsData() const override;
 
    void clearData() override;
 
  protected:
    bool setup() override;
 
    void setupLayout();
 
    template<typename VertexType, typename FieldType>
    void setAttribPointer(ShaderProgram::Attribute sa, size_t offset);
 
    typedef struct
    {
        vector3f position;
    } VT_Position;
 
    typedef struct
    {
        vector3f position;
        Color color{0.7, 0.7, 0.7, 0.3};
    } VT_PositionColor;
 
    typedef struct
    {
        vector3f position;
        vector3f normal;
    } VT_PositionNormal;
 
    typedef struct
    {
        vector3f position;
        vector2f texture;
    } VT_PositionTexture;
 
    typedef struct
    {
        vector3f position;
        vector3f normal;
        Color color{getDefaultColor()};
    } VT_PositionNormalColor;
 
    typedef struct
    {
        vector3f position;
        vector3f normal;
        vector2f texture;
    } VT_PositionNormalTexture;
 
    typedef struct
    {
        vector3f position;
        vector3f normal;
        Color color{getDefaultColor()};
        vector2f texture;
    } VT_PositionNormalColorTexture;
 
    using Vertex = std::conditional_t<
      VertexMembers == vmPosition, VT_Position,
      std::conditional_t<
        VertexMembers == (vmPosition | vmColor), VT_PositionColor,
        std::conditional_t<
          VertexMembers == (vmPosition | vmNormal), VT_PositionNormal,
          std::conditional_t<
            VertexMembers == (vmPosition | vmNormal | vmColor), VT_PositionNormalColor,
            std::conditional_t<
              VertexMembers == (vmPosition | vmTexCoord), VT_PositionTexture,
              std::conditional_t<
                VertexMembers == (vmPosition | vmNormal | vmTexCoord), VT_PositionNormalTexture,
                std::conditional_t<
                  VertexMembers == (vmPosition | vmNormal | vmColor | vmTexCoord), VT_PositionNormalColorTexture,
                  // Ought not to happen but a type is required.
                  void>>>>>>>;
    TVector<Vertex> _vertices;
 
    struct ModeRange
    {
        GLenum mode;
        size_t stop;
        size_t start{std::numeric_limits<size_t>::max()};
        Color color{0.0f, 0.0f, 0.0f, 0.0f};
        Matrix matrix;
        CullingState culling{cfDisabled | cfBackside | cfCCW};
    };
 
    typedef TVector<GLuint> IndexVectorType;
 
    IndexVectorType _indices;
 
    TVector<ModeRange> _modes;
 
    void callModifyContext(const ModeRange& mr, bool before, bool draw, size_t mode_index);
 
    bool checkData() const;
 
  private:
    ShaderProgram* _shaderProgram;
 
    struct
    {
        QOpenGLBuffer vbo{QOpenGLBuffer::VertexBuffer};
        QOpenGLBuffer ebo{QOpenGLBuffer::IndexBuffer};
    } _buffers;
 
    QOpenGLTexture* _texture{nullptr};
};
 
}// namespace sf::xgl
 
// Include all inlined functions and template implementations.
#include <xgl/TVertexArray.hpp>