Phireh/hexnando
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
hexnando/main.cpp

564 lines
20 KiB
C++
Raw Blame History

// stdlib
#include <stdio.h>
// graphics
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include "glad.c"
#define IMGUI_IMPL_OPENGL_LOADER_CUSTOM
#include "imgui/imgui.cpp"
#include "imgui/imgui_demo.cpp"
#include "imgui/imgui_draw.cpp"
#include "imgui/imgui_tables.cpp"
#include "imgui/imgui_widgets.cpp"
#include "imgui/backends/imgui_impl_opengl3.cpp"
#include "imgui/backends/imgui_impl_glfw.cpp"
// fonts
#include <ft2build.h>
#include FT_FREETYPE_H
// math types
#include <glm/matrix.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/vector_angle.hpp>
#include <glm/gtx/string_cast.hpp>
// STL
#include <iostream>
struct charglyph_t {
uint32_t tex; // handle to glyph texture
glm::ivec2 size; // 2d dimensions
glm::ivec2 bearing; // offset from baseline to left/top of glyph
uint32_t advance; // offset to next glyph
};
struct hex_t {
glm::vec3 position;
float radius;
glm::vec3 vertices[7];
glm::vec4 color;
uint32_t vao;
uint32_t vbo;
uint32_t ebo;
};
struct grid_t {
int rows;
int columns;
hex_t *hexes;
};
struct camera_t {
glm::vec3 position;
glm::vec2 size;
};
charglyph_t glyphmap[128];
uint32_t text_program;
uint32_t textvao, textvbo;
uint32_t hex_program;
// error processing
enum err_type {
OK = 0,
ERR_GLFW_INIT,
ERR_GLFW_WINDOW_CREATION,
ERR_GLAD_LOAD,
ERR_FREETYPE_INIT,
ERR_FONT_INIT,
ERR_CHAR_LOAD, };
uint32_t main_errcode = 0;
const char *errcode_string = "";
double mouse_scroll = 0.0;
#define MAIN_ERROR(e) do { main_errcode = e; errcode_string = #e; goto exit_main_with_error; } while(0)
void glfw_error_callback(int error, const char* description)
{
fprintf(stderr, "GLFW error %d: %s\n", error, description);
}
void scroll_callback([[maybe_unused]]GLFWwindow* window, [[maybe_unused]]double xoffset, double yoffset)
{
mouse_scroll = yoffset;
}
char* load_file(const char *pathname)
{
FILE *text_file = fopen(pathname, "r");
if (!text_file)
{
fprintf(stderr, "Failed trying to read file at %s", pathname);
return NULL;
}
fseek(text_file, 0, SEEK_END);
long file_size = ftell(text_file);
fseek(text_file, 0, SEEK_SET); /* same as rewind(f); */
char *file_contents = (char*)calloc(sizeof(char), file_size + 1);
fread(file_contents, 1, file_size, text_file);
fclose(text_file);
return file_contents;
}
uint32_t build_shader_from_source(const char *source, int32_t type)
{
char infoLog[512];
unsigned int shader = glCreateShader(type);
glShaderSource(shader, 1, (const GLchar * const *)(&source), NULL);
glCompileShader(shader);
int success;
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(shader, 512, NULL, infoLog);
const char *type_str = type == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT";
fprintf(stderr, "Error: %s shader compilation failed: %s\n", type_str, infoLog);
}
// TODO: Maybe better error handling?
return shader;
}
uint32_t make_gl_program(const char *pathname_vertex, const char *pathname_fragment)
{
char infoLog[512];
char *vertex_source = load_file(pathname_vertex);
char *fragment_source = load_file(pathname_fragment);
unsigned int vertex_shader = build_shader_from_source(vertex_source, GL_VERTEX_SHADER);
unsigned int fragment_shader = build_shader_from_source(fragment_source, GL_FRAGMENT_SHADER);
uint32_t program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
// print linking errors if any
int32_t success;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success)
{
// TODO: Maybe better error handling?
glGetProgramInfoLog(program, 512, NULL, infoLog);
fprintf(stderr, "Error: shader linking failed: %s\n", infoLog);
}
else
{
// Cleanup of unneeded structures
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
}
return program;
}
void render_text(const char *text, float x, float y, float scale, glm::vec3 color)
{
// activate corresponding render state
glUseProgram(text_program);
glUniform3f(glGetUniformLocation(text_program, "text_color"), color.x, color.y, color.z);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(textvao);
// iterate through 128 ASCI characters
for (const char *p = text; *p != '\0'; ++p)
{
char c = *p;
charglyph_t charglyph = glyphmap[(size_t)c];
float xpos = x + charglyph.bearing.x * scale;
float ypos = y - (charglyph.size.y - charglyph.bearing.y) * scale;
float w = charglyph.size.x * scale;
float h = charglyph.size.y * scale;
// update VBO for each character
float vertices[6][4] = {
{ xpos, ypos + h, 0.0f, 0.0f },
{ xpos, ypos, 0.0f, 1.0f },
{ xpos + w, ypos, 1.0f, 1.0f },
{ xpos, ypos + h, 0.0f, 0.0f },
{ xpos + w, ypos, 1.0f, 1.0f },
{ xpos + w, ypos + h, 1.0f, 0.0f }
};
// render glyph texture over quad
glBindTexture(GL_TEXTURE_2D, charglyph.tex);
// update content of VBO memory
glBindBuffer(GL_ARRAY_BUFFER, textvbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// render quad
glDrawArrays(GL_TRIANGLES, 0, 6);
// now advance cursors for next glyph (note that advance is number of 1/64 pixels)
x += (charglyph.advance >> 6) * scale; // bitshift by 6 to get value in pixels (2^6 = 64)
}
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
}
bool inside_hex(hex_t *hex, glm::vec2 point)
{
for (int i = 1; i < 7; ++i)
{
glm::vec2 outer_edge = glm::vec2(hex->vertices[(i % 6) +1].x, hex->vertices[(i % 6) + 1].y) - glm::vec2(hex->vertices[i].x, hex->vertices[i].y);
glm::vec2 inner_vec = glm::vec2(point - glm::vec2(hex->vertices[i].x, hex->vertices[i].y));
float angle = glm::orientedAngle(glm::normalize(outer_edge), glm::normalize(inner_vec));
if (angle > 0.0f)
return false;
}
return true;
}
// global state
GLFWwindow *window = nullptr;
hex_t hexes[4];
int main([[maybe_unused]]int argc, [[maybe_unused]]char **argv)
{
fprintf(stdout, "Hexnando\n");
// Window initialization
glfwSetErrorCallback(glfw_error_callback);
if (!glfwInit())
{
MAIN_ERROR(ERR_GLFW_INIT);
}
window = glfwCreateWindow(640, 480, "Hexnando", NULL, NULL);
if (!window)
{
MAIN_ERROR(ERR_GLFW_WINDOW_CREATION);
}
glfwMakeContextCurrent(window);
glfwSetScrollCallback(window, scroll_callback);
if (!gladLoadGL())
{
MAIN_ERROR(ERR_GLAD_LOAD);
}
int gl_version_major, gl_version_minor;
glGetIntegerv(GL_MAJOR_VERSION, &gl_version_major);
glGetIntegerv(GL_MINOR_VERSION, &gl_version_minor);
fprintf(stdout, "Using OpenGL %d.%d\n", gl_version_major, gl_version_minor);
// font library initialization
FT_Library ft;
if (FT_Init_FreeType(&ft))
{
MAIN_ERROR(ERR_FREETYPE_INIT);
}
FT_Face face;
if (FT_New_Face(ft, "fonts/Inconsolata-Regular.ttf", 0, &face))
{
MAIN_ERROR(ERR_FONT_INIT);
}
FT_Set_Pixel_Sizes(face, 0, 48);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // disable byte-alignment restriction
for (unsigned char c = 0; c < 128; c++)
{
// load character glyph
if (FT_Load_Char(face, c, FT_LOAD_RENDER))
{
MAIN_ERROR(ERR_CHAR_LOAD);
}
// generate texture
uint32_t texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RED,
face->glyph->bitmap.width,
face->glyph->bitmap.rows,
0,
GL_RED,
GL_UNSIGNED_BYTE,
face->glyph->bitmap.buffer
);
// set texture options
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// now store character for later use
charglyph_t charglyph = {
texture,
glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
(uint32_t)face->glyph->advance.x
};
glyphmap[c] = charglyph;
}
// clear ft2 resources
FT_Done_Face(face);
FT_Done_FreeType(ft);
// text initialization
text_program = make_gl_program("shaders/text.vert", "shaders/text.frag");
glGenVertexArrays(1, &textvao);
glGenBuffers(1, &textvbo);
glBindVertexArray(textvao);
glBindBuffer(GL_ARRAY_BUFFER, textvbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
grid_t grid;
grid.rows = 10;
grid.columns = 10;
grid.hexes = (hex_t*)calloc(grid.rows * grid.columns, sizeof(hex_t));
for (int i = 0; i < grid.rows; ++i)
for (int j = 0; j < grid.columns; ++j)
{
hex_t *the_hexagon = &grid.hexes[i*grid.columns+j];
float radius = 0.2;
the_hexagon->position = glm::vec3(0,0,0) + glm::vec3(j * radius * 3.0f * glm::cos(glm::radians(60.0))
, (i * radius * 2.0f * glm::sin(glm::radians(60.0))) + (j % 2 ? 0 : radius * glm::sin(glm::radians(60.0))),
0);
the_hexagon->radius = radius;
the_hexagon->color = glm::vec4(1.0 - i * 0.1, 1.0 - j * 0.1, 1.0, 1.0);
the_hexagon->vertices[0] = the_hexagon->position;
the_hexagon->vertices[1] = the_hexagon->position + glm::vec3(-radius, 0, 0);
the_hexagon->vertices[2] = the_hexagon->position + glm::vec3(-radius * glm::cos(glm::radians(60.0)), radius * glm::sin(glm::radians(60.0)), 0);
the_hexagon->vertices[3] = the_hexagon->position + glm::vec3(radius * glm::cos(glm::radians(60.0)), radius * glm::sin(glm::radians(60.0)), 0);
the_hexagon->vertices[4] = the_hexagon->position + glm::vec3(radius, 0, 0);
the_hexagon->vertices[5] = the_hexagon->position + glm::vec3(radius * glm::cos(glm::radians(60.0)), -radius * glm::sin(glm::radians(60.0)), 0);
the_hexagon->vertices[6] = the_hexagon->position + glm::vec3(-radius * glm::cos(glm::radians(60.0)), -radius * glm::sin(glm::radians(60.0)), 0);
glGenVertexArrays(1, &the_hexagon->vao);
glGenBuffers(1, &the_hexagon->vbo);
glBindVertexArray(the_hexagon->vao);
glBindBuffer(GL_ARRAY_BUFFER, the_hexagon->vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 7 * 3, the_hexagon->vertices, GL_STATIC_DRAW);
// EBO setup
unsigned int indices[18];
indices[0] = 0; indices[1] = 2; indices[2] = 1;
indices[3] = 0; indices[4] = 3; indices[5] = 2;
indices[6] = 0; indices[7] = 4; indices[8] = 3;
indices[9] = 0; indices[10] = 5; indices[11] = 4;
indices[12] = 0; indices[13] = 6; indices[14] = 5;
indices[15] = 0; indices[16] = 1; indices[17] = 6;
glGenBuffers(1, &the_hexagon->ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, the_hexagon->ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6*3 * sizeof(unsigned int), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
hex_program = make_gl_program("shaders/hex.vert", "shaders/hex.frag");
/* IMGui initalization */
IMGUI_CHECKVERSION();
ImGui::CreateContext();
static ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
ImGui::StyleColorsDark();
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init("#version 330 core"); // same as shader version
double cursor_x;
double cursor_y;
camera_t the_camera;
bool mouse_pressed;
bool mouse_over_gui;
the_camera.position = glm::vec3(0.0f, 0.0f, 1.0f);
the_camera.size = glm::vec2(1.0f, 1.0f);
// main loop
while (!glfwWindowShouldClose(window))
{
double cursor_dx = 0.0;
double cursor_dy = 0.0;
int hovered_hex = -1;
int32_t window_width, window_height;
glfwGetWindowSize(window, &window_width, &window_height);
glViewport(0, 0, window_width, window_height);
float aspect_ratio = (float)window_width/window_height;
/* Input handling */
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
the_camera.position.y += 0.1;
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
the_camera.position.y -= 0.1;
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
the_camera.position.x -= 0.1;
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
the_camera.position.x += 0.1;
if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS)
the_camera.size -= glm::vec2(0.1);
if (glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS)
the_camera.size += glm::vec2(0.1);
if (mouse_scroll > 0.0)
{
the_camera.size -= glm::vec2(0.1);
mouse_scroll = 0.0;
}
if (mouse_scroll < 0.0)
{
the_camera.size += glm::vec2(0.1);
mouse_scroll = 0.0;
}
mouse_pressed = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS;
mouse_over_gui = ImGui::IsWindowHovered(ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem);
cursor_dx = cursor_x;
cursor_dy = cursor_y;
glfwGetCursorPos(window, &cursor_x, &cursor_y);
cursor_dx -= cursor_x;
cursor_dy -= cursor_y;
// Mouse movement
if (!mouse_over_gui && glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS)
{
fprintf(stdout, "Moving camera by %f %f\n", cursor_dx, cursor_dx);
// mouse delta!
the_camera.position.x += cursor_dx * the_camera.size.x/window_width;
// The Y coord is inverted
the_camera.position.y -= cursor_dy * the_camera.size.y/window_height;
}
if (the_camera.size.x < 0.1)
the_camera.size.x = 0.1;
if (the_camera.size.y < 0.1)
the_camera.size.y = 0.1;
/* Rendering */
glClearColor(0.1f, 0.2f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glm::mat4 model_matrix = glm::mat4(1.0f);
glm::mat4 view_matrix = glm::mat4(1.0f);
glm::mat4 proj_matrix = glm::ortho((the_camera.position.x - the_camera.size.x/2) * aspect_ratio, (the_camera.position.x + the_camera.size.x/2) * aspect_ratio, the_camera.position.y - the_camera.size.y/2, the_camera.position.y + the_camera.size.y/2);
glm::vec4 aux((float)cursor_x, (float)cursor_y, 0.0f, 1.0f);
// move screen coordinates to NDC
aux.x -= window_width/2.0f;
aux.x /= window_width/2.0f;
aux.y -= window_height/2.0f;
aux.y /= -window_height/2.0f;
aux = glm::inverse(proj_matrix) * aux;
glm::vec2 cursor_world = glm::vec2(aux.x, aux.y);
glUseProgram(hex_program);
glUniformMatrix4fv(glGetUniformLocation(hex_program, "model"), 1, GL_FALSE, &model_matrix[0][0]);
glUniformMatrix4fv(glGetUniformLocation(hex_program, "view"), 1, GL_FALSE, &view_matrix[0][0]);
glUniformMatrix4fv(glGetUniformLocation(hex_program, "proj"), 1, GL_FALSE, &proj_matrix[0][0]);
for (int i = 0; i < grid.rows; ++i)
for (int j = 0; j < grid.columns; j++)
{
int idx = i * grid.columns + j;
if (!mouse_over_gui && inside_hex(&grid.hexes[idx], cursor_world)) // draw hovered hex differently
{
hovered_hex = i * grid.columns + j;
if (mouse_pressed)
glUniform4f(glGetUniformLocation(hex_program, "hex_color"), 1.0f, 1.0f, 0.0f, 1.0f);
else
glUniform4f(glGetUniformLocation(hex_program, "hex_color"), 1.0f, 0.0f, 0.0f, 1.0f);
}
else
{
glUniform4f(glGetUniformLocation(hex_program, "hex_color"), grid.hexes[idx].color.x, grid.hexes[idx].color.y, grid.hexes[idx].color.z, grid.hexes[idx].color.w);
}
glBindVertexArray(grid.hexes[idx].vao);
glBindBuffer(GL_ARRAY_BUFFER, grid.hexes[idx].vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, grid.hexes[idx].ebo);
glEnable(GL_CULL_FACE);
glDrawElements(GL_TRIANGLES, 3*6, GL_UNSIGNED_INT, 0);
glDisable(GL_CULL_FACE);
glBindVertexArray(0);
}
glUseProgram(text_program);
// text rendering
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glm::mat4 text_proj_matrix = glm::ortho(0.0f, (float)window_width, 0.0f, (float)window_height);
glUniformMatrix4fv(glGetUniformLocation(text_program, "projection"), 1, GL_FALSE, &text_proj_matrix[0][0]);
static char debug_text_buf[256];
snprintf(debug_text_buf, 256, "Cursor position %.0f %.0f screen %.2f %.2f world", cursor_x, cursor_y, cursor_world.x, cursor_world.y);
render_text(debug_text_buf, 25, 25, .5f, glm::vec3(1.0f, 1.0f, 1.0f));
for (int i = 0; i < grid.rows * grid.columns; ++i)
{
// Get position of hexes in screen
glm::vec4 v = glm::vec4(grid.hexes[i].position.x, grid.hexes[i].position.y, grid.hexes[i].position.z, 1.0);
v = proj_matrix * view_matrix * model_matrix * v;
v.x += 1;
v.x *= window_width/2.0f;
v.y += 1;
v.y *= window_height/2.0f;
char number_string[11];
snprintf(number_string, 11, "%d", i);
render_text(number_string, v.x, v.y, .2f + (0.3f / the_camera.size.x), glm::vec3(0.0f, 0.0f, 0.0f));
}
if (hovered_hex != -1)
{
char buf[30];
snprintf(buf, 30, "Cursor INSIDE hex %d", hovered_hex);
render_text(buf, 25.0f, window_height - 25.0f, .5f, glm::vec3(1.0f, 1.0f, 1.0f));
}
glDisable(GL_BLEND);
glfwPollEvents();
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
ImGui::Begin("Hi there");
ImGui::End();
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
glfwSwapBuffers(window);
}
// Cleanup
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
return 0;
exit_main_with_error:
if (window)
glfwDestroyWindow(window);
glfwTerminate();
fprintf(stderr, "Hexnando failed with errcode %d: %s\n", main_errcode, errcode_string);
return main_errcode;
}
Reference in a new issue View git blame Copy permalink