Vertex.h

#pragma once
 
#include "../pch.h"
 
static glm::mat4 getRotationMatrix(glm::vec3 newRot) {
    float radX = glm::radians(newRot.x);
    float radY = glm::radians(newRot.y);
    float radZ = glm::radians(newRot.z);
 
    glm::mat4 rotationX = glm::rotate(glm::mat4(1.0f), radX, glm::vec3(1.0f, 0.0f, 0.0f));
    glm::mat4 rotationY = glm::rotate(glm::mat4(1.0f), radY, glm::vec3(0.0f, 1.0f, 0.0f));
    glm::mat4 rotationZ = glm::rotate(glm::mat4(1.0f), radZ, glm::vec3(0.0f, 0.0f, 1.0f));
 
    glm::mat4 rotationMatrix = rotationZ * rotationY * rotationX;
    return rotationMatrix;
}
 
static glm::vec2 rotatePoint(float x, float y, float centerX, float centerY, float radians) {
    float dx = x - centerX;
    float dy = y - centerY;
    return glm::vec2(
        centerX + dx * cos(radians) - dy * sin(radians),
        centerY + dx * sin(radians) + dy * cos(radians)
    );
};
static glm::vec2 rotatePoint(float x, float y, float radians) {
    return rotatePoint(x, y, 0.0f, 0.0f, radians);
};
/*  glm::vec3 arotatedTopLeft = rotatePoint(atopLeft.x, atopLeft.y, atopLeft.z, centerX, centerY, centerZ, 0, 0, 0);
        glm::vec3 arotatedBottomLeft = rotatePoint(abottomLeft.x, abottomLeft.y, abottomLeft.z, centerX, centerY, centerZ, 0, 0, 0);
        glm::vec3 arotatedBottomRight = rotatePoint(abottomRight.x, abottomRight.y, abottomRight.z, centerX, centerY, centerZ, 0, 0, 0);
        glm::vec3 arotatedTopRight = rotatePoint(atopRight.x, atopRight.y, atopRight.z, centerX, centerY, centerZ, 0, 0, 0);*/
 
namespace TazGraphEngine {
 
    using Position = glm::vec3;
    using Size = glm::vec3;
    using Rotation = glm::vec3;
 
    using Normal = glm::vec3;
 
    using UV = glm::vec2;
 
    struct Color {
        Color() : r(0), g(0), b(0), a(0) {}
        Color(GLubyte R, GLubyte G, GLubyte B, GLubyte A) : r(R), g(G), b(B), a(A) {}
 
        glm::vec4 toVec4() const {
            return glm::vec4(r, g, b, a) / 255.0f; // Normalize 0-255 to 0-1
        }
 
        static Color fromVec4(const glm::vec4& v) {
            return Color(
                static_cast<GLubyte>(v.r * 255.0f),
                static_cast<GLubyte>(v.g * 255.0f),
                static_cast<GLubyte>(v.b * 255.0f),
                static_cast<GLubyte>(v.a * 255.0f)
            );
        }
 
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
 
        Color operator*(float scalar) const {
            return Color(static_cast<GLubyte>(r * scalar),
                static_cast<GLubyte>(g * scalar),
                static_cast<GLubyte>(b * scalar),
                static_cast<GLubyte>(a * scalar));
        }
 
        // Operator overload for color addition
        Color operator+(const Color& other) const {
            return Color(static_cast<GLubyte>(r + other.r),
                static_cast<GLubyte>(g + other.g),
                static_cast<GLubyte>(b + other.b),
                static_cast<GLubyte>(a + other.a));
        }
 
        bool operator==(const Color& other) const {
            return r == other.r && g == other.g && b == other.b && a == other.a;
        }
    };
 
 
    struct Vertex {
        Position position = Position(0);
 
        inline void setPosition(Position m_position) {
            position = m_position;
        }
    };
 
    struct ColorVertex : Vertex { //instead of using the general Vertex that has also info about texture
        // we use this where we want just color
        //todo different instanceVBO for the centers
        //Position centerMesh;
        Color color = Color();
 
        void setColor(GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
            color.r = r;
            color.g = g;
            color.b = b;
            color.a = a;
        }
    };
 
    struct LightVertex : Vertex {
        Normal normal = Normal();
 
    };
 
    struct TextureVertex : Vertex {
        // UV texture coordinates
        UV uv = UV(0);
 
        inline void setUV(UV m_uv) {
            uv = m_uv;
        }
    };
 
}
 
using TazPosition = TazGraphEngine::Position;
using TazSize = TazGraphEngine::Size;
using TazRotation = TazGraphEngine::Rotation;
using TazUV = TazGraphEngine::UV;
using TazNormal = TazGraphEngine::Normal;
using TazColor = TazGraphEngine::Color;
using TazVertex = TazGraphEngine::Vertex;
using TazColorVertex = TazGraphEngine::ColorVertex;
using TazLightVertex = TazGraphEngine::LightVertex;
using TazTexVertex = TazGraphEngine::TextureVertex;