kuhyx/engineer-thesis-WUT
1
0
Fork 0
mirror of https://github.com/kuhyx/engineer-thesis-WUT.git synced 2026-07-04 15:43:19 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "feat: shaders cooperation, uniform and colors from vertice"

Browse Source 
This reverts commit df41a903f3.
This commit is contained in:
Krzysztof Rudnicki 2022-10-19 15:46:29 +02:00
parent aef81a89c5
commit 4fed1960da
7 changed files with 96 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@ -77,8 +77,5 @@
"ctime": "cpp",
"ratio": "cpp"
},
"C_Cpp.errorSquiggles": "Disabled",
"cSpell.words": [
"VERTICE"
]
"C_Cpp.errorSquiggles": "Disabled"
}

143
Engine/engine/constants.hpp
View File

@ -6,146 +6,75 @@
namespace constants
{
inline constexpr int GLFW_MAJOR_VERSION { 3 };
inline constexpr int GLFW_MINOR_VERSION { 3 };
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 {
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 {
inline constexpr struct
{
GLfloat red = 1.0f;
GLfloat green = 1.0f;
GLfloat blue = 1.0f;
GLfloat alpha = 1.0f;
} WHITE;
inline constexpr struct {
inline constexpr struct
{
GLfloat red = 0.2f;
GLfloat green = 0.3f;
GLfloat blue = 0.3f;
GLfloat alpha = 1.0f;
} LEARN_OPEN_GL_COLOR;
inline const std::string_view VERTEX_SHADER_OUTPUT_FILE {
"./shaders/vertexShaderOutput.vs"
};
inline const std::string_view VERTEX_FIRST_SHADER {
"./shaders/firstShader.vs"
};
inline const std::string_view VERTEX_WITH_COLOR {
"./shaders/vertexWithColor.vs"
};
inline const std::string_view FRAGMENT_YELLOW {
"./shaders/yellow.fs"
};
inline const std::string_view FRAGMENT_ORANGE {
"./shaders/orange.fs"
};
inline const std::string_view FRAGMENT_COLOR_INPUT {
"./shaders/fragmentColorInput.fs"
};
inline const std::string_view FRAGMENT_UNIFORMS {
"./shaders/fragmentUniforms.fs"
};
// 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" } ;
// 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"
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_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" } ;
// ... 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"
};
// 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"
};
"}\0"};
// write fragment shader
// we set the color of each pixel to be orange
inline const char *FRAGMENT_SHADER_SOURCE {
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"
};
"}\0"};
inline const char *FRAGMENT_SHADER_SOURCE_YELLOW {
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"
};
"}\0"};
// we specify three vertices
// each of them with position in 3d space
// x y z
inline constexpr float TRIANGLE_VERTICES[] {
inline constexpr float TRIANGLE_VERTICES[]{
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};
0.0f, 0.5f, 0.0f};
inline constexpr size_t TRIANGLE_VERTICES_SIZE = { sizeof(TRIANGLE_VERTICES) };
inline constexpr size_t TRIANGLE_VERTICES_SIZE = {sizeof(TRIANGLE_VERTICES)};
inline constexpr float TRIANGLES_VERTICES[] {
inline constexpr float TRIANGLES_VERTICES[]{
// first triangle
-0.9f, -0.5f, 0.0f, // left
-0.0f, -0.5f, 0.0f, // right
@ -156,35 +85,25 @@ namespace constants
0.45f, 0.5f, 0.0f // top
};
inline constexpr size_t TRIANGLES_VERTICES_SIZE = { sizeof(TRIANGLES_VERTICES) };
inline constexpr size_t TRIANGLES_VERTICES_SIZE = {sizeof(TRIANGLES_VERTICES)};
inline constexpr float TRIANGLE_ONE[] {
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 size_t TRIANGLE_ONE_SIZE = {sizeof(TRIANGLE_ONE)};
inline constexpr float TRIANGLE_TWO[] {
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) };
inline constexpr size_t TRIANGLE_TWO_SIZE = {sizeof(TRIANGLE_TWO)};
// compare with square done with only vertices:
/*
@ -200,23 +119,23 @@ namespace constants
};
bottom right and top left is specified twice !
*/
inline constexpr float SQUARE_VERTICES[] {
inline constexpr float SQUARE_VERTICES[]{
0.5f, 0.5f, 0.0f, // top right
0.5f, -0.5f, 0.0f, // bottom right
-0.5f, -0.5f, 0.0f, // bottom left
-0.5f, 0.5f, 0.0f // top left
};
inline constexpr unsigned int SQUARE_INDICES[] {
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_INDICES_SIZE = {sizeof(SQUARE_INDICES)};
inline constexpr size_t SQUARE_VERTICES_SIZE = { sizeof(SQUARE_VERTICES) };
inline constexpr size_t SQUARE_VERTICES_SIZE = {sizeof(SQUARE_VERTICES)};
inline constexpr int MAX_DRAW_CALL = { 7 };
inline constexpr int MAX_DRAW_CALL = {4};
}

46
Engine/engine/draw.cpp
View File

@ -3,7 +3,6 @@
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <cmath>
#include "draw.hpp"
#include "renderLoop.hpp"
#include "shaders.hpp"
@ -15,27 +14,18 @@ int drawFigure(const int whatToDraw)
switch (whatToDraw)
{
case 0:
return drawTriangle(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE, false);
return drawTriangle(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE);
case 1:
return drawSquare(constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE);
case 2:
// Try to draw 2 triangles next to each other using glDrawArrays by adding more vertices to your data.
return drawTriangle(constants::TRIANGLES_VERTICES, constants::TRIANGLES_VERTICES_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE, false);
return drawTriangle(constants::TRIANGLES_VERTICES, constants::TRIANGLES_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE);
case 3:
// Now create the same 2 triangles using two different VAOs and VBOs for their data
return (drawTriangle(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE, false) == -1 || drawTriangle(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE, false) == -1);
case 4:
// Create two shader programs where the second program uses a different fragment shader that outputs the color yellow; draw both triangles again where one outputs the color yellow
return (drawTriangle(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_ORANGE, false) == -1 || drawTriangle(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_FIRST_SHADER, constants::FRAGMENT_YELLOW, false) == -1);
case 5:
// Get color from vertex shader to fragment shader
return drawTriangle(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_WITH_COLOR, constants::FRAGMENT_COLOR_INPUT, false);
case 6:
// set color from opengl code to uniform value in fragment shader
return drawTriangle(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_WITH_COLOR, constants::FRAGMENT_UNIFORMS, false);
return (drawTriangle(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE) == -1 || drawTriangle(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE) == -1);
case constants::MAX_DRAW_CALL:
// set color from opengl code to uniform value in fragment shader
return drawTriangle(constants::TRIANGLE_COLORS, constants::TRIANGLE_COLORS_SIZE, constants::VERTEX_WITH_COLOR, constants::FRAGMENT_COLOR_INPUT, true);
// Create two shader programs where the second program uses a different fragment shader that outputs the color yellow; draw both triangles again where one outputs the color yellow
return (drawTriangle(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE) == -1 || drawTriangle(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE, constants::FRAGMENT_SHADER_SOURCE_YELLOW) == -1);
default:
throw "No function for this draw call";
}
@ -50,7 +40,8 @@ int drawSquare(const std::string_view vertexShaderSource, const std::string_view
copyVerticesMemory(constants::SQUARE_INDICES, constants::SQUARE_INDICES_SIZE, GL_ELEMENT_ARRAY_BUFFER);
// set vertex attribute pointers
configureVertexAttribute(false);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0);
doDrawElements(ourShader, VAO, GL_TRIANGLES, GL_UNSIGNED_INT, std::size(constants::SQUARE_INDICES));
return 0;
@ -64,36 +55,27 @@ void doDrawElements(const Shader Shader, const unsigned int vertexArrayObject, c
glBindVertexArray(0);
}
int drawTriangle(const float triangleVertices[], const size_t triangleVerticesSize, const std::string_view vertexShaderSource, const std::string_view fragmentShaderSource, const bool colorIncluded)
int drawTriangle(const float triangleVertices[], const size_t triangleVerticesSize, const char *vertexShaderSource, const char *fragmentShaderSource)
{
const unsigned int vertexBufferObject = copyVerticesMemory(triangleVertices, triangleVerticesSize, GL_ARRAY_BUFFER);
Shader ourShader(vertexShaderSource, fragmentShaderSource);
configureVertexAttribute();
const unsigned int vertexArrayObject = generateBindVAO();
copyVerticesArray(vertexBufferObject, triangleVertices, triangleVerticesSize, GL_ARRAY_BUFFER);
// set vertex attribute pointers
configureVertexAttribute(colorIncluded);
doDrawArrays(ourShader, vertexArrayObject, GL_TRIANGLES, 0, triangleVerticesSize);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0);
doDrawArrays(shaderProgram, vertexArrayObject, GL_TRIANGLES, 0, triangleVerticesSize);
return 0;
}
GLfloat updateUniformColor()
{
// update the uniform color
const float timeValue = glfwGetTime(); // retrieve running time
const float greenValue = sin(timeValue) / 2.0f + 0.5f; // vary the color from 0.0 to 1.0 using sin
return greenValue;
}
void doDrawArrays(const Shader Shader, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered)
void doDrawArrays(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered)
{
// use shader program to render an object
Shader.use();
Shader.setFloat("ourColor", updateUniformColor());
glUseProgram(shaderProgram);
glBindVertexArray(vertexArrayObject);
// From left:
// primitive type we want to draw

5
Engine/engine/draw.hpp
View File

@ -6,8 +6,7 @@
int drawFigure(const int whatToDraw);
int drawSquare(const std::string_view vertexShaderSource, const std::string_view fragmentShaderSource);
void doDrawElements(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const GLenum drawType, const int numberOfElementsToDraw);
int drawTriangle(const float triangleVertices[], const size_t triangleVerticesSize, const std::string_view vertexShaderSource, const std::string_view fragmentShaderSource, const bool colorIncluded);
GLfloat updateUniformColor();
void doDrawArrays(const Shader Shader, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered );
int drawTriangle(const float triangleVertices[], const size_t triangleVerticesSize, const char *vertexShaderSource, const char *fragmentShaderSource);
void doDrawArrays(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered);
#endif

BIN
Engine/engine/match
View File

Binary file not shown.

57
Engine/engine/renderLoop.cpp
View File

@ -11,10 +11,8 @@
int processInput(GLFWwindow *window, const int whatToDraw)
{
static bool lockedLeft = false;
static bool lockedRight = false;
const bool PRESSED_CHANGE_LEFT = (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS);
const bool PRESSED_CHANGE_RIGHT = (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS);
static bool locked = false;
const bool PRESSED_CHANGE_DRAW = (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS || glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS);
// glfwGetKey takes window and key as an input and checks is currently being pressed
// if the user pressed escape we close window
@ -22,19 +20,12 @@ int processInput(GLFWwindow *window, const int whatToDraw)
glfwSetWindowShouldClose(window, true);
if (glfwGetKey(window, GLFW_KEY_C) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
if ( !PRESSED_CHANGE_LEFT )
lockedLeft = 0;
if ( !PRESSED_CHANGE_RIGHT )
lockedRight = 0;
if ( PRESSED_CHANGE_RIGHT && lockedRight == 0 )
if ( !PRESSED_CHANGE_DRAW )
locked = 0;
if ( PRESSED_CHANGE_DRAW && locked == 0 )
{
lockedRight = 1;
locked = 1;
return (whatToDraw == constants::MAX_DRAW_CALL ? 0 : whatToDraw + 1);
}
if ( PRESSED_CHANGE_LEFT && lockedLeft == 0 )
{
lockedLeft = 1;
return (whatToDraw == 0 ? constants::MAX_DRAW_CALL : whatToDraw - 1);
}
return whatToDraw;
}
@ -78,35 +69,21 @@ unsigned int copyVerticesMemory(const unsigned int vertices[], const size_t size
return vertexBufferObject;
}
void configureVertexAttribute(const bool colorIncluded)
void configureVertexAttribute()
{
/* specify how OGL interprets vertex data
From left:
which vertex attribute we configure (from shader source code layout (location = 0))
size of vertex attribute (we use vec3 so it contains 3 values)
type of data of which vec consists of
should data be normalized, (useful when we use integer data)
space between vertex attributes, each position data is 3 times the size of float
offset of where position data begins in buffer
see: https://learnopengl.com/img/getting-started/vertex_attribute_pointer.png
vertex attribute data take data from memory managed by VBO bound to GL_ARRAY_BUFFER */
if(!colorIncluded) {
// specify how OGL interprets vertex data
// From left:
// which vertex attribute we configure (from shader source code layout (location = 0))
// size of vertex attribute (we use vec3 so it contains 3 values)
// type of data of which vec consists of
// should data be normalized, (useful when we use integer data)
// space between vertex attributes, each position data is 3 times the size of float
// offset of where position data begins in buffer
// see: https://learnopengl.com/img/getting-started/vertex_attribute_pointer.png
// vertex attribute data take data from memory managed by VBO bound to GL_ARRAY_BUFFER
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
// enable vertex attribute
glEnableVertexAttribArray(0);
return;
}
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
// enable vertex attribute
glEnableVertexAttribArray(0);
/* we change attribute location, color values have size of 3 floats
we do not normalize values, in order to get the next attribute value in data array we need to move 6 floats, (3 for position and 3 for color), we also need to specify an offset, first we have position then after 3 floats we have color
https://learnopengl.com/img/getting-started/vertex_attribute_pointer_interleaved.png */
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3* sizeof(float)));
// enable vertex attribute
glEnableVertexAttribArray(1);
}
unsigned int generateBindVAO()

2
Engine/engine/renderLoop.hpp
View File

@ -7,7 +7,7 @@ void renderLoop(GLFWwindow *window);
int renderLoopInside(GLFWwindow *window, int whatToDraw);
void copyVerticesArray(unsigned int vertexBufferObject, const float vertices[], const size_t sizeOfVertices, const GLenum boundBufferTarget);
unsigned int generateBindVAO();
void configureVertexAttribute(const bool colorIncluded);
void configureVertexAttribute();
int processInput(GLFWwindow *window, int whatToDraw);
unsigned int copyVerticesMemory(const float vertices[], const size_t sizeOfVertices, const GLenum boundBufferTarget);