engineer-thesis-WUT/Engine/engine/constants.hpp

#ifndef CONSTANTS_HPP
#define CONSTANTS_HPP
#include <GLFW/glfw3.h>
#include <iostream>
#include <string_view>


namespace constants 
{
    inline constexpr int GLFW_MAJOR_VERSION { 3 };
    inline constexpr int GLFW_MINOR_VERSION { 3 };
    // best practice is to use inline constexpr std::string_view but glfwCreateWindow takes only char* as input
    inline const char* MAIN_WINDOW_NAME { "Match" }; 
    inline constexpr int MAIN_WINDOW_WIDTH { 800 };
    inline constexpr int MAIN_WINDOW_HEIGHT { 600 };
    inline constexpr struct  { 
        GLfloat red = 1.0f;
        GLfloat green = 0.0f;
        GLfloat blue = 0.0f;
        GLfloat alpha = 1.0f;
    } RED;

        inline constexpr struct  { 
        GLfloat red = 1.0f;
        GLfloat green = 1.0f;
        GLfloat blue = 1.0f;
        GLfloat alpha = 1.0f;
    } WHITE;

    inline constexpr struct  { 
        GLfloat red = 0.2f;
        GLfloat green = 0.3f;
        GLfloat blue = 0.3f;
        GLfloat alpha = 1.0f;
    } LEARN_OPEN_GL_COLOR;

