mirror of
https://github.com/orange-cpp/omath.git
synced 2026-02-13 07:03:25 +00:00
333 lines
10 KiB
C++
333 lines
10 KiB
C++
// main.cpp
|
|
#include <cstdint>
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
// --- OpenGL / windowing ---
|
|
#include <GL/glew.h> // GLEW must come before GLFW
|
|
#include <GLFW/glfw3.h>
|
|
|
|
// --- your math / engine stuff ---
|
|
#include "omath/3d_primitives/mesh.hpp"
|
|
#include "omath/engines/opengl_engine/camera.hpp"
|
|
#include "omath/engines/opengl_engine/constants.hpp"
|
|
#include "omath/engines/opengl_engine/mesh.hpp"
|
|
#include "omath/linear_algebra/vector3.hpp"
|
|
|
|
using omath::Vector3;
|
|
|
|
// ---------------- TYPE ALIASES (ADAPT TO YOUR LIB) ----------------
|
|
|
|
// Your 4x4 matrix type
|
|
using Mat4x4 = omath::opengl_engine::Mat4X4;
|
|
|
|
// Rotation angles for the Mesh (whatever you use for rotation)
|
|
using RotationAngles =
|
|
omath::opengl_engine::ViewAngles; // TODO: if you have a dedicated angle type for mesh rotation, use it
|
|
|
|
// View angles type for camera trait
|
|
using ViewAngles = RotationAngles; // TODO: if your camera uses a different view-angle type, change this
|
|
|
|
// Your trait types (that satisfy the concepts declared in your headers)
|
|
using CameraTrait = /* TODO: your camera engine trait type here */ void;
|
|
using MeshTrait = /* TODO: your mesh rotation trait type here */ void;
|
|
|
|
// For brevity, alias the templates instantiated with your types
|
|
using VertexType = omath::primitives::Vertex<Vector3<float>>;
|
|
using CubeMesh = omath::opengl_engine::Mesh;
|
|
using MyCamera = omath::opengl_engine::Camera;
|
|
|
|
// ---------------- SHADERS ----------------
|
|
|
|
static const char* vertexShaderSource = R"(
|
|
#version 330 core
|
|
layout (location = 0) in vec3 aPos;
|
|
layout (location = 1) in vec3 aNormal;
|
|
layout (location = 2) in vec3 aUv;
|
|
|
|
uniform mat4 uMVP;
|
|
uniform mat4 uModel;
|
|
out vec3 vNormal;
|
|
out vec3 vUv;
|
|
|
|
void main() {
|
|
vNormal = aNormal;
|
|
vUv = aUv;
|
|
gl_Position = uMVP * uModel * vec4(aPos, 1.0);
|
|
}
|
|
)";
|
|
|
|
static const char* fragmentShaderSource = R"(
|
|
#version 330 core
|
|
in vec3 vNormal;
|
|
in vec3 vUv;
|
|
|
|
out vec4 FragColor;
|
|
|
|
void main() {
|
|
vec3 baseColor = normalize(abs(vNormal));
|
|
FragColor = vec4(baseColor, 1.0);
|
|
}
|
|
)";
|
|
|
|
GLuint compileShader(GLenum type, const char* src)
|
|
{
|
|
GLuint shader = glCreateShader(type);
|
|
glShaderSource(shader, 1, &src, nullptr);
|
|
glCompileShader(shader);
|
|
|
|
GLint ok = GL_FALSE;
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
|
|
if (!ok)
|
|
{
|
|
char log[1024];
|
|
glGetShaderInfoLog(shader, sizeof(log), nullptr, log);
|
|
std::cerr << "Shader compile error: " << log << std::endl;
|
|
}
|
|
return shader;
|
|
}
|
|
|
|
GLuint createShaderProgram()
|
|
{
|
|
GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
|
|
GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
|
|
|
|
GLuint prog = glCreateProgram();
|
|
glAttachShader(prog, vs);
|
|
glAttachShader(prog, fs);
|
|
glLinkProgram(prog);
|
|
|
|
GLint ok = GL_FALSE;
|
|
glGetProgramiv(prog, GL_LINK_STATUS, &ok);
|
|
if (!ok)
|
|
{
|
|
char log[1024];
|
|
glGetProgramInfoLog(prog, sizeof(log), nullptr, log);
|
|
std::cerr << "Program link error: " << log << std::endl;
|
|
}
|
|
|
|
glDeleteShader(vs);
|
|
glDeleteShader(fs);
|
|
return prog;
|
|
}
|
|
|
|
void framebuffer_size_callback(GLFWwindow* /*window*/, int w, int h)
|
|
{
|
|
glViewport(0, 0, w, h);
|
|
}
|
|
|
|
// ---------------- MAIN ----------------
|
|
|
|
int main()
|
|
{
|
|
// ---------- GLFW init ----------
|
|
if (!glfwInit())
|
|
{
|
|
std::cerr << "Failed to init GLFW\n";
|
|
return -1;
|
|
}
|
|
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
|
#ifdef __APPLE__
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
|
|
#endif
|
|
|
|
const int SCR_WIDTH = 800;
|
|
const int SCR_HEIGHT = 600;
|
|
|
|
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "omath cube + camera (GLEW)", nullptr, nullptr);
|
|
if (!window)
|
|
{
|
|
std::cerr << "Failed to create GLFW window\n";
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
glfwMakeContextCurrent(window);
|
|
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
|
|
|
|
// ---------- GLEW init ----------
|
|
glewExperimental = GL_TRUE;
|
|
GLenum glewErr = glewInit();
|
|
if (glewErr != GLEW_OK)
|
|
{
|
|
std::cerr << "Failed to initialize GLEW: " << reinterpret_cast<const char*>(glewGetErrorString(glewErr))
|
|
<< "\n";
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
// ---------- Build Cube Mesh (CPU side) ----------
|
|
std::vector<omath::primitives::Vertex<>> vbo;
|
|
vbo.reserve(8);
|
|
|
|
Vector3<float> p000{-0.5f, -0.5f, -0.5f};
|
|
Vector3<float> p001{-0.5f, -0.5f, 0.5f};
|
|
Vector3<float> p010{-0.5f, 0.5f, -0.5f};
|
|
Vector3<float> p011{-0.5f, 0.5f, 0.5f};
|
|
Vector3<float> p100{0.5f, -0.5f, -0.5f};
|
|
Vector3<float> p101{0.5f, -0.5f, 0.5f};
|
|
Vector3<float> p110{0.5f, 0.5f, -0.5f};
|
|
Vector3<float> p111{0.5f, 0.5f, 0.5f};
|
|
|
|
VertexType v0{p000, Vector3<float>{-1, -1, -1}, Vector3<float>{0, 0, 0}};
|
|
VertexType v1{p001, Vector3<float>{-1, -1, 1}, Vector3<float>{0, 1, 0}};
|
|
VertexType v2{p010, Vector3<float>{-1, 1, -1}, Vector3<float>{1, 0, 0}};
|
|
VertexType v3{p011, Vector3<float>{-1, 1, 1}, Vector3<float>{1, 1, 0}};
|
|
VertexType v4{p100, Vector3<float>{1, -1, -1}, Vector3<float>{0, 0, 1}};
|
|
VertexType v5{p101, Vector3<float>{1, -1, 1}, Vector3<float>{0, 1, 1}};
|
|
VertexType v6{p110, Vector3<float>{1, 1, -1}, Vector3<float>{1, 0, 1}};
|
|
VertexType v7{p111, Vector3<float>{1, 1, 1}, Vector3<float>{1, 1, 1}};
|
|
|
|
vbo.push_back(v0); // 0
|
|
vbo.push_back(v1); // 1
|
|
vbo.push_back(v2); // 2
|
|
vbo.push_back(v3); // 3
|
|
vbo.push_back(v4); // 4
|
|
vbo.push_back(v5); // 5
|
|
vbo.push_back(v6); // 6
|
|
vbo.push_back(v7); // 7
|
|
|
|
std::vector<Vector3<std::uint32_t>> ebo;
|
|
ebo.reserve(12);
|
|
using Idx = Vector3<std::uint32_t>;
|
|
|
|
// front (z+)
|
|
ebo.emplace_back(Idx{1, 5, 7});
|
|
ebo.emplace_back(Idx{1, 7, 3});
|
|
|
|
// back (z-)
|
|
ebo.emplace_back(Idx{0, 2, 6});
|
|
ebo.emplace_back(Idx{0, 6, 4});
|
|
|
|
// left (x-)
|
|
ebo.emplace_back(Idx{0, 1, 3});
|
|
ebo.emplace_back(Idx{0, 3, 2});
|
|
|
|
// right (x+)
|
|
ebo.emplace_back(Idx{4, 6, 7});
|
|
ebo.emplace_back(Idx{4, 7, 5});
|
|
|
|
// bottom (y-)
|
|
ebo.emplace_back(Idx{0, 4, 5});
|
|
ebo.emplace_back(Idx{0, 5, 1});
|
|
|
|
// top (y+)
|
|
ebo.emplace_back(Idx{2, 3, 7});
|
|
ebo.emplace_back(Idx{2, 7, 6});
|
|
|
|
CubeMesh cube{std::move(vbo), std::move(ebo)};
|
|
cube.set_origin(Vector3<float>{0.f, 0.f, 0.f});
|
|
cube.set_scale(Vector3<float>{1.f, 2.f, 1.f});
|
|
cube.set_rotation(RotationAngles{});
|
|
|
|
// ---------- OpenGL buffers ----------
|
|
GLuint VAO = 0, VBO = 0, EBO_GL = 0;
|
|
glGenVertexArrays(1, &VAO);
|
|
glGenBuffers(1, &VBO);
|
|
glGenBuffers(1, &EBO_GL);
|
|
|
|
glBindVertexArray(VAO);
|
|
|
|
// upload vertex buffer
|
|
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
|
glBufferData(GL_ARRAY_BUFFER, cube.m_vertex_buffer.size() * sizeof(VertexType), cube.m_vertex_buffer.data(),
|
|
GL_STATIC_DRAW);
|
|
|
|
// flatten Ebo to GL indices
|
|
std::vector<GLuint> flatIndices;
|
|
flatIndices.reserve(cube.m_vertex_array_object.size() * 3);
|
|
for (const auto& tri : cube.m_vertex_array_object)
|
|
{
|
|
flatIndices.push_back(tri.x);
|
|
flatIndices.push_back(tri.y);
|
|
flatIndices.push_back(tri.z);
|
|
}
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO_GL);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, flatIndices.size() * sizeof(GLuint), flatIndices.data(), GL_STATIC_DRAW);
|
|
|
|
// vertex layout: position / normal / uv (each Vector3<float>)
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, position));
|
|
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, normal));
|
|
|
|
glEnableVertexAttribArray(2);
|
|
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, uv));
|
|
|
|
glBindVertexArray(0);
|
|
|
|
// ---------- Camera setup ----------
|
|
omath::projection::ViewPort viewPort{static_cast<float>(SCR_WIDTH), static_cast<float>(SCR_HEIGHT)};
|
|
|
|
Vector3<float> camPos{0.f, 0.f, 3.f};
|
|
|
|
float nearPlane = 0.1f;
|
|
float farPlane = 100.f;
|
|
auto fov = omath::projection::FieldOfView::from_degrees(90.f);
|
|
// NOTE: you must replace CameraTrait alias above with your real type
|
|
MyCamera camera{camPos, {}, viewPort, fov, nearPlane, farPlane};
|
|
|
|
// ---------- Shader ----------
|
|
GLuint shaderProgram = createShaderProgram();
|
|
GLint uMvpLoc = glGetUniformLocation(shaderProgram, "uMVP");
|
|
GLint uModel = glGetUniformLocation(shaderProgram, "uModel");
|
|
static float old_frame_time = glfwGetTime();
|
|
|
|
// ---------- Main loop ----------
|
|
while (!glfwWindowShouldClose(window))
|
|
{
|
|
glfwPollEvents();
|
|
|
|
float currentTime = glfwGetTime();
|
|
float deltaTime = currentTime - old_frame_time;
|
|
old_frame_time = currentTime;
|
|
int fbW, fbH;
|
|
glfwGetFramebufferSize(window, &fbW, &fbH);
|
|
glViewport(0, 0, fbW, fbH);
|
|
|
|
viewPort.m_width = static_cast<float>(fbW);
|
|
viewPort.m_height = static_cast<float>(fbH);
|
|
camera.set_view_port(viewPort);
|
|
|
|
glClearColor(0.1f, 0.15f, 0.2f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
RotationAngles rot = cube.get_rotation_angles();
|
|
rot.yaw += omath::opengl_engine::YawAngle::from_degrees(40.f * deltaTime);
|
|
rot.roll += omath::opengl_engine::YawAngle::from_degrees(40.f * deltaTime);
|
|
cube.set_rotation(rot);
|
|
|
|
const Mat4x4& viewProj = camera.get_view_projection_matrix();
|
|
const auto& model = cube.get_to_world_matrix();
|
|
glUseProgram(shaderProgram);
|
|
|
|
// Send matrix to GPU
|
|
// TODO: replace mvp.data() with whatever your Mat4x4 uses to expose float*
|
|
const float* mvpPtr = viewProj.raw_array().data(); // assumes column-major float[16]
|
|
|
|
glUniformMatrix4fv(uMvpLoc, 1, GL_FALSE, mvpPtr);
|
|
const float* modelPtr = model.raw_array().data(); // assumes column-major float[16]
|
|
glBindVertexArray(VAO);
|
|
glUniformMatrix4fv(uModel, 1, GL_FALSE, modelPtr);
|
|
glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(flatIndices.size()), GL_UNSIGNED_INT, nullptr);
|
|
|
|
glfwSwapBuffers(window);
|
|
}
|
|
|
|
// ---------- Cleanup ----------
|
|
glDeleteVertexArrays(1, &VAO);
|
|
glDeleteBuffers(1, &VBO);
|
|
glDeleteBuffers(1, &EBO_GL);
|
|
glDeleteProgram(shaderProgram);
|
|
|
|
glfwDestroyWindow(window);
|
|
glfwTerminate();
|
|
return 0;
|
|
} |