// Fragment Shader：每个像素运行一次
void main() {
    // 读取当前像素颜色
    vec4 color = texture(inputImage, textureCoord);
    
    // 提升亮度 20%
    color.rgb *= 1.2;
    
    // 输出处理后的颜色
    outputColor = color;
}

uniform sampler2D inputImage;
uniform vec2 imageSize;
uniform float sigmaSpace;  // 空间 sigma
uniform float sigmaColor;  // 颜色 sigma

vec3 BilateralFilter(vec2 uv) {
    vec3 center = texture(inputImage, uv).rgb;
    vec3 result = vec3(0.0);
    float weightSum = 0.0;
    
    // 遍历周围 5×5 区域
    for (int x = -2; x <= 2; x++) {
        for (int y = -2; y <= 2; y++) {
            vec2 offset = vec2(float(x), float(y)) / imageSize;
            vec2 sampleUV = uv + offset;
            vec3 sample = texture(inputImage, sampleUV).rgb;
            
            // 空间权重：基于像素距离
            float spatialDist = length(vec2(float(x), float(y)));
            float spatialWeight = exp(-(spatialDist * spatialDist) / (2.0 * sigmaSpace * sigmaSpace));
            
            // 颜色权重：基于颜色差异
            float colorDist = length(center - sample);
            float colorWeight = exp(-(colorDist * colorDist) / (2.0 * sigmaColor * sigmaColor));
            
            // 双边权重
            float weight = spatialWeight * colorWeight;
            
            result += sample * weight;
            weightSum += weight;
        }
    }
    
    return result / weightSum;
}

vec3 Brightness(vec3 color, float level) {
    // level: 0.0~2.0，1.0 为原亮度
    return color * level;
}

vec3 Contrast(vec3 color, float contrast) {
    // contrast: 0.0~2.0，1.0 为原对比度
    // 先减 0.5 移到中心，乘对比度，再加 0.5 移回去
    return (color - 0.5) * contrast + 0.5;
}

vec3 BeautyAdjust(vec3 color, float brightness, float contrast) {
    color = Brightness(color, brightness);  // 先提亮
    color = Contrast(color, contrast);       // 再调对比度
    return color;
}

uniform sampler2D inputImage;
uniform sampler3D lutTexture;  // 3D LUT 纹理
uniform float lutSize;         // 通常是 33 或 64

vec3 ApplyLUT(vec3 color) {
    // 将 RGB (0.0~1.0) 映射到 LUT 坐标空间
    vec3 lutCoord = color * ((lutSize - 1.0) / lutSize) + (0.5 / lutSize);
    
    // 采样 3D LUT
    return texture(lutTexture, lutCoord).rgb;
}

// 滤镜基类
class IFilter {
public:
    virtual ~IFilter() = default;
    
    // 初始化（创建 GPU 资源）
    virtual bool Initialize(int width, int height) = 0;
    
    // 处理一帧
    virtual void Process(GpuTexture* input, GpuTexture* output) = 0;
    
    // 是否启用
    virtual bool IsEnabled() const { return enabled_; }
    virtual void SetEnabled(bool enabled) { enabled_ = enabled; }
    
    // 释放资源
    virtual void Release() = 0;
    
protected:
    bool enabled_ = true;
    int width_ = 0;
    int height_ = 0;
};

// 双边滤波实现
class BilateralFilter : public IFilter {
public:
    void SetStrength(float strength) { strength_ = strength; }
    void SetSigmaColor(float sigma) { sigma_color_ = sigma; }
    
    void Process(GpuTexture* input, GpuTexture* output) override {
        if (!enabled_) {
            // 如果禁用，直接拷贝
            CopyTexture(input, output);
            return;
        }
        
        // 绑定 Shader 参数
        shader_.SetUniform("sigmaColor", sigma_color_);
        shader_.SetUniform("sigmaSpace", 3.0f);
        
        // 渲染
        RenderFullscreenQuad(shader_, input, output);
    }
    
private:
    float strength_ = 0.5f;
    float sigma_color_ = 0.15f;
    Shader shader_;
};

