dartmind 17.0.0

package/dist/shaders/ImpellerShaderGenerator.js

@@ -0,0 +1,1186 @@
+/**
+ * FlutterAI Supreme Vision v8.0
+ * Impeller Shader Generator - Advanced Rendering Optimization
+ *
+ * Generates optimized shader code for Flutter's Impeller rendering engine:
+ * - Custom fragment shaders
+ * - Optimized vertex processing
+ * - Blur effects (Gaussian, Motion, Radial)
+ * - Color transformations
+ * - Animated effects
+ * - Performance-optimized rendering
+ */
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as path from 'path';
+// =============================================================================
+// TYPES & INTERFACES
+// =============================================================================
+export var ShaderType;
+(function (ShaderType) {
+    ShaderType["FRAGMENT"] = "fragment";
+    ShaderType["VERTEX"] = "vertex";
+    ShaderType["COMPUTE"] = "compute";
+})(ShaderType || (ShaderType = {}));
+export var EffectType;
+(function (EffectType) {
+    EffectType["BLUR_GAUSSIAN"] = "blur_gaussian";
+    EffectType["BLUR_MOTION"] = "blur_motion";
+    EffectType["BLUR_RADIAL"] = "blur_radial";
+    EffectType["COLOR_MATRIX"] = "color_matrix";
+    EffectType["GRADIENT"] = "gradient";
+    EffectType["NOISE"] = "noise";
+    EffectType["RIPPLE"] = "ripple";
+    EffectType["GLOW"] = "glow";
+    EffectType["SHADOW"] = "shadow";
+    EffectType["PIXELATE"] = "pixelate";
+    EffectType["VIGNETTE"] = "vignette";
+    EffectType["CHROMATIC_ABERRATION"] = "chromatic_aberration";
+    EffectType["FISHEYE"] = "fisheye";
+    EffectType["WAVE"] = "wave";
+    EffectType["DISSOLVE"] = "dissolve";
+    EffectType["CUSTOM"] = "custom";
+})(EffectType || (EffectType = {}));
+// =============================================================================
+// SHADER TEMPLATES
+// =============================================================================
+const SHADER_HEADER = `#version 460 core
+#include <flutter/runtime_effect.glsl>
+
+`;
+const BLUR_GAUSSIAN_TEMPLATE = `// Gaussian Blur Shader
+// Optimized for Impeller rendering
+
+uniform vec2 uResolution;
+uniform float uRadius;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+const float PI = 3.14159265359;
+
+float gaussian(float x, float sigma) {
+    return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * PI) * sigma);
+}
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = vec4(0.0);
+    float totalWeight = 0.0;
+    
+    int samples = int(ceil(uRadius * 3.0));
+    float sigma = uRadius / 3.0;
+    
+    for (int x = -samples; x <= samples; x++) {
+        for (int y = -samples; y <= samples; y++) {
+            vec2 offset = vec2(float(x), float(y)) / uResolution;
+            float weight = gaussian(length(vec2(x, y)), sigma);
+            color += texture(uTexture, uv + offset) * weight;
+            totalWeight += weight;
+        }
+    }
+    
+    fragColor = color / totalWeight;
+}
+`;
+const BLUR_MOTION_TEMPLATE = `// Motion Blur Shader
+// Directional blur optimized for performance
+
+uniform vec2 uResolution;
+uniform vec2 uDirection;
+uniform float uStrength;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = vec4(0.0);
+    
+    vec2 velocity = normalize(uDirection) * uStrength / uResolution;
+    
+    const int samples = 16;
+    float totalWeight = 0.0;
+    
+    for (int i = -samples / 2; i <= samples / 2; i++) {
+        float weight = 1.0 - abs(float(i)) / float(samples / 2);
+        color += texture(uTexture, uv + velocity * float(i)) * weight;
+        totalWeight += weight;
+    }
+    
+    fragColor = color / totalWeight;
+}
+`;
+const GLOW_TEMPLATE = `// Glow Effect Shader
+// Creates a soft glow around bright areas
+
+uniform vec2 uResolution;
+uniform float uIntensity;
+uniform float uThreshold;
+uniform vec3 uGlowColor;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 original = texture(uTexture, uv);
+    
+    // Extract bright areas
+    float brightness = dot(original.rgb, vec3(0.299, 0.587, 0.114));
+    vec4 bright = brightness > uThreshold ? original : vec4(0.0);
+    
+    // Blur bright areas
+    vec4 blurred = vec4(0.0);
+    float total = 0.0;
+    
+    for (int x = -4; x <= 4; x++) {
+        for (int y = -4; y <= 4; y++) {
+            vec2 offset = vec2(float(x), float(y)) * 2.0 / uResolution;
+            float weight = 1.0 - length(vec2(x, y)) / 5.66;
+            if (weight > 0.0) {
+                vec4 sample = texture(uTexture, uv + offset);
+                float b = dot(sample.rgb, vec3(0.299, 0.587, 0.114));
+                if (b > uThreshold) {
+                    blurred += sample * weight;
+                    total += weight;
+                }
+            }
+        }
+    }
+    
+    if (total > 0.0) blurred /= total;
+    
+    // Combine
+    vec3 glow = blurred.rgb * uGlowColor * uIntensity;
+    fragColor = vec4(original.rgb + glow, original.a);
+}
+`;
+const RIPPLE_TEMPLATE = `// Ripple Effect Shader
+// Creates water ripple distortion
+
+uniform vec2 uResolution;
+uniform vec2 uCenter;
+uniform float uTime;
+uniform float uAmplitude;
+uniform float uFrequency;
+uniform float uSpeed;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec2 center = uCenter / uResolution;
+    
+    float dist = distance(uv, center);
+    float wave = sin(dist * uFrequency - uTime * uSpeed) * uAmplitude;
+    wave *= 1.0 - smoothstep(0.0, 0.5, dist);
+    
+    vec2 offset = normalize(uv - center) * wave;
+    vec2 distortedUV = uv + offset;
+    
+    fragColor = texture(uTexture, distortedUV);
+}
+`;
+const CHROMATIC_ABERRATION_TEMPLATE = `// Chromatic Aberration Shader
+// Creates color fringing effect
+
+uniform vec2 uResolution;
+uniform float uStrength;
+uniform vec2 uCenter;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec2 center = uCenter / uResolution;
+    
+    vec2 dir = uv - center;
+    float dist = length(dir);
+    vec2 offset = dir * uStrength * dist;
+    
+    float r = texture(uTexture, uv + offset).r;
+    float g = texture(uTexture, uv).g;
+    float b = texture(uTexture, uv - offset).b;
+    float a = texture(uTexture, uv).a;
+    
+    fragColor = vec4(r, g, b, a);
+}
+`;
+const PIXELATE_TEMPLATE = `// Pixelate Shader
+// Creates a pixelated/mosaic effect
+
+uniform vec2 uResolution;
+uniform float uPixelSize;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    
+    vec2 pixelCount = uResolution / uPixelSize;
+    vec2 pixelUV = floor(uv * pixelCount) / pixelCount;
+    pixelUV += 0.5 / pixelCount; // Center of pixel
+    
+    fragColor = texture(uTexture, pixelUV);
+}
+`;
+const VIGNETTE_TEMPLATE = `// Vignette Shader
+// Creates darkened corners effect
+
+uniform vec2 uResolution;
+uniform float uIntensity;
+uniform float uSmoothness;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = texture(uTexture, uv);
+    
+    vec2 center = vec2(0.5);
+    float dist = distance(uv, center);
+    float vignette = smoothstep(0.8 - uSmoothness, 0.8, dist * uIntensity);
+    
+    color.rgb *= 1.0 - vignette;
+    fragColor = color;
+}
+`;
+const DISSOLVE_TEMPLATE = `// Dissolve Shader
+// Creates a dissolve/burn transition
+
+uniform vec2 uResolution;
+uniform float uProgress;
+uniform float uEdgeWidth;
+uniform vec3 uEdgeColor;
+uniform sampler2D uTexture;
+uniform sampler2D uNoiseTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = texture(uTexture, uv);
+    float noise = texture(uNoiseTexture, uv).r;
+    
+    float threshold = uProgress;
+    float edge = smoothstep(threshold - uEdgeWidth, threshold, noise);
+    float alpha = smoothstep(threshold, threshold + 0.01, noise);
+    
+    vec3 edgeGlow = uEdgeColor * (1.0 - edge) * alpha;
+    
+    fragColor = vec4(color.rgb + edgeGlow, color.a * alpha);
+}
+`;
+const WAVE_TEMPLATE = `// Wave Distortion Shader
+// Creates wavy distortion effect
+
+uniform vec2 uResolution;
+uniform float uTime;
+uniform float uAmplitude;
+uniform float uFrequency;
+uniform bool uHorizontal;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    
+    float wave;
+    if (uHorizontal) {
+        wave = sin(uv.y * uFrequency + uTime) * uAmplitude;
+        uv.x += wave;
+    } else {
+        wave = sin(uv.x * uFrequency + uTime) * uAmplitude;
+        uv.y += wave;
+    }
+    
+    fragColor = texture(uTexture, uv);
+}
+`;
+const COLOR_MATRIX_TEMPLATE = `// Color Matrix Shader
+// Applies color transformation matrix
+
+uniform vec2 uResolution;
+uniform mat4 uColorMatrix;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = texture(uTexture, uv);
+    
+    fragColor = uColorMatrix * color;
+}
+`;
+const NOISE_TEMPLATE = `// Noise Shader
+// Generates procedural noise
+
+uniform vec2 uResolution;
+uniform float uTime;
+uniform float uScale;
+uniform float uIntensity;
+uniform int uOctaves;
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+float random(vec2 st) {
+    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
+}
+
+float noise(vec2 st) {
+    vec2 i = floor(st);
+    vec2 f = fract(st);
+    
+    float a = random(i);
+    float b = random(i + vec2(1.0, 0.0));
+    float c = random(i + vec2(0.0, 1.0));
+    float d = random(i + vec2(1.0, 1.0));
+    
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    
+    return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
+float fbm(vec2 st) {
+    float value = 0.0;
+    float amplitude = 0.5;
+    
+    for (int i = 0; i < uOctaves; i++) {
+        value += amplitude * noise(st);
+        st *= 2.0;
+        amplitude *= 0.5;
+    }
+    
+    return value;
+}
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = texture(uTexture, uv);
+    
+    float n = fbm(uv * uScale + uTime * 0.1);
+    
+    fragColor = vec4(mix(color.rgb, vec3(n), uIntensity), color.a);
+}
+`;
+// =============================================================================
+// IMPELLER SHADER GENERATOR CLASS
+// =============================================================================
+export class ImpellerShaderGenerator extends EventEmitter {
+    config;
+    generatedShaders;
+    constructor(config = {}) {
+        super();
+        this.config = {
+            targetPlatform: 'all',
+            enableOptimizations: true,
+            generateDartWrapper: true,
+            generateFlutterWidget: true,
+            outputDir: '.fai/shaders',
+            ...config
+        };
+        this.generatedShaders = new Map();
+    }
+    // ===========================================================================
+    // MAIN GENERATION METHODS
+    // ===========================================================================
+    /**
+     * Generate a shader for a specific effect
+     */
+    async generateShader(config) {
+        const fullConfig = this.normalizeConfig(config);
+        const shaderId = this.generateShaderId();
+        this.emit('generationStarted', { id: shaderId, config: fullConfig });
+        // Generate GLSL code
+        const glslCode = this.generateGLSL(fullConfig);
+        // Generate Dart wrapper
+        const dartWrapper = this.config.generateDartWrapper
+            ? this.generateDartWrapper(fullConfig, shaderId)
+            : '';
+        // Generate Flutter widget
+        const flutterWidget = this.config.generateFlutterWidget
+            ? this.generateFlutterWidget(fullConfig, shaderId)
+            : '';
+        const shader = {
+            id: shaderId,
+            config: fullConfig,
+            glslCode,
+            dartWrapper,
+            flutterWidget,
+            metadata: {
+                version: '1.0.0',
+                generatedAt: new Date(),
+                estimatedPerformance: this.estimatePerformance(fullConfig),
+                complexity: this.calculateComplexity(glslCode),
+                uniformCount: fullConfig.uniforms.length,
+                textureCount: fullConfig.uniforms.filter(u => u.type === 'sampler2D').length
+            }
+        };
+        this.generatedShaders.set(shaderId, shader);
+        this.emit('generationComplete', shader);
+        return shader;
+    }
+    /**
+     * Generate a bundle of related shaders
+     */
+    async generateBundle(name, effects) {
+        const bundleId = this.generateBundleId();
+        const shaders = [];
+        for (const effect of effects) {
+            const shader = await this.generateShader({ effect, name: `${name}_${effect}` });
+            shaders.push(shader);
+        }
+        const dartLibrary = this.generateDartLibrary(name, shaders);
+        const pubspecEntry = this.generatePubspecEntry(name);
+        const readme = this.generateReadme(name, shaders);
+        const bundle = {
+            id: bundleId,
+            name,
+            shaders,
+            dartLibrary,
+            pubspecEntry,
+            readme
+        };
+        this.emit('bundleGenerated', bundle);
+        return bundle;
+    }
+    /**
+     * Save shader to file system
+     */
+    async saveShader(shader, outputDir) {
+        const dir = outputDir || this.config.outputDir;
+        const savedFiles = [];
+        // Ensure directory exists
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Save GLSL file
+        const glslPath = path.join(dir, `${shader.config.name}.frag`);
+        fs.writeFileSync(glslPath, shader.glslCode);
+        savedFiles.push(glslPath);
+        // Save Dart wrapper
+        if (shader.dartWrapper) {
+            const dartPath = path.join(dir, `${shader.config.name}_shader.dart`);
+            fs.writeFileSync(dartPath, shader.dartWrapper);
+            savedFiles.push(dartPath);
+        }
+        // Save Flutter widget
+        if (shader.flutterWidget) {
+            const widgetPath = path.join(dir, `${shader.config.name}_widget.dart`);
+            fs.writeFileSync(widgetPath, shader.flutterWidget);
+            savedFiles.push(widgetPath);
+        }
+        this.emit('shaderSaved', { shader, files: savedFiles });
+        return savedFiles;
+    }
+    // ===========================================================================
+    // GLSL GENERATION
+    // ===========================================================================
+    generateGLSL(config) {
+        let code = SHADER_HEADER;
+        // Add uniforms
+        code += '// Uniforms\n';
+        for (const uniform of config.uniforms) {
+            code += `uniform ${uniform.type} ${uniform.name};\n`;
+        }
+        code += '\n';
+        // Add main shader body based on effect
+        switch (config.effect) {
+            case EffectType.BLUR_GAUSSIAN:
+                code += this.optimizeShader(BLUR_GAUSSIAN_TEMPLATE, config);
+                break;
+            case EffectType.BLUR_MOTION:
+                code += this.optimizeShader(BLUR_MOTION_TEMPLATE, config);
+                break;
+            case EffectType.GLOW:
+                code += this.optimizeShader(GLOW_TEMPLATE, config);
+                break;
+            case EffectType.RIPPLE:
+                code += this.optimizeShader(RIPPLE_TEMPLATE, config);
+                break;
+            case EffectType.CHROMATIC_ABERRATION:
+                code += this.optimizeShader(CHROMATIC_ABERRATION_TEMPLATE, config);
+                break;
+            case EffectType.PIXELATE:
+                code += this.optimizeShader(PIXELATE_TEMPLATE, config);
+                break;
+            case EffectType.VIGNETTE:
+                code += this.optimizeShader(VIGNETTE_TEMPLATE, config);
+                break;
+            case EffectType.DISSOLVE:
+                code += this.optimizeShader(DISSOLVE_TEMPLATE, config);
+                break;
+            case EffectType.WAVE:
+                code += this.optimizeShader(WAVE_TEMPLATE, config);
+                break;
+            case EffectType.COLOR_MATRIX:
+                code += this.optimizeShader(COLOR_MATRIX_TEMPLATE, config);
+                break;
+            case EffectType.NOISE:
+                code += this.optimizeShader(NOISE_TEMPLATE, config);
+                break;
+            default:
+                code += this.generateCustomEffect(config);
+        }
+        return code;
+    }
+    optimizeShader(template, config) {
+        let code = template;
+        if (this.config.enableOptimizations) {
+            switch (config.optimizationLevel) {
+                case 'high':
+                    code = this.applyHighOptimizations(code);
+                    break;
+                case 'medium':
+                    code = this.applyMediumOptimizations(code);
+                    break;
+                case 'low':
+                    // Keep as-is
+                    break;
+            }
+        }
+        return code;
+    }
+    applyHighOptimizations(code) {
+        // Unroll small loops
+        code = code.replace(/for\s*\(\s*int\s+(\w+)\s*=\s*(-?\d+)\s*;\s*\1\s*<=\s*(\d+)\s*;\s*\1\+\+\s*\)/g, (match, varName, start, end) => {
+            const startNum = parseInt(start);
+            const endNum = parseInt(end);
+            if (endNum - startNum <= 4) {
+                return `// Loop unrolled: ${varName} from ${start} to ${end}`;
+            }
+            return match;
+        });
+        // Use fast math approximations
+        code = code.replace(/sin\(/g, 'fastSin(');
+        code = code.replace(/cos\(/g, 'fastCos(');
+        // Add fast math functions
+        const fastMath = `
+// Fast approximations
+float fastSin(float x) {
+    x = mod(x + 3.14159265, 6.28318530) - 3.14159265;
+    return x - (x*x*x)/6.0 + (x*x*x*x*x)/120.0;
+}
+float fastCos(float x) { return fastSin(x + 1.57079632); }
+
+`;
+        code = fastMath + code;
+        return code;
+    }
+    applyMediumOptimizations(code) {
+        // Reduce sample counts
+        code = code.replace(/const int samples = 16;/g, 'const int samples = 8;');
+        code = code.replace(/samples \/ 2/g, '4');
+        // Use lower precision where safe
+        code = code.replace(/float\s+(\w+)\s*=\s*0\.0;/g, 'lowp float $1 = 0.0;');
+        return code;
+    }
+    generateCustomEffect(config) {
+        // Generate a basic pass-through with custom uniforms
+        let code = `// Custom Effect: ${config.name}
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = FlutterFragCoord().xy / uResolution;
+    vec4 color = texture(uTexture, uv);
+    
+    // Apply custom transformations here
+    `;
+        for (const uniform of config.uniforms) {
+            if (uniform.type === 'float') {
+                code += `\n    color.rgb *= ${uniform.name};`;
+            }
+        }
+        code += `
+    
+    fragColor = color;
+}
+`;
+        return code;
+    }
+    // ===========================================================================
+    // DART WRAPPER GENERATION
+    // ===========================================================================
+    generateDartWrapper(config, shaderId) {
+        const className = this.toPascalCase(config.name);
+        let code = `// Generated by FlutterAI Impeller Shader Generator
+// Shader: ${config.name}
+// Effect: ${config.effect}
+// ID: ${shaderId}
+
+import 'dart:ui' as ui;
+import 'package:flutter/material.dart';
+
+/// ${className} shader controller
+class ${className}Shader {
+  ui.FragmentProgram? _program;
+  ui.FragmentShader? _shader;
+  bool _isLoaded = false;
+
+  /// Whether the shader has been loaded
+  bool get isLoaded => _isLoaded;
+
+  /// Load the shader from assets
+  Future<void> load() async {
+    if (_isLoaded) return;
+    
+    try {
+      _program = await ui.FragmentProgram.fromAsset('shaders/${config.name}.frag');
+      _shader = _program!.fragmentShader();
+      _isLoaded = true;
+    } catch (e) {
+      debugPrint('Failed to load ${config.name} shader: \$e');
+      rethrow;
+    }
+  }
+
+  /// Get the fragment shader with uniforms set
+  ui.FragmentShader? getShader({
+`;
+        // Add uniform parameters
+        for (let i = 0; i < config.uniforms.length; i++) {
+            const uniform = config.uniforms[i];
+            const dartType = this.glslTypeToDart(uniform.type);
+            const defaultVal = this.getDefaultValue(uniform);
+            code += `    ${dartType} ${this.toCamelCase(uniform.name)} = ${defaultVal},\n`;
+        }
+        code += `  }) {
+    if (!_isLoaded || _shader == null) return null;
+
+`;
+        // Set uniforms
+        let floatIndex = 0;
+        for (const uniform of config.uniforms) {
+            if (uniform.type === 'sampler2D') {
+                code += `    // Note: Texture '${uniform.name}' should be set separately\n`;
+            }
+            else {
+                const count = this.getFloatCount(uniform.type);
+                if (uniform.type === 'float') {
+                    code += `    _shader!.setFloat(${floatIndex}, ${this.toCamelCase(uniform.name)});\n`;
+                    floatIndex++;
+                }
+                else if (uniform.type === 'vec2') {
+                    code += `    _shader!.setFloat(${floatIndex}, ${this.toCamelCase(uniform.name)}.dx);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 1}, ${this.toCamelCase(uniform.name)}.dy);\n`;
+                    floatIndex += 2;
+                }
+                else if (uniform.type === 'vec3') {
+                    code += `    _shader!.setFloat(${floatIndex}, ${this.toCamelCase(uniform.name)}[0]);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 1}, ${this.toCamelCase(uniform.name)}[1]);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 2}, ${this.toCamelCase(uniform.name)}[2]);\n`;
+                    floatIndex += 3;
+                }
+                else if (uniform.type === 'vec4') {
+                    code += `    _shader!.setFloat(${floatIndex}, ${this.toCamelCase(uniform.name)}.red);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 1}, ${this.toCamelCase(uniform.name)}.green);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 2}, ${this.toCamelCase(uniform.name)}.blue);\n`;
+                    code += `    _shader!.setFloat(${floatIndex + 3}, ${this.toCamelCase(uniform.name)}.alpha);\n`;
+                    floatIndex += 4;
+                }
+            }
+        }
+        code += `
+    return _shader;
+  }
+
+  /// Dispose of shader resources
+  void dispose() {
+    _shader = null;
+    _program = null;
+    _isLoaded = false;
+  }
+}
+`;
+        return code;
+    }
+    // ===========================================================================
+    // FLUTTER WIDGET GENERATION
+    // ===========================================================================
+    generateFlutterWidget(config, shaderId) {
+        const className = this.toPascalCase(config.name);
+        let code = `// Generated by FlutterAI Impeller Shader Generator
+// Widget for: ${config.name}
+// Effect: ${config.effect}
+
+import 'dart:ui' as ui;
+import 'package:flutter/material.dart';
+import '${config.name}_shader.dart';
+
+/// Apply ${config.effect} effect to child widget
+class ${className}Effect extends StatefulWidget {
+  final Widget child;
+`;
+        // Add widget properties
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uResolution' && uniform.name !== 'uTexture') {
+                const dartType = this.glslTypeToDart(uniform.type);
+                const defaultVal = this.getDefaultValue(uniform);
+                code += `  final ${dartType} ${this.toCamelCase(uniform.name.replace('u', ''))};\n`;
+            }
+        }
+        if (config.animated) {
+            code += `  final Duration duration;\n`;
+            code += `  final bool autoAnimate;\n`;
+        }
+        code += `
+  const ${className}Effect({
+    super.key,
+    required this.child,
+`;
+        // Constructor parameters
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uResolution' && uniform.name !== 'uTexture') {
+                const defaultVal = this.getWidgetDefaultValue(uniform);
+                code += `    this.${this.toCamelCase(uniform.name.replace('u', ''))} = ${defaultVal},\n`;
+            }
+        }
+        if (config.animated) {
+            code += `    this.duration = const Duration(milliseconds: 300),\n`;
+            code += `    this.autoAnimate = true,\n`;
+        }
+        code += `  });
+
+  @override
+  State<${className}Effect> createState() => _${className}EffectState();
+}
+
+class _${className}EffectState extends State<${className}Effect>`;
+        if (config.animated) {
+            code += ` with SingleTickerProviderStateMixin`;
+        }
+        code += ` {
+  final ${className}Shader _shaderController = ${className}Shader();
+`;
+        if (config.animated) {
+            code += `  late AnimationController _animationController;
+  double _time = 0.0;
+`;
+        }
+        code += `
+  @override
+  void initState() {
+    super.initState();
+    _loadShader();
+`;
+        if (config.animated) {
+            code += `    _animationController = AnimationController(
+      vsync: this,
+      duration: widget.duration,
+    );
+    if (widget.autoAnimate) {
+      _animationController.repeat();
+    }
+    _animationController.addListener(() {
+      setState(() {
+        _time = _animationController.value * 6.28318;
+      });
+    });
+`;
+        }
+        code += `  }
+
+  Future<void> _loadShader() async {
+    await _shaderController.load();
+    if (mounted) setState(() {});
+  }
+
+  @override
+  void dispose() {
+`;
+        if (config.animated) {
+            code += `    _animationController.dispose();
+`;
+        }
+        code += `    _shaderController.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (!_shaderController.isLoaded) {
+      return widget.child;
+    }
+
+    return CustomPaint(
+      painter: _${className}Painter(
+        shader: _shaderController,
+`;
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uResolution' && uniform.name !== 'uTexture') {
+                const propName = this.toCamelCase(uniform.name.replace('u', ''));
+                if (uniform.name === 'uTime') {
+                    code += `        ${propName}: _time,\n`;
+                }
+                else {
+                    code += `        ${propName}: widget.${propName},\n`;
+                }
+            }
+        }
+        code += `      ),
+      child: widget.child,
+    );
+  }
+}
+
+class _${className}Painter extends CustomPainter {
+  final ${className}Shader shader;
+`;
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uResolution' && uniform.name !== 'uTexture') {
+                const dartType = this.glslTypeToDart(uniform.type);
+                code += `  final ${dartType} ${this.toCamelCase(uniform.name.replace('u', ''))};\n`;
+            }
+        }
+        code += `
+  _${className}Painter({
+    required this.shader,
+`;
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uResolution' && uniform.name !== 'uTexture') {
+                code += `    required this.${this.toCamelCase(uniform.name.replace('u', ''))},\n`;
+            }
+        }
+        code += `  });
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final fragmentShader = shader.getShader(
+`;
+        for (const uniform of config.uniforms) {
+            if (uniform.type !== 'sampler2D' && uniform.name !== 'uTexture') {
+                const camelName = this.toCamelCase(uniform.name);
+                if (uniform.name === 'uResolution') {
+                    code += `      ${camelName}: Offset(size.width, size.height),\n`;
+                }
+                else {
+                    code += `      ${camelName}: ${this.toCamelCase(uniform.name.replace('u', ''))},\n`;
+                }
+            }
+        }
+        code += `    );
+
+    if (fragmentShader != null) {
+      final paint = Paint()..shader = fragmentShader;
+      canvas.drawRect(Offset.zero & size, paint);
+    }
+  }
+
+  @override
+  bool shouldRepaint(covariant _${className}Painter oldDelegate) {
+    return `;
+        const props = config.uniforms
+            .filter(u => u.type !== 'sampler2D' && u.name !== 'uResolution' && u.name !== 'uTexture')
+            .map(u => this.toCamelCase(u.name.replace('u', '')));
+        code += props.map(p => `${p} != oldDelegate.${p}`).join(' || ') || 'false';
+        code += `;
+  }
+}
+`;
+        return code;
+    }
+    // ===========================================================================
+    // LIBRARY GENERATION
+    // ===========================================================================
+    generateDartLibrary(name, shaders) {
+        const libraryName = this.toSnakeCase(name);
+        let code = `/// ${name} Shader Library
+/// Generated by FlutterAI Impeller Shader Generator
+library ${libraryName}_shaders;
+
+`;
+        for (const shader of shaders) {
+            code += `export '${shader.config.name}_shader.dart';\n`;
+            if (shader.flutterWidget) {
+                code += `export '${shader.config.name}_widget.dart';\n`;
+            }
+        }
+        return code;
+    }
+    generatePubspecEntry(name) {
+        return `  # Add to pubspec.yaml under flutter > assets:
+  flutter:
+    assets:
+      - shaders/
+
+  # Or to include specific shaders:
+  flutter:
+    shaders:
+      - shaders/${name}_blur_gaussian.frag
+      - shaders/${name}_glow.frag
+      # Add other shaders as needed
+`;
+    }
+    generateReadme(name, shaders) {
+        let readme = `# ${name} Shader Library
+
+Generated by FlutterAI Impeller Shader Generator
+
+## Included Shaders
+
+`;
+        for (const shader of shaders) {
+            readme += `### ${shader.config.name}
+- **Effect:** ${shader.config.effect}
+- **Performance:** ${shader.metadata.estimatedPerformance}
+- **Complexity:** ${shader.metadata.complexity}
+- **Uniforms:** ${shader.metadata.uniformCount}
+
+`;
+        }
+        readme += `## Usage
+
+\`\`\`dart
+import 'package:your_app/${this.toSnakeCase(name)}_shaders.dart';
+
+// Use as widget
+${this.toPascalCase(name)}BlurGaussianEffect(
+  radius: 10.0,
+  child: Image.asset('your_image.png'),
+)
+
+// Or use shader directly
+final shader = ${this.toPascalCase(name)}BlurGaussianShader();
+await shader.load();
+final fragmentShader = shader.getShader(
+  uRadius: 10.0,
+  uResolution: Offset(width, height),
+);
+\`\`\`
+
+## Setup
+
+1. Copy shader files (\`.frag\`) to \`assets/shaders/\`
+2. Copy Dart files to your lib folder
+3. Add to pubspec.yaml:
+
+\`\`\`yaml
+flutter:
+  assets:
+    - assets/shaders/
+\`\`\`
+`;
+        return readme;
+    }
+    // ===========================================================================
+    // UTILITY METHODS
+    // ===========================================================================
+    normalizeConfig(config) {
+        const effect = config.effect || EffectType.BLUR_GAUSSIAN;
+        const defaults = this.getDefaultUniforms(effect);
+        return {
+            name: config.name || this.generateShaderName(effect),
+            type: config.type || ShaderType.FRAGMENT,
+            effect,
+            uniforms: config.uniforms || defaults,
+            animated: config.animated ?? this.isAnimatedEffect(effect),
+            optimizationLevel: config.optimizationLevel || 'medium'
+        };
+    }
+    getDefaultUniforms(effect) {
+        const base = [
+            { name: 'uResolution', type: 'vec2', description: 'Screen resolution' },
+            { name: 'uTexture', type: 'sampler2D', description: 'Input texture' }
+        ];
+        switch (effect) {
+            case EffectType.BLUR_GAUSSIAN:
+                return [...base, { name: 'uRadius', type: 'float', defaultValue: 10, range: { min: 0, max: 50 } }];
+            case EffectType.BLUR_MOTION:
+                return [...base,
+                    { name: 'uDirection', type: 'vec2', defaultValue: [1, 0] },
+                    { name: 'uStrength', type: 'float', defaultValue: 10, range: { min: 0, max: 50 } }
+                ];
+            case EffectType.GLOW:
+                return [...base,
+                    { name: 'uIntensity', type: 'float', defaultValue: 1, range: { min: 0, max: 3 } },
+                    { name: 'uThreshold', type: 'float', defaultValue: 0.5, range: { min: 0, max: 1 } },
+                    { name: 'uGlowColor', type: 'vec3', defaultValue: [1, 1, 1] }
+                ];
+            case EffectType.RIPPLE:
+                return [...base,
+                    { name: 'uCenter', type: 'vec2', defaultValue: [0.5, 0.5] },
+                    { name: 'uTime', type: 'float', defaultValue: 0 },
+                    { name: 'uAmplitude', type: 'float', defaultValue: 0.03, range: { min: 0, max: 0.1 } },
+                    { name: 'uFrequency', type: 'float', defaultValue: 20, range: { min: 1, max: 50 } },
+                    { name: 'uSpeed', type: 'float', defaultValue: 3, range: { min: 0.5, max: 10 } }
+                ];
+            case EffectType.CHROMATIC_ABERRATION:
+                return [...base,
+                    { name: 'uStrength', type: 'float', defaultValue: 0.01, range: { min: 0, max: 0.05 } },
+                    { name: 'uCenter', type: 'vec2', defaultValue: [0.5, 0.5] }
+                ];
+            case EffectType.PIXELATE:
+                return [...base,
+                    { name: 'uPixelSize', type: 'float', defaultValue: 8, range: { min: 1, max: 32 } }
+                ];
+            case EffectType.VIGNETTE:
+                return [...base,
+                    { name: 'uIntensity', type: 'float', defaultValue: 1.5, range: { min: 0, max: 3 } },
+                    { name: 'uSmoothness', type: 'float', defaultValue: 0.4, range: { min: 0, max: 1 } }
+                ];
+            case EffectType.WAVE:
+                return [...base,
+                    { name: 'uTime', type: 'float', defaultValue: 0 },
+                    { name: 'uAmplitude', type: 'float', defaultValue: 0.02, range: { min: 0, max: 0.1 } },
+                    { name: 'uFrequency', type: 'float', defaultValue: 10, range: { min: 1, max: 30 } },
+                    { name: 'uHorizontal', type: 'int', defaultValue: 1 }
+                ];
+            default:
+                return base;
+        }
+    }
+    isAnimatedEffect(effect) {
+        return [EffectType.RIPPLE, EffectType.WAVE, EffectType.DISSOLVE, EffectType.NOISE].includes(effect);
+    }
+    glslTypeToDart(type) {
+        switch (type) {
+            case 'float': return 'double';
+            case 'vec2': return 'Offset';
+            case 'vec3': return 'List<double>';
+            case 'vec4': return 'Color';
+            case 'mat4': return 'Matrix4';
+            case 'sampler2D': return 'ui.Image';
+            case 'int': return 'int';
+            default: return 'dynamic';
+        }
+    }
+    getDefaultValue(uniform) {
+        if (uniform.defaultValue !== undefined) {
+            if (Array.isArray(uniform.defaultValue)) {
+                switch (uniform.type) {
+                    case 'vec2': return `Offset(${uniform.defaultValue[0]}, ${uniform.defaultValue[1]})`;
+                    case 'vec3': return `[${uniform.defaultValue.join(', ')}]`;
+                    case 'vec4': return `Color.fromRGBO(${uniform.defaultValue.map(v => Math.round(v * 255)).join(', ')}, 1.0)`;
+                    default: return uniform.defaultValue.toString();
+                }
+            }
+            return uniform.defaultValue.toString();
+        }
+        switch (uniform.type) {
+            case 'float': return '0.0';
+            case 'vec2': return 'Offset.zero';
+            case 'vec3': return '[0.0, 0.0, 0.0]';
+            case 'vec4': return 'Colors.white';
+            case 'int': return '0';
+            default: return 'null';
+        }
+    }
+    getWidgetDefaultValue(uniform) {
+        if (uniform.defaultValue !== undefined) {
+            if (Array.isArray(uniform.defaultValue)) {
+                switch (uniform.type) {
+                    case 'vec2': return `const Offset(${uniform.defaultValue[0]}, ${uniform.defaultValue[1]})`;
+                    case 'vec3': return `const [${uniform.defaultValue.join(', ')}]`;
+                    case 'vec4': return `const Color.fromRGBO(${uniform.defaultValue.map(v => Math.round(v * 255)).join(', ')}, 1.0)`;
+                    default: return uniform.defaultValue.toString();
+                }
+            }
+            return uniform.defaultValue.toString();
+        }
+        return this.getDefaultValue(uniform);
+    }
+    getFloatCount(type) {
+        switch (type) {
+            case 'float': return 1;
+            case 'vec2': return 2;
+            case 'vec3': return 3;
+            case 'vec4': return 4;
+            case 'mat4': return 16;
+            default: return 1;
+        }
+    }
+    estimatePerformance(config) {
+        const expensive = [EffectType.BLUR_GAUSSIAN, EffectType.GLOW, EffectType.NOISE];
+        const moderate = [EffectType.BLUR_MOTION, EffectType.RIPPLE, EffectType.DISSOLVE];
+        if (expensive.includes(config.effect)) {
+            return config.optimizationLevel === 'high' ? 'moderate' : 'poor';
+        }
+        if (moderate.includes(config.effect)) {
+            return config.optimizationLevel === 'high' ? 'good' : 'moderate';
+        }
+        return 'excellent';
+    }
+    calculateComplexity(code) {
+        let complexity = 0;
+        // Count loops
+        complexity += (code.match(/for\s*\(/g) || []).length * 10;
+        // Count texture samples
+        complexity += (code.match(/texture\s*\(/g) || []).length * 5;
+        // Count math operations
+        complexity += (code.match(/(sin|cos|pow|exp|sqrt)/g) || []).length * 2;
+        return Math.min(100, complexity);
+    }
+    generateShaderId() {
+        return `shader_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateBundleId() {
+        return `bundle_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateShaderName(effect) {
+        return effect.replace(/_/g, '_');
+    }
+    toPascalCase(str) {
+        return str
+            .split(/[_\-\s]+/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    toCamelCase(str) {
+        const pascal = this.toPascalCase(str);
+        return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    }
+    toSnakeCase(str) {
+        return str
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '')
+            .replace(/[^a-z0-9]+/g, '_');
+    }
+    // ===========================================================================
+    // PUBLIC API
+    // ===========================================================================
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.emit('configUpdated', this.config);
+    }
+    /**
+     * Get all generated shaders
+     */
+    getGeneratedShaders() {
+        return Array.from(this.generatedShaders.values());
+    }
+    /**
+     * Get a specific generated shader
+     */
+    getShader(shaderId) {
+        return this.generatedShaders.get(shaderId);
+    }
+    /**
+     * List available effect types
+     */
+    listEffectTypes() {
+        return Object.values(EffectType);
+    }
+}
+// =============================================================================
+// EXPORTS
+// =============================================================================
+export default ImpellerShaderGenerator;
+//# sourceMappingURL=ImpellerShaderGenerator.js.map