renderable3d.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <iostream>

#include <src/graphics/shader.h>
#include <src/graphics/buffers/buffer.h>
#include <src/graphics/buffers/indexbuffer.h>
#include <src/graphics/buffers/vertexarray.h>
#include <src/graphics/texture.h>
#include <src/graphics/renderers/renderer3d.h>

namespace fireworks { namespace graphics {

    struct VertexData3D
    {
        glm::vec3 vertex;
        // TODO: Use normals!
        //glm::vec3 normal;
        glm::vec2 uv;
        float       tid;
        glm::vec4 color;

        VertexData3D()
            : vertex(glm::vec3(0, 0, 0)), uv(glm::vec2(0, 0)), tid(0.0f), color(glm::vec4(1, 0, 1, 1))
        {

        }

        VertexData3D(glm::vec3 vertex, glm::vec2 uv, float texID, glm::vec4 color)
            : vertex(vertex), uv(uv), tid(texID), color(color)
        {
        }
    };

    struct Transform
    {
        glm::vec3 position;
        glm::vec3 rotation;
        glm::vec3 scale;

        Transform(glm::vec3 pos = glm::vec3(0, 0, 0), glm::vec3 rot = glm::vec3(0, 0, 0), glm::vec3 scale = glm::vec3(1, 1, 1))
            : position(pos), rotation(rot), scale(scale)
        {
        }
    };

    enum class Primitive3D
    {
        Plane,
        Cube,
        UVSphere,   /* UV sphere procedurally generated using rings count on the CPU side */
        Cylinder,  
        Torus,      /* UV Torus procedurally generated using preferences on the CPU side */
        None        /* If the primitive is none, then use the 3D Model for rendering the renderable*/
    };

    class Mesh;

    class Renderable3D
    {
    public:
        std::uint32_t                       objectID;
        Shader*                             shader;
        Texture*                            m_Texture;
    protected:
        Transform                           m_Transform;
        glm::vec4                           m_Color;
        Primitive3D                         m_Primitive3D;
        mutable std::vector<glm::vec2>      m_UV;
        std::vector<VertexData3D>           m_Vertices;
        std::vector<GLushort>               m_Indices;
    private:
        static std::uint32_t                m_UniqueID;
    public:
        Renderable3D(Transform transform, glm::vec4 color, Primitive3D primitive3d)
            : m_Transform(transform), m_Color(color), m_Primitive3D(primitive3d), shader(nullptr), m_Texture(nullptr)
        {
            objectID = ++m_UniqueID;
            setUVDefaults();
        }

        Renderable3D(Transform transform, glm::vec4 color, Primitive3D primitive3d, Shader* shader)
            : m_Transform(transform), m_Color(color), m_Primitive3D(primitive3d), shader(shader), m_Texture(nullptr)
        {
            objectID = ++m_UniqueID;
            setUVDefaults();
        }

        Renderable3D(Transform transform, glm::vec4 color, Primitive3D primitive3d, Shader* shader, Texture* texture)
            : m_Transform(transform), m_Color(color), m_Primitive3D(primitive3d), shader(shader), m_Texture(texture)
        {
            objectID = ++m_UniqueID;
            shader->enable();
            GLint texIDs[] =
            {
                0, 1,  2,  3,  4,  5,  6,  7,
                8, 9, 10, 11, 12, 13, 14, 15
            };
            shader->setUniform1iv("textures", texIDs, 8);
            shader->disable();

            setUVDefaults();
        }

        Renderable3D() : m_Texture(nullptr)
        {
            objectID = ++m_UniqueID;
        }

        virtual ~Renderable3D() { }

        virtual void submit(Renderer3D* renderer) const
        {
            renderer->submit(this);
        }

        inline const Transform& getTransform() const { return m_Transform; }
        inline const glm::vec4& getColor() const { return m_Color; }
        inline const std::vector<glm::vec2>& getUV() const { return m_UV; }
        inline const GLuint getTID() const { return m_Texture == nullptr ? 0 : m_Texture->getID(); }
        inline const Primitive3D& gerPrimitive() const { return m_Primitive3D; }
        inline std::vector<VertexData3D> getVerts() const { return m_Vertices; }
        inline GLuint getVertsSize() const { return m_Vertices.size(); }
        inline std::vector<GLushort> getInidces() const { return m_Indices; }
        inline GLsizei getIndicesSize() const { return m_Indices.size(); }
    private:
        void setUVDefaults()
        {
            int faces;
            if (m_Primitive3D == Primitive3D::Plane) /* Same as a Sprite */
            {
                faces = 1;
                // Iterating over each face
                for (int i = 0; i < faces; i++)
                {
                    m_UV.push_back(glm::vec2(0, 0));  // Bottom Left
                    m_UV.push_back(glm::vec2(0, 4));  // Top Left
                    m_UV.push_back(glm::vec2(4, 4));  // Top Right
                    m_UV.push_back(glm::vec2(4, 0));  // Bottom Right
                }
            }
            else if(m_Primitive3D == Primitive3D::Cube)
            {
                faces = 6;
                // Iterating over each face
                for (int i = 0; i < faces; i++)
                {
                    // Clockwise UV coordinates for each face
                    m_UV.push_back(glm::vec2(0, 0));  // Bottom Left
                    m_UV.push_back(glm::vec2(0, 1));  // Top Left
                    m_UV.push_back(glm::vec2(1, 1));  // Top Right
                    m_UV.push_back(glm::vec2(1, 0));  // Bottom Right
                }
            }
        }
    };

} }