// GPU并行执行示例
CCProgram gpu_execution_model %{
    // GPU以Warp/Wavefront为单位执行
    // 通常32个线程同时执行相同指令
    
    void main() {
        // 好的做法：所有线程执行相同代码路径
        vec4 color = texture(mainTexture, v_uv);
        color.rgb *= 2.0;
        
        // 坏的做法：分支导致执行分歧
        if (v_uv.x > 0.5) {
            color.rgb *= 2.0;  // 一半线程执行这里
        } else {
            color.rgb *= 0.5;  // 另一半线程执行这里
        }
        
        fragColor = color;
    }
}%

// 数学运算优化对比
CCProgram math_optimization %{
    // 未优化版本
    vec3 slowVersion(vec3 input) {
        float result = pow(input.x, 2.0);           // 昂贵的幂运算
        result += sqrt(input.y);                    // 昂贵的开方运算
        result *= sin(input.z * 3.14159);          // 昂贵的三角函数
        return vec3(result);
    }
    
    // 优化版本
    vec3 fastVersion(vec3 input) {
        float result = input.x * input.x;           // 使用乘法替代平方
        result += pow(input.y, 0.5);               // 或使用查找表
        result *= sinLUT(input.z);                 // 使用预计算的查找表
        return vec3(result);
    }
    
    // 查找表实现
    uniform sampler2D sinLUT;
    float sinLUT(float x) {
        float normalized = x / (2.0 * 3.14159);   // 归一化到[0,1]
        return texture(sinLUT, vec2(normalized, 0.5)).r;
    }
}%

// 向量化优�?CCProgram vectorization %{
    // �?标量操作（慢�?    void scalarVersion() {
        float r = texture(tex, uv).r * color.r;
        float g = texture(tex, uv).g * color.g; 
        float b = texture(tex, uv).b * color.b;
        float a = texture(tex, uv).a * color.a;
        fragColor = vec4(r, g, b, a);
    }
    
    // �?向量操作（快�?    void vectorVersion() {
        vec4 texColor = texture(tex, uv);
        fragColor = texColor * color;           // 单个向量操作
    }
    
    // �?SIMD友好的操�?    void simdFriendly() {
        vec4 a = texture(texA, uv);
        vec4 b = texture(texB, uv);
        vec4 c = texture(texC, uv);
        
        // 多个向量同时计算
        vec4 result = a * b + c;               // Fused Multiply-Add
        fragColor = result;
    }
}%

// 纹理采样优化
CCProgram texture_optimization %{
    // �?多次重复采样
    void redundantSampling() {
        vec4 color1 = texture(mainTex, uv);
        vec4 color2 = texture(mainTex, uv + offset1);  // 重复采样
        vec4 color3 = texture(mainTex, uv + offset2);
        
        fragColor = (color1 + color2 + color3) / 3.0;
    }
    
    // �?减少采样次数
    void optimizedSampling() {
        // 使用双线性插值减少采�?        vec4 color = texture(mainTex, uv);
        vec4 neighbor = texture(mainTex, uv + offset);
        
        fragColor = mix(color, neighbor, blendFactor);
    }
    
    // �?合并纹理采样
    void packedTextures() {
        // 将多个单通道纹理打包到一个RGBA纹理�?        vec4 packed = texture(packedTex, uv);
        float roughness = packed.r;
        float metallic = packed.g; 
        float ao = packed.b;
        float height = packed.a;
    }
}%

// Mipmap优化技�?CCProgram mipmap_optimization %{
    // 手动Mipmap级别选择
    float calculateMipmapLevel(vec2 uv, vec2 textureSize) {
        vec2 dx = dFdx(uv * textureSize);
        vec2 dy = dFdy(uv * textureSize);
        float maxDelta = max(dot(dx, dx), dot(dy, dy));
        return 0.5 * log2(maxDelta);
    }
    
    // 优化的纹理采�?    vec4 optimizedTextureSample(sampler2D tex, vec2 uv) {
        float level = calculateMipmapLevel(uv, textureSize);
        return textureLod(tex, uv, level);
    }
    
    // 各向异性过滤优�?    vec4 anisotropicSample(sampler2D tex, vec2 uv) {
        // 计算各向异性比�?        vec2 dx = dFdx(uv * textureSize);
        vec2 dy = dFdy(uv * textureSize);
        
        float maxAniso = max(length(dx), length(dy));
        float minAniso = min(length(dx), length(dy));
        float ratio = maxAniso / minAniso;
        
        // 限制各向异性级别以提高性能
        ratio = min(ratio, 4.0);
        
        return texture(tex, uv);  // GPU自动处理各向异�?    }
}%

