mp2i-vms.fr
465 lines
15 KiB
C
465 lines
15 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include <stdbool.h>
|
|
#include <unistd.h>
|
|
#include <termios.h>
|
|
#include <limits.h>
|
|
#include <time.h>
|
|
#include <glad/glad.h>
|
|
#include <GLFW/glfw3.h>
|
|
|
|
#include "hash.h"
|
|
#include "structure.h"
|
|
#include "base.h"
|
|
#include "move.h"
|
|
#include "menus.h"
|
|
#include "proj.h"
|
|
#include "entities.h"
|
|
#include "display.h"
|
|
#include "generation.h"
|
|
|
|
double sim_time;
|
|
int triCount;
|
|
unsigned int fffff;
|
|
int gamemode;
|
|
|
|
double jPress = false;
|
|
double gPress = false;
|
|
double rPress = false;
|
|
|
|
void reset_everything(GLFWwindow *window, int count, char* folder) {
|
|
hashtbl_free(visited);
|
|
free_proj();
|
|
free_interf();
|
|
free_pool();
|
|
|
|
//init_csts();
|
|
init_hashtbl();
|
|
init_ent_generator(10);
|
|
init_proj();
|
|
init_interf(window);
|
|
parse_rooms(count, folder);
|
|
}
|
|
|
|
void processInput(GLFWwindow *window, float dtime) {
|
|
// quit w
|
|
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
|
|
glfwSetWindowShouldClose(window, true);
|
|
}
|
|
|
|
// horizontal movement
|
|
bool pressed = false;
|
|
if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
|
|
if(gamemode == 1) {
|
|
for(int k = 0; k < 10; k++) {
|
|
camz -= creative_speed*cos(rot_hz)*cos(rot_vt)/10;
|
|
camx -= creative_speed*sin(rot_hz)*cos(rot_vt)/10;
|
|
camy += creative_speed*sin(rot_vt)/10;
|
|
if(is_colliding(dtime)) {
|
|
camz += creative_speed*cos(rot_hz)*cos(rot_vt)/10;
|
|
camx += creative_speed*sin(rot_hz)*cos(rot_vt)/10;
|
|
camy -= creative_speed*sin(rot_vt)/10;
|
|
k=11;
|
|
}
|
|
}
|
|
} else {
|
|
camvz = -speed*cos(rot_hz);
|
|
camvx = -speed*sin(rot_hz);
|
|
}
|
|
pressed = true;
|
|
//camvy = vtmult*speed*sin(rot_vt);
|
|
}
|
|
if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
|
|
if(gamemode == 1) {
|
|
for(int k = 0; k < 10; k++) {
|
|
camx -= creative_speed*cos(rot_hz)/10;
|
|
camz += creative_speed*sin(rot_hz)/10;
|
|
if(is_colliding(dtime)) {
|
|
camx += creative_speed*cos(rot_hz)/10;
|
|
camz -= creative_speed*sin(rot_hz)/10;
|
|
k=11;
|
|
}
|
|
}
|
|
} else {
|
|
camvx = -speed*cos(rot_hz);
|
|
camvz = speed*sin(rot_hz);
|
|
}
|
|
pressed = true;
|
|
}
|
|
if(glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS) {
|
|
if(gamemode == 1) {
|
|
for(int k = 0; k < 10; k++) {
|
|
camz += creative_speed*cos(rot_hz)*cos(rot_vt)/10;
|
|
camx += creative_speed*sin(rot_hz)*cos(rot_vt)/10;
|
|
camy -= creative_speed*sin(rot_vt)/10;
|
|
if(is_colliding(dtime)) {
|
|
camz -= creative_speed*cos(rot_hz)*cos(rot_vt)/10;
|
|
camx -= creative_speed*sin(rot_hz)*cos(rot_vt)/10;
|
|
camy += creative_speed*sin(rot_vt)/10;
|
|
k=11;
|
|
}
|
|
}
|
|
} else {
|
|
camvz = speed*cos(rot_hz);
|
|
camvx = speed*sin(rot_hz);
|
|
}
|
|
pressed = true;
|
|
//camvy = -vtmult*speed*sin(rot_vt);
|
|
}
|
|
if(glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) {
|
|
if(gamemode == 1) {
|
|
for(int k = 0; k < 10; k++) {
|
|
camx += creative_speed*cos(rot_hz)/10;
|
|
camz -= creative_speed*sin(rot_hz)/10;
|
|
if(is_colliding(dtime)) {
|
|
camx -= creative_speed*cos(rot_hz)/10;
|
|
camz += creative_speed*sin(rot_hz)/10;
|
|
k=11;
|
|
}
|
|
}
|
|
} else {
|
|
camvx = speed*cos(rot_hz);
|
|
camvz = -speed*sin(rot_hz);
|
|
}
|
|
pressed = true;
|
|
}
|
|
|
|
// jumps
|
|
if(gamemode == 0 && njumps > 0 && glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
|
|
if(jPress) {
|
|
camvy = vtmult*speed;
|
|
njumps -= 1;
|
|
jPress = false;
|
|
}
|
|
} else {
|
|
jPress = true;
|
|
}
|
|
if(!pressed) {
|
|
camvx *= (1.0-1.0*5.0*((double)dtime));
|
|
camvz *= (1.0-1.0*5.0*((double)dtime));
|
|
}
|
|
|
|
// gamemode
|
|
if(glfwGetKey(window, GLFW_KEY_G) == GLFW_PRESS) {
|
|
if(!gPress) {
|
|
gPress = true;
|
|
gamemode = 1-gamemode;
|
|
njumps = 3;
|
|
camvx = 0.0;
|
|
camvy = 0.0;
|
|
camvz = 0.0;
|
|
}
|
|
} else {
|
|
gPress = false;
|
|
}
|
|
|
|
// camera rotation
|
|
if(glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) {
|
|
rot_hz -= sensitivity;
|
|
}
|
|
if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
|
|
rot_hz += sensitivity;
|
|
}
|
|
|
|
if(glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS) {
|
|
rot_vt = maxd(-3.14159/2.0, rot_vt-sensitivity);
|
|
}
|
|
if(glfwGetKey(window, GLFW_KEY_M) == GLFW_PRESS) {
|
|
rot_vt = mind(3.14159/2.0, rot_vt+sensitivity);
|
|
}
|
|
|
|
// reset
|
|
if(glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS) {
|
|
if(!isMenuOpen() && !rPress) {
|
|
rPress = true;
|
|
reset_everything(window, 7, "templates/");
|
|
}
|
|
}/*else {
|
|
rPress = false;
|
|
}*/
|
|
}
|
|
|
|
const char *vertexShaderSource = "#version 330 core\n"
|
|
"layout (location = 0) in vec3 aPos;\n"
|
|
"uniform mat4 scale;\n"
|
|
"uniform mat4 model;\n"
|
|
"uniform mat4 view;\n"
|
|
"uniform mat4 projection;\n"
|
|
"void main() {\n"
|
|
" gl_Position = projection * view * model * scale * vec4(aPos, 1.0);\n"
|
|
"}\0";
|
|
|
|
// Fragment Shader Source
|
|
const char *fragmentShaderSource = "#version 330 core\n"
|
|
"uniform vec4 u_color;\n"
|
|
"out vec4 FragColor;\n"
|
|
"void main() {\n"
|
|
" FragColor = u_color;\n"
|
|
"}\0";
|
|
|
|
const char *vertexShaderSourceR = "#version 330 core\n"
|
|
"layout (location = 0) in vec3 aPos;\n"
|
|
"uniform mat4 scale;\n"
|
|
"uniform mat4 slide;\n"
|
|
"void main() {\n"
|
|
" gl_Position = slide * scale * vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
|
|
"}\0";
|
|
|
|
const char *fragmentShaderSourceR = "#version 330 core\n"
|
|
"uniform vec4 u_color2;\n"
|
|
"out vec4 FragColor;\n"
|
|
"void main() {\n"
|
|
" FragColor = u_color2;\n"
|
|
"}\0";
|
|
|
|
int main_alt() {
|
|
// glfw: initialize and configure
|
|
// ------------------------------
|
|
glfwInit();
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
|
|
|
// glfw window creation
|
|
// --------------------
|
|
GLFWwindow* window = glfwCreateWindow(1500, 1000, "yahoo", NULL, NULL);
|
|
if (window == NULL)
|
|
{
|
|
fprintf(stderr, "ERROR : cannot initialize GL window");
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
glfwMakeContextCurrent(window);
|
|
|
|
// glad: load all OpenGL function pointers
|
|
// ---------------------------------------
|
|
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
|
|
{
|
|
fprintf(stderr, "ERROR : cannot initialize GLAD loader");
|
|
return -1;
|
|
}
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
glEnable(GL_CULL_FACE);
|
|
glCullFace(GL_FRONT);
|
|
glDepthFunc(GL_LESS);
|
|
|
|
//glfwSetMouseButtonCallback(window, mouse_button_callback);
|
|
|
|
init_csts();
|
|
init_hashtbl();
|
|
init_ent_generator(10);
|
|
init_proj();
|
|
init_interf(window);
|
|
build_all_menus();
|
|
parse_rooms(7, "templates/");
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
|
|
// build and compile our shader program
|
|
// ------------------------------------
|
|
// vertex shader
|
|
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
|
|
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
|
|
glCompileShader(vertexShader);
|
|
// check for shader compile errors
|
|
int success;
|
|
char infoLog[512];
|
|
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
|
|
if (!success)
|
|
{
|
|
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
|
|
fprintf(stderr, "ERROR : cannot initialize shader (1)");
|
|
}
|
|
|
|
// fragment shader
|
|
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
|
|
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
|
|
glCompileShader(fragmentShader);
|
|
// check for shader compile errors
|
|
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
|
|
if (!success)
|
|
{
|
|
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
|
|
fprintf(stderr, "ERROR : cannot initialize shader (3)");
|
|
}
|
|
|
|
// link shaders
|
|
unsigned int shaderProgram = glCreateProgram();
|
|
glAttachShader(shaderProgram, vertexShader);
|
|
glAttachShader(shaderProgram, fragmentShader);
|
|
glLinkProgram(shaderProgram);
|
|
|
|
glDeleteShader(vertexShader);
|
|
glDeleteShader(fragmentShader);
|
|
|
|
// main VAO/VBO
|
|
unsigned int VBO, VAO;
|
|
glGenVertexArrays(1, &VAO);
|
|
glGenBuffers(1, &VBO);
|
|
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
|
|
glBindVertexArray(VAO);
|
|
|
|
init_vertices();
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
|
|
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
|
glEnableVertexAttribArray(0);
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
|
|
// build and compile our shader program
|
|
// ------------------------------------
|
|
// vertex shader
|
|
unsigned int vertexShaderR = glCreateShader(GL_VERTEX_SHADER);
|
|
glShaderSource(vertexShaderR, 1, &vertexShaderSourceR, NULL);
|
|
glCompileShader(vertexShaderR);
|
|
// check for shader compile errors
|
|
glGetShaderiv(vertexShaderR, GL_COMPILE_STATUS, &success);
|
|
if (!success)
|
|
{
|
|
glGetShaderInfoLog(vertexShaderR, 512, NULL, infoLog);
|
|
//std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
|
|
}
|
|
// fragment shader
|
|
unsigned int fragmentShaderR = glCreateShader(GL_FRAGMENT_SHADER);
|
|
glShaderSource(fragmentShaderR, 1, &fragmentShaderSourceR, NULL);
|
|
glCompileShader(fragmentShaderR);
|
|
// check for shader compile errors
|
|
glGetShaderiv(fragmentShaderR, GL_COMPILE_STATUS, &success);
|
|
if (!success)
|
|
{
|
|
glGetShaderInfoLog(fragmentShaderR, 512, NULL, infoLog);
|
|
//std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
|
|
}
|
|
// link shaders
|
|
unsigned int shaderProgramR = glCreateProgram();
|
|
glAttachShader(shaderProgramR, vertexShaderR);
|
|
glAttachShader(shaderProgramR, fragmentShaderR);
|
|
glLinkProgram(shaderProgramR);
|
|
// check for linking errors
|
|
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
|
|
if (!success) {
|
|
glGetProgramInfoLog(shaderProgramR, 512, NULL, infoLog);
|
|
//std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
|
|
}
|
|
glDeleteShader(vertexShaderR);
|
|
glDeleteShader(fragmentShaderR);
|
|
|
|
// rectangle VAO/VBO
|
|
initMenus();
|
|
|
|
unsigned int RVBO, RVAO;
|
|
glGenVertexArrays(1, &RVAO);
|
|
glGenBuffers(1, &RVBO);
|
|
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
|
|
glBindVertexArray(RVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, RVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(rectDefault), rectDefault, GL_STATIC_DRAW);
|
|
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
|
glEnableVertexAttribArray(0);
|
|
|
|
// note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
// You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
|
|
// VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
|
|
glBindVertexArray(0);
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
// ---------------------------------------------------------------------------------------------------------------------------------------------- //
|
|
fffff = shaderProgram;
|
|
|
|
int fps = 90;
|
|
int interval = 1000000/fps;
|
|
double slp_time = 1.0/fps;
|
|
|
|
float delta = 0.0f;
|
|
double deltad = 0.0;
|
|
|
|
clock_t finish = clock();
|
|
clock_t origin = clock();
|
|
|
|
while(!glfwWindowShouldClose(window) && player_hp > 0) {
|
|
// input
|
|
// -----
|
|
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
triCount = 0;
|
|
|
|
fflush(stdout);
|
|
generate_nearby_chunks(1);
|
|
fflush(stdout);
|
|
|
|
// draw the map
|
|
glUseProgram(shaderProgram);
|
|
glBindVertexArray(VAO);
|
|
|
|
gl_initRender(shaderProgram, shaderProgram, VAO, VBO);
|
|
gl_renderNearbyChunks(shaderProgram, shaderProgram, VAO, VBO, 1);
|
|
gl_renderProj(shaderProgram, shaderProgram, VAO, VBO);
|
|
|
|
// draw data
|
|
glUseProgram(shaderProgramR);
|
|
glBindVertexArray(RVAO);
|
|
|
|
gl_drawInteger(shaderProgramR, (int)(1.0f/(delta)), 0.0f, -0.92f, 0.05, 32, 255, 32, 0.005, -1);
|
|
gl_drawInteger(shaderProgramR, triCount, 0.0f, 0.92f, 0.04f, 128, 128, 128, 0.005f, 1);
|
|
gl_drawData(shaderProgramR);
|
|
|
|
if(!isInMenu(window, shaderProgramR)) {
|
|
processInput(window, delta);
|
|
if(gamemode == 0) {
|
|
movePlayerG(delta);
|
|
}
|
|
teleport_on_edge();
|
|
update_entities(delta);
|
|
updateProj(delta);
|
|
}
|
|
|
|
usleep(max(0, interval-(int)(1000000*delta)));
|
|
sim_time += deltad;
|
|
|
|
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
|
|
glfwSwapBuffers(window);
|
|
glfwPollEvents();
|
|
|
|
finish = clock();
|
|
delta = slp_time+((float)finish - (float)origin)/CLOCKS_PER_SEC;
|
|
deltad = slp_time+((double)finish - (double)origin)/CLOCKS_PER_SEC;
|
|
origin = clock();
|
|
incr = 0.0f;
|
|
}
|
|
|
|
hashtbl_free(visited);
|
|
free_proj();
|
|
free_interf();
|
|
free_pool();
|
|
|
|
// optional: de-allocate all resources once they've outlived their purpose:
|
|
// ------------------------------------------------------------------------
|
|
glDeleteVertexArrays(1, &VAO);
|
|
glDeleteBuffers(1, &VBO);
|
|
glDeleteProgram(shaderProgram);
|
|
|
|
// glfw: terminate, clearing all previously allocated GLFW resources.
|
|
// ------------------------------------------------------------------
|
|
glfwTerminate();
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
srand(time(NULL));
|
|
triCount = 0;
|
|
sim_time = 0.0;
|
|
gamemode = 0;
|
|
return main_alt();
|
|
} |