@3driseai/3drise-core 1.0.1

package/dist/services/MaterialRegistry.js

@@ -0,0 +1,362 @@
+// =============================================================================
+// MATERIAL REGISTRY - UNIFIED MATERIAL MANAGEMENT SYSTEM
+// =============================================================================
+import { FrontSide, ShaderMaterial } from 'three';
+import { uniformConverter } from './UniformConverter.js';
+import { settingsToProps } from '../utils/materialUtils.js';
+import { compileShaders } from '../utils/utils.js';
+import materials from '..//data/allMaterials.js';
+// =============================================================================
+// MATERIAL REGISTRY
+// =============================================================================
+const MaterialRegistry = materials;
+// =============================================================================
+// UNIFORM DISCOVERY UTILITIES
+// =============================================================================
+/**
+ * Discover uniforms from a material instance
+ */
+function getUniforms(material) {
+    const uniforms = {};
+    if (material.uniforms) {
+        const shaderUniforms = material.uniforms;
+        Object.keys(shaderUniforms).forEach(key => {
+            const uniform = shaderUniforms[key];
+            uniforms[key] = {
+                value: uniform.value,
+                type: inferUniformType(key, uniform.value)
+            };
+        });
+    }
+    // Handle standard Three.js materials
+    return uniforms;
+}
+/**
+ * Infer uniform type from key name and value
+ */
+function inferUniformType(key, value) {
+    // Type inference based on key name patterns
+    if (key.toLowerCase().includes('color'))
+        return 'color';
+    if (key.toLowerCase().includes('texture') || key.toLowerCase().includes('map'))
+        return 'texture';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'number')
+        return 'float';
+    if (value && typeof value === 'object') {
+        if (value.x !== undefined && value.y !== undefined) {
+            if (value.z !== undefined)
+                return 'vec3';
+            return 'vec2';
+        }
+    }
+    return 'float';
+}
+// =============================================================================
+// MATERIAL FACTORY — Direct Creation (No Pool)
+// =============================================================================
+//
+// Materials are created fresh each time. This is intentional:
+// - `new MeshStandardMaterial()` is very cheap (just sets JS properties)
+// - Three.js internally caches compiled shader programs (WebGLPrograms)
+// - A pool with settings-based keys almost never gets cache hits in practice
+// - Shared pooled materials cause mutation bugs when settings differ per object
+// - Disposal is handled by the consumer (useMaterialApplication cleanup)
+//
+/**
+ * Create a fresh Three.js material instance for the given type + variant.
+ * The material gets `transparent: true` and `side: DoubleSide` by default.
+ */
+function createMaterialInstance(type, variant) {
+    const actualVariant = variant || MaterialRegistry[type].defaultVariant;
+    const variantDef = MaterialRegistry[type].variants[actualVariant];
+    if (!variantDef) {
+        throw new Error(`Unknown variant "${actualVariant}" for material type "${type}"`);
+    }
+    let material;
+    // Handle user shader variants (no materialClass, has _shaderSource)
+    if (!variantDef.materialClass && variantDef._shaderSource) {
+        const { vertex, fragment, uniforms: uniformDefs } = variantDef._shaderSource;
+        const compiled = compileShaders(uniformDefs, vertex, fragment);
+        // Build default settings from uniform definitions
+        const defaultSettings = {};
+        uniformDefs.forEach((u) => {
+            defaultSettings[u.name] = u.defaultValue;
+        });
+        const convertedUniforms = uniformConverter.convertToUniforms(defaultSettings);
+        const threeUniforms = {};
+        Object.keys(convertedUniforms).forEach(key => {
+            threeUniforms[key] = { value: convertedUniforms[key] };
+        });
+        material = new ShaderMaterial({
+            vertexShader: compiled.vertex,
+            fragmentShader: compiled.fragment,
+            uniforms: threeUniforms,
+            transparent: true,
+            side: FrontSide,
+        });
+    }
+    else {
+        material = new variantDef.materialClass();
+    }
+    material.transparent = true;
+    material.side = FrontSide;
+    return material;
+}
+// =============================================================================
+// EXPORTS
+// =============================================================================
+export const MaterialRegistryAPI = {
+    // Get available types
+    getTypes() {
+        return Object.keys(MaterialRegistry);
+    },
+    // Get variants for a type
+    getVariants(type) {
+        if (type) {
+            return Object.keys(MaterialRegistry[type].variants);
+        }
+        const allVariants = [];
+        for (const typeKey in MaterialRegistry) {
+            const typeVariants = Object.keys(MaterialRegistry[typeKey].variants);
+            allVariants.push(...typeVariants);
+        }
+        return allVariants;
+    },
+    getMaterialByMaterialClass(materialClass) {
+        for (const typeKey in MaterialRegistry) {
+            const type = typeKey;
+            const variants = MaterialRegistry[type].variants;
+            for (const variantKey in variants) {
+                const variant = variants[variantKey];
+                const typeOfVariant = typeof variant.materialClass;
+                if (typeOfVariant === materialClass) {
+                    return variant;
+                }
+            }
+        }
+        return null;
+    },
+    // Get type definition
+    getTypeDefinition(type) {
+        return MaterialRegistry[type];
+    },
+    // Get variant definition
+    getVariantDefinition(variant) {
+        const type = this.getTypeFromVariantName(variant);
+        if (!type) {
+            throw new Error(`Unknown material variant "${variant}"`);
+        }
+        return MaterialRegistry[type].variants[variant];
+    },
+    getTypeFromVariantName(variantName) {
+        for (const typeKey in MaterialRegistry) {
+            const type = typeKey;
+            if (Object.prototype.hasOwnProperty.call(MaterialRegistry[type].variants, variantName)) {
+                return type;
+            }
+        }
+        return null;
+    },
+    /**
+     * Get texture properties for a material variant from the registry definition.
+     * Returns the explicitly defined textureProperties array, or falls back to
+     * heuristic detection from defaultSettings keys containing 'map' or 'texture'.
+     */
+    getTextureProperties(variant) {
+        const type = this.getTypeFromVariantName(variant);
+        if (!type) {
+            return [];
+        }
+        const variantDef = MaterialRegistry[type].variants[variant];
+        if (!variantDef) {
+            return [];
+        }
+        // Prefer explicitly defined textureProperties
+        if (variantDef.textureProperties && variantDef.textureProperties.length > 0) {
+            return variantDef.textureProperties;
+        }
+        // Fallback: infer from defaultSettings keys
+        if (!variantDef.defaultSettings) {
+            return [];
+        }
+        return Object.keys(variantDef.defaultSettings).filter(key => {
+            const lowerKey = key.toLowerCase();
+            return lowerKey.includes('map') || lowerKey.includes('texture');
+        });
+    },
+    /**
+     * Get available color properties for a material variant
+     * Returns property paths like ['color'], ['color', 'specular', 'emissive'], or ['uniforms.uColor']
+     */
+    getColorProperties(variant) {
+        const type = this.getTypeFromVariantName(variant);
+        if (!type) {
+            return ['color']; // Default fallback
+        }
+        const variantDef = MaterialRegistry[type].variants[variant];
+        if (!variantDef?.defaultSettings) {
+            return ['color'];
+        }
+        const colorProps = [];
+        const settings = variantDef.defaultSettings;
+        for (const key in settings) {
+            const lowerKey = key.toLowerCase();
+            // Check for color-related keys
+            if (lowerKey.includes('color') && !lowerKey.includes('colormap')) {
+                // For shader materials with uniforms (keys starting with 'u')
+                if (key.startsWith('u') && key.length > 1 && key[1] === key[1].toUpperCase()) {
+                    colorProps.push(`uniforms.${key}`);
+                }
+                else {
+                    colorProps.push(key);
+                }
+            }
+            // Also check for specular and emissive which are color properties
+            if (lowerKey === 'specular' || lowerKey === 'emissive') {
+                colorProps.push(key);
+            }
+        }
+        // Ensure at least 'color' is returned
+        if (colorProps.length === 0) {
+            colorProps.push('color');
+        }
+        return colorProps;
+    },
+    // Create a fresh material instance with uniform discovery.
+    // Each call creates a new material — no pooling, no shared state.
+    // Disposal is the caller's responsibility (e.g., useMaterialApplication cleanup).
+    createMaterial(variant) {
+        const type = this.getTypeFromVariantName(variant);
+        if (!type) {
+            throw new Error(`Unknown material variant "${variant}"`);
+        }
+        const material = createMaterialInstance(type, variant);
+        const uniforms = getUniforms(material);
+        const materialSettings = this.getVariantDefinition(variant).defaultSettings || {};
+        return {
+            material,
+            uniforms,
+            settings: materialSettings,
+            type,
+            variant
+        };
+    },
+    // Update material uniforms
+    updateUniforms(materialInstance, newUniforms) {
+        const { material } = materialInstance;
+        Object.keys(newUniforms).forEach(key => {
+            // Skip internal MaterialRegistry properties
+            if (key === 'materialType' || key === 'materialVariant' || key === 'handlers') {
+                return;
+            }
+            if (material.uniforms && material.uniforms[key]) {
+                material.uniforms[key].value = newUniforms[key];
+            }
+            else if (key in material) {
+                // Standard material property - check if property exists on material
+                material[key] = newUniforms[key];
+            }
+        });
+        material.needsUpdate = true;
+    },
+    applySettings(material, settings) {
+        const isShader = !!material.uniforms;
+        let converted = { ...settings };
+        if (isShader) {
+            converted = uniformConverter.convertToUniforms(settings);
+        }
+        else {
+            converted = settingsToProps(settings);
+        }
+        Object.keys(converted).forEach(key => {
+            // Skip internal MaterialRegistry properties
+            if (key === 'materialType' || key === 'materialVariant' || key === 'handlers') {
+                return;
+            }
+            if (isShader && material.uniforms[key]) {
+                material.uniforms[key].value = converted[key];
+                if (key.toLowerCase().includes('texture') && converted[key] !== null && material.uniforms.uHasTexture) {
+                    material.uniforms.uHasTexture.value = true;
+                }
+            }
+            else if (key in material) {
+                material[key] = converted[key];
+            }
+        });
+        material.needsUpdate = true;
+    },
+    // Dispose a material directly. No pool — just call dispose().
+    releaseMaterial(materialInstance) {
+        if (materialInstance?.material) {
+            materialInstance.material.dispose();
+        }
+    },
+    addCustomMaterial(variant) {
+        if (MaterialRegistry.particles.variants[variant.name]) {
+            throw new Error(`Custom material variant "${variant.name}" already exists.`);
+        }
+        MaterialRegistry.particles.variants[variant.name] = {
+            name: variant.name,
+            description: `Custom shader material "${variant.name}"`,
+            materialClass: variant.materialClass,
+            defaultSettings: variant.defaultSettings
+        };
+    },
+    /**
+     * Register a user-created shader asset as a variant under the 'shaders' type.
+     * If a variant with the same name already exists, it will be updated.
+     */
+    registerUserShader(asset) {
+        if (!asset.name || !asset.vertex || !asset.fragment || !asset.uniforms) {
+            console.warn(`[MaterialRegistry] Cannot register shader "${asset.name}" — missing vertex, fragment, or uniforms.`);
+            return;
+        }
+        // Build defaultSettings from uniform definitions
+        const defaultSettings = {};
+        asset.uniforms.forEach((u) => {
+            defaultSettings[u.name] = u.defaultValue;
+        });
+        MaterialRegistry.shaders.variants[asset.name] = {
+            name: asset.name,
+            description: asset.description || `User shader "${asset.name}"`,
+            materialClass: null,
+            defaultSettings,
+            _shaderSource: {
+                vertex: asset.vertex,
+                fragment: asset.fragment,
+                uniforms: asset.uniforms,
+            }
+        };
+        // Set as default variant if it's the first one
+        if (!MaterialRegistry.shaders.defaultVariant) {
+            MaterialRegistry.shaders.defaultVariant = asset.name;
+        }
+        console.log(`[MaterialRegistry] Registered user shader: "${asset.name}"`);
+    },
+    /**
+     * Unregister a user-created shader variant by name.
+     */
+    unregisterUserShader(name) {
+        if (MaterialRegistry.shaders.variants[name]) {
+            delete MaterialRegistry.shaders.variants[name];
+            // Update defaultVariant if we removed it
+            if (MaterialRegistry.shaders.defaultVariant === name) {
+                const remaining = Object.keys(MaterialRegistry.shaders.variants);
+                MaterialRegistry.shaders.defaultVariant = remaining.length > 0 ? remaining[0] : '';
+            }
+            console.log(`[MaterialRegistry] Unregistered user shader: "${name}"`);
+        }
+    },
+    /**
+     * Get all registered user shader variant names.
+     */
+    getUserShaderVariants() {
+        return Object.keys(MaterialRegistry.shaders.variants);
+    },
+};
+// Export the registry for direct access if needed
+export { MaterialRegistry };
+// Export default API
+export default MaterialRegistryAPI;

