// ❌ 差：逐个绘制
for (auto& obj : objects) {
    glBindTexture(GL_TEXTURE_2D, obj.texture);
    shader.setMat4("model", obj.model);
    glDrawArrays(GL_TRIANGLES, 0, obj.vertexCount);
}

// ✅ 好：按材质分组后实例化
for (auto& group : materialGroups) {
    glBindTexture(GL_TEXTURE_2D, group.texture);
    glDrawArraysInstanced(GL_TRIANGLES, 0, group.vertexCount, group.instanceCount);
}

// 持久映射（OpenGL 4.4+）
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferStorage(GL_ARRAY_BUFFER, size, nullptr,
                GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);

void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, 0, size,
                             GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);

// 每帧直接写入（无需 glBufferSubData）
memcpy(ptr + offset, data, dataSize);

// ❌ 差：在片段着色器中做复杂计算
void main() {
    vec3 normal = normalize(vNormal);
    float NdotL = max(dot(normal, lightDir), 0.0);
    // 使用 pow(..., 128.0) 高光 → 指数运算很贵
    float spec = pow(max(dot(reflectDir, viewDir), 0.0), 128.0);
}

// ✅ 好：使用近似替代
void main() {
    vec3 normal = normalize(vNormal);
    float NdotL = max(dot(normal, lightDir), 0.0);
    // Blinn-Phong + 更小的指数
    float NdotH = max(dot(normal, halfwayDir), 0.0);
    float spec = NdotH * NdotH * NdotH * NdotH;  // 4 次乘法 vs pow
}

// ❌ 差：分支导致线程发散
if (useTexture) {
    color = texture(tex, uv);
} else {
    color = materialColor;
}

// ✅ 好：使用 mix 消除分支
vec4 texColor = texture(tex, uv);
color = mix(materialColor, texColor, float(useTexture));

// ❌ 差：在同一着色器中多次采样不同纹理
vec4 diffuse = texture(diffuseMap, uv);
vec4 normal = texture(normalMap, uv);
vec4 specular = texture(specularMap, uv);
vec4 ao = texture(aoMap, uv);

// ✅ 好：使用纹理图集减少绑定切换
// 或使用 Array Texture
vec4 diffuse = texture(textureArray, vec3(uv, 0));
vec4 normal = texture(textureArray, vec3(uv, 1));

// ✅ 合并访问
__kernel void good(__global float *data) {
    int gid = get_global_id(0);
    float val = data[gid];  // 连续地址
}

// ❌ 跨步访问
__kernel void bad(__global float *data, int stride) {
    int gid = get_global_id(0);
    float val = data[gid * stride];  // 跳跃地址
}

// 查询最优工作组大小
size_t max_work_group;
clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE,
                sizeof(max_work_group), &max_work_group, NULL);

// 经验法则：
// - GPU: 256 是一个好的默认值
// - 图像处理: 16×16 = 256
// - 向量运算: 128 或 256
// - 需要大量局部内存: 64 或 128

// 传输与计算重叠
clEnqueueWriteBuffer(queue, buf1, CL_FALSE, ...);  // 异步写入 buf1
clEnqueueNDRangeKernel(queue, kernel1, ...);        // 同时执行 kernel1
clEnqueueWriteBuffer(queue, buf2, CL_FALSE, ...);  // 异步写入 buf2
clFinish(queue);                                     // 等待全部完成

// 运行时特性检测
struct GPUCapabilities {
    int maxTextureSize;
    int maxTextureUnits;
    int maxVertexAttributes;
    bool hasInstancing;
    bool hasComputeShaders;
    bool hasGeometryShaders;
    bool hasTessellation;
    bool hasAnisotropicFiltering;
    float maxAnisotropy;
};

GPUCapabilities queryCapabilities() {
    GPUCapabilities caps;
    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &caps.maxTextureSize);
    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &caps.maxTextureUnits);
    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &caps.maxVertexAttributes);

    // 版本检测
    int major, minor;
    glGetIntegerv(GL_MAJOR_VERSION, &major);
    glGetIntegerv(GL_MINOR_VERSION, &minor);

    caps.hasInstancing = (major > 3) || (major == 3 && minor >= 3);
    caps.hasComputeShaders = (major > 4) || (major == 4 && minor >= 3);
    caps.hasGeometryShaders = (major > 3) || (major == 3 && minor >= 2);
    caps.hasTessellation = (major > 4) || (major == 4 && minor >= 0);

    return caps;
}