// 分支优化对比
CCProgram branch_optimization %{
    // �?动态分支（GPU执行效率低）
    vec3 dynamicBranch(vec3 color, float condition) {
        if (condition > 0.5) {
            return color * 2.0;      // 分支A
        } else {
            return color * 0.5;      // 分支B
        }
    }
    
    // �?使用step函数消除分支
    vec3 eliminateBranch(vec3 color, float condition) {
        float factor = mix(0.5, 2.0, step(0.5, condition));
        return color * factor;
    }
    
    // �?使用lerp消除分支
    vec3 lerpBranch(vec3 color, float condition) {
        vec3 resultA = color * 2.0;
        vec3 resultB = color * 0.5;
        return mix(resultB, resultA, step(0.5, condition));
    }
}%

// 静态分支和宏定�?CCProgram static_branches %{
    // 使用宏定义创建静态分�?    #if defined(ENABLE_NORMAL_MAPPING)
        vec3 calculateNormal() {
            vec3 normal = texture(normalTexture, v_uv).xyz * 2.0 - 1.0;
            return normalize(normal);
        }
    #else
        vec3 calculateNormal() {
            return normalize(v_worldNormal);
        }
    #endif
    
    // 特性级别静态分�?    #if FEATURE_LEVEL >= 3
        // 高端设备：完整PBR
        vec3 pbrLighting() {
            return calculateFullPBR();
        }
    #elif FEATURE_LEVEL >= 2  
        // 中端设备：简化PBR
        vec3 pbrLighting() {
            return calculateSimplifiedPBR();
        }
    #else
        // 低端设备：Blinn-Phong
        vec3 pbrLighting() {
            return calculateBlinnPhong();
        }
    #endif
}%

// 内存访问优化
CCProgram memory_optimization %{
    // �?重复的内存访�?    void redundantAccess() {
        vec3 normal = normalize(v_worldNormal);
        vec3 lightDir = normalize(lightPosition - v_worldPos);
        vec3 viewDir = normalize(cameraPosition - v_worldPos);
        
        // v_worldPos被多次访�?        float dist1 = distance(lightPosition, v_worldPos);
        float dist2 = distance(cameraPosition, v_worldPos);
    }
    
    // �?缓存频繁访问的�?    void cachedAccess() {
        vec3 worldPos = v_worldPos;  // 缓存到寄存器
        vec3 normal = normalize(v_worldNormal);
        
        vec3 lightDir = lightPosition - worldPos;
        vec3 viewDir = cameraPosition - worldPos;
        
        float lightDist = length(lightDir);
        float viewDist = length(viewDir);
        
        lightDir /= lightDist;  // 复用长度计算结果
        viewDir /= viewDist;
    }
}%

// 数据打包优化
CCProgram data_packing %{
    // �?未打包的数据
    struct UnpackedData {
        float roughness;    // 4 bytes
        float metallic;     // 4 bytes  
        float ao;          // 4 bytes
        float height;      // 4 bytes
        // 总计: 16 bytes
    };
    
    // �?打包的数�?    struct PackedData {
        vec4 packed;       // 4 bytes
        // R: roughness, G: metallic, B: ao, A: height
    };
    
    // 法线向量打包
    vec2 packNormal(vec3 normal) {
        // 球面坐标打包，节省一个分�?        return normal.xy / (normal.z + 1.0);
    }
    
    vec3 unpackNormal(vec2 packed) {
        vec2 f = packed;
        float f2 = dot(f, f);
        float g = sqrt(1.0 - f2 / 4.0);
        return vec3(f * g, 1.0 - f2 / 2.0);
    }
    
    // 颜色打包到更少位�?    uint packColor(vec3 color) {
        uvec3 c = uvec3(color * 255.0);
        return (c.r << 16) | (c.g << 8) | c.b;  // RGB888
    }
}%

// 着色器LOD实现
CCProgram shader_lod %{
    uniform float distanceToCamera;
    uniform float lodBias;
    
    // 计算LOD级别
    float calculateShaderLOD() {
        float distance = distanceToCamera;
        float lod = log2(distance) + lodBias;
        return clamp(lod, 0.0, 3.0);
    }
    
    // 基于LOD的着色器选择
    vec3 calculateLighting() {
        float lod = calculateShaderLOD();
        
        if (lod < 1.0) {
            // LOD 0: 完整PBR光照
            return calculateFullPBR();
        } else if (lod < 2.0) {
            // LOD 1: 简化PBR
            return calculateSimplifiedPBR();
        } else if (lod < 3.0) {
            // LOD 2: Blinn-Phong
            return calculateBlinnPhong();
        } else {
            // LOD 3: 环境光只
            return calculateAmbientOnly();
        }
    }
}%