guezoloic/LearnOpenGL
1
0
Fork 0
mirror of https://github.com/guezoloic/LearnOpenGL.git synced 2026-03-28 18:03:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: replace triangle test by cube

Browse Source
This commit is contained in:
Loïc GUEZO
2026-02-15 20:10:17 +01:00
parent a674c391a8
commit ff7a82f646
13 changed files with 149 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -40,11 +40,11 @@ foreach(SHADER ${SHADERS})
add_custom_command( add_custom_command(
OUTPUT ${OUTPUT_C} OUTPUT ${OUTPUT_C}
COMMAND python3 COMMAND python3
${CMAKE_SOURCE_DIR}/glsl2c.py ${CMAKE_SOURCE_DIR}/scripts/glsl2c.py
${SHADER} ${SHADER}
${OUTPUT_C} ${OUTPUT_C}
DEPENDS ${SHADER} DEPENDS ${SHADER}
${CMAKE_SOURCE_DIR}/glsl2c.py ${CMAKE_SOURCE_DIR}/scripts/glsl2c.py
COMMENT "Converting shader ${NAME_WE}${EXT} to C file" COMMENT "Converting shader ${NAME_WE}${EXT} to C file"
VERBATIM VERBATIM
) )

4
inc/core/camera.hpp
View File

@@ -5,6 +5,8 @@
#include "glm/ext/matrix_float4x4.hpp" #include "glm/ext/matrix_float4x4.hpp"
#include "glm/ext/vector_float3.hpp" #include "glm/ext/vector_float3.hpp"
namespace core
{
class Camera class Camera
{ {
private: private:
@@ -63,5 +65,5 @@ class Camera
void setFov(float newFov); void setFov(float newFov);
void setPosition(const glm::vec3& newPosition); void setPosition(const glm::vec3& newPosition);
}; };
} // namespace core
#endif #endif

2
inc/core/shader.hpp
View File

@@ -29,6 +29,8 @@ class Shader
// Activates the shader program for rendering // Activates the shader program for rendering
// All subsequent draw calls will use this program // All subsequent draw calls will use this program
void use() const; void use() const;
GLuint getId() const { return id; }
}; };
} // namespace core } // namespace core

22
inc/cube.hpp
View File

@@ -1,14 +1,14 @@
#ifndef CUBE_HPP // #ifndef CUBE_HPP
#define CUBE_HPP // #define CUBE_HPP
#include "glm/ext/vector_float3.hpp" // #include "glm/ext/vector_float3.hpp"
#include "shape.hpp" // #include "shape.hpp"
class Cube : public Shape // class Cube : public Shape
{ // {
public: // public:
Cube(Camera &camera, glm::vec3 pos, const char *texture); // Cube(Camera &camera, glm::vec3 pos, const char *texture);
void render(int width, int height) override; // void render(int width, int height) override;
}; // };
#endif // #endif

22
res/render/primitives/p_cube.frag
View File

@@ -1,31 +1,11 @@
#version 330 core #version 330 core
out vec4 FragColor; out vec4 FragColor;
struct Material
{
sampler2D diffuse;
vec3 specular;
float shininess;
};
struct Light
{
vec3 position;
vec3 ambient;
vec3 diffuse;
vec3 specular;
};
in vec3 FragPos; in vec3 FragPos;
in vec3 Normal; in vec3 Normal;
in vec2 TexCoords; in vec2 TexCoords;
uniform vec3 viewPos;
uniform Material material;
uniform Light light;
void main() void main()
{ {
vec4 texColor = texture(material.diffuse , TexCoords); FragColor = vec4(0.8, 0.8, 1.0, 1.0);
FragColor = texColor;
} }

10
res/render/primitives/p_cube.vert
View File

@@ -8,15 +8,7 @@ uniform mat4 projection;
uniform mat4 model; uniform mat4 model;
uniform mat4 view; uniform mat4 view;
out vec3 Normal;
out vec3 FragPos;
out vec2 TexCoords;
void main() void main()
{ {
FragPos = vec3(model*vec4(aPos , 1.0)); gl_Position = projection * view * model * vec4(aPos, 1.0);
gl_Position = projection*view*vec4(FragPos , 1.0);
Normal = mat3(transpose(inverse(model)))*aNormal;
TexCoords = aTexCoords;
} }

