tactileipc3d/test/onlygl/main.cpp

#include <cstddef>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/ext/vector_float3.hpp>
#include <iostream>
#include "camera.h"
#include "myshader.hh"

float deltaTime = 0.0f;
float lastFrame = 0.0f;
float yaw = -90.0f;
float pitch = 0.0f;
float fov = 45.0f;
Camera camera(glm::vec3(0.0f, 0.0f, 3.0));

int dot_rows = 3;
int dot_cols = 4;
float panel_width = 1.2f;
float panel_height = 0.08f;
float panel_deep = 0.08f;

Shader bg_shader();
Shader panel_shader();
Shader dots_shader();

unsigned int panel_vao = 0;
unsigned int panel_vbo = 0;
unsigned int panel_ibo = 0;

unsigned int dots_vao = 0;
unsigned int dots_vbo = 0;
unsigned int instance_vbo = 0;

unsigned int bg_vao = 0;
unsigned int bg_vbo = 0;

void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

void process_input(GLFWwindow* window) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }
}

GLFWwindow* glfw_init() {
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#if __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
    GLFWwindow* window = glfwCreateWindow(800, 600, "Tactile Module Test", NULL, NULL);
    if (window == NULL) {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return NULL;
    }
    glfwMakeContextCurrent(window);
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return NULL;
    }

    glViewport(0, 0, 800, 600);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    return window;
}

void glfw_window_loop(GLFWwindow* window) {
    while (!glfwWindowShouldClose(window)) {
        process_input(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
}

void destroy_context() {
    if (panel_vao) {
        glDeleteVertexArrays(1, &panel_vao);
    }
    if (panel_vbo) {
        glDeleteBuffers(1, &panel_vbo);
    }
    if (panel_ibo) {
        glDeleteBuffers(1, &panel_ibo);
    }
    if (dots_vao) {
        glDeleteVertexArrays(1, &dots_vao);
    }
    if (dots_vbo) {
        glDeleteBuffers(1, &dots_vbo);
    }
}

void init_panel_geometry() {
    if (panel_ibo) {
        glDeleteBuffers(1, &panel_ibo);
        panel_ibo = 0;
    }
    if (panel_vbo) {
        glDeleteBuffers(1, &panel_vbo);
        panel_vbo = 0;
    }
    if (panel_vao) {
        glDeleteVertexArrays(1, &panel_vao);
        panel_vao = 0;
    }

    const float y = panel_height * 0.5f;
    const float hw = panel_width * 0.5f;
    const float hd = panel_deep * 0.5;
    using V = struct {
        float x, y, z;
        float nx, ny, nz;
    };
    V verts[24] = {
        // +Y 顶面 (normal 0, +1, 0)
        {-hw, +y, -hd,  0, +1,  0}, // 0
        {+hw, +y, -hd,  0, +1,  0}, // 1
        {+hw, +y, +hd,  0, +1,  0}, // 2
        {-hw, +y, +hd,  0, +1,  0}, // 3

        // +Z 前面 (normal 0, 0, +1)
        {-hw, +y, +hd,  0,  0, +1}, // 4
        {+hw, +y, +hd,  0,  0, +1}, // 5
        {+hw, -y, +hd,  0,  0, +1}, // 6
        {-hw, -y, +hd,  0,  0, +1}, // 7

        // -Y 底面 (normal 0, -1, 0)
        {-hw, -y, +hd,  0, -1,  0}, // 8
        {+hw, -y, +hd,  0, -1,  0}, // 9
        {+hw, -y, -hd,  0, -1,  0}, // 10
        {-hw, -y, -hd,  0, -1,  0}, // 11

        // -Z 后面 (normal 0, 0, -1)
        {+hw, +y, -hd,  0,  0, -1}, // 12
        {-hw, +y, -hd,  0,  0, -1}, // 13
        {-hw, -y, -hd,  0,  0, -1}, // 14
        {+hw, -y, -hd,  0,  0, -1}, // 15

        // -X 左面 (normal -1, 0, 0)
        {-hw, +y, -hd, -1,  0,  0}, // 16
        {-hw, +y, +hd, -1,  0,  0}, // 17
        {-hw, -y, +hd, -1,  0,  0}, // 18
        {-hw, -y, -hd, -1,  0,  0}, // 19

        // +X 右面 (normal +1, 0, 0)
        {+hw, +y, +hd, +1,  0,  0}, // 20
        {+hw, +y, -hd, +1,  0,  0}, // 21
        {+hw, -y, -hd, +1,  0,  0}, // 22
        {+hw, -y, +hd, +1,  0,  0}, // 23
    };

    unsigned int idx[36] = {
        0, 1, 2,  0, 2, 3,       // top
        4, 5, 6,  4, 6, 7,       // front
        8, 9, 10, 8, 10,11,      // bottom
        12,13,14, 12,14,15,      // back
        16,17,18, 16,18,19,      // left
        20,21,22, 20,22,23       // right
    };
    int panel_index_count = 36;
    glGenVertexArrays(1, &panel_vao);
    glBindVertexArray(panel_vao);
    glGenBuffers(1, &panel_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, panel_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
    glGenBuffers(1, &panel_ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, panel_ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FLOAT, sizeof(V), (void*)(3 * sizeof(float)));
    glBindVertexArray(0);
}

void set_panel_size(float w, float h, float d) {
    panel_width = w;
    panel_height = h;
    panel_deep = d;
}

void set_spec(int rows, int cols, float pitch);

int main() {
    GLFWwindow* window = glfw_init();

    if (window == NULL) {
        return -1;
    }


    glfw_window_loop(window);

    glfwTerminate();
    return 0;
}