VertexArray.hpp

Go to the documentation of this file.

/*
   Copyright 2022 Rishi Challa
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#pragma once
 
#ifdef KALE_OPENGL
 
#include <Kale/OpenGL/Buffer/Buffer.hpp>
 
#include <array>
#include <vector>
#include <algorithm>
 
namespace Kale::OpenGL {
 
    enum class DrawType : GLenum {
        Triangles = GL_TRIANGLES,
        Points = GL_POINTS,
        Lines = GL_LINES
    };
 
    template <typename T, size_t... NFloats> class VertexArray {
    private:
 
        unsigned int vertexArray;
 
        constexpr size_t numFloatsInVert() {
            return sizeof(T) / sizeof(float);
        }
 
        inline bool vertFloatPtrEqual(const float* floatPtr, const T& vert) {
            return std::equal(floatPtr, floatPtr + numFloatsInVert(), reinterpret_cast<const float*>(&vert));
        }
 
        template <typename Container> void condenseVertices(const Container& verts, BufferUsage usage) {
            bind();
 
            vertices.data.reserve(verts.size());
            elements.data.reserve(verts.size());
 
            size_t vertIndex = 0;
 
            for (const T& vert : verts) {
 
                // Check for existing vertex in memory
                bool existingVertFound = false;
                size_t existingVertIndex;
 
                // Reverse iteration as same vertices are more likely to be near eachother in the array
                for (int i = static_cast<int>(elements.data.size()) - 1; i >= 0; i--) {
 
                    // Check if the vert in memory/the vert are equal
                    if (vertFloatPtrEqual(&vertices.data[numFloatsInVert() * elements.data[i]], vert)) {
                        existingVertIndex = static_cast<size_t>(elements.data[i]);
                        existingVertFound = true;
                        break;
                    }
                }
 
                // An existing vertex was found, just add it's index to the elements and continue
                if (existingVertFound) {
                    elements.data.push_back(static_cast<unsigned int>(existingVertIndex));
                    continue;
                }
 
                // No existing vertex was found, add both the vertex to memory and the index
                elements.data.push_back(static_cast<unsigned int>(vertIndex));
                vertIndex++;
 
                const float* vertLoc = reinterpret_cast<const float*>(&vert);
                vertices.data.insert(vertices.data.end(), vertLoc, vertLoc + numFloatsInVert());
            }
 
            vertices.allocBuffer(usage);
            elements.allocBuffer(usage);
            vertices.data.shrink_to_fit();
            elements.data.shrink_to_fit();
        }
 
        template <typename Verts, typename Func>
        void createVerticesAndElements(const Verts& verts, const Func& func, BufferUsage usage) {
            glGenVertexArrays(1, &vertexArray);
            bind();
            vertices.data.insert(vertices.data.begin(), reinterpret_cast<const float*>(verts.data()),
                reinterpret_cast<const float*>(verts.data() + verts.size()));
            func();
            vertices.allocBuffer(usage);
            elements.allocBuffer(usage);
        }
 
    public:
 
        Buffer<float> vertices;
 
        Buffer<unsigned int> elements;
        
        VertexArray() : vertices(BufferType::VertexBuffer), elements(BufferType::ElementBuffer) {
            glGenVertexArrays(1, &vertexArray);
            bind();
            vertices.bind();
            elements.bind();
        }
        
        template <size_t N>
        VertexArray(const std::array<T, N>& verts, BufferUsage usage, bool condense = true) : vertices(BufferType::VertexBuffer),
            elements(BufferType::ElementBuffer) {
            
            glGenVertexArrays(1, &vertexArray);
            if (condense) condenseVertices(verts, usage);
            else {
                bind();
                vertices.data.insert(vertices.data.begin(), reinterpret_cast<const float*>(verts.data()),
                    reinterpret_cast<const float*>(verts.data() + verts.size()));
                vertices.allocBuffer(usage);
            }
        }
        
        VertexArray(const std::vector<T>& verts, BufferUsage usage, bool condense = true) : vertices(BufferType::VertexBuffer),
            elements(BufferType::ElementBuffer) {
            
            glGenVertexArrays(1, &vertexArray);
            if (condense) condenseVertices(verts, usage);
            else {
                bind();
                vertices.data.insert(vertices.data.begin(), reinterpret_cast<const float*>(verts.data()),
                    reinterpret_cast<const float*>(verts.data() + verts.size()));
                vertices.allocBuffer(usage);
            }
        }
        
        template <size_t N1, size_t N2, typename index_type = unsigned int>
        VertexArray(const std::array<T, N1>& verts, const std::array<index_type, N2>& indices, BufferUsage usage) :
            vertices(BufferType::VertexBuffer), elements(BufferType::ElementBuffer) {
 
            createVerticesAndElements(verts, [&]() -> void {
                elements.data.reserve(indices.size());
                for (const index_type& i : indices) elements.data.push_back(static_cast<unsigned int>(i));
            }, usage);
        }
        
        template <typename index_type = unsigned int>
        VertexArray(const std::vector<T>& verts, const std::vector<index_type>& indices, BufferUsage usage) :
            vertices(BufferType::VertexBuffer), elements(BufferType::ElementBuffer) {
 
            createVerticesAndElements(verts, [&]() -> void {
                elements.data.reserve(indices.size());
                for (const index_type& i : indices) elements.data.push_back(static_cast<unsigned int>(i));
            }, usage);
        }
        
        VertexArray(const std::vector<T>& verts, std::vector<unsigned int>&& indices, BufferUsage usage) :
            vertices(BufferType::VertexBuffer), elements(BufferType::ElementBuffer) {
 
            createVerticesAndElements(verts, [&]() -> void {
                elements.data = std::move(indices);
            }, usage);
        }
 
        ~VertexArray() {
            glDeleteVertexArrays(1, &vertexArray);
        }
 
        void enableAttributePointer(const std::array<unsigned int, sizeof...(NFloats)>& attributes) const {
            bind();
            const std::array<size_t, sizeof...(NFloats)> nFloatsArr = {NFloats...};
            const float* offset = nullptr;
            for (size_t i = 0; i < attributes.size(); i++) {
                glVertexAttribPointer(attributes[i], static_cast<GLint>(nFloatsArr[i]), GL_FLOAT, GL_FALSE,
                    sizeof(T), static_cast<const void*>(offset));
                glEnableVertexAttribArray(attributes[i]);
                offset += nFloatsArr[i];
            }
        }
 
        void bind() const {
            glBindVertexArray(vertexArray);
        }
 
        template <size_t N> void updateVerticesCondense(const std::array<T, N>& verts, BufferUsage usage) {
            vertices.data.clear();
            elements.data.clear();
            condenseVertices(verts, usage);
        }
 
        void updateVerticesCondense(const std::vector<T>& verts, BufferUsage usage) {
            vertices.data.clear();
            elements.data.clear();
            condenseVertices(verts, usage);
        }
 
        void draw() const {
            bind();
            glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(elements.data.size()), GL_UNSIGNED_INT, nullptr);
        }
 
        void drawNoElements() const {
            bind();
            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vertices.data.size()));
        }
 
        void draw(DrawType type) const {
            bind();
            glDrawElements(getEnumValue(type), static_cast<GLsizei>(elements.data.size()), GL_UNSIGNED_INT, nullptr);
        }
 
        void drawNoElements(DrawType type) const {
            bind();
            glDrawArrays(getEnumValue(type), 0, static_cast<GLsizei>(vertices.data.size()));
        }
 
    };
 
}
 
#endif