OpenGL 自主高性能三维 GIS 平台架构与实现：从 CPU 调度到 GPU 渲染的全链路剖析

┌─────────────────────────────────────────────────────────────┐
│                     业务应用层 (API)                       │
│         (场景管理、图层叠加、交互事件、标注拾取)            │
├─────────────────────────────────────────────────────────────┤
│                     核心引擎层 (Core)                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌─────────────┐ │
│  │场景图(Scene│ │调度器(Scheduler)│ │渲染器(Renderer)│ │
│  │ Graph)    │ │ 瓦片四叉树 │ │ Shader管理  │ │
│  └──────────┘ └──────────┘ └──────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────┤
│                   硬件抽象层 (HAL)                         │
│          OpenGL 4.5 (VAO/VBO/FBO) + 线程池               │
└─────────────────────────────────────────────────────────────┘

// 使用双精度存储相机位置
glm::dvec3 cameraWorldPos; 

// 遍历瓦片顶点时，计算局部偏移 (float)
void processTile(Tile* tile, const glm::dvec3& cameraPos) {
    // tile 的顶点原始坐标为 double 类型
    for (auto& vertex : tile->vertices) {
        // 核心：相减后数值急剧缩小，转换为 float 无精度损失
        glm::vec3 localPos = glm::vec3(vertex.position - cameraPos);
        // 存入 VBO (GL_FLOAT)
        glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec3), &localPos);
    }
}

// Vertex Shader 核心逻辑
#version 450 core
layout (location = 0) in vec3 aPos; // 此处已经是相对于相机的偏移 (float)
uniform mat4 uViewMatrix;          // 仅包含旋转 (不含平移)
uniform mat4 uProjMatrix;          // 投影矩阵

void main() {
    // 直接使用偏移量，绝无抖动
    gl_Position = uProjMatrix * uViewMatrix * vec4(aPos, 1.0);
}

struct QuadTreeNode {
    int level;                     // 层级
    glm::dvec2 center;             // 中心经纬度
    double size;                   // 覆盖范围（度/米）
    AABB boundingBox;              // 三维世界包围盒
    std::vector<QuadTreeNode*> children;
    TileData* data;                // 几何数据（可为空）
    bool isLoading;                // 防止重复请求
    float lastAccessTime;          // LRU 淘汰依据
};

bool shouldLoadTile(QuadTreeNode* node, Camera* cam) {
    // 1. 视锥体裁剪 (Frustum Culling)
    if (!cam->isBoxVisible(node->boundingBox)) return false;

    // 2. 计算投影边长 (像素)
    double dist = glm::distance(cam->getPosition(), node->boundingBox.center);
    double angularSize = node->size / dist; // 弧度
    double pixelSize = angularSize * cam->getScreenWidth() / cam->getFOV();
    
    // 3. 如果像素大小 > 阈值，且没有子节点/子节点未加载，则加载该瓦片
    if (pixelSize > 30.0) { 
        return true; 
    }
    return false;
}

class TileScheduler {
private:
    std::queue<std::string> loadQueue;
    std::mutex queueMutex;
    std::condition_variable cv;
    std::vector<std::thread> workers;
    std::unordered_map<std::string, std::shared_ptr<MeshData>> cache;

public:
    void requestLoad(const std::string& path) {
        std::lock_guard<std::mutex> lock(queueMutex);
        loadQueue.push(path);
        cv.notify_one();
    }

    // 工作线程函数
    void workerLoop() {
        while (running) {
            std::unique_lock<std::mutex> lock(queueMutex);
            cv.wait(lock, [this]{ return !loadQueue.empty(); });
            std::string path = loadQueue.front(); loadQueue.pop();
            lock.unlock();

            // 解析OSGB/3D Tiles数据（耗时操作）
            auto mesh = parseFile(path); 
            
            // 上传到GPU：必须在主线程执行！所以我们只存入暂存队列
            pendingUploads.push({path, mesh});
        }
    }

    // 主线程每帧调用，检查是否有待上传数据
    void uploadPending() {
        while (!pendingUploads.empty()) {
            auto& item = pendingUploads.front();
            GLuint vao = createVAO(item.mesh); // OpenGL 操作
            cache[item.path] = vao;
            pendingUploads.pop();
        }
    }
};

class RenderStateCache {
private:
    GLuint currentProgram = 0;
    GLuint currentVAO = 0;
    GLuint currentTexture = 0;

public:
    void useProgram(GLuint program) {
        if (currentProgram != program) {
            glUseProgram(program);
            currentProgram = program;
        }
    }
    
    void bindVAO(GLuint vao) {
        if (currentVAO != vao) {
            glBindVertexArray(vao);
            currentVAO = vao;
        }
    }
    // 以此类推...
};

// 收集同类型瓦片的绘制参数
std::vector<GLsizei> counts;
std::vector<const void*> offsets;

for (auto& tile : visibleTiles) {
    if (tile->textureId == currentAtlasId) {
        counts.push_back(tile->indexCount);
        offsets.push_back((void*)(tile->indexOffset * sizeof(GLuint)));
    }
}

// 一次 DrawCall 干掉几十个瓦片
glMultiDrawElements(GL_TRIANGLES, counts.data(), GL_UNSIGNED_INT, offsets.data(), counts.size());

void renderTerrainBase() {
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonOffset(-1.0f, -1.0f); // 将深度向后推
    // ... 绘制底层瓦片
    glDisable(GL_POLYGON_OFFSET_FILL);
}