0x01FE/voxel-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added a player class

Browse Source
This commit is contained in:
JISAUAY 2025-11-20 14:52:54 -06:00
parent de39d10776
commit 5920376262
2 changed files with 28 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
src/Camera.h
View File

@ -4,74 +4,32 @@
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "World.h"
const float CAMERA_HEIGHT = 1.8f;
const float GRAVITY = 18.6f; // Should be in m/s^2 but it doesn't really work out with 9.8 so we double it
#include "Player.h"
class Camera
{
public:
glm::vec3 position;
Player* player;
glm::vec3 target;
glm::vec3 direction;
glm::vec3 up;
// Movement
glm::vec3 horizontal_velocity;
glm::vec3 forward_velocity;
glm::vec3 vertical_velocity;
bool grounded;
float speed;
glm::vec3 worldUp;
Camera(float speed, glm::vec3 pos)
Camera(Player* player)
{
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->player = player;
this->target = glm::vec3(0.0f, 0.0f, -1.0f);
this->direction = glm::normalize(this->position);
this->direction = glm::normalize(this->player->position);
this->worldUp = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 right = glm::normalize(glm::cross(up, this->direction));
this->up = glm::cross(this->direction, right);
this->grounded = false;
}
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;
this->direction = glm::normalize(this->position - this->target);
this->worldUp = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 right = glm::normalize(glm::cross(up, this->direction));
this->up = glm::cross(this->direction, right);
this->grounded = false;
}
glm::mat4 getView()
{
glm::vec3 real_camera_pos = this->position;
real_camera_pos.y += CAMERA_HEIGHT;
glm::vec3 real_camera_pos = this->player->getEyePosition();
glm::mat4 v = glm::lookAt(real_camera_pos,
real_camera_pos + this->target,
@ -80,78 +38,8 @@ class Camera
return v;
}
void move(World* world, float time) // time passed in seconds since last move
{
// bool in_air = this->position.y > 1;
// if (this->position.y > 1)
// this->vertical_velocity.y -= (GRAVITY * time); // no way! physics reference?
glm::vec3 velocity = this->forward_velocity + this->horizontal_velocity + this->vertical_velocity;
glm::vec3 position_delta = (velocity * time);
// glm::vec3 new_position = this->position + position_delta;
// AABB Algorithm
glm::vec3 aabb_dims = glm::vec3(0.8f, 1.8f, 0.8f);
glm::vec3 aabb_half_dims = aabb_dims / 2.0f;
glm::vec3 aabb_center_offset = glm::vec3(0.0f, aabb_dims.y / 2.0f, 0.0f);
bool y_axis_collided = false;
for (int axis = 0; axis < 3; axis++) {
glm::vec3 target_position = this->position;
target_position[axis] += position_delta[axis];
glm::vec3 aabb_center = target_position + aabb_center_offset;
glm::vec3 adjusted_center = aabb_center + glm::vec3(0.5f, 0.5f, 0.5f);
glm::vec3 min = glm::floor(adjusted_center - aabb_half_dims);
glm::vec3 max = glm::ceil(adjusted_center + aabb_half_dims);
bool collided = false;
for (int x = min.x; x < max.x && !collided; x++) {
for (int y = min.y; y < max.y && !collided; y++) {
for (int z = min.z; z < max.z && !collided; z++) {
glm::ivec3 calculated_position = glm::ivec3(x, y, z);
if (world->get_voxel(calculated_position) != VoxelKind::Air) {
collided = true;
// std::cout << "Collided!!" << std::endl;
}
}
}
}
if (!collided) {
this->position[axis] = target_position[axis];
} else if (axis == 1) {
y_axis_collided = true;
grounded = true;
this->vertical_velocity.y = 0.0f;
}
}
if (!y_axis_collided) {
this->vertical_velocity.y -= GRAVITY * time;
grounded = false;
}
// this->position += movement;
// Don't want to clip into the ground right
// if (this->position.y <= 1 && in_air)
// {
// this->position.y = 0.0f;
// this->vertical_velocity.y = 0.0f;
// }
}
glm::vec3 getEyePosition() const {
return position + glm::vec3(0.0f, CAMERA_HEIGHT, 0.0f);
return player->getEyePosition();
}
};