3
res/render/primitives/p_triangle.frag
View File

@@ -1,8 +1,7 @@
#version 330 core #version 330 core
out vec4 color; out vec4 color;
void main() void main()
{ {
color = vec4(1.0f, 0.5f, 0.2f, 1.0f); color = vec4(0.2, 0.51, 1.0, 1.0);
} }

1
res/render/primitives/p_triangle.hpp
View File

@@ -13,7 +13,6 @@ namespace mesh
0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f 0.0f, 0.5f, 0.0f
}; };
// clang-format on
constexpr const std::size_t P_TRIANGLE_VERTICE_LEN = constexpr const std::size_t P_TRIANGLE_VERTICE_LEN =
sizeof(P_TRIANGLE_VERTICE) / sizeof(GLfloat); sizeof(P_TRIANGLE_VERTICE) / sizeof(GLfloat);

5
glsl2c.py → scripts/glsl2c.py
View File

@@ -5,6 +5,7 @@ from pathlib import Path
line: int = 12 line: int = 12
def write_binary(content: bytes) -> str: def write_binary(content: bytes) -> str:
text = "" text = ""
for i, byte in enumerate(content): for i, byte in enumerate(content):
@@ -16,6 +17,7 @@ def write_binary(content: bytes) -> str:
text += "0x00\n" text += "0x00\n"
return text return text
def main() -> int: def main() -> int:
# check arguments # check arguments
if len(sys.argv) < 2 or len(sys.argv) > 3: if len(sys.argv) < 2 or len(sys.argv) > 3:
@@ -37,7 +39,8 @@ def main() -> int:
content = src.read_bytes() content = src.read_bytes()
with open(dst, "w") as f: with open(dst, "w") as f:
f.write(f"const unsigned char {varname}[] = {{\n{write_binary(content)}}};\n") f.write(
f"const unsigned char {varname}[] = {{\n{write_binary(content)}}};\n")
f.write(f"const unsigned int {varname}_LEN = {len(content)};\n") f.write(f"const unsigned int {varname}_LEN = {len(content)};\n")
return 0 return 0

20
scripts/glsl2pak.py Executable file
View File

@@ -0,0 +1,20 @@
#!/usr/bin/env python3
from scripts.glsl2c import write_binary
from pathlib import Path
import sys
def main() -> int:
if len(sys.argv) < 2:
print("glsl2pak.py <shader_file>... output")
return 1
output = sys.argv.pop()
print(sys.argv)
return 0
if __name__ == "__main__":
sys.exit(main())

22
src/core/camera.cpp
View File

