From 498de84943c5d01d6502c7b7d5ec647374e9aad8 Mon Sep 17 00:00:00 2001 From: Derek Christ Date: Sun, 4 Jul 2021 19:42:12 +0200 Subject: [PATCH] Add m_ to member variables. --- src/CMakeLists.txt | 2 +- src/Camera.cpp | 66 ++++++------ src/Camera.h | 20 ++-- src/Controller.cpp | 114 ++++++++++---------- src/Controller.h | 23 ++--- src/Entity.cpp | 84 +++++++-------- src/Entity.h | 33 +++--- src/EventHandler.cpp | 100 +++++++++--------- src/EventHandler.h | 15 ++- src/{Framebuffer.cpp => FrameBuffer.cpp} | 94 ++++++++--------- src/{Framebuffer.h => FrameBuffer.h} | 31 +++--- src/Helper.cpp | 14 +-- src/Helper.h | 8 +- src/JsonParser.cpp | 22 ++-- src/JsonParser.h | 7 +- src/Light.cpp | 52 +++++----- src/Light.h | 21 ++-- src/Menu.cpp | 28 ++--- src/Menu.h | 16 +-- src/Mesh.cpp | 26 ++--- src/Mesh.h | 7 +- src/Model.cpp | 44 ++++---- src/Model.h | 21 ++-- src/Screen.cpp | 40 +++---- src/Screen.h | 20 ++-- src/ShaderProgram.cpp | 44 ++++---- src/ShaderProgram.h | 10 +- src/Texture.cpp | 67 ++++++------ src/Texture.h | 21 ++-- src/VertexArray.cpp | 16 +-- src/VertexArray.h | 6 +- src/Widget.cpp | 36 ++++--- src/Widget.h | 16 +-- src/Window.cpp | 40 +++---- src/Window.h | 9 +- src/World.cpp | 126 ++++++++++++----------- src/World.h | 34 +++--- tools/main.cpp | 16 +-- tools/primitiveModel.h | 8 +- 39 files changed, 679 insertions(+), 678 deletions(-) rename src/{Framebuffer.cpp => FrameBuffer.cpp} (55%) rename src/{Framebuffer.h => FrameBuffer.h} (63%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index cc6cc48..5dc78eb 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -12,7 +12,7 @@ add_executable(Fall-Fever Entity.cpp Light.cpp World.cpp - Framebuffer.cpp + FrameBuffer.cpp Widget.cpp Screen.cpp Menu.cpp diff --git a/src/Camera.cpp b/src/Camera.cpp index 8bbf048..5de4730 100644 --- a/src/Camera.cpp +++ b/src/Camera.cpp @@ -6,66 +6,66 @@ Camera::Camera(float fov, float aspectRatio) { - this->fov = fov; - viewMatrix = glm::mat4(1.0f); + this->m_fov = fov; + m_viewMatrix = glm::mat4(1.0f); updateAspectRatio(aspectRatio); updateVPM(); } void Camera::updateVPM() { - viewProjectionMatrix = projectionMatrix * viewMatrix; + m_viewProjectionMatrix = m_projectionMatrix * m_viewMatrix; } void Camera::updateAspectRatio(float aspectRatio) { - // projectionMatrix = glm::ortho(-2.0f, 2.0f, -2.0f, 2.0f, -10.f, 100.0f); - projectionMatrix = glm::perspective(fov / 2.0f, aspectRatio, 0.1f, 1000.0f); + // m_projectionMatrix = glm::ortho(-2.0f, 2.0f, -2.0f, 2.0f, -10.f, 100.0f); + m_projectionMatrix = glm::perspective(m_fov / 2.0f, aspectRatio, 0.1f, 1000.0f); updateVPM(); } void Camera::translate(glm::vec3 translateVector) { - position += translateVector; - viewMatrix = glm::translate(viewMatrix, translateVector * -1.0f); + m_position += translateVector; + m_viewMatrix = glm::translate(m_viewMatrix, translateVector * -1.0f); } void Camera::lookAtTarget(glm::vec3 target) { - viewMatrix = glm::lookAt(position, target, upVec); + m_viewMatrix = glm::lookAt(m_position, target, m_upVec); } void Camera::lookForward() { - viewMatrix = glm::lookAt(position, position + frontVec, upVec); + m_viewMatrix = glm::lookAt(m_position, m_position + m_frontVec, m_upVec); } void Camera::updatePositionFromKeyboardInput(const CameraActionMap &cameraActionMap, float deltaTime) { - glm::vec3 frontVecWithoutY = glm::vec3(frontVec.x, 0.0f, frontVec.z); + glm::vec3 frontVecWithoutY = glm::vec3(m_frontVec.x, 0.0f, m_frontVec.z); glm::vec3 deltaPos = glm::vec3(0.0f, 0.0f, 0.0f); if (cameraActionMap.at(CameraAction::Forward)) { - deltaPos += speed * deltaTime * glm::normalize(frontVecWithoutY); + deltaPos += m_speed * deltaTime * glm::normalize(frontVecWithoutY); } if (cameraActionMap.at(CameraAction::Backward)) { - deltaPos -= speed * deltaTime * glm::normalize(frontVecWithoutY); + deltaPos -= m_speed * deltaTime * glm::normalize(frontVecWithoutY); } if (cameraActionMap.at(CameraAction::Left)) { - deltaPos -= speed * deltaTime * glm::normalize(glm::cross(frontVec, upVec)); + deltaPos -= m_speed * deltaTime * glm::normalize(glm::cross(m_frontVec, m_upVec)); } if (cameraActionMap.at(CameraAction::Right)) { - deltaPos += speed * deltaTime * glm::normalize(glm::cross(frontVec, upVec)); + deltaPos += m_speed * deltaTime * glm::normalize(glm::cross(m_frontVec, m_upVec)); } if (cameraActionMap.at(CameraAction::Up)) { - deltaPos += speed * deltaTime * upVec; + deltaPos += m_speed * deltaTime * m_upVec; } if (cameraActionMap.at(CameraAction::Down)) { - deltaPos -= speed * deltaTime * upVec; + deltaPos -= m_speed * deltaTime * m_upVec; } - position += deltaPos; + m_position += deltaPos; } void Camera::updateDirectionFromMouseInput(const CameraMouseActionMap &cameraMouseActionMap) @@ -76,49 +76,49 @@ void Camera::updateDirectionFromMouseInput(const CameraMouseActionMap &cameraMou return; } - yaw += cameraMouseActionMap.at(CameraMouseAction::DeltaX); - pitch += cameraMouseActionMap.at(CameraMouseAction::DeltaY); + m_yaw += cameraMouseActionMap.at(CameraMouseAction::DeltaX); + m_pitch += cameraMouseActionMap.at(CameraMouseAction::DeltaY); - if (pitch > 89.0f) { - pitch = 89.0f; + if (m_pitch > 89.0f) { + m_pitch = 89.0f; } - if (pitch < -89.0f) { - pitch = -89.0f; + if (m_pitch < -89.0f) { + m_pitch = -89.0f; } glm::vec3 direction; - direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); - direction.y = sin(glm::radians(pitch)); - direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); - frontVec = glm::normalize(direction); + direction.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch)); + direction.y = sin(glm::radians(m_pitch)); + direction.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch)); + m_frontVec = glm::normalize(direction); } void Camera::setPosition(glm::vec3 position) { - this->position = position; + this->m_position = position; } glm::mat4 Camera::getView() { - return viewMatrix; + return m_viewMatrix; } glm::mat4 Camera::getProj() { - return projectionMatrix; + return m_projectionMatrix; } glm::mat4 Camera::getViewProj() { - return viewProjectionMatrix; + return m_viewProjectionMatrix; } glm::vec3 Camera::getPosition() { - return position; + return m_position; } glm::vec3 Camera::getDirection() { - return frontVec; + return m_frontVec; } diff --git a/src/Camera.h b/src/Camera.h index 870daab..29c556f 100644 --- a/src/Camera.h +++ b/src/Camera.h @@ -29,18 +29,18 @@ public: void setPosition(glm::vec3 position); private: - glm::mat4 viewMatrix; - glm::mat4 projectionMatrix; - glm::mat4 viewProjectionMatrix; + glm::mat4 m_viewMatrix; + glm::mat4 m_projectionMatrix; + glm::mat4 m_viewProjectionMatrix; - glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f); - glm::vec3 frontVec = glm::vec3(0.0f, 0.0f, -1.0f); - glm::vec3 upVec = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 m_position = glm::vec3(0.0f, 0.0f, 0.0f); + glm::vec3 m_frontVec = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 m_upVec = glm::vec3(0.0f, 1.0f, 0.0f); - float pitch = 0.0f; - float yaw = -90.0f; + float m_pitch = 0.0f; + float m_yaw = -90.0f; - float speed = 2.0f; + float m_speed = 2.0f; - float fov; + float m_fov; }; diff --git a/src/Controller.cpp b/src/Controller.cpp index bec6ab6..ccc250e 100644 --- a/src/Controller.cpp +++ b/src/Controller.cpp @@ -25,28 +25,28 @@ Controller::Controller() { - gameWindow = new Window(); - gameEventHandler = new EventHandler(gameWindow->getGLFWwindow()); + m_gameWindow = new Window(); + m_gameEventHandler = new EventHandler(m_gameWindow->getGLFWwindow()); - camera = new Camera(90.0f, gameWindow->getWindowAspectRatio()); + m_camera = new Camera(90.0f, m_gameWindow->getWindowAspectRatio()); JsonParser shaderParser("data/shaderPrograms.json"); - shaderPrograms = shaderParser.getShaderPrograms(); + m_shaderPrograms = shaderParser.getShaderPrograms(); - pp_framebuffer = new Framebuffer(gameWindow->getWindowWidth(), gameWindow->getWindowHeight(), - getShaderProgramByName("postProcessingProgram")); + m_postProcessFrameBuffer = new FrameBuffer(m_gameWindow->getWindowWidth(), m_gameWindow->getWindowHeight(), + getShaderProgramByName("postProcessingProgram")); - menu = new Menu(pp_framebuffer, getShaderProgramByName("menuProgram")); + m_menu = new Menu(m_postProcessFrameBuffer, getShaderProgramByName("menuProgram")); // Show loading screen... glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - menu->showScreenByName("loadingScreen"); - glfwSwapBuffers(gameWindow->getGLFWwindow()); + m_menu->showScreenByName("loadingScreen"); + glfwSwapBuffers(m_gameWindow->getGLFWwindow()); // Show main menu when loading is finished... - menu->showScreenByName("mainMenuScreen"); + m_menu->showScreenByName("mainMenuScreen"); - world = new World(shaderPrograms); + m_world = new World(m_shaderPrograms); #ifdef _DEBUG // Setup Dear ImGui context @@ -55,7 +55,7 @@ Controller::Controller() ImGuiIO &io = ImGui::GetIO(); (void)io; // Setup Platform/Renderer bindings - ImGui_ImplGlfw_InitForOpenGL(gameWindow->getGLFWwindow(), true); + ImGui_ImplGlfw_InitForOpenGL(m_gameWindow->getGLFWwindow(), true); ImGui_ImplOpenGL3_Init("#version 150"); // Setup Dear ImGui style ImGui::StyleColorsDark(); @@ -70,32 +70,32 @@ Controller::~Controller() ImGui::DestroyContext(); #endif - for (auto it = shaderPrograms.begin(); it != shaderPrograms.end(); it++) { + for (auto it = m_shaderPrograms.begin(); it != m_shaderPrograms.end(); it++) { delete *it; } - delete world; - delete camera; - delete menu; - delete pp_framebuffer; - delete gameEventHandler; - delete gameWindow; + delete m_world; + delete m_camera; + delete m_menu; + delete m_postProcessFrameBuffer; + delete m_gameEventHandler; + delete m_gameWindow; } void Controller::run() { updateExposure(getShaderProgramByName("postProcessingProgram")); - Entity *lightSource = world->getEntityByName("light"); + Entity *lightSource = m_world->getEntityByName("light"); lightSource->setScale(0.1f); lightSource->setRotation(glm::vec3(0.f)); lightSource->setPosition(glm::vec3(-2.f, 1.5f, 2.f)); lightSource->setIsLightSource(true); - camera->translate(glm::vec3(0.0f, 1.5f, 5.0f)); + m_camera->translate(glm::vec3(0.0f, 1.5f, 5.0f)); // This is the game loop - while (!glfwWindowShouldClose(gameWindow->getGLFWwindow())) { + while (!glfwWindowShouldClose(m_gameWindow->getGLFWwindow())) { // --- Timing --- limit_framerate(); @@ -106,15 +106,15 @@ void Controller::run() if (rotateLightSource) { float radius = 4.0; glm::vec3 newPos = glm::vec3(-cos(glfwGetTime() * 0.5), 0.5f, sin(glfwGetTime() * 0.5)) * radius; - world->getEntityByName("light")->setPosition(newPos); + m_world->getEntityByName("light")->setPosition(newPos); } if (rotateEntity) { - world->getEntityById(0)->rotate(glm::vec3(0.0f, 1.0f, 0.0f), -0.2f * deltaTime); + m_world->getEntityById(0)->rotate(glm::vec3(0.0f, 1.0f, 0.0f), -0.2f * m_deltaTime); } static glm::vec3 lightColor = glm::vec3(1.f); static float intensity = 7.5f; - world->updatePointLight(0, true, world->getEntityByName("light")->getPosition(), lightColor, intensity); - world->updateDirectionalLight(true, world->getDirectionalLight()->getDirection(), lightColor); + m_world->updatePointLight(0, true, m_world->getEntityByName("light")->getPosition(), lightColor, intensity); + m_world->updateDirectionalLight(true, m_world->getDirectionalLight()->getDirection(), lightColor); getShaderProgramByName("lightProgram")->bind(); getShaderProgramByName("lightProgram")->setUniform("v_lightColor", lightColor * 100.0f); getShaderProgramByName("lightProgram")->unbind(); @@ -129,55 +129,55 @@ void Controller::run() getShaderProgramByName("defaultProgram")->unbind(); if (drawShadows || firstRun) { firstRun = false; - world->calculateShadows(getShaderProgramByName("directionalShadowDepthProgram"), - getShaderProgramByName("pointShadowDepthProgram")); + m_world->calculateShadows(getShaderProgramByName("directionalShadowDepthProgram"), + getShaderProgramByName("pointShadowDepthProgram")); } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - auto activeScreen = menu->getActiveScreen(); + auto activeScreen = m_menu->getActiveScreen(); if (activeScreen) { activeScreen->draw(); } else { - pp_framebuffer->bind(); + m_postProcessFrameBuffer->bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - camera->lookForward(); - camera->updateVPM(); + m_camera->lookForward(); + m_camera->updateVPM(); - world->getSkybox()->draw(camera->getView(), camera->getProj()); - world->draw(camera->getViewProj(), camera->getPosition()); + m_world->getSkybox()->draw(m_camera->getView(), m_camera->getProj()); + m_world->draw(m_camera->getViewProj(), m_camera->getPosition()); - pp_framebuffer->unbind(); - pp_framebuffer->render(); + m_postProcessFrameBuffer->unbind(); + m_postProcessFrameBuffer->render(); #ifdef _DEBUG - renderImGui(world, &lightColor, &rotateEntity, &rotateLightSource, + renderImGui(m_world, &lightColor, &rotateEntity, &rotateLightSource, getShaderProgramByName("postProcessingProgram"), &intensity, &drawShadows); #endif } - glfwSwapBuffers(gameWindow->getGLFWwindow()); + glfwSwapBuffers(m_gameWindow->getGLFWwindow()); // Update window size - if (gameWindow->isWindowResized()) { - gameWindow->updateWindowDimensions(); + if (m_gameWindow->isWindowResized()) { + m_gameWindow->updateWindowDimensions(); updateWindowDimensions(); } // --- Check events, handle input --- - gameEventHandler->handleEvents(); + m_gameEventHandler->handleEvents(); - camera->updatePositionFromKeyboardInput(gameEventHandler->getCameraActionMap(), deltaTime); - if (gameWindow->getMouseIsCatched()) { - camera->updateDirectionFromMouseInput(gameEventHandler->getCameraMouseActionMap()); + m_camera->updatePositionFromKeyboardInput(m_gameEventHandler->getCameraActionMap(), m_deltaTime); + if (m_gameWindow->getMouseIsCatched()) { + m_camera->updateDirectionFromMouseInput(m_gameEventHandler->getCameraMouseActionMap()); } - menu->writeWindowActions(gameEventHandler->getWindowActionMap()); - gameWindow->handleWindowActionMap(gameEventHandler->getWindowActionMap()); + m_menu->writeWindowActions(m_gameEventHandler->getWindowActionMap()); + m_gameWindow->handleWindowActionMap(m_gameEventHandler->getWindowActionMap()); // Handle widget pressed event only when a screen is currently active - if (menu->getActiveScreen()) - menu->handleMouseButtonActionMap(gameEventHandler->getMouseButtonActionMap(), gameWindow); + if (m_menu->getActiveScreen()) + m_menu->handleMouseButtonActionMap(m_gameEventHandler->getMouseButtonActionMap(), m_gameWindow); } } @@ -188,34 +188,34 @@ void Controller::limit_framerate() lastTime = glfwGetTime() - startingTime; - double frameTime = 1 / (double)MAX_FPS; + double frameTime = 1 / (double)m_MAX_FPS; if (frameTime > lastTime) { Helper::sleep((frameTime - lastTime) * 1000000); } - deltaTime = glfwGetTime() - startingTime; + m_deltaTime = glfwGetTime() - startingTime; startingTime = glfwGetTime(); } void Controller::updateWindowDimensions() { - camera->updateAspectRatio(gameWindow->getWindowAspectRatio()); - gameEventHandler->setFirstMouseInput(1); + m_camera->updateAspectRatio(m_gameWindow->getWindowAspectRatio()); + m_gameEventHandler->setFirstMouseInput(1); - pp_framebuffer->changeDimensions(gameWindow->getWindowWidth(), gameWindow->getWindowHeight()); + m_postProcessFrameBuffer->changeDimensions(m_gameWindow->getWindowWidth(), m_gameWindow->getWindowHeight()); } void Controller::updateExposure(ShaderProgram *shaderProgram) { shaderProgram->bind(); - shaderProgram->setUniform("u_exposure", exposure); + shaderProgram->setUniform("u_exposure", m_exposure); shaderProgram->unbind(); } ShaderProgram *Controller::getShaderProgramByName(const std::string &name) { - for (auto it = shaderPrograms.begin(); it != shaderPrograms.end(); it++) { + for (auto it = m_shaderPrograms.begin(); it != m_shaderPrograms.end(); it++) { if ((*it)->getUniqueName() == name) { return *it; } @@ -237,7 +237,7 @@ ShaderProgram *Controller::getShaderProgramByName(std::vector s void Controller::setMaxFps(uint16_t fps) { - MAX_FPS = fps; + m_MAX_FPS = fps; } #ifdef _DEBUG @@ -281,7 +281,7 @@ void Controller::renderImGui(World *world, glm::vec3 *lightColor, bool *rotateEn lightColor->z = color[2]; ImGui::Text("\nMiscellaneous"); - ImGui::SliderFloat("Exposure", &exposure, 0, 5.0f); + ImGui::SliderFloat("Exposure", &m_exposure, 0, 5.0f); ImGui::Checkbox("Draw Shadows", drawShadows); ImGui::Checkbox("Rotate Lightsource", rotateLightSource); diff --git a/src/Controller.h b/src/Controller.h index 95cd09f..ade7586 100644 --- a/src/Controller.h +++ b/src/Controller.h @@ -3,7 +3,7 @@ #include "Camera.h" #include "Entity.h" #include "EventHandler.h" -#include "Framebuffer.h" +#include "FrameBuffer.h" #include "Light.h" #include "Menu.h" #include "ShaderProgram.h" @@ -33,21 +33,20 @@ private: void renderImGui(World *world, glm::vec3 *lightColor, bool *rotateEntity, bool *rotateLightSource, ShaderProgram *postProcessingProgram, float *intensity, bool *drawShadows); -private: - Window *gameWindow; - EventHandler *gameEventHandler; + Window *m_gameWindow; + EventHandler *m_gameEventHandler; - World *world; + World *m_world; - Camera *camera; - Menu *menu; + Camera *m_camera; + Menu *m_menu; - std::vector shaderPrograms; + std::vector m_shaderPrograms; - Framebuffer *pp_framebuffer; + FrameBuffer *m_postProcessFrameBuffer; - uint16_t MAX_FPS = 60; - double deltaTime; + uint16_t m_MAX_FPS = 60; + double m_deltaTime; - float exposure = 1.0f; + float m_exposure = 1.0f; }; diff --git a/src/Entity.cpp b/src/Entity.cpp index 4068b8a..c8844bb 100644 --- a/src/Entity.cpp +++ b/src/Entity.cpp @@ -3,43 +3,43 @@ #include #include -uint32_t Entity::id_counter = 0; +uint32_t Entity::s_idCounter = 0; -Entity::Entity(std::string name, Model *model, ShaderProgram *shaderProgram) - : unique_name(name), model(model), shaderProgram(shaderProgram) +Entity::Entity(const std::string &name, Model *model, ShaderProgram *shaderProgram) + : m_uniqueName(name), m_model(model), m_shaderProgram(shaderProgram) { - id = id_counter++; + m_id = s_idCounter++; } void Entity::draw(glm::mat4 viewProjMatrix, glm::vec3 viewPosition) { - shaderProgram->bind(); + m_shaderProgram->bind(); - glm::mat4 modelViewProj = viewProjMatrix * modelMatrix; - shaderProgram->setUniform("u_modelViewProjMatrix", modelViewProj); - shaderProgram->setUniform("u_modelMatrix", modelMatrix); + glm::mat4 modelViewProj = viewProjMatrix * m_modelMatrix; + m_shaderProgram->setUniform("u_modelViewProjMatrix", modelViewProj); + m_shaderProgram->setUniform("u_modelMatrix", m_modelMatrix); - glm::mat3 normalMatrix = glm::mat3(modelMatrix); + glm::mat3 normalMatrix = glm::mat3(m_modelMatrix); normalMatrix = glm::transpose(glm::inverse(normalMatrix)); - shaderProgram->setUniform("u_normalMatrix", normalMatrix); + m_shaderProgram->setUniform("u_normalMatrix", normalMatrix); - shaderProgram->setUniform("u_viewPosition", viewPosition); + m_shaderProgram->setUniform("u_viewPosition", viewPosition); // Draw the model - model->draw(shaderProgram); + m_model->draw(m_shaderProgram); - shaderProgram->unbind(); + m_shaderProgram->unbind(); } void Entity::drawDirectionalShadows(glm::mat4 viewProjMatrix, ShaderProgram *p_shaderProgram) { p_shaderProgram->bind(); - glm::mat4 modelViewProj = viewProjMatrix * modelMatrix; + glm::mat4 modelViewProj = viewProjMatrix * m_modelMatrix; p_shaderProgram->setUniform("u_modelViewProjMatrix", modelViewProj); // Draw the model - model->drawWithoutTextures(); + m_model->drawWithoutTextures(); p_shaderProgram->unbind(); } @@ -48,48 +48,48 @@ void Entity::drawPointShadows(ShaderProgram *p_shaderProgram) { p_shaderProgram->bind(); - p_shaderProgram->setUniform("u_modelMatrix", modelMatrix); + p_shaderProgram->setUniform("u_modelMatrix", m_modelMatrix); // Draw the model - model->drawWithoutTextures(); + m_model->drawWithoutTextures(); p_shaderProgram->unbind(); } void Entity::translate(glm::vec3 vector) { - position += vector; + m_position += vector; updateModelMatrix(); } void Entity::rotate(glm::vec3 axis, float radians) { glm::quat rotation = glm::angleAxis(radians, axis); - quaternion = rotation * quaternion; + m_quaternion = rotation * m_quaternion; updateModelMatrix(); } void Entity::setPosition(glm::vec3 position) { - this->position = position; + this->m_position = position; updateModelMatrix(); } void Entity::setRotation(glm::vec3 eulerAngles) { - quaternion = glm::quat(eulerAngles); + m_quaternion = glm::quat(eulerAngles); updateModelMatrix(); } void Entity::setRotation(glm::vec3 axis, float radians) { - quaternion = glm::angleAxis(radians, axis); + m_quaternion = glm::angleAxis(radians, axis); updateModelMatrix(); } void Entity::setScale(float scaleFactor) { - modelScale = scaleFactor; + m_modelScale = scaleFactor; updateModelMatrix(); } @@ -99,55 +99,55 @@ void Entity::updateModelMatrix() // First scaling, then rotation, then translation // Translate - glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), position); + glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), m_position); // Rotate - glm::mat4 rotationMatrix = glm::toMat4(quaternion); + glm::mat4 rotationMatrix = glm::toMat4(m_quaternion); // Scale - glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), glm::vec3(modelScale, modelScale, modelScale)); + glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), glm::vec3(m_modelScale, m_modelScale, m_modelScale)); - modelMatrix = translationMatrix * rotationMatrix * scaleMatrix; + m_modelMatrix = translationMatrix * rotationMatrix * scaleMatrix; } void Entity::setIsLightSource(bool temp) { - isLightSource = temp; + m_isLightSource = temp; } void Entity::setId(uint32_t id) { - this->id = id; + this->m_id = id; } uint32_t Entity::getId() { - return id; + return m_id; } std::string Entity::getUniqueName() { - return unique_name; + return m_uniqueName; } glm::vec3 Entity::getPosition() { - return position; + return m_position; } glm::mat4 Entity::getModelMatrix() { - return modelMatrix; + return m_modelMatrix; } bool Entity::getIsLightSource() { - return isLightSource; + return m_isLightSource; } Skybox::Skybox(Model *cubeModel, ShaderProgram *shaderProgram, const char *texturePseudoPath) - : cubeModel(cubeModel), shaderProgram(shaderProgram), cubeMap(texturePseudoPath), - vertexArray(cubeModel->getMesh(0)->getVertexArray()) + : m_cubeModel(cubeModel), m_shaderProgram(shaderProgram), m_cubeMap(texturePseudoPath), + m_vertexArray(cubeModel->getMesh(0)->getVertexArray()) { // Empty } @@ -160,18 +160,18 @@ void Skybox::draw(glm::mat4 viewMatrix, glm::mat4 projectionMatrix) glDisable(GL_CULL_FACE); glDepthMask(GL_FALSE); - shaderProgram->bind(); + m_shaderProgram->bind(); // Delete any translation from the skybox cube glm::mat4 viewProjectionMatrix = projectionMatrix * glm::mat4(glm::mat3(viewMatrix)); - shaderProgram->setUniform("u_viewProjectionMatrix", viewProjectionMatrix); + m_shaderProgram->setUniform("u_viewProjectionMatrix", viewProjectionMatrix); - cubeMap.bind(shaderProgram); - cubeModel->getMesh(0)->drawWithoutTextures(); - cubeMap.unbind(); + m_cubeMap.bind(m_shaderProgram); + m_cubeModel->getMesh(0)->drawWithoutTextures(); + m_cubeMap.unbind(); - shaderProgram->unbind(); + m_shaderProgram->unbind(); glDepthMask(GL_TRUE); // Restore face culling diff --git a/src/Entity.h b/src/Entity.h index 094bb00..4d83edf 100644 --- a/src/Entity.h +++ b/src/Entity.h @@ -10,7 +10,7 @@ class Entity { public: - Entity(std::string name, Model *model, ShaderProgram *shaderProgram); + Entity(const std::string &name, Model *model, ShaderProgram *shaderProgram); ~Entity() = default; void draw(glm::mat4 viewProjMatrix, glm::vec3 viewPosition); @@ -36,23 +36,22 @@ public: private: void updateModelMatrix(); -private: - uint32_t id; - static uint32_t id_counter; - std::string unique_name; + uint32_t m_id; + static uint32_t s_idCounter; + std::string m_uniqueName; - Model *model; - ShaderProgram *shaderProgram; + Model *m_model; + ShaderProgram *m_shaderProgram; - bool isLightSource = false; + bool m_isLightSource = false; - glm::mat4 modelMatrix = glm::mat4(1.0f); + glm::mat4 m_modelMatrix = glm::mat4(1.0f); - glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f); - glm::quat quaternion; - glm::vec3 velocity = glm::vec3(0.0f, 0.0f, 0.0f); + glm::vec3 m_position = glm::vec3(0.0f, 0.0f, 0.0f); + glm::vec3 m_velocity = glm::vec3(0.0f, 0.0f, 0.0f); + glm::quat m_quaternion; - float modelScale = 1.0f; + float m_modelScale = 1.0f; }; class Skybox @@ -64,10 +63,10 @@ public: void draw(glm::mat4 viewMatrix, glm::mat4 projectionMatrix); private: - Model *cubeModel; - ShaderProgram *shaderProgram; + Model *m_cubeModel; + ShaderProgram *m_shaderProgram; - CubeMap cubeMap; + CubeMap m_cubeMap; - VertexArray *vertexArray; + VertexArray *m_vertexArray; }; diff --git a/src/EventHandler.cpp b/src/EventHandler.cpp index 3ca0716..0408e14 100644 --- a/src/EventHandler.cpp +++ b/src/EventHandler.cpp @@ -2,29 +2,29 @@ #include -CameraActionMap EventHandler::cameraActionMap = {{CameraAction::Forward, false}, {CameraAction::Backward, false}, - {CameraAction::Up, false}, {CameraAction::Down, false}, - {CameraAction::Left, false}, {CameraAction::Right, false}}; +CameraActionMap EventHandler::s_cameraActionMap = {{CameraAction::Forward, false}, {CameraAction::Backward, false}, + {CameraAction::Up, false}, {CameraAction::Down, false}, + {CameraAction::Left, false}, {CameraAction::Right, false}}; -CameraMouseActionMap EventHandler::cameraMouseActionMap = {{CameraMouseAction::DeltaX, 0.0}, - {CameraMouseAction::DeltaY, 0.0}}; +CameraMouseActionMap EventHandler::s_cameraMouseActionMap = {{CameraMouseAction::DeltaX, 0.0}, + {CameraMouseAction::DeltaY, 0.0}}; -WindowActionMap EventHandler::windowActionMap = {{WindowAction::WireFrameToggle, false}, - {WindowAction::MouseCatchToggle, false}, - {WindowAction::WindowShouldClose, false}}; +WindowActionMap EventHandler::s_windowActionMap = {{WindowAction::WireFrameToggle, false}, + {WindowAction::MouseCatchToggle, false}, + {WindowAction::WindowShouldClose, false}}; -MouseButtonActionMap EventHandler::mouseButtonActionMap = {{MouseButtonAction::LeftClicked, false}, - {MouseButtonAction::RightClicked, false}, - {MouseButtonAction::MiddleClicked, false}}; +MouseButtonActionMap EventHandler::s_mouseButtonActionMap = {{MouseButtonAction::LeftClicked, false}, + {MouseButtonAction::RightClicked, false}, + {MouseButtonAction::MiddleClicked, false}}; -bool EventHandler::firstMouseInput = 1; -float EventHandler::mouseSensitivity = 0.15f; +bool EventHandler::s_firstMouseInput = 1; +float EventHandler::s_mouseSensitivity = 0.15f; -EventHandler::EventHandler(GLFWwindow *p_window) : window(p_window) +EventHandler::EventHandler(GLFWwindow *p_window) : m_window(p_window) { - glfwSetKeyCallback(window, key_callback); - glfwSetCursorPosCallback(window, mouse_callback); - glfwSetMouseButtonCallback(window, mouse_button_callback); + glfwSetKeyCallback(m_window, key_callback); + glfwSetCursorPosCallback(m_window, mouse_callback); + glfwSetMouseButtonCallback(m_window, mouse_button_callback); } void EventHandler::handleEvents() @@ -35,15 +35,15 @@ void EventHandler::handleEvents() void EventHandler::clearActionRegisters() { - for (auto &element : cameraMouseActionMap) { + for (auto &element : s_cameraMouseActionMap) { element.second = 0.0; } - for (auto &element : windowActionMap) { + for (auto &element : s_windowActionMap) { element.second = 0.0; } - for (auto &element : mouseButtonActionMap) { + for (auto &element : s_mouseButtonActionMap) { element.second = 0.0; } } @@ -56,55 +56,55 @@ void EventHandler::key_callback(GLFWwindow *window, int key, int scancode, int a (void)mods; if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) { - windowActionMap[WindowAction::WindowShouldClose] = 1; + s_windowActionMap[WindowAction::WindowShouldClose] = 1; } if (key == GLFW_KEY_O && action == GLFW_PRESS) { - windowActionMap[WindowAction::WireFrameToggle] = 1; + s_windowActionMap[WindowAction::WireFrameToggle] = 1; } if (key == GLFW_KEY_LEFT_CONTROL && action == GLFW_PRESS) { - windowActionMap[WindowAction::MouseCatchToggle] = 1; - firstMouseInput = 1; + s_windowActionMap[WindowAction::MouseCatchToggle] = 1; + s_firstMouseInput = 1; } // Movement press if (key == GLFW_KEY_W && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Forward] = 1; + s_cameraActionMap[CameraAction::Forward] = 1; } if (key == GLFW_KEY_S && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Backward] = 1; + s_cameraActionMap[CameraAction::Backward] = 1; } if (key == GLFW_KEY_SPACE && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Up] = 1; + s_cameraActionMap[CameraAction::Up] = 1; } if (key == GLFW_KEY_LEFT_SHIFT && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Down] = 1; + s_cameraActionMap[CameraAction::Down] = 1; } if (key == GLFW_KEY_A && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Left] = 1; + s_cameraActionMap[CameraAction::Left] = 1; } if (key == GLFW_KEY_D && action == GLFW_PRESS) { - cameraActionMap[CameraAction::Right] = 1; + s_cameraActionMap[CameraAction::Right] = 1; } // Movement release if (key == GLFW_KEY_W && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Forward] = 0; + s_cameraActionMap[CameraAction::Forward] = 0; } if (key == GLFW_KEY_S && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Backward] = 0; + s_cameraActionMap[CameraAction::Backward] = 0; } if (key == GLFW_KEY_SPACE && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Up] = 0; + s_cameraActionMap[CameraAction::Up] = 0; } if (key == GLFW_KEY_LEFT_SHIFT && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Down] = 0; + s_cameraActionMap[CameraAction::Down] = 0; } if (key == GLFW_KEY_A && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Left] = 0; + s_cameraActionMap[CameraAction::Left] = 0; } if (key == GLFW_KEY_D && action == GLFW_RELEASE) { - cameraActionMap[CameraAction::Right] = 0; + s_cameraActionMap[CameraAction::Right] = 0; } } @@ -122,17 +122,17 @@ void EventHandler::mouse_callback(GLFWwindow *window, double xpos, double ypos) lastCursorPosY = ypos; // Check if this is the first VALID mouse event after window being resized - if (firstMouseInput && !(deltaCursorPosX == 0 && deltaCursorPosY == 0)) { - firstMouseInput = 0; + if (s_firstMouseInput && !(deltaCursorPosX == 0 && deltaCursorPosY == 0)) { + s_firstMouseInput = 0; deltaCursorPosX = 0.0; deltaCursorPosY = 0.0; } - deltaCursorPosX *= mouseSensitivity; - deltaCursorPosY *= mouseSensitivity; + deltaCursorPosX *= s_mouseSensitivity; + deltaCursorPosY *= s_mouseSensitivity; - cameraMouseActionMap[CameraMouseAction::DeltaX] += deltaCursorPosX; - cameraMouseActionMap[CameraMouseAction::DeltaY] += deltaCursorPosY; + s_cameraMouseActionMap[CameraMouseAction::DeltaX] += deltaCursorPosX; + s_cameraMouseActionMap[CameraMouseAction::DeltaY] += deltaCursorPosY; } void EventHandler::mouse_button_callback(GLFWwindow *window, int button, int action, int mods) @@ -141,34 +141,34 @@ void EventHandler::mouse_button_callback(GLFWwindow *window, int button, int act (void)mods; if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) - mouseButtonActionMap[MouseButtonAction::LeftClicked] = true; + s_mouseButtonActionMap[MouseButtonAction::LeftClicked] = true; if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) - mouseButtonActionMap[MouseButtonAction::RightClicked] = true; + s_mouseButtonActionMap[MouseButtonAction::RightClicked] = true; if (button == GLFW_MOUSE_BUTTON_MIDDLE && action == GLFW_PRESS) - mouseButtonActionMap[MouseButtonAction::MiddleClicked] = true; + s_mouseButtonActionMap[MouseButtonAction::MiddleClicked] = true; } const CameraActionMap &EventHandler::getCameraActionMap() const { - return cameraActionMap; + return s_cameraActionMap; } WindowActionMap &EventHandler::getWindowActionMap() const { - return windowActionMap; + return s_windowActionMap; } const MouseButtonActionMap &EventHandler::getMouseButtonActionMap() const { - return mouseButtonActionMap; + return s_mouseButtonActionMap; } const CameraMouseActionMap &EventHandler::getCameraMouseActionMap() const { - return cameraMouseActionMap; + return s_cameraMouseActionMap; } void EventHandler::setFirstMouseInput(bool val) { - firstMouseInput = val; + s_firstMouseInput = val; } diff --git a/src/EventHandler.h b/src/EventHandler.h index b27ccca..0782e7b 100644 --- a/src/EventHandler.h +++ b/src/EventHandler.h @@ -32,14 +32,13 @@ private: static void mouse_button_callback(GLFWwindow *window, int button, int action, int mods); static void mouse_callback(GLFWwindow *window, double xpos, double ypos); -private: - static CameraActionMap cameraActionMap; - static CameraMouseActionMap cameraMouseActionMap; - static WindowActionMap windowActionMap; - static MouseButtonActionMap mouseButtonActionMap; + static CameraActionMap s_cameraActionMap; + static CameraMouseActionMap s_cameraMouseActionMap; + static WindowActionMap s_windowActionMap; + static MouseButtonActionMap s_mouseButtonActionMap; - GLFWwindow *window; + static float s_mouseSensitivity; + static bool s_firstMouseInput; - static float mouseSensitivity; - static bool firstMouseInput; + GLFWwindow *m_window; }; diff --git a/src/Framebuffer.cpp b/src/FrameBuffer.cpp similarity index 55% rename from src/Framebuffer.cpp rename to src/FrameBuffer.cpp index 7dedd7b..462ee5a 100644 --- a/src/Framebuffer.cpp +++ b/src/FrameBuffer.cpp @@ -1,45 +1,45 @@ -#include "Framebuffer.h" +#include "FrameBuffer.h" #include #include -Framebuffer::Framebuffer(uint32_t width, uint32_t height, ShaderProgram *shaderProgram) : shaderProgram(shaderProgram) +FrameBuffer::FrameBuffer(uint32_t width, uint32_t height, ShaderProgram *shaderProgram) : m_shaderProgram(shaderProgram) { - glGenFramebuffers(1, &FBO); + glGenFramebuffers(1, &m_FBO); generateTextures(width, height); setExposureCorrection(true); } -Framebuffer::~Framebuffer() +FrameBuffer::~FrameBuffer() { - glDeleteFramebuffers(1, &FBO); - glDeleteTextures(1, &colorBuffer); - glDeleteRenderbuffers(1, &depthStencilBuffer); + glDeleteFramebuffers(1, &m_FBO); + glDeleteTextures(1, &m_colorBuffer); + glDeleteRenderbuffers(1, &m_depthStencilBuffer); } -void Framebuffer::bind() +void FrameBuffer::bind() { - glBindFramebuffer(GL_FRAMEBUFFER, FBO); + glBindFramebuffer(GL_FRAMEBUFFER, m_FBO); } -void Framebuffer::unbind() +void FrameBuffer::unbind() { glBindFramebuffer(GL_FRAMEBUFFER, 0); } -void Framebuffer::render() +void FrameBuffer::render() { // Disable wireframe mode GLint wireframe; glGetIntegerv(GL_POLYGON_MODE, &wireframe); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); - shaderProgram->bind(); + m_shaderProgram->bind(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, getTextureId()); - GLint location = glGetUniformLocation(shaderProgram->getShaderProgramId(), "u_texture"); + GLint location = glGetUniformLocation(m_shaderProgram->getShaderProgramId(), "u_texture"); glUniform1i(location, 0); // A VAO is necessary although no data is stored in it @@ -50,66 +50,66 @@ void Framebuffer::render() glBindVertexArray(0); glPolygonMode(GL_FRONT_AND_BACK, wireframe); - shaderProgram->unbind(); + m_shaderProgram->unbind(); } -void Framebuffer::changeDimensions(uint32_t width, uint32_t height) +void FrameBuffer::changeDimensions(uint32_t width, uint32_t height) { // Delete old textures - glDeleteTextures(1, &colorBuffer); - glDeleteRenderbuffers(1, &depthStencilBuffer); + glDeleteTextures(1, &m_colorBuffer); + glDeleteRenderbuffers(1, &m_depthStencilBuffer); generateTextures(width, height); } -void Framebuffer::generateTextures(uint32_t width, uint32_t height) +void FrameBuffer::generateTextures(uint32_t width, uint32_t height) { bind(); // Create new textures - glGenTextures(1, &colorBuffer); - glGenRenderbuffers(1, &depthStencilBuffer); + glGenTextures(1, &m_colorBuffer); + glGenRenderbuffers(1, &m_depthStencilBuffer); - glBindTexture(GL_TEXTURE_2D, colorBuffer); + glBindTexture(GL_TEXTURE_2D, m_colorBuffer); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBuffer, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0); - glBindRenderbuffer(GL_RENDERBUFFER, depthStencilBuffer); + glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height); - glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthStencilBuffer); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); glBindTexture(GL_TEXTURE_2D, 0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) - std::cout << "[Error] Framebuffer is not complete!" << std::endl; + std::cout << "[Error] FrameBuffer is not complete!" << std::endl; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); unbind(); } -void Framebuffer::setExposureCorrection(bool exposureCorrection) +void FrameBuffer::setExposureCorrection(bool exposureCorrection) { - shaderProgram->bind(); - shaderProgram->setUniform("u_exposureCorrection", exposureCorrection); - shaderProgram->unbind(); + m_shaderProgram->bind(); + m_shaderProgram->setUniform("u_exposureCorrection", exposureCorrection); + m_shaderProgram->unbind(); } -GLuint Framebuffer::getTextureId() +GLuint FrameBuffer::getTextureId() { - return colorBuffer; + return m_colorBuffer; } -DepthMap::DepthMap(int TYPE, int RESOLUTION) +DepthMap::DepthMap(DepthMapType type, int RESOLUTION) { - glGenFramebuffers(1, &depthMapFBO); + glGenFramebuffers(1, &m_depthMapFBO); bind(); - if (TYPE == DEPTHMAP_NORMAL) { + if (type == DepthMapType::Normal) { - glGenTextures(1, &depthMap); - glBindTexture(GL_TEXTURE_2D, depthMap); + glGenTextures(1, &m_depthMap); + glBindTexture(GL_TEXTURE_2D, m_depthMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, RESOLUTION, RESOLUTION, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); @@ -119,33 +119,33 @@ DepthMap::DepthMap(int TYPE, int RESOLUTION) glBindTexture(GL_TEXTURE_2D, 0); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthMap, 0); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); - } else if (TYPE == DEPTHMAP_CUBEMAP) { - cubeMap = new CubeMap(RESOLUTION); + } else if (type == DepthMapType::CubeMap) { + m_cubeMap = new CubeMap(RESOLUTION); - glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, cubeMap->getTextureId(), 0); + glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_cubeMap->getTextureId(), 0); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); } if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) - std::cout << "[Error] Framebuffer is not complete!" << std::endl; + std::cout << "[Error] FrameBuffer is not complete!" << std::endl; unbind(); } DepthMap::~DepthMap() { - if (cubeMap) - delete cubeMap; + if (m_cubeMap) + delete m_cubeMap; } void DepthMap::bind() { - glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO); + glBindFramebuffer(GL_FRAMEBUFFER, m_depthMapFBO); } void DepthMap::unbind() @@ -155,15 +155,15 @@ void DepthMap::unbind() GLuint DepthMap::getFBO() { - return depthMapFBO; + return m_depthMapFBO; } GLuint DepthMap::getDepthMap() { - return depthMap; + return m_depthMap; } GLuint DepthMap::getCubeMapId() { - return cubeMap->getTextureId(); + return m_cubeMap->getTextureId(); } diff --git a/src/Framebuffer.h b/src/FrameBuffer.h similarity index 63% rename from src/Framebuffer.h rename to src/FrameBuffer.h index b7594c1..c2e6db9 100644 --- a/src/Framebuffer.h +++ b/src/FrameBuffer.h @@ -4,11 +4,11 @@ #include "Texture.h" #include -class Framebuffer +class FrameBuffer { public: - Framebuffer(uint32_t width, uint32_t height, ShaderProgram *shaderProgram); - ~Framebuffer(); + FrameBuffer(uint32_t width, uint32_t height, ShaderProgram *shaderProgram); + ~FrameBuffer(); void bind(); void unbind(); @@ -23,26 +23,25 @@ public: private: void generateTextures(uint32_t width, uint32_t height); -private: - GLuint FBO; - GLuint colorBuffer; - GLuint depthStencilBuffer; + GLuint m_FBO; + GLuint m_colorBuffer; + GLuint m_depthStencilBuffer; - ShaderProgram *shaderProgram; + ShaderProgram *m_shaderProgram; }; -enum depthMapType +enum class DepthMapType { - DEPTHMAP_NORMAL, - DEPTHMAP_CUBEMAP + Normal, + CubeMap }; -// Framebuffer without color buffer. (Shadows) +// FrameBuffer without color buffer. (Shadows) class DepthMap { public: // Normal depthMap with texture and point depthMap with cubeMap - DepthMap(int TYPE, int RESOLUTION); + DepthMap(DepthMapType type, int RESOLUTION); ~DepthMap(); void bind(); @@ -53,10 +52,10 @@ public: GLuint getCubeMapId(); private: - GLuint depthMapFBO; + GLuint m_depthMapFBO; // Either a normal depthMap is used (Directional shadows) // or a cubeMap is used (Point shadows) - GLuint depthMap; - CubeMap *cubeMap; + GLuint m_depthMap; + CubeMap *m_cubeMap; }; diff --git a/src/Helper.cpp b/src/Helper.cpp index e04ea30..a232b99 100644 --- a/src/Helper.cpp +++ b/src/Helper.cpp @@ -75,7 +75,7 @@ void Helper::gl_debug_callback(GLenum source, GLenum type, GLuint id, GLenum sev break; case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: - _type = "UDEFINED BEHAVIOR"; + _type = "UNDEFINED BEHAVIOR"; break; case GL_DEBUG_TYPE_PORTABILITY: @@ -131,17 +131,17 @@ void Helper::gl_debug_callback(GLenum source, GLenum type, GLuint id, GLenum sev << std::endl; } -Helper::Timer::Timer(const std::string &name) : name(name) +Helper::Timer::Timer(const std::string &name) : m_name(name) { - start = std::chrono::high_resolution_clock::now(); + m_start = std::chrono::high_resolution_clock::now(); } Helper::Timer::~Timer() { - end = std::chrono::high_resolution_clock::now(); + m_end = std::chrono::high_resolution_clock::now(); - duration = end - start; - float ms = duration.count() * 1000.0f; + m_duration = m_end - m_start; + float ms = m_duration.count() * 1000.0f; - std::cout << "Timer " << name << " took " << ms << "ms!" << std::endl; + std::cout << "Timer " << m_name << " took " << ms << "ms!" << std::endl; } diff --git a/src/Helper.h b/src/Helper.h index 06a37e1..c24ba49 100644 --- a/src/Helper.h +++ b/src/Helper.h @@ -18,9 +18,11 @@ public: ~Timer(); private: - std::string name; - std::chrono::high_resolution_clock::time_point start, end; - std::chrono::duration duration; + std::string m_name; + + std::chrono::high_resolution_clock::time_point m_start; + std::chrono::high_resolution_clock::time_point m_end; + std::chrono::duration m_duration; }; } // namespace Helper diff --git a/src/JsonParser.cpp b/src/JsonParser.cpp index d13231d..c344d9c 100644 --- a/src/JsonParser.cpp +++ b/src/JsonParser.cpp @@ -14,8 +14,8 @@ JsonParser::JsonParser(const std::string &path) } std::string errs; - rbuilder["collectComments"] = false; - bool parsingSuccessful = Json::parseFromStream(rbuilder, file, &root, &errs); + m_rbuilder["collectComments"] = false; + bool parsingSuccessful = Json::parseFromStream(m_rbuilder, file, &m_root, &errs); file.close(); if (!parsingSuccessful) { std::cout << "Failed to parse file\n" << errs << std::endl; @@ -30,7 +30,7 @@ std::vector JsonParser::getModels() { std::vector temp_models; - const Json::Value modelsJson = root["models"]; + const Json::Value modelsJson = m_root["models"]; struct ModelSkeleton { @@ -72,7 +72,7 @@ std::vector JsonParser::getEntities(std::vector &models, std: { std::vector temp_entities; - const Json::Value entitiesJson = root["entities"]; + const Json::Value entitiesJson = m_root["entities"]; for (unsigned int index = 0; index < entitiesJson.size(); index++) { std::string entity_name = entitiesJson[index]["unique_name"].asString(); @@ -135,7 +135,7 @@ std::vector JsonParser::getShaderPrograms() { std::vector temp_shaderPrograms; - const Json::Value shaderProgramsJson = root["shaderPrograms"]; + const Json::Value shaderProgramsJson = m_root["shaderPrograms"]; for (unsigned int index = 0; index < shaderProgramsJson.size(); index++) { std::string shaderProgram_name = shaderProgramsJson[index]["unique_name"].asString(); @@ -166,7 +166,7 @@ std::vector JsonParser::getLights(ShaderProgram *shaderProgram) glm::vec3 light_color = {1.0f, 1.0f, 1.0f}; float light_intensity = 10.0f; - const Json::Value directionalLightsJson = root["directionalLight"]; + const Json::Value directionalLightsJson = m_root["directionalLight"]; const Json::Value directionJson = directionalLightsJson["direction"]; Json::Value colorJson = directionalLightsJson["color"]; @@ -192,7 +192,7 @@ std::vector JsonParser::getLights(ShaderProgram *shaderProgram) temp_lights.push_back(current_directionalLight); // Pointlights - const Json::Value pointLightsJson = root["pointLights"]; + const Json::Value pointLightsJson = m_root["pointLights"]; int index = 0; for (; index < (int)pointLightsJson.size(); index++) { @@ -235,12 +235,12 @@ std::vector JsonParser::getLights(ShaderProgram *shaderProgram) return temp_lights; } -std::vector JsonParser::getScreens(ShaderProgram *menuProgram, Framebuffer *framebuffer) +std::vector JsonParser::getScreens(ShaderProgram *menuProgram, FrameBuffer *framebuffer) { std::vector temp_screens; - const Json::Value loadingScreenJson = root["loadingScreen"]; - const Json::Value mainMenuScreenJson = root["mainMenuScreen"]; + const Json::Value loadingScreenJson = m_root["loadingScreen"]; + const Json::Value mainMenuScreenJson = m_root["mainMenuScreen"]; std::string name; Screen *screen; @@ -282,7 +282,7 @@ Skybox *JsonParser::getSkybox(Model *cubeModel, ShaderProgram *skyboxProgram) { Skybox *temp_skybox; - const Json::Value shaderProgramsJson = root["skybox"]; + const Json::Value shaderProgramsJson = m_root["skybox"]; std::string skybox_texturePath = shaderProgramsJson["texturePath"].asString(); temp_skybox = new Skybox(cubeModel, skyboxProgram, skybox_texturePath.c_str()); diff --git a/src/JsonParser.h b/src/JsonParser.h index f2133c5..60b0897 100644 --- a/src/JsonParser.h +++ b/src/JsonParser.h @@ -19,7 +19,7 @@ public: std::vector getModels(); std::vector getEntities(std::vector &models, std::vector shaderPrograms); std::vector getLights(ShaderProgram *shaderProgram); - std::vector getScreens(ShaderProgram *menuProgram, Framebuffer *framebuffer); + std::vector getScreens(ShaderProgram *menuProgram, FrameBuffer *framebuffer); Skybox *getSkybox(Model *cubeModel, ShaderProgram *skyboxProgram); std::vector getShaderPrograms(); @@ -27,7 +27,6 @@ public: private: std::vector getWidgetsFromScreen(const Json::Value &screenJson); -private: - Json::Value root; - Json::CharReaderBuilder rbuilder; + Json::Value m_root; + Json::CharReaderBuilder m_rbuilder; }; diff --git a/src/Light.cpp b/src/Light.cpp index e7edd9d..01d9a02 100644 --- a/src/Light.cpp +++ b/src/Light.cpp @@ -2,108 +2,108 @@ #include -uint32_t Light::id_counter = 0; +uint32_t Light::s_idCounter = 0; // Light Light::Light(glm::vec3 color, float intensity, ShaderProgram *shaderProgram) - : shaderProgram(shaderProgram), intensity(intensity) + : m_shaderProgram(shaderProgram), m_intensity(intensity) { - id = id_counter++; - lightColor = color * intensity; + m_id = s_idCounter++; + m_lightColor = color * intensity; } glm::vec3 Light::getColor() { - return lightColor; + return m_lightColor; } void Light::setShaderProgram(ShaderProgram *shaderProgram) { - this->shaderProgram = shaderProgram; + this->m_shaderProgram = shaderProgram; update(); } void Light::setColor(glm::vec3 color) { - lightColor = color * intensity; + m_lightColor = color * m_intensity; update(); } void Light::setIntensity(float intensity) { - this->intensity = intensity; + this->m_intensity = intensity; } void Light::setActive(bool active) { - isActive = active; + m_isActive = active; update(); } // PointLight PointLight::PointLight(glm::vec3 position, glm::vec3 color, float intensity, ShaderProgram *shaderProgram) - : Light(color, intensity, shaderProgram), position(position) + : Light(color, intensity, shaderProgram), m_position(position) { // Empty } void PointLight::update() { - shaderProgram->bind(); + m_shaderProgram->bind(); - shaderProgram->setUniform((getStructMemberName() + "isActive").c_str(), isActive); - shaderProgram->setUniform((getStructMemberName() + "position").c_str(), position); - shaderProgram->setUniform((getStructMemberName() + "color").c_str(), lightColor); + m_shaderProgram->setUniform((getStructMemberName() + "isActive").c_str(), m_isActive); + m_shaderProgram->setUniform((getStructMemberName() + "position").c_str(), m_position); + m_shaderProgram->setUniform((getStructMemberName() + "color").c_str(), m_lightColor); - shaderProgram->unbind(); + m_shaderProgram->unbind(); } std::string PointLight::getStructMemberName() { // id - 1 because id 0 is always the DirectionalLight! - std::string temp = "u_pointLight[" + std::to_string(id - 1) + "]."; + std::string temp = "u_pointLight[" + std::to_string(m_id - 1) + "]."; return temp; } glm::vec3 PointLight::getPosition() { - return position; + return m_position; } void PointLight::setPosition(glm::vec3 position) { - this->position = position; + this->m_position = position; update(); } // DirectionalLight DirectionalLight::DirectionalLight(glm::vec3 direction, glm::vec3 color, float intensity, ShaderProgram *shaderProgram) - : Light(color, intensity, shaderProgram), direction(direction) + : Light(color, intensity, shaderProgram), m_direction(direction) { // Empty } void DirectionalLight::update() { - shaderProgram->bind(); + m_shaderProgram->bind(); - shaderProgram->setUniform("u_directionalLight.isActive", isActive); - shaderProgram->setUniform("u_directionalLight.direction", direction); - shaderProgram->setUniform("u_directionalLight.color", lightColor); + m_shaderProgram->setUniform("u_directionalLight.isActive", m_isActive); + m_shaderProgram->setUniform("u_directionalLight.direction", m_direction); + m_shaderProgram->setUniform("u_directionalLight.color", m_lightColor); - shaderProgram->unbind(); + m_shaderProgram->unbind(); } void DirectionalLight::setDirection(glm::vec3 direction) { - this->direction = direction; + this->m_direction = direction; update(); } glm::vec3 DirectionalLight::getDirection() { - return direction; + return m_direction; } diff --git a/src/Light.h b/src/Light.h index d6b90b2..25bed6f 100644 --- a/src/Light.h +++ b/src/Light.h @@ -24,19 +24,18 @@ public: protected: Light(glm::vec3 color, float intensity, ShaderProgram *shaderProgram); -protected: - ShaderProgram *shaderProgram; + ShaderProgram *m_shaderProgram; - uint32_t id; - static uint32_t id_counter; + uint32_t m_id; + static uint32_t s_idCounter; - bool isActive; - bool shouldCastShadow = true; + bool m_isActive; + bool m_shouldCastShadow = true; - float intensity; + float m_intensity; // Color - glm::vec3 lightColor; + glm::vec3 m_lightColor; }; class PointLight : public Light @@ -53,8 +52,7 @@ private: void update() override; std::string getStructMemberName(); -private: - glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f); + glm::vec3 m_position = glm::vec3(0.0f, 0.0f, 0.0f); }; class DirectionalLight : public Light @@ -69,6 +67,5 @@ public: private: void update() override; -private: - glm::vec3 direction; + glm::vec3 m_direction; }; diff --git a/src/Menu.cpp b/src/Menu.cpp index 7fed6e4..6480d97 100644 --- a/src/Menu.cpp +++ b/src/Menu.cpp @@ -5,29 +5,29 @@ #include -Menu::Menu(Framebuffer *p_framebuffer, ShaderProgram *p_shaderProgram) - : framebuffer(p_framebuffer), shaderProgram(p_shaderProgram) +Menu::Menu(FrameBuffer *p_framebuffer, ShaderProgram *p_shaderProgram) + : m_frameBuffer(p_framebuffer), m_shaderProgram(p_shaderProgram) { JsonParser screenParser("data/screens.json"); - screens = screenParser.getScreens(shaderProgram, framebuffer); + m_screens = screenParser.getScreens(m_shaderProgram, m_frameBuffer); } Menu::~Menu() { // Iterate over screens delete all items - for (auto it = screens.begin(); it != screens.end(); it++) { + for (auto it = m_screens.begin(); it != m_screens.end(); it++) { delete (*it); } } Screen *Menu::getScreenByName(const std::string &name) const { - if (m_screen_name_cache.find(name) != m_screen_name_cache.end()) - return m_screen_name_cache[name]; + if (m_screenNameCache.find(name) != m_screenNameCache.end()) + return m_screenNameCache[name]; - for (auto it : screens) { + for (auto it : m_screens) { if (it->getUniqueName() == name) { - m_screen_name_cache[name] = it; + m_screenNameCache[name] = it; return it; } } @@ -37,7 +37,7 @@ Screen *Menu::getScreenByName(const std::string &name) const Screen *Menu::getActiveScreen() const { - return activeScreen; + return m_activeScreen; } void Menu::showScreenByName(const std::string &name) @@ -48,25 +48,25 @@ void Menu::showScreenByName(const std::string &name) return; screen->draw(); - activeScreen = screen; + m_activeScreen = screen; } void Menu::resetActiveScreen() { - activeScreen = nullptr; + m_activeScreen = nullptr; } void Menu::handleMouseButtonActionMap(const MouseButtonActionMap &mouseButtonActionMap, Window *window) { if (mouseButtonActionMap.at(MouseButtonAction::LeftClicked)) { - auto widgets = activeScreen->getWidgets(); + auto widgets = m_activeScreen->getWidgets(); for (auto it = widgets.begin(); it != widgets.end(); it++) { if ((*it)->isHovered(window)) { // std::cout << (*it)->getUniqueName() << " clicked!" << std::endl; if ((*it)->getCallbackId() == 1) resetActiveScreen(); if ((*it)->getCallbackId() == 2) - shouldExit = true; + m_shouldExit = true; } } } @@ -74,7 +74,7 @@ void Menu::handleMouseButtonActionMap(const MouseButtonActionMap &mouseButtonAct void Menu::writeWindowActions(WindowActionMap &windowActionMap) { - if (shouldExit) + if (m_shouldExit) windowActionMap[WindowAction::WindowShouldClose] = true; } diff --git a/src/Menu.h b/src/Menu.h index 08fb74c..cfcf746 100644 --- a/src/Menu.h +++ b/src/Menu.h @@ -3,7 +3,7 @@ #include #include -#include "Framebuffer.h" +#include "FrameBuffer.h" #include "JsonParser.h" #include "Screen.h" #include "EventHandler.h" @@ -11,7 +11,7 @@ class Menu { public: - Menu(Framebuffer *p_framebuffer, ShaderProgram *p_shaderProgram); + Menu(FrameBuffer *p_framebuffer, ShaderProgram *p_shaderProgram); ~Menu(); Screen *getScreenByName(const std::string &name) const; @@ -28,17 +28,17 @@ public: void onExitPressed(); private: - Framebuffer *framebuffer; - ShaderProgram *shaderProgram; + FrameBuffer *m_frameBuffer; + ShaderProgram *m_shaderProgram; - bool shouldExit = false; + bool m_shouldExit = false; - std::vector screens; - Screen *activeScreen; + std::vector m_screens; + Screen *m_activeScreen; /*Screen *loadingScreen; Screen *mainMenuScreen; Screen *optionMenuScreen; Screen *pauseMenuScreen;*/ - mutable std::unordered_map m_screen_name_cache; + mutable std::unordered_map m_screenNameCache; }; diff --git a/src/Mesh.cpp b/src/Mesh.cpp index a2092db..ce7130e 100644 --- a/src/Mesh.cpp +++ b/src/Mesh.cpp @@ -1,9 +1,9 @@ #include "Mesh.h" Mesh::Mesh(std::vector vertices, std::vector indices, std::vector textures) - : numElements(indices.size()), textures(textures), - vertexArray(static_cast(vertices.data()), static_cast(indices.data()), vertices.size(), - indices.size()) + : m_numElements(indices.size()), m_textures(textures), + m_vertexArray(static_cast(vertices.data()), static_cast(indices.data()), vertices.size(), + indices.size()) {} void Mesh::draw(ShaderProgram *shaderProgram) @@ -11,8 +11,8 @@ void Mesh::draw(ShaderProgram *shaderProgram) uint8_t typeNumberCount[static_cast(TextureType::TEXTURE_TYPE_NUM_ITEMS)]{0}; glBindTexture(GL_TEXTURE_2D, 0); // Bind all textures in order to its texture unit - for (auto it = textures.begin(); it != textures.end(); it++) { - const int i = it - textures.begin(); + for (auto it = m_textures.begin(); it != m_textures.end(); it++) { + const int i = it - m_textures.begin(); TextureType currentTextureType = (*it)->getTextureType(); @@ -22,24 +22,24 @@ void Mesh::draw(ShaderProgram *shaderProgram) } // Draw elements - vertexArray.bind(); - glDrawElements(GL_TRIANGLES, numElements, GL_UNSIGNED_INT, 0); - vertexArray.unbind(); + m_vertexArray.bind(); + glDrawElements(GL_TRIANGLES, m_numElements, GL_UNSIGNED_INT, 0); + m_vertexArray.unbind(); // Unbind all textures - for (auto it = textures.begin(); it != textures.end(); it++) { + for (auto it = m_textures.begin(); it != m_textures.end(); it++) { (*it)->unbind(); } } void Mesh::drawWithoutTextures() { - vertexArray.bind(); - glDrawElements(GL_TRIANGLES, numElements, GL_UNSIGNED_INT, 0); - vertexArray.unbind(); + m_vertexArray.bind(); + glDrawElements(GL_TRIANGLES, m_numElements, GL_UNSIGNED_INT, 0); + m_vertexArray.unbind(); } VertexArray *Mesh::getVertexArray() { - return &vertexArray; + return &m_vertexArray; } diff --git a/src/Mesh.h b/src/Mesh.h index 39a008b..d147eb8 100644 --- a/src/Mesh.h +++ b/src/Mesh.h @@ -21,9 +21,8 @@ public: private: void setupMesh(); -private: - uint32_t numElements; - std::vector textures; + uint32_t m_numElements; + std::vector m_textures; - VertexArray vertexArray; + VertexArray m_vertexArray; }; diff --git a/src/Model.cpp b/src/Model.cpp index eedeed7..c47ed32 100644 --- a/src/Model.cpp +++ b/src/Model.cpp @@ -3,46 +3,46 @@ #include #include -uint32_t Model::id_counter = 0; +uint32_t Model::s_idCounter = 0; -Model::Model(const std::string &modelName, const std::string &modelPath) : unique_name(modelName) +Model::Model(const std::string &modelName, const std::string &modelPath) : m_uniqueName(modelName) { - directory = modelPath.substr(0, modelPath.find_last_of('/')); + m_workingPath = modelPath.substr(0, modelPath.find_last_of('/')); loadModel(modelPath); - id = id_counter++; + m_id = s_idCounter++; } Model::~Model() { // Go through all loaded textures and delete them - for (auto it = loadedTextures.begin(); it != loadedTextures.end(); it++) { + for (auto it = m_loadedTextures.begin(); it != m_loadedTextures.end(); it++) { delete (*it); } } void Model::draw(ShaderProgram *shaderProgram) { - if (!model_prepared) { + if (!m_modelPrepared) { std::cout << "WARNING: Model not prepared! Unable to draw!" << std::endl; return; } // Iterate through every mesh and call the draw function - for (auto mesh : meshes) { + for (auto mesh : m_meshes) { mesh->draw(shaderProgram); } } void Model::drawWithoutTextures() { - if (!model_prepared) { + if (!m_modelPrepared) { std::cout << "WARNING: Model not prepared! Unable to draw!" << std::endl; return; } // Iterate through every mesh and call the draw function - for (auto mesh : meshes) { + for (auto mesh : m_meshes) { mesh->drawWithoutTextures(); } } @@ -82,12 +82,12 @@ void Model::loadModel(const std::string &pathToModel) for (unsigned int i = 0; i < numTextures; i++) { TexturePrototype texture_prototype; - std::string texturePath = directory + '/' + textureSources[i].c_str(); + std::string texturePath = m_workingPath + '/' + textureSources[i].c_str(); texture_prototype.texturePath = std::move(texturePath); texture_prototype.textureType = textureTypes[i]; - modelTexturePrototypes.push_back(texture_prototype); + m_modelTexturePrototypes.push_back(texture_prototype); } // When there is no normal map bound, please use fallback texture @@ -103,7 +103,7 @@ void Model::loadModel(const std::string &pathToModel) texture_prototype.texturePath = "data/res/models/tex/fallback_normal.png"; texture_prototype.textureType = TextureType::Normal; - modelTexturePrototypes.push_back(texture_prototype); + m_modelTexturePrototypes.push_back(texture_prototype); } // Here starts the first mesh @@ -146,7 +146,7 @@ void Model::loadModel(const std::string &pathToModel) mesh_prototype.textureIds.push_back(numTextures); } - modelMeshPrototypes.push_back(std::move(mesh_prototype)); + m_modelMeshPrototypes.push_back(std::move(mesh_prototype)); } input.close(); @@ -154,32 +154,32 @@ void Model::loadModel(const std::string &pathToModel) void Model::prepareModel() { - model_prepared = true; + m_modelPrepared = true; // Create textures on GPU - for (auto &it : modelTexturePrototypes) { + for (auto &it : m_modelTexturePrototypes) { Texture *newTex = new Texture(it.texturePath.c_str(), it.textureType); - loadedTextures.push_back(newTex); + m_loadedTextures.push_back(newTex); } // Create meshes on GPU - for (const auto &it : modelMeshPrototypes) { + for (const auto &it : m_modelMeshPrototypes) { std::vector meshTextures; for (const auto it2 : it.textureIds) { - meshTextures.push_back(loadedTextures[it2]); + meshTextures.push_back(m_loadedTextures[it2]); } Mesh *currentMesh = new Mesh(std::move(it.meshVertices), std::move(it.meshIndices), meshTextures); - meshes.push_back(currentMesh); + m_meshes.push_back(currentMesh); } } Mesh *Model::getMesh(unsigned int index) { - return meshes[index]; + return m_meshes[index]; } -std::string Model::getUniqueName() +const std::string &Model::getUniqueName() { - return unique_name; + return m_uniqueName; } diff --git a/src/Model.h b/src/Model.h index 5f7fa6e..201b01e 100644 --- a/src/Model.h +++ b/src/Model.h @@ -30,23 +30,22 @@ public: void drawWithoutTextures(); Mesh *getMesh(unsigned int index); - std::string getUniqueName(); + const std::string &getUniqueName(); private: void loadModel(const std::string &pathToModel); -private: - std::vector meshes; - std::vector loadedTextures; + std::vector m_meshes; + std::vector m_loadedTextures; - std::vector modelTexturePrototypes; - std::vector modelMeshPrototypes; + std::vector m_modelTexturePrototypes; + std::vector m_modelMeshPrototypes; - std::string directory; + std::string m_workingPath; - bool model_prepared = false; + bool m_modelPrepared = false; - static uint32_t id_counter; - uint32_t id; - std::string unique_name; + static uint32_t s_idCounter; + uint32_t m_id; + std::string m_uniqueName; }; diff --git a/src/Screen.cpp b/src/Screen.cpp index 2e038b5..9f3887c 100644 --- a/src/Screen.cpp +++ b/src/Screen.cpp @@ -1,44 +1,44 @@ #include "Screen.h" #include "Helper.h" -uint32_t Screen::id_counter = 0; +uint32_t Screen::s_idCounter = 0; -Screen::Screen(const std::string &name, std::vector widgets, Framebuffer *framebuffer, +Screen::Screen(const std::string &name, std::vector widgets, FrameBuffer *framebuffer, ShaderProgram *shaderProgram) - : unique_name(name), framebuffer(framebuffer), shaderProgram(shaderProgram), widgets(widgets) + : m_uniqueName(name), m_frameBuffer(framebuffer), m_shaderProgram(shaderProgram), m_widgets(widgets) { - id = id_counter++; + m_id = s_idCounter++; } Screen::~Screen() { // Iterate over Widgets and Textures to delete all of them - for (auto it = widgets.begin(); it != widgets.end(); it++) { + for (auto it = m_widgets.begin(); it != m_widgets.end(); it++) { delete *it; } - for (auto it = textures.begin(); it != textures.end(); it++) { + for (auto it = m_textures.begin(); it != m_textures.end(); it++) { delete *it; } } const std::string &Screen::getUniqueName() const { - return unique_name; + return m_uniqueName; } std::vector Screen::getWidgets() const { - return widgets; + return m_widgets; } Widget *Screen::getWidgetByName(const std::string &name) const { - if (m_widget_name_cache.find(name) != m_widget_name_cache.end()) - return m_widget_name_cache[name]; + if (m_widgetNameCache.find(name) != m_widgetNameCache.end()) + return m_widgetNameCache[name]; - for (auto it : widgets) { + for (auto it : m_widgets) { if (it->getUniqueName() == name) { - m_widget_name_cache[name] = it; + m_widgetNameCache[name] = it; return it; } } @@ -47,19 +47,19 @@ Widget *Screen::getWidgetByName(const std::string &name) const void Screen::addWidget(Widget *widget) { - widgets.push_back(widget); + m_widgets.push_back(widget); } void Screen::draw() const { - framebuffer->setExposureCorrection(false); - framebuffer->bind(); + m_frameBuffer->setExposureCorrection(false); + m_frameBuffer->bind(); - for (auto it = widgets.begin(); it != widgets.end(); it++) { - (*it)->draw(shaderProgram); + for (auto it = m_widgets.begin(); it != m_widgets.end(); it++) { + (*it)->draw(m_shaderProgram); } - framebuffer->unbind(); - framebuffer->render(); - framebuffer->setExposureCorrection(true); + m_frameBuffer->unbind(); + m_frameBuffer->render(); + m_frameBuffer->setExposureCorrection(true); } diff --git a/src/Screen.h b/src/Screen.h index 4091fb5..46b0539 100644 --- a/src/Screen.h +++ b/src/Screen.h @@ -2,7 +2,7 @@ #include -#include "Framebuffer.h" +#include "FrameBuffer.h" #include "ShaderProgram.h" #include "Widget.h" @@ -11,7 +11,7 @@ class Menu; class Screen { public: - Screen(const std::string &name, std::vector widgets, Framebuffer *framebuffer, + Screen(const std::string &name, std::vector widgets, FrameBuffer *framebuffer, ShaderProgram *shaderProgram); ~Screen(); @@ -23,15 +23,15 @@ public: Widget *getWidgetByName(const std::string &name) const; private: - uint32_t id; - static uint32_t id_counter; - std::string unique_name; + uint32_t m_id; + static uint32_t s_idCounter; + std::string m_uniqueName; - Framebuffer *framebuffer; - ShaderProgram *shaderProgram; + FrameBuffer *m_frameBuffer; + ShaderProgram *m_shaderProgram; - std::vector textures; - std::vector widgets; + std::vector m_textures; + std::vector m_widgets; - mutable std::unordered_map m_widget_name_cache; + mutable std::unordered_map m_widgetNameCache; }; diff --git a/src/ShaderProgram.cpp b/src/ShaderProgram.cpp index 9bf70b9..93dfa40 100644 --- a/src/ShaderProgram.cpp +++ b/src/ShaderProgram.cpp @@ -8,22 +8,22 @@ ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) - : unique_name(name) + : m_uniqueName(name) { std::string vertexShaderSource = parse(vertexShaderPath.c_str()); std::string fragmentShaderSource = parse(fragmentShaderPath.c_str()); - shaderProgramId = glCreateProgram(); + m_shaderProgramId = glCreateProgram(); GLuint vs = compile(vertexShaderSource, GL_VERTEX_SHADER); GLuint fs = compile(fragmentShaderSource, GL_FRAGMENT_SHADER); - glAttachShader(shaderProgramId, vs); - glAttachShader(shaderProgramId, fs); + glAttachShader(m_shaderProgramId, vs); + glAttachShader(m_shaderProgramId, fs); - glLinkProgram(shaderProgramId); + glLinkProgram(m_shaderProgramId); GLint isLinked = 0; - glGetProgramiv(shaderProgramId, GL_LINK_STATUS, &isLinked); + glGetProgramiv(m_shaderProgramId, GL_LINK_STATUS, &isLinked); if (!isLinked) { std::cout << "Failed to link shaderProgram: " << vertexShaderPath << ", " << fragmentShaderPath << std::endl; } @@ -39,25 +39,25 @@ ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexS ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &geometryShaderPath, const std::string &fragmentShaderPath) - : unique_name(name) + : m_uniqueName(name) { std::string vertexShaderSource = parse(vertexShaderPath.c_str()); std::string geometryShaderSource = parse(geometryShaderPath.c_str()); std::string fragmentShaderSource = parse(fragmentShaderPath.c_str()); - shaderProgramId = glCreateProgram(); + m_shaderProgramId = glCreateProgram(); GLuint vs = compile(vertexShaderSource, GL_VERTEX_SHADER); GLuint gs = compile(geometryShaderSource, GL_GEOMETRY_SHADER); GLuint fs = compile(fragmentShaderSource, GL_FRAGMENT_SHADER); - glAttachShader(shaderProgramId, vs); - glAttachShader(shaderProgramId, gs); - glAttachShader(shaderProgramId, fs); + glAttachShader(m_shaderProgramId, vs); + glAttachShader(m_shaderProgramId, gs); + glAttachShader(m_shaderProgramId, fs); - glLinkProgram(shaderProgramId); + glLinkProgram(m_shaderProgramId); GLint isLinked = 0; - glGetProgramiv(shaderProgramId, GL_LINK_STATUS, &isLinked); + glGetProgramiv(m_shaderProgramId, GL_LINK_STATUS, &isLinked); if (!isLinked) { std::cout << "Failed to link shaderProgram: " << vertexShaderPath << ", " << geometryShaderPath << ", " << fragmentShaderPath << std::endl; @@ -76,12 +76,12 @@ ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexS ShaderProgram::~ShaderProgram() { - glDeleteProgram(shaderProgramId); + glDeleteProgram(m_shaderProgramId); } void ShaderProgram::bind() { - glUseProgram(shaderProgramId); + glUseProgram(m_shaderProgramId); } void ShaderProgram::unbind() @@ -127,11 +127,11 @@ GLuint ShaderProgram::compile(const std::string &shaderSource, GLenum type) GLint ShaderProgram::retrieveUniformLocation(const std::string &name) const { - if (uniformLocationCache.find(name) != uniformLocationCache.end()) - return uniformLocationCache[name]; + if (m_uniformLocationCache.find(name) != m_uniformLocationCache.end()) + return m_uniformLocationCache[name]; - GLint location = glGetUniformLocation(shaderProgramId, name.c_str()); - uniformLocationCache[name] = location; + GLint location = glGetUniformLocation(m_shaderProgramId, name.c_str()); + m_uniformLocationCache[name] = location; return location; } @@ -174,10 +174,10 @@ void ShaderProgram::setUniform(const std::string &name, glm::mat4 matrix) const GLuint ShaderProgram::getShaderProgramId() { - return shaderProgramId; + return m_shaderProgramId; } -std::string ShaderProgram::getUniqueName() +const std::string &ShaderProgram::getUniqueName() { - return unique_name; + return m_uniqueName; } diff --git a/src/ShaderProgram.h b/src/ShaderProgram.h index 7b7aa23..7dbee1d 100644 --- a/src/ShaderProgram.h +++ b/src/ShaderProgram.h @@ -25,16 +25,14 @@ public: void setUniform(const std::string &name, glm::mat3 matrix) const; void setUniform(const std::string &name, glm::mat4 matrix) const; -public: GLuint getShaderProgramId(); - std::string getUniqueName(); + const std::string &getUniqueName(); private: std::string parse(const std::string &filename); GLuint compile(const std::string &shaderSource, GLenum type); -private: - GLuint shaderProgramId; - std::string unique_name; - mutable std::unordered_map uniformLocationCache; + GLuint m_shaderProgramId; + std::string m_uniqueName; + mutable std::unordered_map m_uniformLocationCache; }; diff --git a/src/Texture.cpp b/src/Texture.cpp index f810988..3236209 100644 --- a/src/Texture.cpp +++ b/src/Texture.cpp @@ -4,27 +4,27 @@ #include Texture::Texture(const std::string &texturePath, TextureType textureType) - : texturePath(texturePath), textureType(textureType) + : m_texturePath(texturePath), m_textureType(textureType) { stbi_set_flip_vertically_on_load(1); - auto *textureBuffer = stbi_load(texturePath.c_str(), &textureWidth, &textureHeight, &numComponents, 0); + auto *textureBuffer = stbi_load(texturePath.c_str(), &m_textureWidth, &m_textureHeight, &m_numComponents, 0); GLenum internalFormat; GLenum dataFormat; - if (numComponents == 1) { + if (m_numComponents == 1) { internalFormat = GL_RED; dataFormat = GL_RED; - } else if (numComponents == 3) { + } else if (m_numComponents == 3) { internalFormat = (textureType == TextureType::Diffuse) ? GL_SRGB8 : GL_RGB8; dataFormat = GL_RGB; - } else if (numComponents == 4) { + } else if (m_numComponents == 4) { internalFormat = (textureType == TextureType::Diffuse) ? GL_SRGB8_ALPHA8 : GL_RGBA8; dataFormat = GL_RGBA; } // Push texture to grahics card - glGenTextures(1, &textureId); - glBindTexture(GL_TEXTURE_2D, textureId); + glGenTextures(1, &m_textureId); + glBindTexture(GL_TEXTURE_2D, m_textureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); @@ -38,7 +38,7 @@ Texture::Texture(const std::string &texturePath, TextureType textureType) return; } - glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, textureWidth, textureHeight, 0, dataFormat, GL_UNSIGNED_BYTE, + glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_textureWidth, m_textureHeight, 0, dataFormat, GL_UNSIGNED_BYTE, textureBuffer); glGenerateMipmap(GL_TEXTURE_2D); @@ -48,14 +48,14 @@ Texture::Texture(const std::string &texturePath, TextureType textureType) Texture::~Texture() { - glDeleteTextures(1, &textureId); + glDeleteTextures(1, &m_textureId); } void Texture::bind(uint8_t textureUnit, ShaderProgram *shaderProgram, uint8_t textureTypeNum) { std::string uniformName = "texture_"; - switch (textureType) { + switch (m_textureType) { case TextureType::Diffuse: uniformName += "diffuse" + std::to_string(textureTypeNum); @@ -79,7 +79,7 @@ void Texture::bind(uint8_t textureUnit, ShaderProgram *shaderProgram, uint8_t te shaderProgram->setUniform(uniformName.c_str(), textureUnit); glActiveTexture(GL_TEXTURE0 + textureUnit); - glBindTexture(GL_TEXTURE_2D, textureId); + glBindTexture(GL_TEXTURE_2D, m_textureId); } void Texture::unbind() @@ -89,29 +89,29 @@ void Texture::unbind() TextureType Texture::getTextureType() { - return textureType; + return m_textureType; } std::string Texture::getPath() { - return texturePath; + return m_texturePath; } GLuint Texture::getTextureId() { - return textureId; + return m_textureId; } CubeMap::CubeMap(const char *texturePseudoPath) { // Reserve space in vector so that elements can be accessed explicitly. - texturePaths.resize(CUBEMAP_FACES_NUM_ITEMS); + m_texturePaths.resize(CUBEMAP_FACES_NUM_ITEMS); fillTexturePathVector(texturePseudoPath); stbi_set_flip_vertically_on_load(0); - glGenTextures(1, &textureId); - glBindTexture(GL_TEXTURE_CUBE_MAP, textureId); + glGenTextures(1, &m_textureId); + glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureId); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); @@ -122,7 +122,8 @@ CubeMap::CubeMap(const char *texturePseudoPath) for (unsigned int i = 0; i < CUBEMAP_FACES_NUM_ITEMS; i++) { int32_t numComponents; - auto *textureBuffer = stbi_load(texturePaths[i].c_str(), &textureWidth, &textureHeight, &numComponents, 0); + auto *textureBuffer = + stbi_load(m_texturePaths[i].c_str(), &m_textureWidth, &m_textureHeight, &numComponents, 0); GLenum internalFormat; GLenum dataFormat; @@ -138,12 +139,12 @@ CubeMap::CubeMap(const char *texturePseudoPath) } if (!textureBuffer) { - std::cout << "[Warning] CubeMap Texture " << texturePaths[i].c_str() << " not found!" << std::endl; + std::cout << "[Warning] CubeMap Texture " << m_texturePaths[i].c_str() << " not found!" << std::endl; return; } - glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormat, textureWidth, textureHeight, 0, dataFormat, - GL_UNSIGNED_BYTE, textureBuffer); + glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormat, m_textureWidth, m_textureHeight, 0, + dataFormat, GL_UNSIGNED_BYTE, textureBuffer); stbi_image_free(textureBuffer); } @@ -151,11 +152,11 @@ CubeMap::CubeMap(const char *texturePseudoPath) glBindTexture(GL_TEXTURE_CUBE_MAP, 0); } -CubeMap::CubeMap(int RESOLUTION) : textureWidth(RESOLUTION), textureHeight(RESOLUTION) +CubeMap::CubeMap(int RESOLUTION) : m_textureWidth(RESOLUTION), m_textureHeight(RESOLUTION) { - glGenTextures(1, &textureId); - glBindTexture(GL_TEXTURE_CUBE_MAP, textureId); + glGenTextures(1, &m_textureId); + glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureId); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); @@ -174,7 +175,7 @@ CubeMap::CubeMap(int RESOLUTION) : textureWidth(RESOLUTION), textureHeight(RESOL CubeMap::~CubeMap() { - glDeleteTextures(1, &textureId); + glDeleteTextures(1, &m_textureId); } void CubeMap::bind(ShaderProgram *shaderProgram) @@ -183,7 +184,7 @@ void CubeMap::bind(ShaderProgram *shaderProgram) shaderProgram->setUniform(uniformName.c_str(), 0); glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_CUBE_MAP, textureId); + glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureId); } void CubeMap::unbind() @@ -194,16 +195,16 @@ void CubeMap::unbind() void CubeMap::fillTexturePathVector(const char *texturePseudoPath) { for (unsigned int i = 0; i < CUBEMAP_FACES_NUM_ITEMS; i++) { - texturePaths[cm_front] = std::string(texturePseudoPath) + "front.png"; - texturePaths[cm_back] = std::string(texturePseudoPath) + "back.png"; - texturePaths[cm_top] = std::string(texturePseudoPath) + "top.png"; - texturePaths[cm_bottom] = std::string(texturePseudoPath) + "bottom.png"; - texturePaths[cm_left] = std::string(texturePseudoPath) + "left.png"; - texturePaths[cm_right] = std::string(texturePseudoPath) + "right.png"; + m_texturePaths[cm_front] = std::string(texturePseudoPath) + "front.png"; + m_texturePaths[cm_back] = std::string(texturePseudoPath) + "back.png"; + m_texturePaths[cm_top] = std::string(texturePseudoPath) + "top.png"; + m_texturePaths[cm_bottom] = std::string(texturePseudoPath) + "bottom.png"; + m_texturePaths[cm_left] = std::string(texturePseudoPath) + "left.png"; + m_texturePaths[cm_right] = std::string(texturePseudoPath) + "right.png"; } } GLuint CubeMap::getTextureId() { - return textureId; + return m_textureId; } diff --git a/src/Texture.h b/src/Texture.h index 3132dd9..78e8a4e 100644 --- a/src/Texture.h +++ b/src/Texture.h @@ -35,15 +35,15 @@ public: GLuint getTextureId(); private: - std::string texturePath; + std::string m_texturePath; - int32_t textureWidth; - int32_t textureHeight; - int32_t numComponents; + int32_t m_textureWidth; + int32_t m_textureHeight; + int32_t m_numComponents; - GLuint textureId; + GLuint m_textureId; - TextureType textureType; + TextureType m_textureType; }; class CubeMap @@ -62,11 +62,10 @@ public: private: void fillTexturePathVector(const char *texturePseudoPath); -private: - std::vector texturePaths; + std::vector m_texturePaths; - GLuint textureId; + GLuint m_textureId; - int32_t textureWidth; - int32_t textureHeight; + int32_t m_textureWidth; + int32_t m_textureHeight; }; diff --git a/src/VertexArray.cpp b/src/VertexArray.cpp index c25161c..015c6b6 100644 --- a/src/VertexArray.cpp +++ b/src/VertexArray.cpp @@ -6,15 +6,15 @@ VertexArray::VertexArray(void *vertexData, void *indexData, uint32_t numVertices, uint32_t numIndices) { - glGenVertexArrays(1, &VAO); - glBindVertexArray(VAO); + glGenVertexArrays(1, &m_VAO); + glBindVertexArray(m_VAO); - glGenBuffers(1, &VBO); - glBindBuffer(GL_ARRAY_BUFFER, VBO); + glGenBuffers(1, &m_VBO); + glBindBuffer(GL_ARRAY_BUFFER, m_VBO); glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(Vertex), vertexData, GL_STATIC_DRAW); - glGenBuffers(1, &EBO); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glGenBuffers(1, &m_EBO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_EBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices * sizeof(uint32_t), indexData, GL_STATIC_DRAW); // Position @@ -43,12 +43,12 @@ VertexArray::VertexArray(void *vertexData, void *indexData, uint32_t numVertices VertexArray::~VertexArray() { - glDeleteBuffers(1, &VBO); + glDeleteBuffers(1, &m_VBO); } void VertexArray::bind() { - glBindVertexArray(VAO); + glBindVertexArray(m_VAO); } void VertexArray::unbind() diff --git a/src/VertexArray.h b/src/VertexArray.h index c3a7a87..0fa628b 100644 --- a/src/VertexArray.h +++ b/src/VertexArray.h @@ -16,7 +16,7 @@ public: static std::vector createVertices(double *vertices, uint32_t numVertices, float *textureCoordinates); private: - GLuint VAO; - GLuint VBO; - GLuint EBO; + GLuint m_VAO; + GLuint m_VBO; + GLuint m_EBO; }; diff --git a/src/Widget.cpp b/src/Widget.cpp index 2fbf890..d1c9dad 100644 --- a/src/Widget.cpp +++ b/src/Widget.cpp @@ -3,45 +3,53 @@ #include "VertexArray.h" Widget::Widget(std::string &name, Texture *texture, float p_x, float p_y, float p_w, float p_h, uint16_t callbackId) - : x(p_x), y(p_y), w(p_w), h(p_h), unique_name(name), callbackId(callbackId) + : m_posX(p_x), m_posY(p_y), m_width(p_w), m_height(p_h), m_uniqueName(name), m_callbackId(callbackId) { - widgetTextures.push_back(texture); + m_widgetTextures.push_back(texture); double widgetVerticesData[12] = { - 2 * (x + w) - 1.0f, 2 * (y)-1.0f, 0.0f, // Bottom right - 2 * (x)-1.0f, 2 * (y + h) - 1.0f, 0.0f, // Top left - 2 * (x)-1.0f, 2 * (y)-1.0f, 0.0f, // Bottom left - 2 * (x + w) - 1.0f, 2 * (y + h) - 1.0f, 0.0f // Top right + 2 * (m_posX + m_width) - 1.0f, + 2 * (m_posY)-1.0f, + 0.0f, // Bottom right + 2 * (m_posX)-1.0f, + 2 * (m_posY + m_height) - 1.0f, + 0.0f, // Top left + 2 * (m_posX)-1.0f, + 2 * (m_posY)-1.0f, + 0.0f, // Bottom left + 2 * (m_posX + m_width) - 1.0f, + 2 * (m_posY + m_height) - 1.0f, + 0.0f // Top right }; unsigned int widgetIndicesData[6] = {0, 1, 2, 0, 3, 1}; float widgetTextureCoordinates[8] = {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f}; - widgetVertices = VertexArray::createVertices(widgetVerticesData, 12, widgetTextureCoordinates); - widgetIndices.assign(widgetIndicesData, widgetIndicesData + 6); - widgetMesh = new Mesh(widgetVertices, widgetIndices, widgetTextures); + m_widgetVertices = VertexArray::createVertices(widgetVerticesData, 12, widgetTextureCoordinates); + m_widgetIndices.assign(widgetIndicesData, widgetIndicesData + 6); + m_widgetMesh = new Mesh(m_widgetVertices, m_widgetIndices, m_widgetTextures); } Widget::~Widget() { - delete widgetMesh; + delete m_widgetMesh; } std::string Widget::getUniqueName() { - return unique_name; + return m_uniqueName; } uint16_t Widget::getCallbackId() { - return callbackId; + return m_callbackId; } void Widget::draw(ShaderProgram *shaderProgram) { shaderProgram->bind(); - widgetMesh->draw(shaderProgram); + m_widgetMesh->draw(shaderProgram); shaderProgram->unbind(); } @@ -56,7 +64,7 @@ bool Widget::isHovered(Window *window) double yrel = -ypos / height + 1; bool isHovered = false; - if (xrel >= x && xrel <= x + w && yrel >= y && yrel <= y + h) + if (xrel >= m_posX && xrel <= m_posX + m_width && yrel >= m_posY && yrel <= m_posY + m_height) isHovered = true; return isHovered; diff --git a/src/Widget.h b/src/Widget.h index 720323d..b59d121 100644 --- a/src/Widget.h +++ b/src/Widget.h @@ -1,6 +1,6 @@ #pragma once -#include "Framebuffer.h" +#include "FrameBuffer.h" #include "Mesh.h" #include "Texture.h" #include "Window.h" @@ -22,15 +22,15 @@ public: bool isHovered(Window *window); private: - double x, y, w, h; + double m_posX, m_posY, m_width, m_height; - std::string unique_name; + std::string m_uniqueName; - uint16_t callbackId; + uint16_t m_callbackId; - std::vector widgetVertices; - std::vector widgetIndices; - std::vector widgetTextures; + std::vector m_widgetVertices; + std::vector m_widgetIndices; + std::vector m_widgetTextures; - Mesh *widgetMesh; + Mesh *m_widgetMesh; }; diff --git a/src/Window.cpp b/src/Window.cpp index 9c7788a..6abcab7 100644 --- a/src/Window.cpp +++ b/src/Window.cpp @@ -13,8 +13,8 @@ Window::Window() exit(-1); } - width = INIT_WINDOW_WIDTH; - height = INIT_WINDOW_HEIGHT; + m_width = INIT_WINDOW_WIDTH; + m_height = INIT_WINDOW_HEIGHT; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); @@ -28,7 +28,7 @@ Window::Window() glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE); #endif - window = glfwCreateWindow(width, height, "OpenGL", NULL, NULL); + window = glfwCreateWindow(m_width, m_height, "OpenGL", NULL, NULL); if (!window) { std::cout << "Failed to create window" << std::endl; } @@ -36,8 +36,8 @@ Window::Window() // Wait for window to maximize (in case) Helper::sleep(1000); - glfwGetWindowPos(window, &posX, &posY); - glfwGetWindowSize(window, &width, &height); + glfwGetWindowPos(window, &m_posX, &m_posY); + glfwGetWindowSize(window, &m_width, &m_height); // Create OpenGL context glfwMakeContextCurrent(window); @@ -54,7 +54,7 @@ Window::Window() glDebugMessageCallback(Helper::gl_debug_callback, NULL); // Disable mouse cursor - mouseCatched = false; + m_mouseCatched = false; #endif // Enable z buffer @@ -71,9 +71,9 @@ Window::Window() // Disable VSync since my sleep function handles this glfwSwapInterval(0); - setCatchedCursor(mouseCatched); + setCatchedCursor(m_mouseCatched); - glViewport(0, 0, width, height); + glViewport(0, 0, m_width, m_height); // Tell GLFW which function to call when window is resized // glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); @@ -91,15 +91,15 @@ bool Window::isWindowResized() glfwGetFramebufferSize(window, &new_width, &new_height); glfwGetWindowPos(window, &new_posx, &new_posy); - return !(new_width == width && new_height == height && new_posx == posX && new_posy == posY); + return !(new_width == m_width && new_height == m_height && new_posx == m_posX && new_posy == m_posY); } void Window::updateWindowDimensions() { - glfwGetFramebufferSize(window, &width, &height); - glfwGetWindowPos(window, &posX, &posY); + glfwGetFramebufferSize(window, &m_width, &m_height); + glfwGetWindowPos(window, &m_posX, &m_posY); - glViewport(0, 0, width, height); + glViewport(0, 0, m_width, m_height); } void Window::setCatchedCursor(bool value) @@ -115,8 +115,8 @@ void Window::handleWindowActionMap(WindowActionMap &windowActionMap) { if (windowActionMap.at(WindowAction::WireFrameToggle)) { windowActionMap[WindowAction::WireFrameToggle] = false; - wireFrameMode = !wireFrameMode; - if (wireFrameMode) { + m_wireFrameMode = !m_wireFrameMode; + if (m_wireFrameMode) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); @@ -125,8 +125,8 @@ void Window::handleWindowActionMap(WindowActionMap &windowActionMap) if (windowActionMap.at(WindowAction::MouseCatchToggle)) { windowActionMap[WindowAction::MouseCatchToggle] = false; - mouseCatched = !mouseCatched; - setCatchedCursor(mouseCatched); + m_mouseCatched = !m_mouseCatched; + setCatchedCursor(m_mouseCatched); } if (windowActionMap.at(WindowAction::WindowShouldClose)) { @@ -154,20 +154,20 @@ GLFWwindow *Window::getGLFWwindow() int Window::getWindowWidth() { - return width; + return m_width; } int Window::getWindowHeight() { - return height; + return m_height; } float Window::getWindowAspectRatio() { - return (float)width / (float)height; + return (float)m_width / (float)m_height; } bool Window::getMouseIsCatched() { - return mouseCatched; + return m_mouseCatched; } diff --git a/src/Window.h b/src/Window.h index 8827f95..b417ca1 100644 --- a/src/Window.h +++ b/src/Window.h @@ -27,12 +27,11 @@ private: static void framebuffer_size_callback(GLFWwindow *window, int width, int height); void setCatchedCursor(bool value); -private: GLFWwindow *window; - int posX, posY; - int width, height; + int m_posX, m_posY; + int m_width, m_height; - bool mouseCatched = true; - bool wireFrameMode = false; + bool m_mouseCatched = true; + bool m_wireFrameMode = false; }; diff --git a/src/World.cpp b/src/World.cpp index 12d3668..d08f878 100644 --- a/src/World.cpp +++ b/src/World.cpp @@ -5,62 +5,62 @@ #include World::World(std::vector shaderPrograms) - : shaderProgram(Controller::getShaderProgramByName(shaderPrograms, "defaultProgram")), - depthMapDirectionalFBO(DEPTHMAP_NORMAL, SHADOW_RES) + : m_shaderProgram(Controller::getShaderProgramByName(shaderPrograms, "defaultProgram")), + m_depthMapDirectionalFBO(DepthMapType::Normal, SHADOW_RES) { // Create 4 depthMaps for (int i = 0; i < 4; i++) { - DepthMap *temp_depthMap = new DepthMap(DEPTHMAP_CUBEMAP, SHADOW_RES); - depthMapPointFBO.push_back(temp_depthMap); + DepthMap *temp_depthMap = new DepthMap(DepthMapType::CubeMap, SHADOW_RES); + m_depthMapPointFBO.push_back(temp_depthMap); } // This will be removed in future when gloss maps are implemented - shaderProgram->bind(); - shaderProgram->setUniform("u_material.shininess", 100.0f); - shaderProgram->unbind(); + m_shaderProgram->bind(); + m_shaderProgram->setUniform("u_material.shininess", 100.0f); + m_shaderProgram->unbind(); JsonParser modelParser("data/models.json"); - models = modelParser.getModels(); + m_models = modelParser.getModels(); - for (const auto &it : models) { + for (const auto &it : m_models) { it->prepareModel(); } - entities = modelParser.getEntities(models, shaderPrograms); - skybox = modelParser.getSkybox(getModelByName("cube"), - Controller::getShaderProgramByName(shaderPrograms, "skyboxProgram")); + m_entities = modelParser.getEntities(m_models, shaderPrograms); + m_skybox = modelParser.getSkybox(getModelByName("cube"), + Controller::getShaderProgramByName(shaderPrograms, "skyboxProgram")); JsonParser lightParser("data/lights.json"); - lights = lightParser.getLights(shaderProgram); + m_lights = lightParser.getLights(m_shaderProgram); } World::~World() { // Iterate over depthMapPointFBO vector and delete all items - for (auto it = depthMapPointFBO.begin(); it != depthMapPointFBO.end(); it++) { + for (auto it = m_depthMapPointFBO.begin(); it != m_depthMapPointFBO.end(); it++) { delete (*it); } // Iterate over models and entities and delete all items - for (auto it = models.begin(); it != models.end(); it++) { + for (auto it = m_models.begin(); it != m_models.end(); it++) { delete (*it); } - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { delete (*it); } - delete skybox; + delete m_skybox; } void World::addEntity(Entity *entity) { - entities.push_back(entity); + m_entities.push_back(entity); } void World::removeEntityByName(std::string name) { - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { if ((*it)->getUniqueName() == name) { - entities.erase(it); + m_entities.erase(it); return; } } @@ -70,8 +70,8 @@ void World::removeEntityByName(std::string name) void World::clearEntities() { - for (auto it = entities.begin(); it != entities.end(); it++) { - entities.erase(it); + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { + m_entities.erase(it); } } @@ -95,7 +95,7 @@ void World::updateDirectionalLight(bool active, glm::vec3 direction, glm::vec3 c void World::draw(glm::mat4 viewProjMatrix, glm::vec3 viewPosition) { // Draw all entities - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { (*it)->draw(viewProjMatrix, viewPosition); } @@ -113,60 +113,66 @@ void World::calculateShadows(ShaderProgram *directionalShaderProgram, ShaderProg // Switch face culling (Peter panning) glCullFace(GL_BACK); - depthMapDirectionalFBO.bind(); + m_depthMapDirectionalFBO.bind(); glClear(GL_DEPTH_BUFFER_BIT); // --- Directional shadows --- glm::mat4 directionalLightView = glm::lookAt(-5.0f * glm::vec3(-0.2f, -1.0f, -0.3f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)); - glm::mat4 directionalLightViewProjectionMatrix = directionalLightProjection * directionalLightView; + glm::mat4 directionalLightViewProjectionMatrix = m_directionalLightProjection * directionalLightView; // Draw scene from light perspective // Draw all entities - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { (*it)->drawDirectionalShadows(directionalLightViewProjectionMatrix, directionalShaderProgram); } - depthMapDirectionalFBO.unbind(); + m_depthMapDirectionalFBO.unbind(); - shaderProgram->bind(); + m_shaderProgram->bind(); // Send lightViewProjMatrix to basic shader - shaderProgram->setUniform("u_directionalLightViewProjMatrix", directionalLightViewProjectionMatrix); + m_shaderProgram->setUniform("u_directionalLightViewProjMatrix", directionalLightViewProjectionMatrix); // Send shadowMap to basic shader int textureUnit = static_cast(TextureType::TEXTURE_TYPE_NUM_ITEMS) * 2; - shaderProgram->setUniform("u_texture_directionalShadowMap", (int)textureUnit); + m_shaderProgram->setUniform("u_texture_directionalShadowMap", (int)textureUnit); glActiveTexture(GL_TEXTURE0 + textureUnit); - glBindTexture(GL_TEXTURE_2D, depthMapDirectionalFBO.getDepthMap()); + glBindTexture(GL_TEXTURE_2D, m_depthMapDirectionalFBO.getDepthMap()); - shaderProgram->unbind(); + m_shaderProgram->unbind(); // --- Point shadows --- std::vector pointLights = getPointLights(); // 4 depthMaps for 4 point lights for (int i = 0; i < 1; i++) { - depthMapPointFBO[i]->bind(); + m_depthMapPointFBO[i]->bind(); glClear(GL_DEPTH_BUFFER_BIT); // Create 6 view matrices for every face of the cubeMap std::vector viewProjMatrices; glm::vec3 lightPos = pointLights[i]->getPosition(); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(1.0f, 0.0f, 0.0f), - glm::vec3(0.0f, -1.0f, 0.0f))); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(-1.0f, 0.0f, 0.0f), - glm::vec3(0.0f, -1.0f, 0.0f))); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(0.0f, 1.0f, 0.0f), - glm::vec3(0.0f, 0.0f, 1.0f))); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(0.0f, -1.0f, 0.0f), - glm::vec3(0.0f, 0.0f, -1.0f))); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(0.0f, 0.0f, 1.0f), - glm::vec3(0.0f, -1.0f, 0.0f))); - viewProjMatrices.push_back(pointLightProjection * glm::lookAt(lightPos, lightPos + glm::vec3(0.0f, 0.0f, -1.0f), - glm::vec3(0.0f, -1.0f, 0.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(1.0f, 0.0f, 0.0f), + glm::vec3(0.0f, -1.0f, 0.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(-1.0f, 0.0f, 0.0f), + glm::vec3(0.0f, -1.0f, 0.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(0.0f, 1.0f, 0.0f), + glm::vec3(0.0f, 0.0f, 1.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(0.0f, -1.0f, 0.0f), + glm::vec3(0.0f, 0.0f, -1.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(0.0f, 0.0f, 1.0f), + glm::vec3(0.0f, -1.0f, 0.0f))); + viewProjMatrices.push_back(m_pointLightProjection * glm::lookAt(lightPos, + lightPos + glm::vec3(0.0f, 0.0f, -1.0f), + glm::vec3(0.0f, -1.0f, 0.0f))); pointShaderProgram->bind(); @@ -175,27 +181,27 @@ void World::calculateShadows(ShaderProgram *directionalShaderProgram, ShaderProg viewProjMatrices[i]); } - pointShaderProgram->setUniform("pointShadowDepthMapFarPlane", far_plane_point); + pointShaderProgram->setUniform("pointShadowDepthMapFarPlane", m_farPlanePoint); pointShaderProgram->setUniform("v_lightPos", lightPos); // Draw scene from light perspective // Draw all entities - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { (*it)->drawPointShadows(pointShaderProgram); } - depthMapPointFBO[i]->unbind(); + m_depthMapPointFBO[i]->unbind(); - shaderProgram->bind(); + m_shaderProgram->bind(); - shaderProgram->setUniform("pointShadowDepthMapFarPlane", far_plane_point); + m_shaderProgram->setUniform("pointShadowDepthMapFarPlane", m_farPlanePoint); textureUnit = static_cast(TextureType::TEXTURE_TYPE_NUM_ITEMS) * 2 + i + 1; - shaderProgram->setUniform("u_texture_pointShadowMap0", (int)textureUnit); + m_shaderProgram->setUniform("u_texture_pointShadowMap0", (int)textureUnit); glActiveTexture(GL_TEXTURE0 + textureUnit); - glBindTexture(GL_TEXTURE_CUBE_MAP, depthMapPointFBO[i]->getCubeMapId()); + glBindTexture(GL_TEXTURE_CUBE_MAP, m_depthMapPointFBO[i]->getCubeMapId()); - shaderProgram->unbind(); + m_shaderProgram->unbind(); } // Reset viewport size @@ -205,7 +211,7 @@ void World::calculateShadows(ShaderProgram *directionalShaderProgram, ShaderProg Model *World::getModelByName(std::string name) { - for (auto it = models.begin(); it != models.end(); it++) { + for (auto it = m_models.begin(); it != m_models.end(); it++) { if ((*it)->getUniqueName() == name) { return *it; } @@ -216,7 +222,7 @@ Model *World::getModelByName(std::string name) Entity *World::getEntityByName(std::string name) { - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { if ((*it)->getUniqueName() == name) { return *it; } @@ -227,7 +233,7 @@ Entity *World::getEntityByName(std::string name) Entity *World::getEntityById(uint32_t id) { - for (auto it = entities.begin(); it != entities.end(); it++) { + for (auto it = m_entities.begin(); it != m_entities.end(); it++) { if ((*it)->getId() == id) { return *it; } @@ -240,7 +246,7 @@ std::vector World::getPointLights() { std::vector temp_pointLights; - for (auto it = lights.begin(); it != lights.end(); it++) { + for (auto it = m_lights.begin(); it != m_lights.end(); it++) { PointLight *temp_pointLight = dynamic_cast(*it); if (temp_pointLight) { temp_pointLights.push_back(temp_pointLight); @@ -254,7 +260,7 @@ DirectionalLight *World::getDirectionalLight() { DirectionalLight *temp_directionalLight = nullptr; - for (auto it = lights.begin(); it != lights.end(); it++) { + for (auto it = m_lights.begin(); it != m_lights.end(); it++) { temp_directionalLight = dynamic_cast(*it); if (temp_directionalLight) break; @@ -265,10 +271,10 @@ DirectionalLight *World::getDirectionalLight() std::vector World::getEntities() { - return entities; + return m_entities; } Skybox *World::getSkybox() { - return skybox; + return m_skybox; } diff --git a/src/World.h b/src/World.h index 4295551..c111947 100644 --- a/src/World.h +++ b/src/World.h @@ -4,7 +4,7 @@ #include "Camera.h" #include "Entity.h" -#include "Framebuffer.h" +#include "FrameBuffer.h" #include "Light.h" #include "ShaderProgram.h" @@ -33,27 +33,27 @@ public: void calculateShadows(ShaderProgram *directionalShaderProgram, ShaderProgram *pointShaderProgram); private: - ShaderProgram *shaderProgram; + ShaderProgram *m_shaderProgram; - std::vector models; - std::vector entities; - Skybox *skybox; + std::vector m_models; + std::vector m_entities; + Skybox *m_skybox; // Lights - std::vector lights; + std::vector m_lights; // Shadows const int SHADOW_RES = 4096 / 4; - DepthMap depthMapDirectionalFBO; - std::vector depthMapPointFBO; + DepthMap m_depthMapDirectionalFBO; + std::vector m_depthMapPointFBO; // Shadow projection matrices - const float near_plane_directional = 1.0f; - const float far_plane_directional = 15.0f; - glm::mat4 directionalLightProjection = - glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane_directional, far_plane_directional); - const float aspect_ratio_point = 1.0f; - const float near_plane_point = 1.0f; - const float far_plane_point = 25.0f; - glm::mat4 pointLightProjection = - glm::perspective(glm::radians(90.0f), aspect_ratio_point, near_plane_point, far_plane_point); + const float m_nearPlaneDirectional = 1.0f; + const float m_farPlaneDirectional = 15.0f; + glm::mat4 m_directionalLightProjection = + glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, m_nearPlaneDirectional, m_farPlaneDirectional); + const float m_aspectRatioPoint = 1.0f; + const float m_nearPlanePoint = 1.0f; + const float m_farPlanePoint = 25.0f; + glm::mat4 m_pointLightProjection = + glm::perspective(glm::radians(90.0f), m_aspectRatioPoint, m_nearPlanePoint, m_farPlanePoint); }; diff --git a/tools/main.cpp b/tools/main.cpp index a86a51e..83dee40 100644 --- a/tools/main.cpp +++ b/tools/main.cpp @@ -60,9 +60,9 @@ int main(int argc, char** argv) { Model currentModel; if(((*it).find('/')) < (*it).length()) { // source includes a / - currentModel.directory = (*it).substr(0, (*it).find_last_of('/')); + currentModel.m_workingPath = (*it).substr(0, (*it).find_last_of('/')); } else { - currentModel.directory = "."; + currentModel.m_workingPath = "."; } processNode(scene->mRootNode, scene, ¤tModel); @@ -96,9 +96,9 @@ int main(int argc, char** argv) { } // Write meshes - uint32_t numMeshes = currentModel.meshes.size(); + uint32_t numMeshes = currentModel.m_meshes.size(); output.write((char*) &numMeshes, sizeof(uint32_t)); - for(auto it1 = currentModel.meshes.begin(); it1 != currentModel.meshes.end(); it1++) { + for (auto it1 = currentModel.m_meshes.begin(); it1 != currentModel.m_meshes.end(); it1++) { uint32_t numVertices = (*it1).vertices.size(); uint32_t numIndices = (*it1).indices.size(); uint32_t numTextureIds = (*it1).textureIds.size(); @@ -128,7 +128,7 @@ void processNode(aiNode *node, const aiScene *scene, Model* model) { // Push the node's meshes into the mesh vector for(uint32_t i = 0; i < node->mNumMeshes; i++) { aiMesh *mesh = scene->mMeshes[node->mMeshes[i]]; - model->meshes.push_back(processMesh(mesh, scene, model)); + model->m_meshes.push_back(processMesh(mesh, scene, model)); } // Process child nodes too @@ -228,7 +228,7 @@ std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, u aiString filename; mat->GetTexture(type, i, &filename); - std::string currentPath = model->directory + '/' + filename.C_Str(); + std::string currentPath = model->m_workingPath + '/' + filename.C_Str(); bool skip = 0; for(uint32_t j = 0; j < model->textures.size(); j++) { @@ -244,12 +244,12 @@ std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, u texture.pathToTexture = currentPath; texture.textureType = textureType; // textureIds start at 0, but vector elements start at 1. - texture.textureId = model->textures.size(); + texture.m_textureId = model->textures.size(); model->textures.push_back(texture); // Add newest texture id to mesh - mesh->textureIds.push_back(texture.textureId); + mesh->textureIds.push_back(texture.m_textureId); } } diff --git a/tools/primitiveModel.h b/tools/primitiveModel.h index f572e97..95868b2 100644 --- a/tools/primitiveModel.h +++ b/tools/primitiveModel.h @@ -7,8 +7,7 @@ struct Texture { std::string pathToTexture; uint32_t textureType; - uint32_t textureId; - + uint32_t m_textureId; }; struct Mesh { @@ -22,7 +21,6 @@ struct Mesh { struct Model { std::vector textures; - std::vector meshes; - std::string directory; - + std::vector m_meshes; + std::string m_workingPath; };