40
src/main.cpp
View File

@ -5,6 +5,7 @@
#include <glm/glm.hpp>
#include "Shader.h"
#include "Player.h"
#include "Camera.h"
#include "Object3D.h"
#include "World.h"
@ -37,7 +38,8 @@ const int VIEW_DISTANCE = 4; // In Chunks
bool W_pressed, S_pressed, A_pressed, D_pressed = false;
glm::mat4 projection = glm::mat4(1.0f);
Camera camera = Camera(CAMERA_SPEED, glm::vec3(0.0f, 1.85f, 0.0f));
Player player = Player(CAMERA_SPEED, glm::vec3(0.0f, 1.85f, 0.0f));
Camera camera = Camera(&player);
// Targeted block for highlighting
std::optional<glm::ivec3> targeted_block = std::nullopt;
@ -143,25 +145,25 @@ void processInput(GLFWwindow *window)
// Forward / Backward
if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
{
camera.forward_velocity = camera.speed * glm::vec3(camera.target.x, 0.0f, camera.target.z);
player.forward_velocity = player.speed * glm::vec3(camera.target.x, 0.0f, camera.target.z);
W_pressed = true;
}
if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
{
camera.forward_velocity = -camera.speed * glm::vec3(camera.target.x, 0.0f, camera.target.z);
player.forward_velocity = -player.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);
player.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);
player.forward_velocity = glm::vec3(0.0f);
W_pressed = false;
}
@ -169,44 +171,44 @@ void processInput(GLFWwindow *window)
// Horizontal
if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
{
camera.horizontal_velocity = -glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * camera.speed;
player.horizontal_velocity = -glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * player.speed;
A_pressed = true;
}
if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
{
camera.horizontal_velocity = glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * camera.speed;
player.horizontal_velocity = glm::normalize(glm::cross(glm::vec3(camera.target.x, 0.0f, camera.target.z), camera.worldUp)) * player.speed;
D_pressed = true;
}
if(glfwGetKey(window, GLFW_KEY_A) == GLFW_RELEASE && A_pressed)
{
camera.horizontal_velocity = glm::vec3(0.0f);
player.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);
player.horizontal_velocity = glm::vec3(0.0f);
D_pressed = false;
}
// Jump
if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
// camera.velocity -= glm::normalize(glm::cross(camera.target, glm::normalize(glm::cross(camera.target, camera.worldUp)))) * camera.speed * 0.5f;
// player.velocity -= glm::normalize(glm::cross(camera.target, glm::normalize(glm::cross(camera.target, camera.worldUp)))) * player.speed * 0.5f;
{
if (current_time - last_jump > JUMP_COOLDOWN && camera.grounded)
if (current_time - last_jump > JUMP_COOLDOWN && player.grounded)
{
camera.vertical_velocity.y = JUMP_POWER;
player.vertical_velocity.y = JUMP_POWER;
last_jump = current_time;
}
}
// Sprint
if(glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
camera.speed = CAMERA_SPEED * 7.5;
player.speed = CAMERA_SPEED * 7.5;
if(glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_RELEASE)
camera.speed = CAMERA_SPEED * 20;
player.speed = CAMERA_SPEED * 20;
static bool left_mouse_pressed = false;
static bool right_mouse_pressed = false;
@ -421,11 +423,11 @@ int main() {
shader.use();
// Generate chunks around the camera
// Generate chunks around the player
glm::ivec3 camera_chunk = glm::ivec3(
std::floor(camera.position.x / CHUNK_SIZE),
std::floor(camera.position.y / CHUNK_SIZE),
std::floor(camera.position.z / CHUNK_SIZE)
std::floor(player.position.x / CHUNK_SIZE),
std::floor(player.position.y / CHUNK_SIZE),
std::floor(player.position.z / CHUNK_SIZE)
);
// ---- PASS 1: Draw solid grey cubes ----
@ -517,7 +519,7 @@ int main() {
float time_since_last_move = end_time - move_time;
if (time_since_last_move >= 0.017)
{
camera.move(&world, time_since_last_move);
player.move(&world, time_since_last_move);
move_time = end_time;
}