main.cpp

#include <glad/glad.h>
#include <GLFW/glfw3.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <opengl/shader.hpp>
#include <opengl/camera.hpp>
#include <opengl/model.hpp>
#include <opengl/light.hpp>
#include <opengl/volume.hpp> 

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void processInput(GLFWwindow *window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

// camera
Camera camera(glm::vec3(0.0f, 0.0f, 5.0f));
float lastX = SCR_WIDTH / 2.0f;
float lastY = SCR_HEIGHT / 2.0f;
bool firstMouse = true;

// timing
float deltaTime = 0.0f;
float lastFrame = 0.0f;

int main()
{


 // glfw: initialize and configure
 // ------------------------------
 glfwInit();
 glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
 glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
 glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
 glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

 // glfw window creation
 // --------------------
 GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "ModelCloudRenderer", NULL, NULL);
 if (window == NULL)
 {
 std::cout << "Failed to create GLFW window" << std::endl;
 glfwTerminate();
 return -1;
 }
 glfwMakeContextCurrent(window);
 glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
 glfwSetCursorPosCallback(window, mouse_callback);
 glfwSetScrollCallback(window, scroll_callback);

 // tell GLFW to capture our mouse
 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

 // glad: load all OpenGL function pointers
 // ---------------------------------------
 if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
 {
 std::cout << "Failed to initialize GLAD" << std::endl;
 return -1;
 }

 // configure global opengl state
 // -----------------------------
 glEnable(GL_DEPTH_TEST);
 glEnable(GL_BLEND);
 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 // build and compile shaders
 // -------------------------
 Shader volumeShader("../resources/shaders/volume.vert", "../resources/shaders/volume.frag"); 

 // load models
 // -----------
 Volume ourVolume("../resources/models/bunny/bunny.obj", false);

 // generate light source
 LightManager dayLight;
 dayLight.setAmbientLight(glm::vec3(0.5f, 0.5f, 0.5f));

 LightManager sunset;
 sunset.setAmbientLight(glm::vec3(0.3f, 0.3f, 0.3f));
 sunset.setDirectionalLight(glm::vec3(-1.0f, 0.5f, 1.0f), glm::vec3(1.0f, 0.4f, 0.0f), 5.0f);

 // render loop
 // -----------
 while (!glfwWindowShouldClose(window))
 {
 // per-frame time logic
 // --------------------
 float currentFrame = static_cast<float>(glfwGetTime());
 deltaTime = currentFrame - lastFrame;
 lastFrame = currentFrame;

 // input
 // -----
 processInput(window);

 // render
 // ------
 glClearColor(0.05f, 0.65f, 0.85f, 1.0f);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 // render volume
 glDisable(GL_DEPTH_TEST);
 volumeShader.use();

 // view/projection transformations
 glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.01f, 100.0f);
 glm::mat4 view = camera.GetViewMatrix();
 volumeShader.setMat4("projection", projection);
 volumeShader.setMat4("view", view);

 // model transformation
 glm::mat4 model = glm::mat4(1.0f);
 model = glm::translate(model, glm::vec3(0.5f, -1.0f, 0.0f));
 model = glm::scale(model, glm::vec3(10.0f, 10.0f, 10.0f));	
 volumeShader.setMat4("model", model);

 // set camera position
 volumeShader.setVec3("cameraPos", camera.Position);
 
 // apply light to shader
 dayLight.Apply(volumeShader);
 // sunset.Apply(volumeShader);

 // render the model
 ourVolume.Draw(volumeShader);

 // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
 // -------------------------------------------------------------------------------
 glfwSwapBuffers(window);
 glfwPollEvents();
 }

 // glfw: terminate, clearing all previously allocated GLFW resources.
 // ------------------------------------------------------------------
 glfwTerminate();
 return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
 if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
 glfwSetWindowShouldClose(window, true);

 if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 camera.ProcessKeyboard(FORWARD, deltaTime);
 if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 camera.ProcessKeyboard(BACKWARD, deltaTime);
 if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 camera.ProcessKeyboard(LEFT, deltaTime);
 if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 camera.ProcessKeyboard(RIGHT, deltaTime);
 if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
 camera.ProcessKeyboard(UP, deltaTime);
 if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
 camera.ProcessKeyboard(DOWN, deltaTime);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
 // make sure the viewport matches the new window dimensions; note that width and 
 // height will be significantly larger than specified on retina displays.
 glViewport(0, 0, width, height);
}

// glfw: whenever the mouse moves, this callback is called
// -------------------------------------------------------
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
 float xpos = static_cast<float>(xposIn);
 float ypos = static_cast<float>(yposIn);

 if (firstMouse)
 {
 lastX = xpos;
 lastY = ypos;
 firstMouse = false;
 }

 float xoffset = xpos - lastX;
 float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

 lastX = xpos;
 lastY = ypos;

 camera.ProcessMouseMovement(xoffset, yoffset);
}

// glfw: whenever the mouse scroll wheel scrolls, this callback is called
// ----------------------------------------------------------------------
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
 camera.ProcessMouseScroll(static_cast<float>(yoffset));
}