package/dist/services/NoiseGenerator.d.ts

@@ -0,0 +1,93 @@
+import * as THREE from 'three';
+export type NoiseType = 'perlin' | 'simplex' | 'worley' | 'voronoi' | 'fractal' | 'ridged' | 'billowy' | 'white' | 'blue' | 'pink' | 'value' | 'turbulence' | 'domain-warped';
+export interface NoiseConfig {
+    type: NoiseType;
+    octaves?: number;
+    frequency?: number;
+    amplitude?: number;
+    lacunarity?: number;
+    persistence?: number;
+    seed?: number;
+    scale?: number;
+    offset?: THREE.Vector2;
+    cellSize?: number;
+    ridgeOffset?: number;
+    warpStrength?: number;
+}
+export interface GeneratedNoise {
+    glslCode: string;
+    uniforms: Record<string, {
+        value: any;
+        type?: string;
+    }>;
+    dependencies: string[];
+}
+export declare class NoiseGenerator {
+    private static permutationTable;
+    /**
+     * Generate noise function based on configuration
+     */
+    static generateNoise(config: NoiseConfig): GeneratedNoise;
+    /**
+     * Generate Perlin noise GLSL code
+     */
+    private static generatePerlinNoise;
+    /**
+     * Generate Simplex noise GLSL code
+     */
+    private static generateSimplexNoise;
+    /**
+     * Generate Worley/Voronoi noise GLSL code
+     */
+    private static generateWorleyNoise;
+    /**
+     * Generate Fractal noise GLSL code
+     */
+    private static generateFractalNoise;
+    /**
+     * Generate Ridged noise GLSL code
+     */
+    private static generateRidgedNoise;
+    /**
+     * Generate Billowy noise GLSL code
+     */
+    private static generateBillowyNoise;
+    /**
+     * Generate White noise GLSL code
+     */
+    private static generateWhiteNoise;
+    /**
+     * Generate Blue noise GLSL code
+     */
+    private static generateBlueNoise;
+    /**
+     * Generate Pink noise GLSL code
+     */
+    private static generatePinkNoise;
+    /**
+     * Generate Value noise GLSL code
+     */
+    private static generateValueNoise;
+    /**
+     * Generate Turbulence noise GLSL code
+     */
+    private static generateTurbulenceNoise;
+    /**
+     * Generate Domain Warped noise GLSL code
+     */
+    private static generateDomainWarpedNoise;
+    static getAvailableNoises(): NoiseType[];
+    /**
+     * Create a noise texture for sampling
+     */
+    static createNoiseTexture(width?: number, height?: number, type?: NoiseType, config?: Partial<NoiseConfig>): THREE.DataTexture;
+    /**
+     * Simple Perlin noise implementation for texture generation
+     */
+    private static simplePerlin;
+    private static fractalNoise;
+    private static fade;
+    private static lerp;
+    private static grad;
+}
+//# sourceMappingURL=NoiseGenerator.d.ts.map

package/dist/services/NoiseGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoiseGenerator.d.ts","sourceRoot":"","sources":["../../src/services/NoiseGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,eAAe,CAAC;AAE9K,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QACrB,KAAK,EAAE,GAAG,CAAC;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAiB7B;IACF;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc;IAgDzD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA+DlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAuDnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA8ClC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA4BnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAiClC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA8BnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAuBjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA4BhC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAkChC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAqCjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA4BtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IA0BxC,MAAM,CAAC,kBAAkB,IAAI,SAAS,EAAE;IAiBxC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,GAAE,MAAY,EAAE,MAAM,GAAE,MAAY,EAAE,IAAI,GAAE,SAAoB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,WAAW;IAqDlJ;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAe3B,OAAO,CAAC,MAAM,CAAC,YAAY;IAW3B,OAAO,CAAC,MAAM,CAAC,IAAI;IAGnB,OAAO,CAAC,MAAM,CAAC,IAAI;IAGnB,OAAO,CAAC,MAAM,CAAC,IAAI;CAMtB"}