// 亮度调节实现
class BrightnessFilter : public IFilter {
public:
    void SetLevel(float level) { level_ = level; }
    
    void Process(GpuTexture* input, GpuTexture* output) override {
        if (!enabled_ || level_ == 1.0f) {
            CopyTexture(input, output);
            return;
        }
        
        shader_.SetUniform("brightness", level_);
        RenderFullscreenQuad(shader_, input, output);
    }
    
private:
    float level_ = 1.0f;
    Shader shader_;
};

class FilterChain {
public:
    // 添加滤镜到链尾
    void AddFilter(std::unique_ptr<IFilter> filter) {
        filters_.push_back(std::move(filter));
    }
    
    // 处理一帧
    void ProcessFrame(GpuTexture* input, GpuTexture* output) {
        if (filters_.empty()) {
            CopyTexture(input, output);
            return;
        }
        
        GpuTexture* current_input = input;
        GpuTexture temp_texture;  // 临时纹理
        
        for (size_t i = 0; i < filters_.size(); i++) {
            // 确定输出目标
            GpuTexture* current_output = (i == filters_.size() - 1) 
                ? output : &temp_texture;
            
            // 处理
            filters_[i]->Process(current_input, current_output);
            
            // 当前输出成为下一级输入
            current_input = current_output;
        }
    }
    
    // 动态调整滤镜参数
    void SetFilterParam(size_t index, const std::string& name, float value) {
        if (index < filters_.size()) {
            // 根据 name 设置对应参数
            // 具体实现取决于滤镜类型
        }
    }
    
private:
    std::vector<std::unique_ptr<IFilter>> filters_;
};

// 创建滤镜链
FilterChain chain;

// 添加磨皮滤镜
auto bilateral = std::make_unique<BilateralFilter>();
bilateral->SetStrength(0.6f);
chain.AddFilter(std::move(bilateral));

// 添加美白滤镜
auto brightness = std::make_unique<BrightnessFilter>();
brightness->SetLevel(1.15f);
chain.AddFilter(std::move(brightness));

// 添加 LUT 调色滤镜
auto lut = std::make_unique<LUTFilter>();
lut->LoadLUT("skin_warm.cube");
chain.AddFilter(std::move(lut));

// 处理视频帧
chain.ProcessFrame(cameraTexture, outputTexture);

void FastBilateralFilter(GpuTexture* input, GpuTexture* output) {
    // 1. 创建降采样纹理（540p）
    GpuTexture downsampled(input->GetWidth() / 2, input->GetHeight() / 2);
    
    // 2. 降采样
    Downsample(input, &downsampled);
    
    // 3. 在降采样分辨率做双边滤波
    GpuTexture filtered(downsampled.GetWidth(), downsampled.GetHeight());
    BilateralFilter(&downsampled, &filtered);
    
    // 4. 上采样回原始分辨率
    Upsample(&filtered, output);
}

// 合并亮度、对比度、饱和度调节
uniform sampler2D inputImage;
uniform float brightness;
uniform float contrast;
uniform float saturation;

void main() {
    vec3 color = texture(inputImage, uv).rgb;
    
    // 亮度
    color *= brightness;
    
    // 对比度
    color = (color - 0.5) * contrast + 0.5;
    
    // 饱和度
    float gray = dot(color, vec3(0.299, 0.587, 0.114));
    color = mix(vec3(gray), color, saturation);
    
    outputColor = vec4(color, 1.0);
}

void FilterChain::ProcessFrame(GpuTexture* input, GpuTexture* output) {
    // 统计实际启用的滤镜数
    int enabled_count = 0;
    for (const auto& filter : filters_) {
        if (filter->IsEnabled()) enabled_count++;
    }
    
    if (enabled_count == 0) {
        // 全部禁用，直接拷贝
        CopyTexture(input, output);
        return;
    }
    
    // 只处理启用的滤镜
    // ...
}

// 使用 NVENC 的降噪功能替代软件双边滤波
encoder_config.enableNoiseReduction = true;
encoder_config.noiseReductionLevel = 3;  // 1-5