@@ -5,7 +5,7 @@
#include "glm/ext/matrix_transform.hpp" #include "glm/ext/matrix_transform.hpp"
#include "glm/ext/matrix_clip_space.hpp" #include "glm/ext/matrix_clip_space.hpp"
Camera::Camera(int width, int height, GLFWwindow* window, float sensitivity) core::Camera::Camera(int width, int height, GLFWwindow* window, float sensitivity)
: width(width), : width(width),
height(height), height(height),
window(window), window(window),
@@ -15,7 +15,7 @@ Camera::Camera(int width, int height, GLFWwindow* window, float sensitivity)
updateCameraVectors(); updateCameraVectors();
} }
void Camera::update(float deltaTime) void core::Camera::update(float deltaTime)
{ {
processInput(deltaTime); processInput(deltaTime);
processMouseMovement(); processMouseMovement();
@@ -23,7 +23,7 @@ void Camera::update(float deltaTime)
} }
// TODO: callback management // TODO: callback management
void Camera::processInput(float deltaTime) void core::Camera::processInput(float deltaTime)
{ {
float velocity = speed * deltaTime; float velocity = speed * deltaTime;
@@ -51,7 +51,7 @@ void Camera::processInput(float deltaTime)
: 45.f; : 45.f;
} }
void Camera::processMouseMovement() void core::Camera::processMouseMovement()
{ {
double mouseX, mouseY; double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY); glfwGetCursorPos(window, &mouseX, &mouseY);
@@ -80,7 +80,7 @@ void Camera::processMouseMovement()
if (cameraPitch < -89.0f) cameraPitch = -89.0f; if (cameraPitch < -89.0f) cameraPitch = -89.0f;
} }
void Camera::updateCameraVectors() void core::Camera::updateCameraVectors()
{ {
glm::vec3 front; glm::vec3 front;
front.x = cos(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch)); front.x = cos(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch));
@@ -92,12 +92,12 @@ void Camera::updateCameraVectors()
cameraUp = glm::normalize(glm::cross(cameraRight, cameraFront)); cameraUp = glm::normalize(glm::cross(cameraRight, cameraFront));
} }
glm::mat4 Camera::getViewMatrix() const glm::mat4 core::Camera::getViewMatrix() const
{ {
return glm::lookAt(cameraPosition, cameraPosition + cameraFront, cameraUp); return glm::lookAt(cameraPosition, cameraPosition + cameraFront, cameraUp);
} }
glm::mat4 Camera::getProjectionMatrix() const glm::mat4 core::Camera::getProjectionMatrix() const
{ {
return glm::perspective( return glm::perspective(
glm::radians(this->fov), glm::radians(this->fov),
@@ -105,7 +105,7 @@ glm::mat4 Camera::getProjectionMatrix() const
100.0f); 100.0f);
} }
void Camera::setSpeed(float newSpeed) void core::Camera::setSpeed(float newSpeed)
{ {
if (newSpeed > 0.0f) if (newSpeed > 0.0f)
{ {
@@ -113,7 +113,7 @@ void Camera::setSpeed(float newSpeed)
} }
} }
void Camera::setCameraSensitivity(float newSensitivity) void core::Camera::setCameraSensitivity(float newSensitivity)
{ {
if (newSensitivity > 0.0f) if (newSensitivity > 0.0f)
{ {
@@ -121,7 +121,7 @@ void Camera::setCameraSensitivity(float newSensitivity)
} }
} }
void Camera::setFov(float newFov) void core::Camera::setFov(float newFov)
{ {
if (newFov > 1.0f && newFov < 179.0f) if (newFov > 1.0f && newFov < 179.0f)
{ {
@@ -129,7 +129,7 @@ void Camera::setFov(float newFov)
} }
} }
void Camera::setPosition(const glm::vec3& newPosition) void core::Camera::setPosition(const glm::vec3& newPosition)
{ {
cameraPosition = newPosition; cameraPosition = newPosition;
} }

93
src/cube.cpp
View File

