From b299a8d8a2f6e56f883d145d95b297179ad350cb Mon Sep 17 00:00:00 2001 From: Jackson H Date: Tue, 4 Jun 2024 15:25:14 -0500 Subject: [PATCH] playing with another shader for a sun type thing and WAY better camera movement --- Camera.h | 38 +++++++++++- main.cpp | 146 +++++++++++++++++++++++++++++++++----------- shaders/shader.frag | 6 +- shaders/sun.frag | 11 ++++ shaders/sun.vert | 15 +++++ 5 files changed, 175 insertions(+), 41 deletions(-) create mode 100644 shaders/sun.frag create mode 100644 shaders/sun.vert diff --git a/Camera.h b/Camera.h index 608f964..fca7831 100644 --- a/Camera.h +++ b/Camera.h @@ -11,15 +11,25 @@ class Camera glm::vec3 target; glm::vec3 direction; glm::vec3 up; + + // Movement + glm::vec3 horizontal_velocity; + glm::vec3 forward_velocity; + glm::vec3 vertical_velocity; + float speed; glm::vec3 worldUp; - Camera(float speed) + Camera(float speed, glm::vec3 pos) { this->speed = speed; + this->vertical_velocity = glm::vec3(0.0f); - this->position = glm::vec3(0.0f, 0.0f, 3.0f); + this->horizontal_velocity = glm::vec3(0.0f); + this->forward_velocity = glm::vec3(0.0f); + + this->position = pos; this->target = glm::vec3(0.0f, 0.0f, -1.0f); this->direction = glm::normalize(this->position); @@ -32,6 +42,10 @@ class Camera Camera(glm::vec3 pos, glm::vec3 target, float speed) { this->speed = speed; + this->vertical_velocity = glm::vec3(0.0f); + + this->horizontal_velocity = glm::vec3(0.0f); + this->forward_velocity = glm::vec3(0.0f); this->position = pos; this->target = target; @@ -50,6 +64,26 @@ class Camera this->worldUp); } + void move(float time) // time passed in seconds since last move + { + if (this->position.y > 0) + this->vertical_velocity.y -= (9.8 * time); // gravity is 9.8m/s^2 no way! physics reference? + + std::cout << "pos: " << this->position.x << " " << this->position.y << " " << this->position.z << std::endl; + + glm::vec3 velocity = this->forward_velocity + this->horizontal_velocity + this->vertical_velocity; + + glm::vec3 movement = (velocity * time); + this->position += movement; + + // Don't want to clip into the ground right + if (this->position.y < 0) + { + this->position.y = 0; + this->vertical_velocity.y = 0; + } + } + }; #endif diff --git a/main.cpp b/main.cpp index 387bb74..c9a27aa 100644 --- a/main.cpp +++ b/main.cpp @@ -31,8 +31,14 @@ int flipped = 1; // 1 for normal, -1 for flipped bool flipping = false; glm::vec3 flip_target = glm::vec3(0.0f); +// Jump +const float jump_cooldown = 1.0f; +float last_jump = 0.0f; + // Various other settings -const float camera_speed = 0.05f; +const float camera_speed = 1.0f; +const float max_camera_speed = 2.0f; + const float look_sensitivity = 0.1f; const float Z_FAR = 1000.0f; const float Z_NEAR = 0.1f; @@ -41,31 +47,24 @@ const float TARGET_FPS = 60.0f; const float FOV = 90.0f; float sleep_time = 15.0f; +bool W_pressed, S_pressed, A_pressed, D_pressed = false; + glm::mat4 projection = glm::mat4(1.0f); float yaw, pitch = 0; // Camera -Camera camera = Camera(camera_speed); +Camera camera = Camera(camera_speed, glm::vec3(0.0f, 0.0f, 115.0f)); // Lighting glm::vec3 lightPos(1.2f, 1.0f, 2.0f); -glm::vec3 lightColor(0.557, 0.482, 0.6); +glm::vec3 lightColor(1.0f, 1.0f, 0.949f); -glm::vec3 objectColor(0.671f, 0.671f, 0.671f); +glm::vec3 objectColor(0.0f, 1.0f, 0.0f); -glm::vec3 cubePositions[] = { - glm::vec3( 0.0f, 0.0f, 0.0f), - glm::vec3( 2.0f, 5.0f, -15.0f), - glm::vec3(-1.5f, -2.2f, -2.5f), - glm::vec3(-3.8f, -2.0f, -12.3f), - glm::vec3 (2.4f, -0.4f, -3.5f), - glm::vec3(-1.7f, 3.0f, -7.5f), - glm::vec3( 1.3f, -2.0f, -2.5f), - glm::vec3( 1.5f, 2.0f, -2.5f), - glm::vec3( 1.5f, 0.2f, -1.5f), - glm::vec3(-1.3f, 1.0f, -1.5f) +float planets[][2] = { + {140.0f, 1.0f} }; // Mouse Look @@ -135,6 +134,7 @@ int main() // ------ Setup Shader ------ Shader shader("shaders/shader.vert", "shaders/shader.frag"); + Shader sun_shader("shaders/sun.vert", "shaders/sun.frag"); // ------ World Objects ------ std::vector world_objects; @@ -185,6 +185,7 @@ int main() glEnable(GL_DEPTH_TEST); // Z-Buffer double start_time = glfwGetTime(); + double move_time = glfwGetTime(); // Setup mouse look glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); @@ -201,24 +202,36 @@ int main() processInput(window); // ------ SETUP Matrices ------ - shader.use(); + glm::mat4 view = camera.getView(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Z-Buffer - // Camera Rotate around origin - // const float radius = 10.0f; - // camera.position.x = sin(glfwGetTime()) * radius; - // camera.position.z = cos(glfwGetTime()) * radius; + // Orbitting sun thing? + float t = glfwGetTime() * 10.0f; + float radius = 15.0f; + glm::mat4 model = glm::mat4(1.0f); + model = glm::scale(model, glm::vec3(109)); // The sun should be BIG + glm::vec3 sun_pos = glm::vec3(0.0f, 0.0f, 0.0f); - glm::mat4 view = camera.getView(); + model = glm::translate(model, sun_pos); + sun_shader.use(); + sun_shader.setMat4("model", model); + sun_shader.setMat4("view", view); + sun_shader.setMat4("projection", projection); + sun_shader.setVec3("lightColor", lightColor); + glDrawElements(GL_TRIANGLES, cube.EBO_buffer.size(), GL_UNSIGNED_INT, nullptr); + + // Switch to normal shader + shader.use(); shader.setMat4("projection", projection); shader.setMat4("view", view); // Fragment shader things - shader.setVec3("lightPos", lightPos); + shader.setFloat("light_power", 40.0f); + shader.setVec3("lightPos", sun_pos); shader.setVec3("viewPos", camera.position); shader.setVec3("lightColor", lightColor); shader.setVec3("objectColor", objectColor); @@ -234,13 +247,20 @@ int main() // model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.5f, 0.0f)); // shader.setMat4("model", model); - for (unsigned int i = 0; i < 10; i++) + for (unsigned int i = 0; i < sizeof(planets) / sizeof(float[2]); i++) { // calculate the model matrix for each object and pass it to shader before drawing glm::mat4 model = glm::mat4(1.0f); - model = glm::translate(model, cubePositions[i]); - float angle = 20.0f * i; - model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f)); + + float radius = planets[i][0]; + model = glm::scale(model, glm::vec3(planets[i][1])); + + float x = sin(glm::radians(0.0f)) * radius; + float z = cos(glm::radians(0.0f)) * radius; + + model = glm::translate(model, glm::vec3(x, 0.0f, z)); + + shader.setMat4("model", model); // glDrawArrays(GL_TRIANGLES, 0, 36); @@ -272,6 +292,13 @@ int main() } } + float time_since_last_move = end_time - move_time; + if (time_since_last_move >= 0.017) + { + camera.move(time_since_last_move); + move_time = end_time; + } + // ------ FPS output ------ if (delta_time >= 1) { @@ -306,6 +333,8 @@ int main() // process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly void processInput(GLFWwindow *window) { + float current_time = glfwGetTime(); + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { // if (mouse_lock) { // glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL); @@ -320,32 +349,75 @@ void processInput(GLFWwindow *window) // ---- Movement ---- // Forward / Backward if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) - camera.position += camera.speed * camera.target; + { + camera.forward_velocity = camera.speed * glm::vec3(camera.target.x, 0.0f, camera.target.z); + W_pressed = true; + } + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) - camera.position -= camera.speed * camera.target; + { + camera.forward_velocity = -camera.speed * glm::vec3(camera.target.x, 0.0f, camera.target.z); + S_pressed = true; + } + + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_RELEASE && S_pressed) + { + camera.forward_velocity = glm::vec3(0.0f); + S_pressed = false; + } + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_RELEASE && W_pressed) + { + camera.forward_velocity = glm::vec3(0.0f); + W_pressed = false; + } + // Horizontal if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) - camera.position -= glm::normalize(glm::cross(camera.target, camera.worldUp)) * camera.speed; + { + camera.horizontal_velocity = -glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * camera.speed; + A_pressed = true; + } if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) - camera.position += glm::normalize(glm::cross(camera.target, camera.worldUp)) * camera.speed; + { + camera.horizontal_velocity = glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * camera.speed; + D_pressed = true; + } - // Vertical + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_RELEASE && A_pressed) + { + camera.horizontal_velocity = glm::vec3(0.0f); + A_pressed = false; + } + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_RELEASE && D_pressed) + { + camera.horizontal_velocity = glm::vec3(0.0f); + D_pressed = false; + } + + + // Jump if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) - camera.position -= glm::normalize(glm::cross(camera.target, glm::normalize(glm::cross(camera.target, camera.worldUp)))) * camera.speed * 0.5f; - if(glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) - camera.position += glm::normalize(glm::cross(camera.target, glm::normalize(glm::cross(camera.target, camera.worldUp)))) * camera.speed * 0.5f; + // camera.velocity -= glm::normalize(glm::cross(camera.target, glm::normalize(glm::cross(camera.target, camera.worldUp)))) * camera.speed * 0.5f; + { + if (current_time - last_jump > jump_cooldown && camera.position.y == 0) + { + camera.vertical_velocity.y += 10.0f; + last_jump = current_time; + } + } // Sprint if(glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) - camera.speed = camera_speed; + camera.speed = camera_speed * 7.5; if(glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_RELEASE) - camera.speed = camera_speed * 5; + camera.speed = camera_speed * 20; // World Flip if(glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS) { - float current_time = glfwGetTime(); if (current_time - last_flip > flip_cooldown && !flipping) { // flip_target = camera.worldUp; diff --git a/shaders/shader.frag b/shaders/shader.frag index 59ff15a..ff0a798 100644 --- a/shaders/shader.frag +++ b/shaders/shader.frag @@ -2,6 +2,7 @@ out vec4 FragColor; +uniform float light_power; uniform vec3 lightColor; uniform vec3 objectColor; uniform vec3 viewPos; @@ -10,8 +11,9 @@ in vec3 FragPos; in vec3 Normal; in vec3 LightPos; +// const float light_power = 12.0; const float ambientStrength = 0.2; -const float shininess = 32.0; +const float shininess = 64.0; const float screenGamma = 2.2; // Assume the monitor is calibrated to the sRGB color space void main() @@ -39,7 +41,7 @@ void main() specular = pow(specAngle, shininess); } - vec3 colorLinear = (ambient + diffuse + specular) * objectColor; + vec3 colorLinear = (ambient + (diffuse * light_power) + (specular * light_power)) * objectColor; // vec3 colorGammaCorrected = pow(colorLinear, vec3(1.0 / screenGamma)); diff --git a/shaders/sun.frag b/shaders/sun.frag new file mode 100644 index 0000000..2b17190 --- /dev/null +++ b/shaders/sun.frag @@ -0,0 +1,11 @@ +#version 330 core +out vec4 FragColor; + +uniform vec3 lightColor; + +void main() +{ + FragColor = vec4(lightColor, 1.0); +} + + diff --git a/shaders/sun.vert b/shaders/sun.vert new file mode 100644 index 0000000..0d2757f --- /dev/null +++ b/shaders/sun.vert @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0); +} + + +