1306 lines
43 KiB
C++
1306 lines
43 KiB
C++
// GLFW 版本的渲染入口：画触觉面板盒子 + 点阵实例化圆点，
|
||
// 右键拖拽环绕相机，滚轮调 FOV，内置简单波纹数据做演示。
|
||
#include <glad/glad.h>
|
||
#include <GLFW/glfw3.h>
|
||
|
||
#include <algorithm>
|
||
#include <cmath>
|
||
#include <glm/glm.hpp>
|
||
#include <glm/gtc/matrix_transform.hpp>
|
||
#include <iostream>
|
||
#include <vector>
|
||
|
||
#include "myshader.hh"
|
||
#include "stb_image_wrap.h"
|
||
|
||
|
||
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 = 500;
|
||
// 渲染模式：0=有光照，1=无光照（flat/unlit）
|
||
int renderMode = 1;
|
||
|
||
// 相机状态（环绕）
|
||
float camYaw = -90.0f;
|
||
float camPitch = 0.0f;
|
||
float zoom = 45.0f;
|
||
bool rightDown = false;
|
||
double lastMouseX = 0.0;
|
||
double lastMouseY = 0.0;
|
||
|
||
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* base_shader = nullptr;
|
||
Shader* room_shader = nullptr;
|
||
Shader* panel_shader = nullptr;
|
||
Shader* dots_shader = nullptr;
|
||
Shader* heatmap_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;
|
||
|
||
unsigned int metal_tex = 0;
|
||
bool panel_geometry_dirty = true;
|
||
bool dot_geometry_dirty = true;
|
||
|
||
unsigned int base_vao = 0;
|
||
unsigned int base_vbo = 0;
|
||
unsigned int base_ibo = 0;
|
||
int base_index_count = 0;
|
||
|
||
unsigned int skirt_vao = 0;
|
||
unsigned int skirt_vbo = 0;
|
||
unsigned int skirt_ibo = 0;
|
||
int skirt_index_count = 0;
|
||
|
||
unsigned int heatmap_vao = 0;
|
||
unsigned int heatmap_vbo = 0;
|
||
unsigned int heatmap_ibo = 0;
|
||
int heatmap_index_count = 0;
|
||
|
||
unsigned int height_tex = 0;
|
||
|
||
constexpr int kLowRows = 7;
|
||
constexpr int kLowCols = 12;
|
||
constexpr int kHeightW = 1200;
|
||
constexpr int kHeightH = 700;
|
||
constexpr int kMeshCols = 240;
|
||
constexpr int kMeshRows = 140;
|
||
constexpr float kPlaneW = 1.2f;
|
||
constexpr float kPlaneH = 0.7f;
|
||
constexpr float kThickness = 0.12f;
|
||
constexpr float kDentMax = 0.08f;
|
||
|
||
std::vector<float> low_values;
|
||
std::vector<float> height_values;
|
||
bool height_dirty = true;
|
||
|
||
std::vector<glm::vec2> skirt_uvs;
|
||
std::vector<glm::vec3> skirt_normals;
|
||
std::vector<float> skirt_vertices;
|
||
|
||
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, -89.0f, 89.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);
|
||
}
|
||
}
|
||
|
||
GLFWwindow* glfw_init() {
|
||
// 初始化 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 (GLFW)",
|
||
nullptr, nullptr);
|
||
if (window == nullptr) {
|
||
std::cerr << "Failed to create GLFW window" << std::endl;
|
||
glfwTerminate();
|
||
return nullptr;
|
||
}
|
||
glfwMakeContextCurrent(window);
|
||
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
|
||
std::cerr << "Failed to initialize GLAD" << std::endl;
|
||
glfwDestroyWindow(window);
|
||
glfwTerminate();
|
||
return nullptr;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
int dot_count() {
|
||
// 当前点阵总数
|
||
return g_state.rows * g_state.cols;
|
||
}
|
||
|
||
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 (bg_vao) {
|
||
glDeleteVertexArrays(1, &bg_vao);
|
||
bg_vao = 0;
|
||
}
|
||
|
||
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 (room_vbo) {
|
||
glDeleteBuffers(1, &room_vbo);
|
||
room_vbo = 0;
|
||
}
|
||
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;
|
||
}
|
||
if (panel_vbo) {
|
||
glDeleteBuffers(1, &panel_vbo);
|
||
panel_vbo = 0;
|
||
}
|
||
if (panel_vao) {
|
||
glDeleteVertexArrays(1, &panel_vao);
|
||
panel_vao = 0;
|
||
}
|
||
|
||
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] = {
|
||
{-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, 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};
|
||
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_FALSE, sizeof(V),
|
||
(void*)(3 * sizeof(float)));
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
float lerp_float(float a, float b, float t) { return a + (b - a) * t; }
|
||
|
||
float gaussian2d(float dx, float dy, float sigma) {
|
||
const float s = std::max(1e-6f, sigma);
|
||
const float inv = 1.0f / (2.0f * s * s);
|
||
return std::exp(-(dx * dx + dy * dy) * inv);
|
||
}
|
||
|
||
float sample_height_value(float u, float v) {
|
||
if (height_values.empty()) {
|
||
return static_cast<float>(g_state.minV);
|
||
}
|
||
const float x = std::clamp(u, 0.0f, 1.0f) * static_cast<float>(kHeightW - 1);
|
||
const float y = std::clamp(v, 0.0f, 1.0f) * static_cast<float>(kHeightH - 1);
|
||
const int x0 = std::clamp(static_cast<int>(std::floor(x)), 0, kHeightW - 1);
|
||
const int y0 = std::clamp(static_cast<int>(std::floor(y)), 0, kHeightH - 1);
|
||
const int x1 = std::min(x0 + 1, kHeightW - 1);
|
||
const int y1 = std::min(y0 + 1, kHeightH - 1);
|
||
const float fx = x - static_cast<float>(x0);
|
||
const float fy = y - static_cast<float>(y0);
|
||
|
||
const float v00 = height_values[static_cast<size_t>(y0) * static_cast<size_t>(kHeightW) + static_cast<size_t>(x0)];
|
||
const float v10 = height_values[static_cast<size_t>(y0) * static_cast<size_t>(kHeightW) + static_cast<size_t>(x1)];
|
||
const float v01 = height_values[static_cast<size_t>(y1) * static_cast<size_t>(kHeightW) + static_cast<size_t>(x0)];
|
||
const float v11 = height_values[static_cast<size_t>(y1) * static_cast<size_t>(kHeightW) + static_cast<size_t>(x1)];
|
||
|
||
const float vx0 = lerp_float(v00, v10, fx);
|
||
const float vx1 = lerp_float(v01, v11, fx);
|
||
return lerp_float(vx0, vx1, fy);
|
||
}
|
||
|
||
void init_base_geometry() {
|
||
if (base_ibo) {
|
||
glDeleteBuffers(1, &base_ibo);
|
||
base_ibo = 0;
|
||
}
|
||
if (base_vbo) {
|
||
glDeleteBuffers(1, &base_vbo);
|
||
base_vbo = 0;
|
||
}
|
||
if (base_vao) {
|
||
glDeleteVertexArrays(1, &base_vao);
|
||
base_vao = 0;
|
||
}
|
||
|
||
const float hw = kPlaneW * 0.5f;
|
||
const float hh = kPlaneH * 0.5f;
|
||
const float hz = kThickness * 0.5f;
|
||
|
||
struct V {
|
||
float x, y, z;
|
||
float nx, ny, nz;
|
||
};
|
||
|
||
V verts[24] = {
|
||
{-hw, -hh, +hz, 0, 0, +1}, {+hw, -hh, +hz, 0, 0, +1},
|
||
{+hw, +hh, +hz, 0, 0, +1}, {-hw, +hh, +hz, 0, 0, +1},
|
||
|
||
{+hw, -hh, -hz, 0, 0, -1}, {-hw, -hh, -hz, 0, 0, -1},
|
||
{-hw, +hh, -hz, 0, 0, -1}, {+hw, +hh, -hz, 0, 0, -1},
|
||
|
||
{-hw, -hh, -hz, -1, 0, 0}, {-hw, -hh, +hz, -1, 0, 0},
|
||
{-hw, +hh, +hz, -1, 0, 0}, {-hw, +hh, -hz, -1, 0, 0},
|
||
|
||
{+hw, -hh, +hz, +1, 0, 0}, {+hw, -hh, -hz, +1, 0, 0},
|
||
{+hw, +hh, -hz, +1, 0, 0}, {+hw, +hh, +hz, +1, 0, 0},
|
||
|
||
{-hw, +hh, +hz, 0, +1, 0}, {+hw, +hh, +hz, 0, +1, 0},
|
||
{+hw, +hh, -hz, 0, +1, 0}, {-hw, +hh, -hz, 0, +1, 0},
|
||
|
||
{-hw, -hh, -hz, 0, -1, 0}, {+hw, -hh, -hz, 0, -1, 0},
|
||
{+hw, -hh, +hz, 0, -1, 0}, {-hw, -hh, +hz, 0, -1, 0},
|
||
};
|
||
|
||
unsigned int idx[6] = {0, 1, 2, 0, 2, 3};
|
||
base_index_count = 6;
|
||
|
||
glGenVertexArrays(1, &base_vao);
|
||
glBindVertexArray(base_vao);
|
||
|
||
glGenBuffers(1, &base_vbo);
|
||
glBindBuffer(GL_ARRAY_BUFFER, base_vbo);
|
||
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
|
||
|
||
glGenBuffers(1, &base_ibo);
|
||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, base_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_FALSE, sizeof(V),
|
||
(void*)(3 * sizeof(float)));
|
||
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
void init_skirt_geometry() {
|
||
if (skirt_ibo) {
|
||
glDeleteBuffers(1, &skirt_ibo);
|
||
skirt_ibo = 0;
|
||
}
|
||
if (skirt_vbo) {
|
||
glDeleteBuffers(1, &skirt_vbo);
|
||
skirt_vbo = 0;
|
||
}
|
||
if (skirt_vao) {
|
||
glDeleteVertexArrays(1, &skirt_vao);
|
||
skirt_vao = 0;
|
||
}
|
||
|
||
skirt_uvs.clear();
|
||
skirt_normals.clear();
|
||
|
||
const int cols = std::max(2, kMeshCols);
|
||
const int rows = std::max(2, kMeshRows);
|
||
|
||
auto push_border = [&](int c, int r, const glm::vec3& n) {
|
||
const float u = (cols > 1) ? static_cast<float>(c) / static_cast<float>(cols - 1) : 0.0f;
|
||
const float v = (rows > 1) ? static_cast<float>(r) / static_cast<float>(rows - 1) : 0.0f;
|
||
skirt_uvs.emplace_back(u, v);
|
||
skirt_normals.emplace_back(n);
|
||
};
|
||
|
||
for (int c = 0; c < cols; ++c) {
|
||
push_border(c, 0, glm::vec3(0.0f, -1.0f, 0.0f));
|
||
}
|
||
for (int r = 1; r < rows - 1; ++r) {
|
||
push_border(cols - 1, r, glm::vec3(1.0f, 0.0f, 0.0f));
|
||
}
|
||
for (int c = cols - 1; c >= 0; --c) {
|
||
push_border(c, rows - 1, glm::vec3(0.0f, 1.0f, 0.0f));
|
||
}
|
||
for (int r = rows - 2; r >= 1; --r) {
|
||
push_border(0, r, glm::vec3(-1.0f, 0.0f, 0.0f));
|
||
}
|
||
|
||
const int border_count = static_cast<int>(skirt_uvs.size());
|
||
skirt_vertices.assign(static_cast<size_t>(border_count) * 2 * 6, 0.0f);
|
||
|
||
std::vector<unsigned int> idx;
|
||
idx.reserve(static_cast<size_t>(border_count) * 6);
|
||
for (int i = 0; i < border_count; ++i) {
|
||
const int next = (i + 1) % border_count;
|
||
const unsigned int top0 = static_cast<unsigned int>(i * 2);
|
||
const unsigned int bot0 = static_cast<unsigned int>(i * 2 + 1);
|
||
const unsigned int top1 = static_cast<unsigned int>(next * 2);
|
||
const unsigned int bot1 = static_cast<unsigned int>(next * 2 + 1);
|
||
|
||
idx.push_back(top0);
|
||
idx.push_back(top1);
|
||
idx.push_back(bot1);
|
||
idx.push_back(top0);
|
||
idx.push_back(bot1);
|
||
idx.push_back(bot0);
|
||
}
|
||
skirt_index_count = static_cast<int>(idx.size());
|
||
|
||
glGenVertexArrays(1, &skirt_vao);
|
||
glBindVertexArray(skirt_vao);
|
||
|
||
glGenBuffers(1, &skirt_vbo);
|
||
glBindBuffer(GL_ARRAY_BUFFER, skirt_vbo);
|
||
glBufferData(GL_ARRAY_BUFFER, skirt_vertices.size() * sizeof(float), skirt_vertices.data(), GL_DYNAMIC_DRAW);
|
||
|
||
glGenBuffers(1, &skirt_ibo);
|
||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, skirt_ibo);
|
||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx.size() * sizeof(unsigned int), idx.data(), GL_STATIC_DRAW);
|
||
|
||
glEnableVertexAttribArray(0);
|
||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
|
||
glEnableVertexAttribArray(1);
|
||
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
|
||
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
void init_heatmap_geometry() {
|
||
if (heatmap_ibo) {
|
||
glDeleteBuffers(1, &heatmap_ibo);
|
||
heatmap_ibo = 0;
|
||
}
|
||
if (heatmap_vbo) {
|
||
glDeleteBuffers(1, &heatmap_vbo);
|
||
heatmap_vbo = 0;
|
||
}
|
||
if (heatmap_vao) {
|
||
glDeleteVertexArrays(1, &heatmap_vao);
|
||
heatmap_vao = 0;
|
||
}
|
||
|
||
const int cols = std::max(2, kMeshCols);
|
||
const int rows = std::max(2, kMeshRows);
|
||
const int vertex_count = cols * rows;
|
||
std::vector<float> verts;
|
||
verts.reserve(vertex_count * 5);
|
||
|
||
for (int r = 0; r < rows; ++r) {
|
||
const float v = (rows > 1)
|
||
? static_cast<float>(r) / static_cast<float>(rows - 1)
|
||
: 0.0f;
|
||
const float y = (v - 0.5f) * kPlaneH;
|
||
for (int c = 0; c < cols; ++c) {
|
||
const float u = (cols > 1)
|
||
? static_cast<float>(c) / static_cast<float>(cols - 1)
|
||
: 0.0f;
|
||
const float x = (u - 0.5f) * kPlaneW;
|
||
verts.push_back(x);
|
||
verts.push_back(y);
|
||
verts.push_back(0.0f);
|
||
verts.push_back(u);
|
||
verts.push_back(v);
|
||
}
|
||
}
|
||
|
||
std::vector<unsigned int> idx;
|
||
idx.reserve((cols - 1) * (rows - 1) * 6);
|
||
for (int r = 0; r < rows - 1; ++r) {
|
||
for (int c = 0; c < cols - 1; ++c) {
|
||
const unsigned int i0 = static_cast<unsigned int>(r * cols + c);
|
||
const unsigned int i1 = static_cast<unsigned int>(r * cols + c + 1);
|
||
const unsigned int i2 = static_cast<unsigned int>((r + 1) * cols + c + 1);
|
||
const unsigned int i3 = static_cast<unsigned int>((r + 1) * cols + c);
|
||
idx.push_back(i0);
|
||
idx.push_back(i1);
|
||
idx.push_back(i2);
|
||
idx.push_back(i0);
|
||
idx.push_back(i2);
|
||
idx.push_back(i3);
|
||
}
|
||
}
|
||
heatmap_index_count = static_cast<int>(idx.size());
|
||
|
||
glGenVertexArrays(1, &heatmap_vao);
|
||
glBindVertexArray(heatmap_vao);
|
||
|
||
glGenBuffers(1, &heatmap_vbo);
|
||
glBindBuffer(GL_ARRAY_BUFFER, heatmap_vbo);
|
||
glBufferData(GL_ARRAY_BUFFER, verts.size() * sizeof(float), verts.data(),
|
||
GL_STATIC_DRAW);
|
||
|
||
glGenBuffers(1, &heatmap_ibo);
|
||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, heatmap_ibo);
|
||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx.size() * sizeof(unsigned int),
|
||
idx.data(), GL_STATIC_DRAW);
|
||
|
||
glEnableVertexAttribArray(0);
|
||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
|
||
glEnableVertexAttribArray(1);
|
||
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
|
||
(void*)(3 * sizeof(float)));
|
||
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
void init_height_texture() {
|
||
if (height_tex) {
|
||
glDeleteTextures(1, &height_tex);
|
||
height_tex = 0;
|
||
}
|
||
if (height_values.size() !=
|
||
static_cast<size_t>(kHeightW) * static_cast<size_t>(kHeightH)) {
|
||
height_values.assign(
|
||
static_cast<size_t>(kHeightW) * static_cast<size_t>(kHeightH), 0.0f);
|
||
}
|
||
|
||
glGenTextures(1, &height_tex);
|
||
glBindTexture(GL_TEXTURE_2D, height_tex);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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);
|
||
glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, kHeightW, kHeightH, 0, GL_RED,
|
||
GL_FLOAT, height_values.data());
|
||
glBindTexture(GL_TEXTURE_2D, 0);
|
||
}
|
||
|
||
void update_skirt_vertices() {
|
||
if (skirt_vertices.empty() || skirt_uvs.empty()) {
|
||
return;
|
||
}
|
||
const float baseZ = -kThickness * 0.5f;
|
||
const float backZ = baseZ + kThickness;
|
||
const float minV = static_cast<float>(g_state.minV);
|
||
const float maxV = static_cast<float>(g_state.maxV);
|
||
const float invRange = 1.0f / std::max(1e-6f, (maxV - minV));
|
||
|
||
const int border_count = static_cast<int>(skirt_uvs.size());
|
||
for (int i = 0; i < border_count; ++i) {
|
||
const float u = skirt_uvs[i].x;
|
||
const float v = skirt_uvs[i].y;
|
||
const float value = sample_height_value(u, v);
|
||
const float t = std::clamp((value - minV) * invRange, 0.0f, 1.0f);
|
||
const float h = t * kDentMax;
|
||
|
||
const float x = (u - 0.5f) * kPlaneW;
|
||
const float y = (v - 0.5f) * kPlaneH;
|
||
const glm::vec3 n = skirt_normals[i];
|
||
|
||
const int topIndex = i * 2;
|
||
const int botIndex = i * 2 + 1;
|
||
|
||
const size_t topBase = static_cast<size_t>(topIndex) * 6;
|
||
skirt_vertices[topBase + 0] = x;
|
||
skirt_vertices[topBase + 1] = y;
|
||
skirt_vertices[topBase + 2] = baseZ + h;
|
||
skirt_vertices[topBase + 3] = n.x;
|
||
skirt_vertices[topBase + 4] = n.y;
|
||
skirt_vertices[topBase + 5] = n.z;
|
||
|
||
const size_t botBase = static_cast<size_t>(botIndex) * 6;
|
||
skirt_vertices[botBase + 0] = x;
|
||
skirt_vertices[botBase + 1] = y;
|
||
skirt_vertices[botBase + 2] = backZ;
|
||
skirt_vertices[botBase + 3] = n.x;
|
||
skirt_vertices[botBase + 4] = n.y;
|
||
skirt_vertices[botBase + 5] = n.z;
|
||
}
|
||
|
||
glBindBuffer(GL_ARRAY_BUFFER, skirt_vbo);
|
||
glBufferSubData(GL_ARRAY_BUFFER, 0, skirt_vertices.size() * sizeof(float), skirt_vertices.data());
|
||
}
|
||
|
||
void update_demo_heightmap(float t) {
|
||
if (low_values.size() !=
|
||
static_cast<size_t>(kLowRows) * static_cast<size_t>(kLowCols)) {
|
||
low_values.assign(
|
||
static_cast<size_t>(kLowRows) * static_cast<size_t>(kLowCols), 0.0f);
|
||
}
|
||
if (height_values.size() !=
|
||
static_cast<size_t>(kHeightW) * static_cast<size_t>(kHeightH)) {
|
||
height_values.assign(
|
||
static_cast<size_t>(kHeightW) * static_cast<size_t>(kHeightH), 0.0f);
|
||
}
|
||
|
||
const float minV = static_cast<float>(g_state.minV);
|
||
const float maxV = static_cast<float>(g_state.maxV);
|
||
const float range = std::max(1.0f, maxV - minV);
|
||
|
||
const float t1 = t * 0.25f;
|
||
const float t2 = t * 0.18f;
|
||
const float t3 = t * 0.12f;
|
||
|
||
const float cx1 = 0.30f + 0.12f * std::sin(t1);
|
||
const float cy1 = 0.50f + 0.10f * std::cos(t1 * 0.9f);
|
||
const float cx2 = 0.72f + 0.10f * std::cos(t2 * 1.1f);
|
||
const float cy2 = 0.36f + 0.10f * std::sin(t2 * 0.8f);
|
||
const float cx3 = 0.50f + 0.05f * std::sin(t3);
|
||
const float cy3 = 0.72f + 0.05f * std::cos(t3 * 1.2f);
|
||
|
||
const float a1 = 0.70f + 0.15f * std::sin(t * 0.20f);
|
||
const float a2 = 0.55f + 0.20f * std::cos(t * 0.16f);
|
||
const float a3 = 0.25f + 0.10f * std::sin(t * 0.13f);
|
||
|
||
const float s1 = 0.18f;
|
||
const float s2 = 0.12f;
|
||
const float s3 = 0.10f;
|
||
|
||
for (int r = 0; r < kLowRows; ++r) {
|
||
const float v = (kLowRows > 1) ? static_cast<float>(r) /
|
||
static_cast<float>(kLowRows - 1)
|
||
: 0.0f;
|
||
for (int c = 0; c < kLowCols; ++c) {
|
||
const float u = (kLowCols > 1) ? static_cast<float>(c) /
|
||
static_cast<float>(kLowCols - 1)
|
||
: 0.0f;
|
||
const float g1 = gaussian2d(u - cx1, v - cy1, s1);
|
||
const float g2 = gaussian2d(u - cx2, v - cy2, s2);
|
||
const float g3 = gaussian2d(u - cx3, v - cy3, s3);
|
||
float value01 = 0.05f + a1 * g1 + a2 * g2 + a3 * g3;
|
||
value01 = std::clamp(value01, 0.0f, 1.0f);
|
||
low_values[static_cast<size_t>(r) * static_cast<size_t>(kLowCols) +
|
||
static_cast<size_t>(c)] = minV + range * value01;
|
||
}
|
||
}
|
||
|
||
const float invHighW =
|
||
(kHeightW > 1) ? (1.0f / static_cast<float>(kHeightW - 1)) : 0.0f;
|
||
const float invHighH =
|
||
(kHeightH > 1) ? (1.0f / static_cast<float>(kHeightH - 1)) : 0.0f;
|
||
const float lowW = static_cast<float>(kLowCols - 1);
|
||
const float lowH = static_cast<float>(kLowRows - 1);
|
||
|
||
for (int y = 0; y < kHeightH; ++y) {
|
||
const float gy = static_cast<float>(y) * invHighH * lowH;
|
||
const int y0 = std::clamp(static_cast<int>(gy), 0, kLowRows - 1);
|
||
const int y1 = std::min(y0 + 1, kLowRows - 1);
|
||
const float fy = gy - static_cast<float>(y0);
|
||
for (int x = 0; x < kHeightW; ++x) {
|
||
const float gx = static_cast<float>(x) * invHighW * lowW;
|
||
const int x0 = std::clamp(static_cast<int>(gx), 0, kLowCols - 1);
|
||
const int x1 = std::min(x0 + 1, kLowCols - 1);
|
||
const float fx = gx - static_cast<float>(x0);
|
||
|
||
const float v00 =
|
||
low_values[static_cast<size_t>(y0) * static_cast<size_t>(kLowCols) +
|
||
static_cast<size_t>(x0)];
|
||
const float v10 =
|
||
low_values[static_cast<size_t>(y0) * static_cast<size_t>(kLowCols) +
|
||
static_cast<size_t>(x1)];
|
||
const float v01 =
|
||
low_values[static_cast<size_t>(y1) * static_cast<size_t>(kLowCols) +
|
||
static_cast<size_t>(x0)];
|
||
const float v11 =
|
||
low_values[static_cast<size_t>(y1) * static_cast<size_t>(kLowCols) +
|
||
static_cast<size_t>(x1)];
|
||
|
||
const float vx0 = lerp_float(v00, v10, fx);
|
||
const float vx1 = lerp_float(v01, v11, fx);
|
||
const float vxy = lerp_float(vx0, vx1, fy);
|
||
height_values[static_cast<size_t>(y) * static_cast<size_t>(kHeightW) +
|
||
static_cast<size_t>(x)] = vxy;
|
||
}
|
||
}
|
||
height_dirty = true;
|
||
}
|
||
|
||
void upload_height_texture_if_needed() {
|
||
if (!height_dirty || !height_tex) {
|
||
return;
|
||
}
|
||
glBindTexture(GL_TEXTURE_2D, height_tex);
|
||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kHeightW, kHeightH, GL_RED, GL_FLOAT,
|
||
height_values.data());
|
||
glBindTexture(GL_TEXTURE_2D, 0);
|
||
height_dirty = false;
|
||
}
|
||
|
||
void render_heatmap() {
|
||
if (!heatmap_shader || !heatmap_vao || heatmap_index_count <= 0 ||
|
||
!height_tex) {
|
||
return;
|
||
}
|
||
|
||
heatmap_shader->use();
|
||
heatmap_shader->setMat4("uMVP", g_state.mvp);
|
||
heatmap_shader->setFloat("uMinV", static_cast<float>(g_state.minV));
|
||
heatmap_shader->setFloat("uMaxV", static_cast<float>(g_state.maxV));
|
||
heatmap_shader->setFloat("uHeightScale", kDentMax);
|
||
heatmap_shader->setFloat("uBaseZ", -kThickness * 0.5f);
|
||
heatmap_shader->setVec2("uTexelSize",
|
||
glm::vec2(1.0f / static_cast<float>(kHeightW),
|
||
1.0f / static_cast<float>(kHeightH)));
|
||
heatmap_shader->setVec2("uPlaneSize", glm::vec2(kPlaneW, kPlaneH));
|
||
heatmap_shader->setVec3("uCameraPos", g_state.cameraPos);
|
||
heatmap_shader->setVec3("uLightDir",
|
||
glm::normalize(glm::vec3(-0.25f, 0.35f, 1.0f)));
|
||
heatmap_shader->setInt("uHeightTex", 0);
|
||
|
||
glActiveTexture(GL_TEXTURE0);
|
||
glBindTexture(GL_TEXTURE_2D, height_tex);
|
||
|
||
glBindVertexArray(heatmap_vao);
|
||
glDrawElements(GL_TRIANGLES, heatmap_index_count, GL_UNSIGNED_INT, nullptr);
|
||
glBindVertexArray(0);
|
||
|
||
glBindTexture(GL_TEXTURE_2D, 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 vsb_path = "../shaders/bg.vert";
|
||
const std::string fsb_path = "../shaders/bg.frag";
|
||
const std::string vsbase_path = "../shaders/base.vert";
|
||
const std::string fsbase_path = "../shaders/base.frag";
|
||
const std::string vsh_path = "../shaders/heatmap.vert";
|
||
const std::string fsh_path = "../shaders/heatmap.frag";
|
||
|
||
bg_shader = new Shader(vsb_path.c_str(), fsb_path.c_str());
|
||
base_shader = new Shader(vsbase_path.c_str(), fsbase_path.c_str());
|
||
heatmap_shader = new Shader(vsh_path.c_str(), fsh_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(kPlaneW * kPlaneW + kPlaneH * kPlaneH);
|
||
const float distance = std::max(0.6f, radius * 2.4f);
|
||
|
||
// 目标点：面板中心
|
||
const glm::vec3 center(0.0f, 0.0f, 0.0f);
|
||
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_base() {
|
||
if (!base_shader || !base_vao) {
|
||
return;
|
||
}
|
||
|
||
base_shader->use();
|
||
base_shader->setMat4("uMVP", g_state.mvp);
|
||
base_shader->setVec3("uCameraPos", g_state.cameraPos);
|
||
base_shader->setVec3("uLightDir",
|
||
glm::normalize(glm::vec3(-0.25f, 0.35f, 1.0f)));
|
||
base_shader->setVec3("uColor", glm::vec3(0.10f, 0.15f, 0.85f));
|
||
|
||
glBindVertexArray(base_vao);
|
||
glDrawElements(GL_TRIANGLES, base_index_count, GL_UNSIGNED_INT, nullptr);
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
void render_skirt() {
|
||
if (!base_shader || !skirt_vao || skirt_index_count <= 0) {
|
||
return;
|
||
}
|
||
|
||
base_shader->use();
|
||
base_shader->setMat4("uMVP", g_state.mvp);
|
||
base_shader->setVec3("uCameraPos", g_state.cameraPos);
|
||
base_shader->setVec3("uLightDir", glm::normalize(glm::vec3(-0.25f, 0.35f, 1.0f)));
|
||
base_shader->setVec3("uColor", glm::vec3(0.10f, 0.15f, 0.85f));
|
||
|
||
glBindVertexArray(skirt_vao);
|
||
glDrawElements(GL_TRIANGLES, skirt_index_count, GL_UNSIGNED_INT, nullptr);
|
||
glBindVertexArray(0);
|
||
}
|
||
|
||
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 base_shader;
|
||
delete room_shader;
|
||
delete panel_shader;
|
||
delete dots_shader;
|
||
delete heatmap_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);
|
||
if (base_vao) glDeleteVertexArrays(1, &base_vao);
|
||
if (base_vbo) glDeleteBuffers(1, &base_vbo);
|
||
if (base_ibo) glDeleteBuffers(1, &base_ibo);
|
||
if (skirt_vao) glDeleteVertexArrays(1, &skirt_vao);
|
||
if (skirt_vbo) glDeleteBuffers(1, &skirt_vbo);
|
||
if (skirt_ibo) glDeleteBuffers(1, &skirt_ibo);
|
||
if (heatmap_vao) glDeleteVertexArrays(1, &heatmap_vao);
|
||
if (heatmap_vbo) glDeleteBuffers(1, &heatmap_vbo);
|
||
if (heatmap_ibo) glDeleteBuffers(1, &heatmap_ibo);
|
||
if (height_tex) glDeleteTextures(1, &height_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);
|
||
}
|
||
|
||
int main() {
|
||
// 初始化窗口/上下文
|
||
GLFWwindow* window = glfw_init();
|
||
if (window == nullptr) {
|
||
return -1;
|
||
}
|
||
|
||
glEnable(GL_DEPTH_TEST);
|
||
glDepthFunc(GL_LESS);
|
||
|
||
// 初始化规格与资源
|
||
init_programs();
|
||
init_background_geometry();
|
||
init_base_geometry();
|
||
init_heatmap_geometry();
|
||
init_skirt_geometry();
|
||
update_demo_heightmap(0.0f);
|
||
init_height_texture();
|
||
update_skirt_vertices();
|
||
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(0.06f, 0.07f, 0.09f, 1.0f);
|
||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||
|
||
update_matrices(fbWidth, fbHeight);
|
||
update_demo_heightmap(currentFrame);
|
||
upload_height_texture_if_needed();
|
||
update_skirt_vertices();
|
||
|
||
render_background(fbWidth, fbHeight);
|
||
render_base();
|
||
render_skirt();
|
||
render_heatmap();
|
||
|
||
glfwSwapBuffers(window);
|
||
glfwPollEvents();
|
||
}
|
||
|
||
destroy_context();
|
||
glfwDestroyWindow(window);
|
||
glfwTerminate();
|
||
return 0;
|
||
}
|