@@ -1,65 +1,64 @@
// #include "primitives/cube.hpp" // #include "cube.hpp"
// #include "core/ebo.hpp"
// #include "core/vao.hpp"
// #include "core/vbo.hpp" // #include "core/vbo.hpp"
// #include "ebo.hpp"
// #include "glm/ext/matrix_clip_space.hpp" // #include "glm/ext/matrix_clip_space.hpp"
// #include "glm/ext/matrix_transform.hpp" // #include "glm/ext/matrix_transform.hpp"
// #include "glm/gtc/type_ptr.hpp" // #include "glm/gtc/type_ptr.hpp"
// #include "p_cube.hpp" // #include "primitives/p_cube.hpp"
// #include "vao.hpp"
// #include "vbo.hpp"
// static GLsizei stride = 8 * sizeof(float); // constexpr static GLsizei STRIDE = 8 * sizeof(float);
// Cube::Cube(Camera &camera, glm::vec3 pos, std::string texture) // // Cube::Cube(Camera &camera, glm::vec3 pos, std::string texture)
// : Shape(camera, pos, Shader{}, Texture{texture}) // // : Shape(camera, pos, Shader{}, Texture{texture})
// { // // {
// this->vao.bind(); // // this->vao.bind();
// this->vbo.bind(); // // this->vbo.bind();
// this->ebo.bind(); // // this->ebo.bind();
// this->vbo.setData(P_CUBE_VERTICE, sizeof(P_CUBE_VERTICE)); // // this->vbo.setData(P_CUBE_VERTICE, sizeof(P_CUBE_VERTICE));
// // positions // // // positions
// this->vao.setAttributePointer(0, 3, GL_FLOAT, stride, (void *)(0)); // // this->vao.setAttributePointer(0, 3, GL_FLOAT, stride, (void *)(0));
// // normales // // // normales
// this->vao.setAttributePointer(1, 3, GL_FLOAT, stride, // // this->vao.setAttributePointer(1, 3, GL_FLOAT, stride,
// (void *)(3 * sizeof(float))); // // (void *)(3 * sizeof(float)));
// // texture // // // texture
// this->vao.setAttributePointer(2, 2, GL_FLOAT, stride, // // this->vao.setAttributePointer(2, 2, GL_FLOAT, stride,
// (void *)(6 * sizeof(float))); // // (void *)(6 * sizeof(float)));
// this->ebo.setData(P_CUBE_INDICE, sizeof(P_CUBE_INDICE)); // // this->ebo.setData(P_CUBE_INDICE, sizeof(P_CUBE_INDICE));
// this->shader.compile((char *)P_CUBE_VERT, (char *)P_CUBE_FRAG); // // this->shader.compile((char *)P_CUBE_VERT, (char *)P_CUBE_FRAG);
// } // // }
// void Cube::render(int width, int height) // // void Cube::render(int width, int height)
// { // // {
// shader.use(); // // shader.use();
// glActiveTexture(GL_TEXTURE0); // // glActiveTexture(GL_TEXTURE0);
// glm::vec3 coordinate = glm::vec3(0.0f, 0.0f, -1.0f); // // glm::vec3 coordinate = glm::vec3(0.0f, 0.0f, -1.0f);
// glm::mat4 projection = glm::perspective( // // glm::mat4 projection = glm::perspective(
// glm::radians(this->camera.getFov()), // // glm::radians(this->camera.getFov()),
// static_cast<float>(width) / static_cast<float>(height), 0.1f, 100.0f); // // static_cast<float>(width) / static_cast<float>(height), 0.1f, 100.0f);
// GLint texLoc = // // GLint texLoc =
// glGetUniformLocation(shader.getShaderProgramID(), "material.diffuse"); // // glGetUniformLocation(shader.getShaderProgramID(), "material.diffuse");
// glUniform1i(texLoc, 0); // // glUniform1i(texLoc, 0);
// GLint projectionLoc = // // GLint projectionLoc =
// glGetUniformLocation(shader.getShaderProgramID(), "projection"); // // glGetUniformLocation(shader.getShaderProgramID(), "projection");
// glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection)); // // glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
// GLint viewLoc = glGetUniformLocation(shader.getShaderProgramID(), "view"); // // GLint viewLoc = glGetUniformLocation(shader.getShaderProgramID(), "view");
// glUniformMatrix4fv(viewLoc, 1, GL_FALSE, // // glUniformMatrix4fv(viewLoc, 1, GL_FALSE,
// glm::value_ptr(camera.getViewMatrix())); // // glm::value_ptr(camera.getViewMatrix()));
// glm::mat4 model = glm::translate(glm::mat4(1.0f), coordinate); // // glm::mat4 model = glm::translate(glm::mat4(1.0f), coordinate);
// GLint modelLoc = glGetUniformLocation(shader.getShaderProgramID(), "model"); // // GLint modelLoc = glGetUniformLocation(shader.getShaderProgramID(),
// glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); // // "model"); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
// vao.drawElement(GL_TRIANGLES, sizeof(P_CUBE_INDICE) / sizeof(unsigned int), // // vao.drawElement(GL_TRIANGLES, sizeof(P_CUBE_INDICE) / sizeof(unsigned int),
// GL_UNSIGNED_INT, 0); // // GL_UNSIGNED_INT, 0);
// } // // }

