zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-04-10 06:14:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
f56e5aaa514a97f38bd1889d752a059ea7aae01d
Cubed/src/main.cpp

357 lines
11 KiB
C++
Raw Blame History

#include <fstream>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
#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 <Cubed/camera.hpp>
#include <Cubed/tools/log.hpp>
#include <Cubed/tools/shader_tools.hpp>
constexpr int numVAOs = 1;
constexpr int numVBOs = 3;
constexpr int WORLD_SIZE_X = 32;
constexpr int WORLD_SIZE_Z = 32;
bool blockPresent[WORLD_SIZE_X][WORLD_SIZE_Z] = {false};
GLuint renderingProgram;
GLuint vao[numVAOs];
GLuint vbo[numVBOs];
GLuint pyrTexture;
float cubLocX, cubLocY, cubLocZ;
float pyLocX, pyLocY, pyLocZ;
GLuint mvLoc, projLoc, tfLoc;
int width ,height;
float aspect;
glm::mat4 pMat, vMat, mMat, mvMat;
float inc = 0.01f;
float tf = 0.0f;
glm::mat4 tMat, rMat, sMat;
std::vector<GLuint> grass_block_texture(6);
void setupVertices(void) {
float verticesPos[108] = {
// ===== 前面 (z = +1) =====
-0.5f, -0.5f, 0.5f, // 左下
-0.5f, 0.5f, 0.5f, // 左上
0.5f, 0.5f, 0.5f, // 右上
0.5f, 0.5f, 0.5f, // 右上
0.5f, -0.5f, 0.5f, // 右下
-0.5f, -0.5f, 0.5f, // 左下
// ===== 右面 (x = +1) =====
0.5f, -0.5f, 0.5f, // 前下
0.5f, -0.5f, -0.5f, // 后下
0.5f, 0.5f, -0.5f, // 后上
0.5f, 0.5f, -0.5f, // 后上
0.5f, 0.5f, 0.5f, // 前上
0.5f, -0.5f, 0.5f, // 前下
// ===== 后面 (z = -1) =====
-0.5f, -0.5f, -0.5f, // 左下
0.5f, -0.5f, -0.5f, // 右下
0.5f, 0.5f, -0.5f, // 右上
0.5f, 0.5f, -0.5f, // 右上
-0.5f, 0.5f, -0.5f, // 左上
-0.5f, -0.5f, -0.5f, // 左下
// ===== 左面 (x = -1) =====
-0.5f, -0.5f, -0.5f, // 后下
-0.5f, -0.5f, 0.5f, // 前下
-0.5f, 0.5f, 0.5f, // 前上
-0.5f, 0.5f, 0.5f, // 前上
-0.5f, 0.5f, -0.5f, // 后上
-0.5f, -0.5f, -0.5f, // 后下
// ===== 上面 (y = +1) =====
-0.5f, 0.5f, -0.5f, // 后左
0.5f, 0.5f, -0.5f, // 后右
0.5f, 0.5f, 0.5f, // 前右
0.5f, 0.5f, 0.5f, // 前右
-0.5f, 0.5f, 0.5f, // 前左
-0.5f, 0.5f, -0.5f, // 后左
// ===== 下面 (y = -1) =====
-0.5f, -0.5f, 0.5f, // 前左
0.5f, -0.5f, 0.5f, // 前右
0.5f, -0.5f, -0.5f, // 后右
0.5f, -0.5f, -0.5f, // 后右
-0.5f, -0.5f, -0.5f, // 后左
-0.5f, -0.5f, 0.5f // 前左
};
float tex_coords[72] {
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
};
glGenVertexArrays(numVAOs, vao);
glBindVertexArray(vao[0]);
glGenBuffers(numVBOs, vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesPos), verticesPos, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
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 vShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fShader = 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);
if (vc != 1) {
LOG::error("vertex compilation failed");
printShaderLog(vShader);
}
glCompileShader(fShader);
checkOpenGLError();
glGetShaderiv(fShader, GL_COMPILE_STATUS, &fc);
if (fc != 1) {
LOG::error("vertex compilation failed");
printShaderLog(fShader);
}
GLuint vfProgram = glCreateProgram();
glAttachShader(vfProgram, vShader);
glAttachShader(vfProgram, fShader);
glLinkProgram(vfProgram);
GLint linked;
checkOpenGLError();
glGetProgramiv(vfProgram, GL_LINK_STATUS, &linked);
if (linked != 1) {
LOG::error("linking failed");
printProgramInfo(vfProgram);
}
return vfProgram;
}
void init(GLFWwindow* window) {
renderingProgram = createShaderProgram();
cubLocX = 0.0f;
cubLocY = -2.0f;
cubLocZ = 0.0f;
pyLocX = 0.0f;
pyLocY = -2.0f;
pyLocZ = -20.0f;
cameraInit();
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);
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");
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, grass_block_texture[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
setupVertices();
}
void window_reshape_callback(GLFWwindow* window, int newWidth, int newHeight) {
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);
}
void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
updateCursorPositionCamera(xpos, ypos);
}
void display(GLFWwindow* window, double currentTime) {
updateMoveCamera();
for (int i = 0; i < WORLD_SIZE_X; i++) {
for (int j = 0; j < WORLD_SIZE_Z; j++) {
blockPresent[i][j] = true;
}
}
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glUseProgram(renderingProgram);
mvLoc = glGetUniformLocation(renderingProgram, "mv_matrix");
projLoc = glGetUniformLocation(renderingProgram, "proj_matrix");
/*
cameraX += inc;
if (cameraX > 1.0f) {
inc = -inc;
}
if (cameraX < -1.0f) {
inc = -inc;
}
*/
glBindVertexArray(vao[0]);
//sMat = glm::scale(glm::mat4(1.0f), glm::vec3(0.3f, 0.3f, 0.3f));
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(1);
glActiveTexture(GL_TEXTURE0);
for (int x = -16; x < 16; x++) {
for (int z = -16; z < 16; z++) {
int ix = x + 16;
int iz = z + 16;
mMat = glm::translate(glm::mat4(1.0f), glm::vec3((float)x, 0.0f, (float)z));
vMat = getCameraLookAt();
mvMat = vMat * mMat;
glUniformMatrix4fv(mvLoc, 1, GL_FALSE, glm::value_ptr(mvMat));
glUniformMatrix4fv(projLoc, 1 ,GL_FALSE, glm::value_ptr(pMat));
bool drawFace[6] = {true, true, true, true, true, true};
if (z < 15 && blockPresent[ix][iz + 1]) {
drawFace[0] = false;
}
if (x < 15 && blockPresent[ix + 1][iz]) {
drawFace[1] = false;
}
if (z > -16 && blockPresent[ix][iz + 1]) {
drawFace[2] = false;
}
if (x > -16 && blockPresent[ix - 1][iz]) {
drawFace[3] = false;
}
for (int face = 0; face < 6; face++) {
if (!drawFace[face]) {
continue;
}
glBindTexture(GL_TEXTURE_2D, grass_block_texture[face]);
//glPointSize(30.0f);
glDrawArrays(GL_TRIANGLES, face * 6, 6);
}
}
}
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
switch(key) {
case GLFW_KEY_ESCAPE:
if (action == GLFW_PRESS) {
if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED) {
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
} else if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_NORMAL) {
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
}
}
break;
}
updateCameraKey(key, action);
}
int main() {
if (!glfwInit()) {
LOG::error("glfwinit fail");
exit(EXIT_FAILURE);
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
GLFWwindow* window = glfwCreateWindow(800, 600, "Cubed", NULL, NULL);
glfwMakeContextCurrent(window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
LOG::error("Failed to initialize glad");
return -1;
}
LOG::info("OpenGL Version: {}.{}", GLVersion.major, GLVersion.minor);
LOG::info("Renderer: {}", reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
glfwSwapInterval(1);
glfwSetWindowSizeCallback(window, window_reshape_callback);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, cursor_position_callback);
init(window);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
while(!glfwWindowShouldClose(window)) {
display(window, glfwGetTime());
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
Reference in New Issue View Git Blame Copy Permalink