// 根据平台选择着色器版本
std::string getShaderPrefix() {
#if defined(__EMSCRIPTEN__)
    return "#version 300 es\nprecision mediump float;\n";  // WebGL 2.0
#elif defined(__ANDROID__) || defined(__APPLE__)
    return "#version 300 es\nprecision highp float;\n";    // OpenGL ES 3.0
#else
    return "#version 460 core\n";                          // Desktop OpenGL 4.6
#endif
}

// 已知问题的绕过方案
bool isIntelGPU() {
    const char* renderer = (const char*)glGetString(GL_RENDERER);
    return strstr(renderer, "Intel") != nullptr;
}

void workaroundIntelBug() {
    if (isIntelGPU()) {
        // Intel 驱动在某些情况下 FBO 不完整
        // 绕过：使用 GL_DEPTH_COMPONENT24 代替 GL_DEPTH_COMPONENT32F
    }
}

// 开发阶段：启用所有检查
#ifdef DEBUG
    glEnable(GL_DEBUG_OUTPUT);
    glDebugMessageCallback(debugCallback, nullptr);
    #define GL_CHECK(x) do { x; checkGLError(#x); } while(0)
#else
    // 发布阶段：仅在关键点检查
    #define GL_CHECK(x) x
#endif

// 关键操作后始终检查
void initGraphics() {
    if (!gladLoadGLLoader(...)) {
        logFatal("Failed to initialize GLAD");
        return;
    }

    // 验证 FBO 完整性
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        logFatal("Framebuffer incomplete");
        return;
    }
}

// RAII 风格的 OpenGL 资源管理
class GLBuffer {
    GLuint id_ = 0;
public:
    GLBuffer() { glGenBuffers(1, &id_); }
    ~GLBuffer() { if (id_) glDeleteBuffers(1, &id_); }

    // 禁止拷贝
    GLBuffer(const GLBuffer&) = delete;
    GLBuffer& operator=(const GLBuffer&) = delete;

    // 允许移动
    GLBuffer(GLBuffer&& other) noexcept : id_(other.id_) { other.id_ = 0; }
    GLBuffer& operator=(GLBuffer&& other) noexcept {
        if (this != &other) {
            if (id_) glDeleteBuffers(1, &id_);
            id_ = other.id_;
            other.id_ = 0;
        }
        return *this;
    }

    GLuint id() const { return id_; }
    operator GLuint() const { return id_; }
};

// 使用
{
    GLBuffer vbo;  // 自动创建
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
}  // 自动释放

// 着色器库：避免重复编译
class ShaderLibrary {
    std::unordered_map<std::string, std::shared_ptr<Shader>> shaders_;
public:
    std::shared_ptr<Shader> load(const std::string& name,
                                  const std::string& vertPath,
                                  const std::string& fragPath) {
        auto it = shaders_.find(name);
        if (it != shaders_.end()) return it->second;

        auto shader = std::make_shared<Shader>(vertPath, fragPath);
        shaders_[name] = shader;
        return shader;
    }

    std::shared_ptr<Shader> get(const std::string& name) {
        return shaders_.at(name);
    }
};

// 设置超时检测（用于调试，生产环境通常不启用）
#ifdef DEBUG
    // 使用 GL_TIMEOUT_IGNORED 的情况下可以用 fence 手动超时
    GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
    GLenum result = glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000); // 1 秒
    if (result == GL_TIMEOUT_EXPIRED) {
        logError("GPU operation timed out!");
    }
    glDeleteSync(sync);
#endif

// 定期保存渲染状态
void saveRenderState(const RenderState& state) {
    // 保存帧缓冲到磁盘
    std::vector<unsigned char> pixels(width * height * 4);
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
    saveToPNG("crash_recovery.png", width, height, pixels);
}