58
src/main.cpp
View File

@@ -1,8 +1,13 @@
#include "core/core.hpp" #include "core/core.hpp"
#include "core/ebo.hpp" #include "glm/ext/matrix_clip_space.hpp"
#include "core/shader.hpp" #include "glm/ext/matrix_transform.hpp"
#include "glm/fwd.hpp"
#include "glm/gtc/type_ptr.hpp"
#include "primitives/p_cube.hpp"
#include "primitives/p_triangle.hpp" #include "primitives/p_triangle.hpp"
using namespace mesh;
int main() int main()
{ {
// Game game{800, 600, "window"}; // Game game{800, 600, "window"};
@@ -57,34 +62,65 @@ int main()
glfwSwapInterval(1); // activate vsync glfwSwapInterval(1); // activate vsync
// glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
// glEnable(GL_MULTISAMPLE); glEnable(GL_MULTISAMPLE);
// CUBE
core::VAO vao{}; core::VAO vao{};
core::VBO vbo{mesh::P_TRIANGLE_VERTICE, sizeof(mesh::P_TRIANGLE_VERTICE)}; core::VBO vbo{P_CUBE_VERTICE, sizeof(P_CUBE_VERTICE)};
core::EBO ebo{mesh::P_TRIANGLE_INDICE, sizeof(mesh::P_TRIANGLE_INDICE)}; core::EBO ebo{P_CUBE_INDICE, sizeof(P_CUBE_INDICE)};
core::Shader shader{(char *)mesh::P_TRIANGLE_VERT, core::Shader shader{(char *)P_CUBE_VERT, (char *)P_CUBE_FRAG};
(char *)mesh::P_TRIANGLE_FRAG};
// CAMERA
core::Camera camera(width, height, window, .1f);
// BINDING
vao.bind(); vao.bind();
vbo.bind(); vbo.bind();
ebo.bind(); ebo.bind();
vao.setAttributePointer(0, 3, GL_FLOAT, 3 * sizeof(GLfloat), (void *)(0)); // positions
vao.setAttributePointer(0, 3, GL_FLOAT, 8 * sizeof(GLfloat), (void *)(0));
// normales
vao.setAttributePointer(1, 3, GL_FLOAT, 8 * sizeof(GLfloat),
(void *)(3 * sizeof(float)));
// texture
vao.setAttributePointer(2, 2, GL_FLOAT, 8 * sizeof(GLfloat),
(void *)(6 * sizeof(float)));
glm::vec3 coordinate = glm::vec3(0.0f, 0.0f, -10.0f);
time.start(); time.start();
while (!glfwWindowShouldClose(window)) while (!glfwWindowShouldClose(window))
{ {
glfwGetFramebufferSize(window, &width, &height); glfwGetFramebufferSize(window, &width, &height);
glfwGetWindowSize(window, &width, &height);
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
glClearColor(0.5f, 0.2f, 0.2f, 1.0f); glClearColor(0.5f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
camera.update(time.getDeltaTime());
shader.use(); shader.use();
vao.drawElement(GL_TRIANGLES, mesh::P_TRIANGLE_INDICE_LEN, GL_UNSIGNED_INT, 0); // projection matrix
const glm::float32 *view = glm::value_ptr(camera.getViewMatrix());
glm::mat4 model = glm::translate(glm::mat4(1.0f), coordinate);
glm::mat4 projection = glm::perspective(
glm::radians(camera.getFov()),
static_cast<float>(width) / static_cast<float>(height), 0.1f, 100.f);
glUniformMatrix4fv(glGetUniformLocation(shader.getId(), "projection"), 1,
GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(shader.getId(), "view"), 1,
GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
glUniformMatrix4fv(glGetUniformLocation(shader.getId(), "model"), 1,
GL_FALSE, glm::value_ptr(model));
vao.drawElement(GL_TRIANGLES, sizeof(P_TRIANGLE_VERTICE), GL_UNSIGNED_INT,
0);
glfwPollEvents(); glfwPollEvents();
glfwSwapBuffers(window); glfwSwapBuffers(window);