mirror of
https://github.com/zhenyan121/Cubed.git
synced 2026-04-09 21:54:09 +08:00
style: unify naming conventions across the project
This commit is contained in:
21
.clang-tidy
Normal file
21
.clang-tidy
Normal file
@@ -0,0 +1,21 @@
|
||||
Checks: '-*,readability-identifier-naming'
|
||||
CheckOptions:
|
||||
|
||||
- { key: readability-identifier-naming.ClassCase, value: CamelCase }
|
||||
- { key: readability-identifier-naming.StructCase, value: CamelCase }
|
||||
|
||||
- { key: readability-identifier-naming.FunctionCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.MemberFunctionCase, value: lower_case }
|
||||
|
||||
- { key: readability-identifier-naming.VariableCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.GlobalVariableCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.LocalVariableCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.StaticVariableCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.ParameterCase, value: lower_case }
|
||||
|
||||
- { key: readability-identifier-naming.ConstantCase, value: UPPER_CASE }
|
||||
- { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE }
|
||||
- { key: readability-identifier-naming.MemberConstantCase, value: UPPER_CASE }
|
||||
- { key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE }
|
||||
|
||||
- { key: readability-identifier-naming.MemberCase, value: lower_case }
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@@ -21,6 +21,7 @@ Release/
|
||||
x64/
|
||||
x86/
|
||||
out/
|
||||
.cache/
|
||||
.vs/
|
||||
.vscode/
|
||||
.idea/
|
||||
|
||||
@@ -4,6 +4,7 @@ project(Cubed LANGUAGES C CXX)
|
||||
set(CMAKE_CXX_STANDARD 20)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
|
||||
|
||||
if(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE Debug)
|
||||
|
||||
@@ -12,23 +12,23 @@ class Player;
|
||||
class Camera {
|
||||
private:
|
||||
|
||||
bool m_firseMouse = true;
|
||||
bool m_firse_mouse = true;
|
||||
Player* m_player;
|
||||
float m_lastMouseX, m_lastMouseY;
|
||||
glm::vec3 m_cameraPos;
|
||||
float m_last_mouse_x, m_last_mouse_y;
|
||||
glm::vec3 m_camera_pos;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
Camera();
|
||||
|
||||
void updateMoveCamera();
|
||||
void update_move_camera();
|
||||
|
||||
void cameraInit(Player* player);
|
||||
void camera_init(Player* player);
|
||||
|
||||
void updateCursorPositionCamera(double xpos, double ypos);
|
||||
void update_cursor_position_camera(double xpos, double ypos);
|
||||
|
||||
const glm::mat4 getCameraLookAt() const;
|
||||
const glm::mat4 get_camera_lookat() const;
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ struct MoveState {
|
||||
class Player {
|
||||
private:
|
||||
|
||||
bool** m_blockPresent;
|
||||
bool** m_block_present;
|
||||
|
||||
float m_yaw;
|
||||
float m_pitch;
|
||||
@@ -24,23 +24,23 @@ private:
|
||||
|
||||
float m_speed = 0.1f;
|
||||
// player is tow block tall, the pos is the lower pos
|
||||
glm::vec3 m_playerPos = glm::vec3(0.0f, 5.0f, 0.0f);
|
||||
glm::vec3 m_player_pos = glm::vec3(0.0f, 5.0f, 0.0f);
|
||||
glm::vec3 m_front = glm::vec3(0, 0, -1);
|
||||
glm::vec3 m_right;
|
||||
MoveState m_moveState;
|
||||
MoveState m_move_state;
|
||||
|
||||
public:
|
||||
Player();
|
||||
|
||||
const glm::vec3& getFront() const;
|
||||
const glm::vec3& getPlayerPos() const;
|
||||
const MoveState& getMoveState() const;
|
||||
const glm::vec3& get_front() const;
|
||||
const glm::vec3& get_player_pos() const;
|
||||
const MoveState& get_move_state() const;
|
||||
|
||||
void init(bool** blockPresent);
|
||||
void setPlayerPos(const glm::vec3& pos);
|
||||
void update(float deltaTime);
|
||||
void updateFrontVec(float offsetX, float offsetY);
|
||||
void updatePlayerMoveState(int key, int action);
|
||||
void init(bool** block_present);
|
||||
void set_player_pos(const glm::vec3& pos);
|
||||
void update(float delta_time);
|
||||
void update_front_vec(float offset_x, float offset_y);
|
||||
void update_player_move_state(int key, int action);
|
||||
|
||||
|
||||
};
|
||||
@@ -1,14 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <SOIL2.h>
|
||||
#include <string>
|
||||
|
||||
void printShaderLog(GLuint shader);
|
||||
void printProgramInfo(int prog);
|
||||
bool checkOpenGLError();
|
||||
std::string readShaderSource(const char* filePath);
|
||||
GLuint loadTexture(const char* texImagePath);
|
||||
|
||||
void print_shader_log(GLuint shader);
|
||||
void print_program_info(int prog);
|
||||
bool check_opengl_error();
|
||||
std::string read_shader_source(const char* file_path);
|
||||
GLuint load_texture(const char* tex_image_path);
|
||||
@@ -1,5 +1,3 @@
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <Cubed/camera.hpp>
|
||||
#include <Cubed/gameplay/player.hpp>
|
||||
#include <Cubed/tools/cubed_assert.hpp>
|
||||
@@ -8,35 +6,35 @@ Camera::Camera() {
|
||||
|
||||
}
|
||||
|
||||
void Camera::updateMoveCamera() {
|
||||
void Camera::update_move_camera() {
|
||||
CUBED_ASSERT_MSG(m_player, "nullptr");
|
||||
auto pos = m_player->getPlayerPos();
|
||||
m_cameraPos = glm::vec3(pos.x, pos.y + 1, pos.z);
|
||||
auto pos = m_player->get_player_pos();
|
||||
m_camera_pos = glm::vec3(pos.x, pos.y + 1, pos.z);
|
||||
}
|
||||
|
||||
|
||||
void Camera::cameraInit(Player* _player) {
|
||||
m_cameraPos = glm::vec3(0.0f, 2.0f, 0.0f);
|
||||
m_player = _player;
|
||||
void Camera::camera_init(Player* player) {
|
||||
m_camera_pos = glm::vec3(0.0f, 2.0f, 0.0f);
|
||||
m_player = player;
|
||||
}
|
||||
|
||||
void Camera::updateCursorPositionCamera(double xpos, double ypos) {
|
||||
if (m_firseMouse) {
|
||||
m_lastMouseX = xpos;
|
||||
m_lastMouseY = ypos;
|
||||
m_firseMouse = false;
|
||||
void Camera::update_cursor_position_camera(double xpos, double ypos) {
|
||||
if (m_firse_mouse) {
|
||||
m_last_mouse_x = xpos;
|
||||
m_last_mouse_y = ypos;
|
||||
m_firse_mouse = false;
|
||||
}
|
||||
|
||||
float offsetX = xpos - m_lastMouseX;
|
||||
float offsetY = m_lastMouseY - ypos;
|
||||
float offset_x = xpos - m_last_mouse_x;
|
||||
float offset_y = m_last_mouse_y - ypos;
|
||||
|
||||
m_lastMouseX = xpos;
|
||||
m_lastMouseY = ypos;
|
||||
m_last_mouse_x = xpos;
|
||||
m_last_mouse_y = ypos;
|
||||
CUBED_ASSERT_MSG(m_player, "nullptr");
|
||||
m_player->updateFrontVec(offsetX, offsetY);
|
||||
m_player->update_front_vec(offset_x, offset_y);
|
||||
}
|
||||
|
||||
const glm::mat4 Camera::getCameraLookAt() const{
|
||||
const glm::mat4 Camera::get_camera_lookat() const{
|
||||
CUBED_ASSERT_MSG(m_player, "nullptr");
|
||||
return glm::lookAt(m_cameraPos, m_cameraPos + m_player->getFront(), glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
return glm::lookAt(m_camera_pos, m_camera_pos + m_player->get_front(), glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
}
|
||||
|
||||
@@ -1,111 +1,112 @@
|
||||
#include <Cubed/gameplay/player.hpp>
|
||||
#include <GLFW/glfw3.h>
|
||||
|
||||
static constexpr int UPDATE_TIME = 0.1f;
|
||||
static float currentTime = 0.0f;
|
||||
#include <Cubed/gameplay/player.hpp>
|
||||
|
||||
static constexpr float UPDATE_TIME = 0.005f;
|
||||
static float current_time = 0.0f;
|
||||
|
||||
|
||||
Player::Player() {
|
||||
|
||||
}
|
||||
|
||||
const glm::vec3& Player::getFront() const {
|
||||
const glm::vec3& Player::get_front() const {
|
||||
return m_front;
|
||||
}
|
||||
|
||||
const glm::vec3& Player::getPlayerPos() const {
|
||||
return m_playerPos;
|
||||
const glm::vec3& Player::get_player_pos() const {
|
||||
return m_player_pos;
|
||||
}
|
||||
|
||||
const MoveState& Player::getMoveState() const {
|
||||
return m_moveState;
|
||||
const MoveState& Player::get_move_state() const {
|
||||
return m_move_state;
|
||||
}
|
||||
|
||||
void Player::init(bool** blockPresent) {
|
||||
m_blockPresent = blockPresent;
|
||||
void Player::init(bool** block_present) {
|
||||
m_block_present = block_present;
|
||||
}
|
||||
|
||||
void Player::setPlayerPos(const glm::vec3& pos) {
|
||||
m_playerPos = pos;
|
||||
void Player::set_player_pos(const glm::vec3& pos) {
|
||||
m_player_pos = pos;
|
||||
}
|
||||
|
||||
void Player::update(float deltaTime) {
|
||||
void Player::update(float delta_time) {
|
||||
|
||||
currentTime += deltaTime;
|
||||
if (currentTime < UPDATE_TIME) {
|
||||
current_time += delta_time;
|
||||
if (current_time < UPDATE_TIME) {
|
||||
return;
|
||||
}
|
||||
currentTime = 0.0f;
|
||||
current_time = 0.0f;
|
||||
m_right = glm::normalize(glm::cross(m_front, glm::vec3(0.0f, 1.0f, 0.0f)));
|
||||
if (m_moveState.forward) {
|
||||
m_playerPos += glm::vec3(m_front.x, 0.0f, m_front.z) * m_speed;
|
||||
if (m_move_state.forward) {
|
||||
m_player_pos += glm::vec3(m_front.x, 0.0f, m_front.z) * m_speed;
|
||||
}
|
||||
if (m_moveState.back) {
|
||||
m_playerPos -= glm::vec3(m_front.x, 0.0f, m_front.z) * m_speed;
|
||||
if (m_move_state.back) {
|
||||
m_player_pos -= glm::vec3(m_front.x, 0.0f, m_front.z) * m_speed;
|
||||
}
|
||||
if (m_moveState.left) {
|
||||
m_playerPos -= glm::vec3(m_right.x, 0.0f, m_right.z) * m_speed;
|
||||
if (m_move_state.left) {
|
||||
m_player_pos -= glm::vec3(m_right.x, 0.0f, m_right.z) * m_speed;
|
||||
}
|
||||
if (m_moveState.right) {
|
||||
m_playerPos += glm::vec3(m_right.x, 0.0f, m_right.z) * m_speed;
|
||||
if (m_move_state.right) {
|
||||
m_player_pos += glm::vec3(m_right.x, 0.0f, m_right.z) * m_speed;
|
||||
}
|
||||
if (m_moveState.up) {
|
||||
m_playerPos += glm::vec3(0.0f, 1.0f, 0.0f) * m_speed;
|
||||
if (m_move_state.up) {
|
||||
m_player_pos += glm::vec3(0.0f, 1.0f, 0.0f) * m_speed;
|
||||
}
|
||||
if (m_moveState.down) {
|
||||
m_playerPos -= glm::vec3(0.0f, 1.0f, 0.0f) * m_speed;
|
||||
if (m_move_state.down) {
|
||||
m_player_pos -= glm::vec3(0.0f, 1.0f, 0.0f) * m_speed;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void Player::updatePlayerMoveState(int key, int action) {
|
||||
void Player::update_player_move_state(int key, int action) {
|
||||
switch(key) {
|
||||
case GLFW_KEY_W:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.forward = true;
|
||||
m_move_state.forward = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.forward = false;
|
||||
m_move_state.forward = false;
|
||||
}
|
||||
break;
|
||||
case GLFW_KEY_S:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.back = true;
|
||||
m_move_state.back = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.back = false;
|
||||
m_move_state.back = false;
|
||||
}
|
||||
break;
|
||||
case GLFW_KEY_A:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.left = true;
|
||||
m_move_state.left = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.left = false;
|
||||
m_move_state.left = false;
|
||||
}
|
||||
break;
|
||||
case GLFW_KEY_D:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.right = true;
|
||||
m_move_state.right = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.right = false;
|
||||
m_move_state.right = false;
|
||||
}
|
||||
break;
|
||||
case GLFW_KEY_SPACE:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.up = true;
|
||||
m_move_state.up = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.up = false;
|
||||
m_move_state.up = false;
|
||||
}
|
||||
break;
|
||||
case GLFW_KEY_LEFT_SHIFT:
|
||||
if (action == GLFW_PRESS) {
|
||||
m_moveState.down = true;
|
||||
m_move_state.down = true;
|
||||
}
|
||||
if (action == GLFW_RELEASE) {
|
||||
m_moveState.down = false;
|
||||
m_move_state.down = false;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -113,9 +114,9 @@ void Player::updatePlayerMoveState(int key, int action) {
|
||||
}
|
||||
}
|
||||
|
||||
void Player::updateFrontVec(float offsetX, float offsetY) {
|
||||
m_yaw += offsetX * m_sensitivity;
|
||||
m_pitch += offsetY * m_sensitivity;
|
||||
void Player::update_front_vec(float offset_x, float offset_y) {
|
||||
m_yaw += offset_x * m_sensitivity;
|
||||
m_pitch += offset_y * m_sensitivity;
|
||||
|
||||
|
||||
if (m_pitch > 89.0f) m_pitch = 89.0f;
|
||||
|
||||
160
src/main.cpp
160
src/main.cpp
@@ -1,6 +1,3 @@
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <stack>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
@@ -18,26 +15,25 @@
|
||||
#include <Cubed/tools/log.hpp>
|
||||
#include <Cubed/tools/shader_tools.hpp>
|
||||
|
||||
constexpr int numVAOs = 1;
|
||||
constexpr int numVBOs = 3;
|
||||
bool blockPresent[WORLD_SIZE_X][WORLD_SIZE_Z] = {false};
|
||||
GLuint renderingProgram;
|
||||
GLuint vao[numVAOs];
|
||||
GLuint vbo[numVBOs];
|
||||
GLuint mvLoc, projLoc;
|
||||
constexpr int NUM_VAO = 1;
|
||||
constexpr int NUM_VBO = 3;
|
||||
bool block_present[WORLD_SIZE_X][WORLD_SIZE_Z] = {false};
|
||||
GLuint rendering_program;
|
||||
GLuint vao[NUM_VAO];
|
||||
GLuint vbo[NUM_VBO];
|
||||
GLuint mv_loc, proj_loc;
|
||||
int width ,height;
|
||||
float aspect;
|
||||
glm::mat4 pMat, vMat, mMat, mvMat;
|
||||
glm::mat4 p_mat, v_mat, m_mat, mv_mat;
|
||||
float inc = 0.01f;
|
||||
float tf = 0.0f;
|
||||
double lastTime = 0.0f;
|
||||
double deltaTime = 0.0f;
|
||||
glm::mat4 tMat, rMat;
|
||||
double last_time = 0.0f;
|
||||
double delta_time = 0.0f;
|
||||
std::vector<GLuint> grass_block_texture(6);
|
||||
Player player;
|
||||
Camera camera;
|
||||
void setupVertices(void) {
|
||||
float verticesPos[108] = {
|
||||
void setup_vertices(void) {
|
||||
float vertices_pos[108] = {
|
||||
// ===== front (z = +1) =====
|
||||
-0.5f, -0.5f, 0.5f, // bottom left
|
||||
-0.5f, 0.5f, 0.5f, // top left
|
||||
@@ -93,12 +89,12 @@ void setupVertices(void) {
|
||||
};
|
||||
|
||||
|
||||
glGenVertexArrays(numVAOs, vao);
|
||||
glGenVertexArrays(NUM_VAO, vao);
|
||||
glBindVertexArray(vao[0]);
|
||||
glGenBuffers(numVBOs, vbo);
|
||||
glGenBuffers(NUM_VBO, vbo);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesPos), verticesPos, GL_STATIC_DRAW);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_pos), vertices_pos, GL_STATIC_DRAW);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_STATIC_DRAW);
|
||||
@@ -111,67 +107,67 @@ void setupVertices(void) {
|
||||
|
||||
|
||||
|
||||
GLuint createShaderProgram() {
|
||||
std::string vShaderStr = readShaderSource("shaders/vShader.glsl");
|
||||
std::string fShaderStr = readShaderSource("shaders/fShader.glsl");
|
||||
const char *vshaderSource = vShaderStr.c_str();
|
||||
const char *fshaderSource = fShaderStr.c_str();
|
||||
GLuint create_shader_program() {
|
||||
std::string v_shader_str = read_shader_source("shaders/vShader.glsl");
|
||||
std::string f_shader_str = read_shader_source("shaders/fShader.glsl");
|
||||
const char *v_shader_source = v_shader_str.c_str();
|
||||
const char *f_shader_source = f_shader_str.c_str();
|
||||
|
||||
GLuint vShader = glCreateShader(GL_VERTEX_SHADER);
|
||||
GLuint fShader = glCreateShader(GL_FRAGMENT_SHADER);
|
||||
GLuint v_shader = glCreateShader(GL_VERTEX_SHADER);
|
||||
GLuint f_shader = glCreateShader(GL_FRAGMENT_SHADER);
|
||||
|
||||
GLint vc, fc;
|
||||
glShaderSource(vShader, 1, &vshaderSource, NULL);
|
||||
glShaderSource(fShader, 1, &fshaderSource, NULL);
|
||||
glCompileShader(vShader);
|
||||
checkOpenGLError();
|
||||
glGetShaderiv(vShader, GL_COMPILE_STATUS, &vc);
|
||||
glShaderSource(v_shader, 1, &v_shader_source, NULL);
|
||||
glShaderSource(f_shader, 1, &f_shader_source, NULL);
|
||||
glCompileShader(v_shader);
|
||||
check_opengl_error();
|
||||
glGetShaderiv(v_shader, GL_COMPILE_STATUS, &vc);
|
||||
if (vc != 1) {
|
||||
LOG::error("vertex compilation failed");
|
||||
printShaderLog(vShader);
|
||||
print_shader_log(v_shader);
|
||||
}
|
||||
glCompileShader(fShader);
|
||||
checkOpenGLError();
|
||||
glGetShaderiv(fShader, GL_COMPILE_STATUS, &fc);
|
||||
glCompileShader(f_shader);
|
||||
check_opengl_error();
|
||||
glGetShaderiv(f_shader, GL_COMPILE_STATUS, &fc);
|
||||
if (fc != 1) {
|
||||
LOG::error("vertex compilation failed");
|
||||
printShaderLog(fShader);
|
||||
print_shader_log(f_shader);
|
||||
}
|
||||
GLuint vfProgram = glCreateProgram();
|
||||
glAttachShader(vfProgram, vShader);
|
||||
glAttachShader(vfProgram, fShader);
|
||||
glLinkProgram(vfProgram);
|
||||
GLuint vf_program = glCreateProgram();
|
||||
glAttachShader(vf_program, v_shader);
|
||||
glAttachShader(vf_program, f_shader);
|
||||
glLinkProgram(vf_program);
|
||||
|
||||
GLint linked;
|
||||
checkOpenGLError();
|
||||
glGetProgramiv(vfProgram, GL_LINK_STATUS, &linked);
|
||||
check_opengl_error();
|
||||
glGetProgramiv(vf_program, GL_LINK_STATUS, &linked);
|
||||
if (linked != 1) {
|
||||
LOG::error("linking failed");
|
||||
printProgramInfo(vfProgram);
|
||||
print_program_info(vf_program);
|
||||
}
|
||||
|
||||
return vfProgram;
|
||||
return vf_program;
|
||||
}
|
||||
|
||||
|
||||
void init(GLFWwindow* window) {
|
||||
renderingProgram = createShaderProgram();
|
||||
rendering_program = create_shader_program();
|
||||
|
||||
mvLoc = glGetUniformLocation(renderingProgram, "mv_matrix");
|
||||
projLoc = glGetUniformLocation(renderingProgram, "proj_matrix");
|
||||
mv_loc = glGetUniformLocation(rendering_program, "mv_matrix");
|
||||
proj_loc = glGetUniformLocation(rendering_program, "proj_matrix");
|
||||
|
||||
camera.cameraInit(&player);
|
||||
camera.camera_init(&player);
|
||||
glfwGetFramebufferSize(window, &width, &height);
|
||||
aspect = (float)width / (float)height;
|
||||
glViewport(0, 0, width, height);
|
||||
pMat = glm::perspective(glm::radians(60.0f), aspect, 0.1f, 1000.0f);
|
||||
p_mat = glm::perspective(glm::radians(60.0f), aspect, 0.1f, 1000.0f);
|
||||
|
||||
grass_block_texture[0] = loadTexture("assets/texture/block/grass_block/front.png");
|
||||
grass_block_texture[1] = loadTexture("assets/texture/block/grass_block/right.png");
|
||||
grass_block_texture[2] = loadTexture("assets/texture/block/grass_block/back.png");
|
||||
grass_block_texture[3] = loadTexture("assets/texture/block/grass_block/left.png");
|
||||
grass_block_texture[4] = loadTexture("assets/texture/block/grass_block/top.png");
|
||||
grass_block_texture[5] = loadTexture("assets/texture/block/grass_block/base.png");
|
||||
grass_block_texture[0] = load_texture("assets/texture/block/grass_block/front.png");
|
||||
grass_block_texture[1] = load_texture("assets/texture/block/grass_block/right.png");
|
||||
grass_block_texture[2] = load_texture("assets/texture/block/grass_block/back.png");
|
||||
grass_block_texture[3] = load_texture("assets/texture/block/grass_block/left.png");
|
||||
grass_block_texture[4] = load_texture("assets/texture/block/grass_block/top.png");
|
||||
grass_block_texture[5] = load_texture("assets/texture/block/grass_block/base.png");
|
||||
|
||||
for (int i = 0; i < 6; i++) {
|
||||
glBindTexture(GL_TEXTURE_2D, grass_block_texture[i]);
|
||||
@@ -183,35 +179,35 @@ void init(GLFWwindow* window) {
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDepthFunc(GL_LEQUAL);
|
||||
|
||||
setupVertices();
|
||||
setup_vertices();
|
||||
|
||||
}
|
||||
|
||||
void window_reshape_callback(GLFWwindow* window, int newWidth, int newHeight) {
|
||||
void window_reshape_callback(GLFWwindow* window, int new_width, int new_height) {
|
||||
glfwGetFramebufferSize(window, &width, &height);
|
||||
aspect = (float)width / (float)height;
|
||||
glViewport(0, 0, width, height);
|
||||
pMat = glm::perspective(glm::radians(60.0f), aspect, 0.1f, 1000.0f);
|
||||
p_mat = glm::perspective(glm::radians(60.0f), aspect, 0.1f, 1000.0f);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
|
||||
camera.updateCursorPositionCamera(xpos, ypos);
|
||||
camera.update_cursor_position_camera(xpos, ypos);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void display(GLFWwindow* window, double currentTime) {
|
||||
deltaTime = currentTime - lastTime;
|
||||
lastTime = currentTime;
|
||||
player.update(deltaTime);
|
||||
camera.updateMoveCamera();
|
||||
void display(GLFWwindow* window, double current_time) {
|
||||
delta_time = current_time - last_time;
|
||||
last_time = current_time;
|
||||
player.update(delta_time);
|
||||
camera.update_move_camera();
|
||||
|
||||
for (int i = 0; i < WORLD_SIZE_X; i++) {
|
||||
for (int j = 0; j < WORLD_SIZE_Z; j++) {
|
||||
blockPresent[i][j] = true;
|
||||
block_present[i][j] = true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -219,7 +215,7 @@ void display(GLFWwindow* window, double currentTime) {
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
glClear(GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
glUseProgram(renderingProgram);
|
||||
glUseProgram(rendering_program);
|
||||
glBindVertexArray(vao[0]);
|
||||
|
||||
|
||||
@@ -238,30 +234,30 @@ void display(GLFWwindow* window, double currentTime) {
|
||||
int wx = x - WORLD_SIZE_X / 2;
|
||||
int wz = z - WORLD_SIZE_Z / 2;
|
||||
|
||||
mMat = glm::translate(glm::mat4(1.0f), glm::vec3((float)wx, 0.0f, (float)wz));
|
||||
vMat = camera.getCameraLookAt();
|
||||
mvMat = vMat * mMat;
|
||||
glUniformMatrix4fv(mvLoc, 1, GL_FALSE, glm::value_ptr(mvMat));
|
||||
glUniformMatrix4fv(projLoc, 1 ,GL_FALSE, glm::value_ptr(pMat));
|
||||
m_mat = glm::translate(glm::mat4(1.0f), glm::vec3((float)wx, 0.0f, (float)wz));
|
||||
v_mat = camera.get_camera_lookat();
|
||||
mv_mat = v_mat * m_mat;
|
||||
glUniformMatrix4fv(mv_loc, 1, GL_FALSE, glm::value_ptr(mv_mat));
|
||||
glUniformMatrix4fv(proj_loc, 1 ,GL_FALSE, glm::value_ptr(p_mat));
|
||||
|
||||
bool drawFace[6] = {true, true, true, true, true, true};
|
||||
bool draw_face[6] = {true, true, true, true, true, true};
|
||||
|
||||
if (z < WORLD_SIZE_Z - 1&& blockPresent[x][z + 1]) {
|
||||
drawFace[0] = false;
|
||||
if (z < WORLD_SIZE_Z - 1&& block_present[x][z + 1]) {
|
||||
draw_face[0] = false;
|
||||
}
|
||||
if (x < WORLD_SIZE_X - 1 && blockPresent[x + 1][z]) {
|
||||
drawFace[1] = false;
|
||||
if (x < WORLD_SIZE_X - 1 && block_present[x + 1][z]) {
|
||||
draw_face[1] = false;
|
||||
}
|
||||
if (z > 0 && blockPresent[x][z - 1]) {
|
||||
drawFace[2] = false;
|
||||
if (z > 0 && block_present[x][z - 1]) {
|
||||
draw_face[2] = false;
|
||||
}
|
||||
if (x > 0 && blockPresent[x - 1][z]) {
|
||||
drawFace[3] = false;
|
||||
if (x > 0 && block_present[x - 1][z]) {
|
||||
draw_face[3] = false;
|
||||
}
|
||||
|
||||
|
||||
for (int face = 0; face < 6; face++) {
|
||||
if (!drawFace[face]) {
|
||||
if (!draw_face[face]) {
|
||||
continue;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, grass_block_texture[face]);
|
||||
@@ -292,7 +288,7 @@ void key_callback(GLFWwindow* window, int key, int scancode, int action, int mod
|
||||
|
||||
}
|
||||
|
||||
player.updatePlayerMoveState(key, action);
|
||||
player.update_player_move_state(key, action);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,16 +1,18 @@
|
||||
#include <fstream>
|
||||
|
||||
#include <Cubed/tools/shader_tools.hpp>
|
||||
#include <Cubed/tools/log.hpp>
|
||||
|
||||
|
||||
|
||||
void printShaderLog(GLuint shader) {
|
||||
void print_shader_log(GLuint shader) {
|
||||
int len = 0;
|
||||
int chWritten = 0;
|
||||
int ch_written = 0;
|
||||
char *log;
|
||||
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
|
||||
if (len > 0) {
|
||||
log = (char*)malloc(len);
|
||||
glGetShaderInfoLog(shader, len, &chWritten, log);
|
||||
glGetShaderInfoLog(shader, len, &ch_written, log);
|
||||
LOG::info("Shader Info Log: {}", log);
|
||||
free(log);
|
||||
}
|
||||
@@ -18,55 +20,55 @@ void printShaderLog(GLuint shader) {
|
||||
}
|
||||
|
||||
|
||||
void printProgramInfo(int prog) {
|
||||
void print_program_info(int prog) {
|
||||
int len = 0;
|
||||
int chWritten = 0;
|
||||
int ch_written = 0;
|
||||
char *log;
|
||||
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &len);
|
||||
if (len > 0) {
|
||||
log = (char*)malloc(len);
|
||||
glGetProgramInfoLog(prog, len, &chWritten, log);
|
||||
glGetProgramInfoLog(prog, len, &ch_written, log);
|
||||
LOG::info("Program Info Log: {}", log);
|
||||
free(log);
|
||||
}
|
||||
}
|
||||
|
||||
bool checkOpenGLError() {
|
||||
bool foundError = false;
|
||||
int glErr = glGetError();
|
||||
while (glErr != GL_NO_ERROR) {
|
||||
LOG::error("glEorr: {}", glErr);
|
||||
foundError = true;
|
||||
glErr = glGetError();
|
||||
bool check_opengl_error() {
|
||||
bool found_error = false;
|
||||
int gl_err = glGetError();
|
||||
while (gl_err != GL_NO_ERROR) {
|
||||
LOG::error("glEorr: {}", gl_err);
|
||||
found_error = true;
|
||||
gl_err = glGetError();
|
||||
}
|
||||
|
||||
return foundError;
|
||||
return found_error;
|
||||
}
|
||||
|
||||
|
||||
std::string readShaderSource(const char* filePath) {
|
||||
std::string read_shader_source(const char* file_path) {
|
||||
std::string content;
|
||||
std::ifstream fileStream(filePath, std::ios::in);
|
||||
std::ifstream file_stream(file_path, std::ios::in);
|
||||
|
||||
if (!fileStream.is_open()) {
|
||||
if (!file_stream.is_open()) {
|
||||
LOG::error("file not exist");
|
||||
}
|
||||
|
||||
std::string line = "";
|
||||
while (!fileStream.eof()) {
|
||||
while (!file_stream.eof()) {
|
||||
|
||||
getline(fileStream, line);
|
||||
getline(file_stream, line);
|
||||
content.append(line + "\n");
|
||||
}
|
||||
fileStream.close();
|
||||
file_stream.close();
|
||||
return content;
|
||||
}
|
||||
|
||||
GLuint loadTexture(const char* texImagePath) {
|
||||
GLuint textureID;
|
||||
textureID = SOIL_load_OGL_texture(texImagePath, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_INVERT_Y);
|
||||
if (textureID == 0) {
|
||||
GLuint load_texture(const char* tex_image_path) {
|
||||
GLuint texture_id;
|
||||
texture_id = SOIL_load_OGL_texture(tex_image_path, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_INVERT_Y);
|
||||
if (texture_id == 0) {
|
||||
LOG::error("could not find texture file");
|
||||
}
|
||||
return textureID;
|
||||
return texture_id;
|
||||
}
|
||||
Reference in New Issue
Block a user