lenn/tactileipc3d
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

完成主要交互、高性能组件、国际化和A型传感器数据包接收

Browse Source
This commit is contained in:
lenn
2026-01-13 16:34:28 +08:00
parent 47e6dc7244
commit 1960e6a5b9
84 changed files with 7752 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

769
test/onlygl/main.cpp
View File

@@ -1,43 +1,122 @@
#include <cstddef>
// GLFW 版本的渲染入口：画触觉面板盒子 + 点阵实例化圆点，
// 右键拖拽环绕相机，滚轮调 FOV，内置简单波纹数据做演示。
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/ext/vector_float3.hpp>
#include <iostream>
#include "camera.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "myshader.hh"
#include "stb_image_wrap.h"
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));
struct AppState {
// 点阵规格
int rows = 8;
int cols = 10;
float pitch = 0.025f;
float dotRadius = 0.008f;
// 面板尺寸
float panelW = 0.25f;
float panelH = 0.35f;
float panelD = 0.01f;
// 数据范围
int minV = 0;
int maxV = 100;
// 渲染模式：0=有光照，1=无光照（flat/unlit）
int renderMode = 1;
int dot_rows = 3;
int dot_cols = 4;
float panel_width = 1.2f;
float panel_height = 0.08f;
float panel_deep = 0.08f;
// 相机状态（环绕）
float camYaw = -90.0f;
float camPitch = 0.0f;
float zoom = 45.0f;
bool rightDown = false;
double lastMouseX = 0.0;
double lastMouseY = 0.0;
Shader bg_shader();
Shader panel_shader();
Shader dots_shader();
bool valuesDirty = true;
std::vector<float> values;
glm::mat4 mvp{1.0f};
glm::vec3 cameraPos{0.0f, 0.0f, 3.0f};
};
AppState g_state;
Shader* bg_shader = nullptr;
Shader* room_shader = nullptr;
Shader* panel_shader = nullptr;
Shader* dots_shader = nullptr;
unsigned int panel_vao = 0;
unsigned int panel_vbo = 0;
unsigned int panel_ibo = 0;
int panel_index_count = 0;
unsigned int room_vao = 0;
unsigned int room_vbo = 0;
unsigned int room_ibo = 0;
int room_index_count = 0;
unsigned int dots_vao = 0;
unsigned int dots_vbo = 0;
unsigned int instance_vbo = 0;
int instance_count = 0;
unsigned int dot_tex = 0;
unsigned int bg_vao = 0;
unsigned int bg_vbo = 0;
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
unsigned int metal_tex = 0;
bool panel_geometry_dirty = true;
bool dot_geometry_dirty = true;
void framebuffer_size_callback(GLFWwindow* /*window*/, int width, int height) {
// 视口随窗口大小变化
glViewport(0, 0, width, height);
}
void mouse_button_callback(GLFWwindow* window, int button, int action, int /*mods*/) {
// 右键按下/抬起，用于开启/关闭环绕相机拖拽
if (button == GLFW_MOUSE_BUTTON_RIGHT) {
if (action == GLFW_PRESS) {
g_state.rightDown = true;
glfwGetCursorPos(window, &g_state.lastMouseX, &g_state.lastMouseY);
} else if (action == GLFW_RELEASE) {
g_state.rightDown = false;
}
}
}
void cursor_pos_callback(GLFWwindow* /*window*/, double xpos, double ypos) {
// 右键拖拽时，根据鼠标增量更新 yaw/pitch
if (!g_state.rightDown)
return;
const float dx = static_cast<float>(xpos - g_state.lastMouseX);
const float dy = static_cast<float>(ypos - g_state.lastMouseY);
g_state.lastMouseX = xpos;
g_state.lastMouseY = ypos;
g_state.camYaw += dx * 0.3f;
if (g_state.camYaw >= -70) {
g_state.camYaw = -70;
}
if (g_state.camYaw <= -110) {
g_state.camYaw = -110;
}
g_state.camPitch = std::clamp(g_state.camPitch + dy * 0.3f, -20.0f, 20.0f);
}
void scroll_callback(GLFWwindow* /*window*/, double /*xoffset*/, double yoffset) {
// 滚轮调整视角 FOV（越小越近）
const float factor = std::pow(0.9f, static_cast<float>(yoffset));
g_state.zoom = std::clamp(g_state.zoom * factor, 5.0f, 80.0f);
}
void process_input(GLFWwindow* window) {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
glfwSetWindowShouldClose(window, true);
@@ -45,58 +124,198 @@ void process_input(GLFWwindow* window) {
}
GLFWwindow* glfw_init() {
glfwInit();
// 初始化 GLFW + GLAD，创建窗口与上下文
if (!glfwInit()) {
std::cerr << "Failed to init GLFW" << std::endl;
return nullptr;
}
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;
GLFWwindow* window = glfwCreateWindow(800, 600, "Tactile Module Test (GLFW)", nullptr, nullptr);
if (window == nullptr) {
std::cerr << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return NULL;
return nullptr;
}
glfwMakeContextCurrent(window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
std::cout << "Failed to initialize GLAD" << std::endl;
return NULL;
std::cerr << "Failed to initialize GLAD" << std::endl;
glfwDestroyWindow(window);
glfwTerminate();
return nullptr;
}
glViewport(0, 0, 800, 600);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, cursor_pos_callback);
glfwSetScrollCallback(window, scroll_callback);
glViewport(0, 0, 800, 600);
glfwSwapInterval(1);
return window;
}
void glfw_window_loop(GLFWwindow* window) {
while (!glfwWindowShouldClose(window)) {
process_input(window);
glfwSwapBuffers(window);
glfwPollEvents();
}
int dot_count() {
// 当前点阵总数
return g_state.rows * g_state.cols;
}
void destroy_context() {
if (panel_vao) {
glDeleteVertexArrays(1, &panel_vao);
void set_panel_size(float w, float h, float d) {
g_state.panelW = w;
g_state.panelH = h;
g_state.panelD = d;
panel_geometry_dirty = true;
}
void set_spec(int rows, int cols, float pitch, float dotRadius) {
// 设置点阵规格，同时自动计算面板宽/深以留出圆点边界
g_state.rows = std::max(0, rows);
g_state.cols = std::max(0, cols);
g_state.pitch = std::max(0.0f, pitch);
g_state.dotRadius = std::max(0.0f, dotRadius);
const float gridW = static_cast<float>(std::max(0, g_state.cols - 1)) * g_state.pitch;
const float gridD = static_cast<float>(std::max(0, g_state.rows - 1)) * g_state.pitch;
g_state.panelW = gridW + 2.0f * g_state.dotRadius;
g_state.panelH = gridD + 2.0f * g_state.dotRadius;
panel_geometry_dirty = true;
dot_geometry_dirty = true;
g_state.values.assign(dot_count(), static_cast<float>(g_state.minV));
g_state.valuesDirty = true;
}
void init_background_geometry() {
// 背景网格：全屏二三角形，顶点坐标直接在 NDC 空间
if (bg_vbo) {
glDeleteBuffers(1, &bg_vbo);
bg_vbo = 0;
}
if (panel_vbo) {
glDeleteBuffers(1, &panel_vbo);
if (bg_vao) {
glDeleteVertexArrays(1, &bg_vao);
bg_vao = 0;
}
if (panel_ibo) {
glDeleteBuffers(1, &panel_ibo);
const float verts[] = {
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, 1.0f,
};
glGenVertexArrays(1, &bg_vao);
glBindVertexArray(bg_vao);
glGenBuffers(1, &bg_vbo);
glBindBuffer(GL_ARRAY_BUFFER, bg_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);
glBindVertexArray(0);
}
void init_room_geometry() {
// 房间：一个“倒扣的大盒子”（立方体），我们从里面看，所以法线朝向盒子内部
if (room_ibo) {
glDeleteBuffers(1, &room_ibo);
room_ibo = 0;
}
if (dots_vao) {
glDeleteVertexArrays(1, &dots_vao);
if (room_vbo) {
glDeleteBuffers(1, &room_vbo);
room_vbo = 0;
}
if (dots_vbo) {
glDeleteBuffers(1, &dots_vbo);
if (room_vao) {
glDeleteVertexArrays(1, &room_vao);
room_vao = 0;
}
struct V {
float x, y, z;
float nx, ny, nz;
};
// 单位立方体：顶点范围 [-1, 1]，真正房间大小在 room.vert 里通过 uRoomHalfSize 缩放
// 下面的法线是“朝内”的（方便在房间内部打光）
V verts[24] = {
// floor (y = -1), normal +Y
{-1, -1, -1, 0, +1, 0},
{+1, -1, -1, 0, +1, 0},
{+1, -1, +1, 0, +1, 0},
{-1, -1, +1, 0, +1, 0},
// ceiling (y = +1), normal -Y
{-1, +1, +1, 0, -1, 0},
{+1, +1, +1, 0, -1, 0},
{+1, +1, -1, 0, -1, 0},
{-1, +1, -1, 0, -1, 0},
// back wall (z = -1), normal +Z
{-1, +1, -1, 0, 0, +1},
{+1, +1, -1, 0, 0, +1},
{+1, -1, -1, 0, 0, +1},
{-1, -1, -1, 0, 0, +1},
// front wall (z = +1), normal -Z
{+1, +1, +1, 0, 0, -1},
{-1, +1, +1, 0, 0, -1},
{-1, -1, +1, 0, 0, -1},
{+1, -1, +1, 0, 0, -1},
// left wall (x = -1), normal +X
{-1, +1, +1, +1, 0, 0},
{-1, +1, -1, +1, 0, 0},
{-1, -1, -1, +1, 0, 0},
{-1, -1, +1, +1, 0, 0},
// right wall (x = +1), normal -X
{+1, +1, -1, -1, 0, 0},
{+1, +1, +1, -1, 0, 0},
{+1, -1, +1, -1, 0, 0},
{+1, -1, -1, -1, 0, 0},
};
unsigned int idx[36] = {
0, 1, 2, 0, 2, 3, // floor
4, 5, 6, 4, 6, 7, // ceiling
8, 9, 10, 8, 10, 11, // back
12, 13, 14, 12, 14, 15, // front
16, 17, 18, 16, 18, 19, // left
20, 21, 22, 20, 22, 23 // right
};
room_index_count = 36;
glGenVertexArrays(1, &room_vao);
glBindVertexArray(room_vao);
glGenBuffers(1, &room_vbo);
glBindBuffer(GL_ARRAY_BUFFER, room_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glGenBuffers(1, &room_ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, room_ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);
// layout 和 panel 一样：
// location 0: position
// location 1: normal
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(3 * sizeof(float)));
glBindVertexArray(0);
}
void init_panel_geometry() {
// 面板盒子：VAO+VBO+IBO，包含顶面/底面/侧面 6 个面
if (panel_ibo) {
glDeleteBuffers(1, &panel_ibo);
panel_ibo = 0;
@@ -110,65 +329,59 @@ void init_panel_geometry() {
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 {
const float y = g_state.panelH * 0.5f;
const float hw = g_state.panelW * 0.5f;
const float hd = g_state.panelD * 0.5f;
struct V {
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
{-hw, +y, -hd, 0, +1, 0},
{+hw, +y, -hd, 0, +1, 0},
{+hw, +y, +hd, 0, +1, 0},
{-hw, +y, +hd, 0, +1, 0},
{-hw, +y, +hd, 0, 0, +1},
{+hw, +y, +hd, 0, 0, +1},
{+hw, -y, +hd, 0, 0, +1},
{-hw, -y, +hd, 0, 0, +1},
{-hw, -y, +hd, 0, -1, 0},
{+hw, -y, +hd, 0, -1, 0},
{+hw, -y, -hd, 0, -1, 0},
{-hw, -y, -hd, 0, -1, 0},
{+hw, +y, -hd, 0, 0, -1},
{-hw, +y, -hd, 0, 0, -1},
{-hw, -y, -hd, 0, 0, -1},
{+hw, -y, -hd, 0, 0, -1},
{-hw, +y, -hd, -1, 0, 0},
{-hw, +y, +hd, -1, 0, 0},
{-hw, -y, +hd, -1, 0, 0},
{-hw, -y, -hd, -1, 0, 0},
{+hw, +y, +hd, +1, 0, 0},
{+hw, +y, -hd, +1, 0, 0},
{+hw, -y, -hd, +1, 0, 0},
{+hw, -y, +hd, +1, 0, 0},
};
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
0, 1, 2, 0, 2, 3,
4, 5, 6, 4, 6, 7,
8, 9, 10, 8, 10, 11,
12, 13, 14, 12, 14, 15,
16, 17, 18, 16, 18, 19,
20, 21, 22, 20, 22, 23
};
int panel_index_count = 36;
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);
@@ -176,28 +389,386 @@ void init_panel_geometry() {
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)));
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 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 init_dot_geometry() {
// 圆点：基于一个单位 quad，使用 instanced attributes 传位置/值
if (instance_vbo) {
glDeleteBuffers(1, &instance_vbo);
instance_vbo = 0;
}
if (dots_vbo) {
glDeleteBuffers(1, &dots_vbo);
dots_vbo = 0;
}
if (dots_vao) {
glDeleteVertexArrays(1, &dots_vao);
dots_vao = 0;
}
struct V {
float x, y;
float u, v;
};
V quad[6] = {
{-1, -1, 0, 0},
{ 1, -1, 1, 0},
{ 1, 1, 1, 1},
{-1, -1, 0, 0},
{ 1, 1, 1, 1},
{-1, 1, 0, 1},
};
glGenVertexArrays(1, &dots_vao);
glBindVertexArray(dots_vao);
glGenBuffers(1, &dots_vbo);
glBindBuffer(GL_ARRAY_BUFFER, dots_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(2 * sizeof(float)));
glGenBuffers(1, &instance_vbo);
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * std::max(1, dot_count()), nullptr, GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glVertexAttribDivisor(2, 1);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)(2 * sizeof(float)));
glVertexAttribDivisor(3, 1);
glBindVertexArray(0);
}
// void init_dot_texture() {
// // 简单 4x4 RGBA 程序化纹理，模拟金属纹理感
// if (dot_tex) {
// glDeleteTextures(1, &dot_tex);
// dot_tex = 0;
// }
// // Simple procedural 4x4 texture to mimic a brushed metal feel.
// const unsigned char pixels[] = {
// 180, 175, 170, 255, 185, 180, 175, 255, 190, 185, 180, 255, 185, 180, 175, 255,
// 185, 180, 175, 255, 190, 185, 180, 255, 195, 190, 185, 255, 190, 185, 180, 255,
// 190, 185, 180, 255, 195, 190, 185, 255, 200, 195, 190, 255, 195, 190, 185, 255,
// 185, 180, 175, 255, 190, 185, 180, 255, 195, 190, 185, 255, 190, 185, 180, 255,
// };
// glGenTextures(1, &dot_tex);
// glBindTexture(GL_TEXTURE_2D, dot_tex);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_LINEAR_MIPMAP_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_LINEAR_MIPMAP_LINEGL_LINEARAR);
// glPixelStorei(GL_UNPACK_ALIGNMENT, 1GL_LINEARGL_CLAMP_TO_EDGE glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 40, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// glGenerateMipmap(GL_TEXTURE_GL_CLAMP_TO_EDGE2D
// glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// glBindTexture(GL_TEXTURE_2D, 0);
// }
void init_programs() {
// 加载并编译 shader program
const std::string vsd_path = "../shaders/dots.vert";
const std::string fsd_path = "../shaders/dots.frag";
glBindTexture(GL_TEXTURE_2D, 0);
const std::string vsb_path = "../shaders/bg.vert";
const std::string fsb_path = "../shaders/bg.frag";
const std::string vsr_path = "../shaders/room.vert";
const std::string fsr_path = "../shaders/room.frag";
const std::string vsp_path = "../shaders/panel.vert";
const std::string fsp_path = "../shaders/panel.frag";
bg_shader = new Shader(vsb_path.c_str(), fsb_path.c_str());
room_shader = new Shader(vsr_path.c_str(), fsr_path.c_str());
dots_shader = new Shader(vsd_path.c_str(), fsd_path.c_str());
panel_shader = new Shader(vsp_path.c_str(), fsp_path.c_str());
}
void update_instance_buffer_if_needed() {
// 如果有新数据，重新填充实例缓冲：每个点 3 个 float (x,z,value)
if (dot_count() <= 0) {
instance_count = 0;
return;
}
if (!g_state.valuesDirty)
return;
const int n = dot_count();
instance_count = n;
std::vector<float> inst;
inst.resize(n * 3);
const float w = static_cast<float>(std::max(0, g_state.cols - 1)) * g_state.pitch;
const float h = static_cast<float>(std::max(0, g_state.rows - 1)) * g_state.pitch;
for (int i = 0; i < n; ++i) {
const int r = (g_state.cols > 0) ? (i / g_state.cols) : 0;
const int c = (g_state.cols > 0) ? (i % g_state.cols) : 0;
const float x = (static_cast<float>(c) * g_state.pitch) - w * 0.5f;
const float y = (static_cast<float>(r) * g_state.pitch) - h * 0.5f;
inst[i * 3 + 0] = x;
inst[i * 3 + 1] = y;
inst[i * 3 + 2] = (i < static_cast<int>(g_state.values.size())) ? g_state.values[i] : static_cast<float>(g_state.minV);
}
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, inst.size() * sizeof(float), inst.data());
g_state.valuesDirty = false;
}
void update_matrices(int fbWidth, int fbHeight) {
// 计算 MVP：透视投影 * 观察（环绕相机）* 单位模型
if (fbWidth <= 0 || fbHeight <= 0) {
g_state.mvp = glm::mat4(1.0f);
return;
}
const float aspect = static_cast<float>(fbWidth) / static_cast<float>(fbHeight);
const float radius = 0.5f * std::sqrt(g_state.panelW * g_state.panelW + g_state.panelD * g_state.panelD);
const float distance = std::max(0.5f, radius * 2.5f);
// 目标点：面板中心
const glm::vec3 center(0.0f, 0.0f, g_state.panelD*0.5f);
const float yawRad = glm::radians(g_state.camYaw);
const float pitchRad = glm::radians(g_state.camPitch);
const float cosPitch = std::cos(pitchRad);
const glm::vec3 eye = center + glm::vec3(
distance * cosPitch * std::cos(yawRad),
distance * std::sin(pitchRad),
distance * cosPitch * std::sin(yawRad)
);
g_state.cameraPos = eye;
// 构建视图矩阵与透视矩阵
const glm::mat4 view = glm::lookAt(eye, center, glm::vec3(0.0f, 1.0f, 0.0f));
const glm::mat4 proj = glm::perspective(glm::radians(g_state.zoom), aspect, 0.01f, std::max(10.0f, distance * 10.0f));
g_state.mvp = proj * view;
}
void render_background(int fbWidth, int fbHeight) {
// 屏幕空间网格，不受相机旋转影响
if (!bg_shader || !bg_vao) return;
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
bg_shader->use();
bg_shader->setVec2("uViewport", glm::vec2(static_cast<float>(fbWidth), static_cast<float>(fbHeight)));
bg_shader->setFloat("uMinorStep", 24.0f);
bg_shader->setFloat("uMajorStep", 120.0f);
glBindVertexArray(bg_vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
}
void render_room() {
// 3D 房间背景：用一个大盒子把场景包起来（相当于“屋子墙壁/地面”）
if (!room_shader || !room_vao)
return;
// 房间尺寸：根据面板尺寸做一个“够大”的包围盒（单位：世界坐标）
const float base = std::max({g_state.panelW, g_state.panelH, g_state.panelD});
const glm::vec3 roomHalfSize(
std::max(1.0f, base * 1.1f), // X: 左右墙离中心的距离
std::max(1.0f, base * 1.1f), // Y: 地面/天花板离中心的距离
std::max(1.0f, base * 1.1f) // Z: 前后墙离中心的距离
);
// 网格尺寸（让房间更有空间感）
const float minorStep = std::max(0.05f, base * 0.25f);
const float majorStep = minorStep * 5.0f;
room_shader->use();
room_shader->setMat4("uMVP", g_state.mvp);
room_shader->setVec3("uCameraPos", g_state.cameraPos);
room_shader->setVec3("uRoomHalfSize", roomHalfSize);
room_shader->setFloat("uMinorStep", minorStep);
room_shader->setFloat("uMajorStep", majorStep);
room_shader->setInt("uRenderMode", g_state.renderMode);
glBindVertexArray(room_vao);
glDrawElements(GL_TRIANGLES, room_index_count, GL_UNSIGNED_INT, nullptr);
glBindVertexArray(0);
}
void render_panel() {
// 绘制面板盒子
if (!panel_shader || !panel_vao) return;
panel_shader->use();
panel_shader->setMat4("uMVP", g_state.mvp);
panel_shader->setVec3("uCameraPos", g_state.cameraPos);
panel_shader->setFloat("uPanelW", g_state.panelW);
panel_shader->setFloat("uPanelH", g_state.panelH);
panel_shader->setFloat("uPanelD", g_state.panelD);
panel_shader->setInt("uRows", g_state.rows);
panel_shader->setInt("uCols", g_state.cols);
panel_shader->setFloat("uPitch", g_state.pitch);
panel_shader->setFloat("uDotRadius", g_state.dotRadius);
panel_shader->setInt("uRenderMode", g_state.renderMode);
glBindVertexArray(panel_vao);
glDrawElements(GL_TRIANGLES, panel_index_count, GL_UNSIGNED_INT, nullptr);
glBindVertexArray(0);
}
void render_dots() {
// 实例化绘制圆点
if (!dots_shader || !dots_vao || instance_count <= 0) return;
dots_shader->use();
dots_shader->setMat4("uMVP", g_state.mvp);
dots_shader->setInt("uRenderMode", g_state.renderMode);
dots_shader->setFloat("uDotRadius", g_state.dotRadius);
dots_shader->setFloat("uBaseZ", -(g_state.panelD * 0.5f) - 0.001f);
dots_shader->setFloat("uMinV", static_cast<float>(g_state.minV));
dots_shader->setFloat("uMaxV", static_cast<float>(g_state.maxV));
dots_shader->setInt("uHasData", 1);
dots_shader->setVec3("uCameraPos", g_state.cameraPos);
dots_shader->setInt("uDotTex", 0);
if (dot_tex) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, dot_tex);
}
glBindVertexArray(dots_vao);
glDrawArraysInstanced(GL_TRIANGLES, 0, 6, instance_count);
glBindVertexArray(0);
if (dot_tex) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
}
}
void update_demo_values(float t) {
// 生成演示用波纹数据，保持实例缓冲在动
const int n = dot_count();
if (n <= 0) {
instance_count = 0;
return;
}
if (static_cast<int>(g_state.values.size()) != n) {
g_state.values.assign(n, static_cast<float>(g_state.minV));
}
for (int i = 0; i < n; ++i) {
const float phase = t * 0.6f + static_cast<float>(i) * 0.35f;
const float wave = 0.5f + 0.5f * std::sin(phase);
const float minV = static_cast<float>(g_state.minV);
const float maxV = static_cast<float>(g_state.maxV);
g_state.values[i] = minV + (maxV - minV) * wave;
}
g_state.valuesDirty = true;
}
void destroy_context() {
delete bg_shader;
delete room_shader;
delete panel_shader;
delete dots_shader;
if (room_vao) glDeleteVertexArrays(1, &room_vao);
if (room_vbo) glDeleteBuffers(1, &room_vbo);
if (room_ibo) glDeleteBuffers(1, &room_ibo);
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);
if (instance_vbo) glDeleteBuffers(1, &instance_vbo);
if (bg_vao) glDeleteVertexArrays(1, &bg_vao);
if (bg_vbo) glDeleteBuffers(1, &bg_vbo);
if (dot_tex) glDeleteTextures(1, &dot_tex);
}
void load_metal_texture(const std::string& path) {
if (metal_tex) {
glDeleteTextures(1, &metal_tex);
metal_tex = 0;
}
glGenTextures(1, &metal_tex);
glBindTexture(GL_TEXTURE_2D, metal_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
int width, height, channels;
unsigned char* data = stbi_load(path.c_str(), &width, &height, &channels, 0);
if (data) {
std::cout << "load texture image path: " << path << std::endl;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
}
stbi_image_free(data);
}
void set_spec(int rows, int cols, float pitch);
int main() {
// 初始化窗口/上下文
GLFWwindow* window = glfw_init();
if (window == NULL) {
if (window == nullptr) {
return -1;
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glfw_window_loop(window);
// 初始化规格与资源
set_spec(8, 10, 0.025f, 0.008f);
init_programs();
// init_dot_texture();
init_room_geometry();
load_metal_texture("../images/metal.jpeg");
while (!glfwWindowShouldClose(window)) {
const float currentFrame = static_cast<float>(glfwGetTime());
process_input(window);
int fbWidth = 0, fbHeight = 0;
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
glViewport(0, 0, fbWidth, fbHeight);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (panel_geometry_dirty) {
init_panel_geometry();
panel_geometry_dirty = false;
}
if (dot_geometry_dirty) {
init_dot_geometry();
dot_geometry_dirty = false;
g_state.valuesDirty = true;
}
update_matrices(fbWidth, fbHeight);
update_demo_values(currentFrame);
update_instance_buffer_if_needed();
render_room();
render_panel();
render_dots();
glfwSwapBuffers(window);
glfwPollEvents();
}
destroy_context();
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}