    // we send output from vertex shader (vertexColor)...
    inline const char *VERTEX_SHADER_COLOR { "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "out vec3 vertexColor;\n" // color output to fragment shader
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos, 1.0);\n" // we directly give xyz of aPos as an argument
    "   vertexColor = vec3(0.5, 0.0, 0.0);\n" // dark red color
    "}\0" } ;

    inline const char*  VERTEX_SHADER_COLOR_FILENAME {
        "./Shaders/vertexShaderColor.vs"
    };

    inline const char* VERTEX_SHADER_UPSIDE_DOWN_FILENAME {
        "./Shaders/vertexShaderUpsideDown.vs"
    };

        inline const char* VERTEX_SHADER_OFFSET_FILENAME {
        "./Shaders/vertexShaderOffset.vs"
    };
    
    // we write vertex shader 
    // version of glsl (since ogl 3.3 same as ogl so we pick 330)
    // in this shader we just forward input data to shader output
    inline const char *VERTEX_SHADER_SOURCE { "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0" } ;
    
    inline const char* VERTEX_SHADER_SOURCE_FILENAME {
        "./Shaders/vertexShaderSource.vs"
    };

    inline const char *VERTEX_SHADER_VERTICE_COLOR { "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n" // position has attribute position 0
    "layout (location = 1) in vec3 aColor;\n" // color has attribute position 1
    "out vec3 vertexColor;\n" // output a color to fragment shader
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos, 1.0);\n"
    "   vertexColor = aColor;\n"
    "}\0" } ;

    inline const char*  VERTEX_SHADER_VERTICE_COLOR_FILENAME {
        "./Shaders/vertexShaderVerticeColor.vs"
    };

    inline const char* VERTEX_SHADER_TASK_THREE_FILENAME {
        "./Shaders/vertexShaderTaskThree.vs"
    };

    inline const char* FRAGMENT_SHADER_TASK_THREE_FILENAME {
        "./Shaders/fragmentShaderTaskThree.fs"
    };

        // ... to fragment shader (vertexColor)
    inline const char *FRAGMENT_SHADER_COLOR_FROM_VERTEX {
        "#version 330 core\n"
        "out vec4 FragColor;\n"
        "in vec3 vertexColor;\n" // from vertex
        "void main()\n"
        "{\n"
            "FragColor = vec4(vertexColor, 1.0);\n"
        "}\0"
    };

    inline const char*  FRAGMENT_SHADER_COLOR_FROM_VERTEX_FILENAME {
        "./Shaders/fragmentShaderColorFromVertex.fs"
    };

    // uniforms
    inline const char *FRAGMENT_SHADER_UNIFORMS {
        "#version 330 core\n"
        "out vec4 FragColor;\n"
        "uniform vec4 ourColor;\n" // set in OGL code
        "void main()\n"
        "{\n"
            "FragColor = ourColor;\n"
        "}\0"
    };

    inline const char*  FRAGMENT_SHADER_UNIFORMS_FILENAME {
        "./Shaders/fragmentShaderUniforms.fs"
    };

    // write fragment shader
    // we set the color of each pixel to be orange
    inline const char *FRAGMENT_SHADER_SOURCE {
        "#version 330 core\n"
        "out vec4 FragColor;\n"
        "void main()\n"
        "{\n"
            "FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
        "}\0"
    };

    inline const char*  FRAGMENT_SHADER_SOURCE_FILENAME {
        "./Shaders/fragmentShaderSource.fs"
    };

    inline const char *FRAGMENT_SHADER_SOURCE_YELLOW {
        "#version 330 core\n"
        "out vec4 FragColor;\n"
        "void main()\n"
        "{\n"
            "FragColor = vec4(1.0f, 1.0f, 0.0f, 1.0f);\n"
        "}\0"
    };

    inline const char*  FRAGMENT_SHADER_SOURCE_YELLOW_FILENAME {
        "./Shaders/fragmentShaderSourceYellow.fs"
    };

    // we specify three vertices
    // each of them with position in 3d space
    // x y z
    inline constexpr float TRIANGLE_VERTICES[] {
        -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f,
        0.0f,  0.5f, 0.0f
    };

    inline constexpr size_t TRIANGLE_VERTICES_SIZE = { sizeof(TRIANGLE_VERTICES) };

    inline constexpr float TRIANGLES_VERTICES[] {
        // first triangle
        -0.9f, -0.5f, 0.0f,  // left 
        -0.0f, -0.5f, 0.0f,  // right
        -0.45f, 0.5f, 0.0f,  // top 
        // second triangle
         0.0f, -0.5f, 0.0f,  // left
         0.9f, -0.5f, 0.0f,  // right
         0.45f, 0.5f, 0.0f   // top 
    };

    inline constexpr size_t TRIANGLES_VERTICES_SIZE = { sizeof(TRIANGLES_VERTICES) };

    inline constexpr float TRIANGLE_ONE[] {
        // first triangle
        -0.9f, -0.5f, 0.0f,  // left 
        -0.0f, -0.5f, 0.0f,  // right
        -0.45f, 0.5f, 0.0f,  // top 
    };

    inline constexpr size_t TRIANGLE_ONE_SIZE = { sizeof(TRIANGLE_ONE) };

    inline constexpr float TRIANGLE_TWO[] {
        // second triangle
         0.0f, -0.5f, 0.0f,  // left
         0.9f, -0.5f, 0.0f,  // right
         0.45f, 0.5f, 0.0f   // top 
    };

    inline constexpr size_t TRIANGLE_TWO_SIZE = { sizeof(TRIANGLE_TWO) };

    inline constexpr float TRIANGLE_COLORS[] {
        // positions         // colors
        0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // bottom right
        -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // bottom left
        0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // top 
    };

    inline constexpr size_t TRIANGLE_COLORS_SIZE = { sizeof(TRIANGLE_COLORS) };

    // compare with square done with only vertices:
    /*
    float vertices[] = {
    // first triangle
     0.5f,  0.5f, 0.0f,  // top right
     0.5f, -0.5f, 0.0f,  // bottom right
    -0.5f,  0.5f, 0.0f,  // top left 
    // second triangle
     0.5f, -0.5f, 0.0f,  // bottom right
    -0.5f, -0.5f, 0.0f,  // bottom left
    -0.5f,  0.5f, 0.0f   // top left
    };
    bottom right and top left is specified twice ! 
    */
    inline constexpr float SQUARE_VERTICES[] {
        0.5f,  0.5f, 0.0f,  // top right
        0.5f, -0.5f, 0.0f,  // bottom right
        -0.25f, -0.5f, 0.0f,  // bottom left
        -0.25f,  0.5f, 0.0f   // top left 
    };

    inline constexpr unsigned int SQUARE_INDICES[] {
        0, 1, 3,   // first triangle
        1, 2, 3,    // second triangle
    };

    inline constexpr size_t SQUARE_INDICES_SIZE = { sizeof(SQUARE_INDICES) };

    inline constexpr size_t SQUARE_VERTICES_SIZE = { sizeof(SQUARE_VERTICES) };

    inline constexpr int MAX_DRAW_CALL = { 10 };

    // https://learnopengl.com/img/getting-started/tex_coords.png
    inline constexpr float TEXTURE_COORDINATES[] {
        0.0f, 0.0f,  // lower-left corner  
        1.0f, 0.0f,  // lower-right corner
        0.5f, 1.0f   // top-center corner
    };

}

#endif