tarion/Engine2026
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

restructure work

Browse source
This commit is contained in:
Claire Schwarzer 2026-07-04 17:43:15 +02:00
parent 64c8492e5c
commit e01595e155
3424 changed files with 492 additions and 1696851 deletions
Download patch file Download diff file Expand all files Collapse all files

252
mainold.cpp Normal file
View file

@ -0,0 +1,252 @@
#include <iomanip>
#include <iostream>
#include <glad/glad.h>
#include <glfw/include/GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <engine/shader.h>
#include <engine/model.h>
#include <engine/camera.h>
#include <engine/assets/modelLoader.h>
void window_resize_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void processInput(GLFWwindow *window);
int SCREEN_WIDTH = 1920;
int SCREEN_HEIGHT = 1080;
static bool drawWireframe = false;
static bool wireframeHeld = false;
static bool flashlight = true;
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
float lastX = SCREEN_WIDTH / 2.0f;
float lastY = SCREEN_HEIGHT / 2.0f;
bool firstMouse = true;
float deltaTime = 0.0f; // time between current frame and last frame
float lastFrame = 0.0f;
int main(int argc, char* argv[])
{
// Initialize GLFW
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Create GLFW Window
GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Renderer", NULL, NULL);
if (window == NULL)
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
// Initialize GLAD
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
{
std::cout << "Failed to initialize GLAD" << std::endl;
return -1;
}
// Initialize Viewport & setup resize callback
glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
glfwSetFramebufferSizeCallback(window, window_resize_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
glEnable(GL_DEPTH_TEST);
// Hide & Lock Cursor
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetInputMode(window, GLFW_RAW_MOUSE_MOTION, GLFW_TRUE);
/*
Testing
*/
Shader shaderTest("assets/shaders/basicVertex.vert", "assets/shaders/basicFragment.frag");
Model ourModel = engine::assets::loadModel("assets/models/sponza/Sponza.gltf");
shaderTest.Use();
shaderTest.setInt("ourTexture", 0);
shaderTest.setInt("material.diffuse", 0);
shaderTest.setInt("material.specular", 1);
// Set decals - TODO: Shift this to mesh.h with helpers
shaderTest.setDecal(0, 2, 1, glm::vec4(0.5, 0.5, 0, 0));
shaderTest.setDecal(1, 2, 1, glm::vec4(0.5, 0.5, -0.75, -0.75));
shaderTest.setInt("numberOfDecals", 2);
shaderTest.setInt("numberOfPointLights", 1);
shaderTest.setInt("numberOfSpotLights", 1);
// Render Loop
float lastUpdate = 0;
while (!glfwWindowShouldClose(window))
{
// per-frame time logic
float currentFrame = static_cast<float>(glfwGetTime());
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// crappy fps printout
if (currentFrame - lastUpdate >= 1.0) {
// std::cout << 1.0f / deltaTime << std::endl;
lastUpdate += 1.0f;
}
// Input processing
processInput(window);
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderTest.Use();
camera.Update(shaderTest, SCREEN_WIDTH, SCREEN_HEIGHT);
shaderTest.setFloat("material.shininess", 32.0f);
shaderTest.setVec3("dirLight.direction", -0.2f, -1.0f, -0.3f);
shaderTest.setVec3("dirLight.ambient", 0.05f, 0.05f, 0.05f);
shaderTest.setVec3("dirLight.diffuse", 0.8f, 0.8f, 0.8f);
shaderTest.setVec3("dirLight.specular", 0.8f, 0.8f, 0.8f);
// -----------------------------------------------------------------------------
// Ground Floor - Right Corridor (Warm Light)
// Placed halfway down the right hallway behind the arches
// -----------------------------------------------------------------------------
shaderTest.setVec3("pointLights[0].position", -1.88f, 8.45f, -0.98f);
shaderTest.setVec3("pointLights[0].ambient", 0.05f, 0.05f, 0.05f);
shaderTest.setVec3("pointLights[0].diffuse", 1.0f, 0.7f, 0.4f);
shaderTest.setVec3("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
shaderTest.setFloat("pointLights[0].constant", 1.0f);
shaderTest.setFloat("pointLights[0].linear", 0.09f);
shaderTest.setFloat("pointLights[0].quadratic", 0.032f);
// spotLight1
shaderTest.setBool("spotLights[0].disabled", flashlight);
shaderTest.setVec3("spotLights[0].position", camera.position);
shaderTest.setVec3("spotLights[0].direction", camera.front);
shaderTest.setVec3("spotLights[0].ambient", 0.0f, 0.0f, 0.0f);
shaderTest.setVec3("spotLights[0].diffuse", 1.0f, 1.0f, 1.0f);
shaderTest.setVec3("spotLights[0].specular", 1.0f, 1.0f, 1.0f);
shaderTest.setFloat("spotLights[0].constant", 1.0f);
shaderTest.setFloat("spotLights[0].linear", 0.09f);
shaderTest.setFloat("spotLights[0].quadratic", 0.032f);
shaderTest.setFloat("spotLights[0].cutOff", glm::cos(glm::radians(12.5f)));
shaderTest.setFloat("spotLights[0].outerCutOff", glm::cos(glm::radians(15.0f)));
// render the loaded model
glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));
model = glm::scale(model, glm::vec3(0.02f, 0.02f, 0.02f));
shaderTest.setMat4("model", model);
ourModel.Draw(shaderTest);
// Call events & swap buffers
glfwSwapBuffers(window);
glfwPollEvents();
}
// Clean up memory
glfwTerminate();
return 0;
}
void window_resize_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
SCREEN_WIDTH = width;
SCREEN_HEIGHT = height;
}
void processInput(GLFWwindow* window)
{
// Close on Escape
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
// Wireframe toggle
if (glfwGetKey(window, GLFW_KEY_F1) == GLFW_PRESS && !wireframeHeld)
{
wireframeHeld = true;
drawWireframe = !drawWireframe;
if (drawWireframe)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
}
if (glfwGetKey(window, GLFW_KEY_F1) == GLFW_RELEASE)
wireframeHeld = false;
// Flashlight toggle
if (glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS && !wireframeHeld)
{
wireframeHeld = true;
flashlight = !flashlight;
}
if (glfwGetKey(window, GLFW_KEY_F) == GLFW_RELEASE)
wireframeHeld = false;
// Camera
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera.processKeyboard(FORWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera.processKeyboard(BACKWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera.processKeyboard(LEFT, deltaTime);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera.processKeyboard(RIGHT, deltaTime);
if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
camera.processKeyboard(SPRINT, deltaTime);
}
// glfw: whenever the mouse moves, this callback is called
// -------------------------------------------------------
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
float xpos = static_cast<float>(xposIn);
float ypos = static_cast<float>(yposIn);
if (firstMouse)
{
lastX = xpos;
lastY = ypos;
firstMouse = false;
}
float xoffset = xpos - lastX;
float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top
lastX = xpos;
lastY = ypos;
camera.processMouseMovement(xoffset, yoffset);
}
// glfw: whenever the mouse scroll wheel scrolls, this callback is called
// ----------------------------------------------------------------------
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
camera.processMouseScroll(static_cast<float>(yoffset));
}