three-cad-viewer 4.3.2 → 4.3.5

package/dist/three-cad-viewer.js

@@ -83127,10 +83127,12 @@ void main() {
 	            }
 	        }
 	        // --- Anisotropy (brushed metal) ---
-	        // Skipped: anisotropic reflections require tangent vectors on the mesh.
-	        // CAD tessellation never provides tangents, so Three.js falls back to
-	        // screen-space derivative tangents which produce visible diamond-shaped
-	        // facet artifacts on coarse meshes.
+	        if (def.anisotropy !== undefined && def.anisotropy > 0) {
+	            material.anisotropy = def.anisotropy;
+	            if (def.anisotropyRotation !== undefined) {
+	                material.anisotropyRotation = def.anisotropyRotation;
+	            }
+	        }
 	        // --- Textures ---
 	        // Resolve all texture references via TextureCache.
 	        // The TextureCache determines colorSpace internally from the texture role name.
@@ -83147,13 +83149,14 @@ void main() {
 	     * "roughness", "normal") where each entry has an optional `value` (scalar or
 	     * [r,g,b] array in **linear RGB**) and/or `texture` (inline data URI).
 	     *
-	     * @param properties - Material properties from threejs-materials
+	     * @param values - Scalar PBR values from threejs-materials
+	     * @param textures - Texture map references from threejs-materials
 	     * @param textureRepeat - Optional [u, v] texture tiling applied to all loaded textures
 	     * @param textureCache - TextureCache for resolving data URI textures
 	     * @param label - Optional label for GPU tracking
 	     * @returns Configured MeshPhysicalMaterial
 	     */
-	    async createStudioMaterialFromMaterialX(properties, textureRepeat, textureCache, label) {
+	    async createStudioMaterialFromMaterialX(values, textures, textureRepeat, textureCache, label) {
 	        // --- Build material options from scalar values ---
 	        const matOptions = {
 	            flatShading: false,
@@ -83164,37 +83167,32 @@ void main() {
 	            depthTest: true,
 	        };
 	        // Warn once if displacement data is present (not supported in Studio)
-	        if (properties.displacement?.texture || properties.displacementScale?.value !== undefined) {
+	        if (textures.displacement || values.displacementScale !== undefined) {
 	            logger.warn("Displacement not supported by the Studio");
 	        }
-	        for (const [key, prop] of Object.entries(properties)) {
-	            if (prop.value === undefined)
-	                continue;
+	        for (const [key, value] of Object.entries(values)) {
 	            // Skip displacement properties (not supported, would waste GPU memory)
 	            if (key === "displacement" || key === "displacementScale" || key === "displacementBias")
 	                continue;
-	            // Skip anisotropy — requires tangent vectors that CAD meshes don't have
-	            if (key === "anisotropy" || key === "anisotropyRotation")
-	                continue;
 	            // Color arrays → THREE.Color (already linear, no sRGB conversion)
-	            if (COLOR_ARRAY_KEYS.has(key) && Array.isArray(prop.value)) {
-	                const [r, g, b] = prop.value;
+	            if (COLOR_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+	                const [r, g, b] = value;
 	                matOptions[key] = new Color(r, g, b);
 	            }
-	            else if ((key === "normalScale" || key === "clearcoatNormalScale") && Array.isArray(prop.value)) {
-	                matOptions[key] = new Vector2(prop.value[0], prop.value[1]);
+	            else if ((key === "normalScale" || key === "clearcoatNormalScale") && Array.isArray(value)) {
+	                matOptions[key] = new Vector2(value[0], value[1]);
 	            }
-	            else if (key === "iridescenceThicknessRange" && Array.isArray(prop.value)) {
-	                matOptions[key] = prop.value;
+	            else if (key === "iridescenceThicknessRange" && Array.isArray(value)) {
+	                matOptions[key] = value;
 	            }
 	            else {
-	                matOptions[key] = prop.value;
+	                matOptions[key] = value;
 	            }
 	        }
 	        // --- Handle transmission ---
-	        const transmissionVal = properties.transmission?.value;
-	        const opacityVal = properties.opacity?.value;
-	        const transparentVal = properties.transparent?.value;
+	        const transmissionVal = values.transmission;
+	        const opacityVal = values.opacity;
+	        const transparentVal = values.transparent;
 	        if (typeof transmissionVal === "number" && transmissionVal > 0) {
 	            matOptions.transparent = false;
 	            matOptions.opacity = 1.0;
@@ -83212,9 +83210,7 @@ void main() {
 	        // --- Resolve textures ---
 	        let hasTextures = false;
 	        if (textureCache) {
-	            for (const [key, prop] of Object.entries(properties)) {
-	                if (!prop.texture)
-	                    continue;
+	            for (const [key, textureRef] of Object.entries(textures)) {
 	                const mapName = PROPERTY_TO_MAP[key];
 	                if (!mapName)
 	                    continue;
@@ -83225,7 +83221,7 @@ void main() {
 	                const roleForCache = colorSpace === SRGBColorSpace
 	                    ? "baseColorTexture"
 	                    : "normalTexture";
-	                const tex = await textureCache.get(prop.texture, roleForCache);
+	                const tex = await textureCache.get(textureRef, roleForCache);
 	                if (tex) {
 	                    if (textureRepeat) {
 	                        tex.repeat.set(textureRepeat[0], textureRepeat[1]);
@@ -83346,9 +83342,9 @@ void main() {
 	        const sheenRoughnessTex = await resolve(def.sheenRoughnessMap, "sheenRoughnessTexture");
 	        if (sheenRoughnessTex)
 	            material.sheenRoughnessMap = sheenRoughnessTex;
-	        // Anisotropy texture skipped — CAD meshes lack tangent vectors.
-	        // const anisotropyTex = await resolve(def.anisotropyMap, "anisotropyTexture");
-	        // if (anisotropyTex) material.anisotropyMap = anisotropyTex;
+	        const anisotropyTex = await resolve(def.anisotropyMap, "anisotropyTexture");
+	        if (anisotropyTex)
+	            material.anisotropyMap = anisotropyTex;
 	    }
 	    /**
 	     * Update global settings.
@@ -83386,10 +83382,10 @@ void main() {
 	})(exports.CollapseState || (exports.CollapseState = {}));
 	/**
 	 * Type guard to check if a material entry is a threejs-materials format dict.
-	 * Detected by the presence of the `properties` key.
+	 * Detected by the presence of the `values` key.
 	 */
 	function isMaterialXMaterial(m) {
-	    return typeof m === "object" && m !== null && "properties" in m;
+	    return typeof m === "object" && m !== null && "values" in m;
 	}
 	/**
 	 * Check if shape uses binary format (has triangles_per_face).
@@ -84007,13 +84003,9 @@ float metalnessFactor = metalness;
 	    }
 	    return false;
 	}
-	/** Check whether a threejs-materials entry has texture references in its properties. */
+	/** Check whether a threejs-materials entry has texture references. */
 	function materialXHasTextures(entry) {
-	    for (const [, prop] of Object.entries(entry.properties)) {
-	        if (prop.texture)
-	            return true;
-	    }
-	    return false;
+	    return Object.keys(entry.textures).length > 0;
 	}
 	class NestedGroup {
 	    /**
@@ -84131,7 +84123,7 @@ float metalnessFactor = metalness;
 	                logger.warn(`Invalid material string '${entry}' for tag '${tag}' (expected "builtin:" prefix)`);
 	                return null;
 	            }
-	            // MaterialXMaterial entry: object with `properties` key
+	            // MaterialXMaterial entry: object with `values` key
 	            if (isMaterialXMaterial(entry)) {
 	                this.resolvedMaterialX.set(tag, entry);
 	                return entry;
@@ -84145,11 +84137,15 @@ float metalnessFactor = metalness;
 	                    logger.warn(`Unknown builtin preset '${presetName}' referenced by '${tag}' on '${objectPath}'`);
 	                    return null;
 	                }
-	                const resolved = { ...preset, ...appearance };
+	                // Strip preset color unless the user explicitly provides one,
+	                // so the leaf node's CAD color is used as fallback.
+	                const { color: presetColor, ...presetRest } = preset;
+	                const resolved = "color" in appearance
+	                    ? { ...preset, ...appearance }
+	                    : { ...presetRest, ...appearance };
 	                this.resolvedMaterials.set(tag, resolved);
 	                return resolved;
 	            }
-	            // Should not happen with current type, but guard anyway
 	            logger.warn(`Unrecognised material entry for tag '${tag}' on '${objectPath}'`);
 	            return null;
 	        }
@@ -84763,7 +84759,7 @@ float metalnessFactor = metalness;
 	                try {
 	                    if (resolved && isMaterialXMaterial(resolved)) {
 	                        // --- threejs-materials path ---
-	                        studioMaterial = await this.materialFactory.createStudioMaterialFromMaterialX(resolved.properties, resolved.textureRepeat, this._textureCache);
+	                        studioMaterial = await this.materialFactory.createStudioMaterialFromMaterialX(resolved.values, resolved.textures, resolved.textureRepeat, this._textureCache);
 	                        if (materialXHasTextures(resolved)) {
 	                            this._texturedMaterialKeys.add(sharingKey);
 	                        }
@@ -84840,6 +84836,18 @@ float metalnessFactor = metalness;
 	                }
 	                studioBack = cachedBack;
 	            }
+	            // Compute tangents for anisotropic materials (required by Three.js)
+	            if (studioMaterial instanceof MeshPhysicalMaterial &&
+	                studioMaterial.anisotropy > 0 &&
+	                obj.shapeGeometry?.getAttribute("uv") != null &&
+	                obj.shapeGeometry.getAttribute("tangent") == null) {
+	                try {
+	                    obj.shapeGeometry.computeTangents();
+	                }
+	                catch {
+	                    logger.debug(`Studio "${path}": tangent computation failed, anisotropy may have artifacts`);
+	                }
+	            }
 	            // Apply to ObjectGroup
 	            obj.enterStudioMode(studioMaterial instanceof MeshPhysicalMaterial ? studioMaterial : null, studioBack);
 	        }
@@ -87476,6 +87484,15 @@ float metalnessFactor = metalness;
 	        const z = this.distanceToPoint(new Vector3(0, 0, 0));
 	        this.constant = z - c + value;
 	    }
+	    /**
+	     * Clone this CenteredPlane.
+	     * Overrides THREE.Plane.clone() which calls `new this.constructor()` without
+	     * arguments, causing `center` to be undefined during shadow map generation.
+	     */
+	    // @ts-expect-error -- THREE.Plane.clone() returns `this`, but we need a concrete CenteredPlane
+	    clone() {
+	        return new CenteredPlane(this.normal.clone(), this.centeredConstant, [...this.center]);
+	    }
 	}
 	// ============================================================================
 	// PlaneMesh - Visual representation of a clipping plane
@@ -94290,7 +94307,7 @@ float metalnessFactor = metalness;
 	    }
 	}
 
-	const version = "4.3.2";
+	const version = "4.3.5";
 
 	/**
 	 * Clean room environment for Studio mode PMREM generation.
@@ -95915,7 +95932,7 @@ float metalnessFactor = metalness;
 	     * Create a shadow-receiving plane at the floor position.
 	     */
 	    _createShadowPlane(zPosition, sceneSize) {
-	        const floorSize = sceneSize * 4;
+	        const floorSize = sceneSize * 6;
 	        const geometry = new PlaneGeometry(floorSize, floorSize);
 	        const material = new ShadowMaterial({ opacity: 0.5, depthWrite: false });
 	        const plane = new Mesh(geometry, material);
@@ -104762,7 +104779,7 @@ void mainImage(const in vec4 inputColor, const in vec2 uv, const in float depth,
 	            light.position.copy(bboxCenter).addScaledVector(dir, maxExtent * 3);
 	            light.target.position.copy(bboxCenter);
 	            light.castShadow = true;
-	            const frustumSize = maxExtent * 4.0;
+	            const frustumSize = maxExtent * 6.0;
 	            light.shadow.camera.left = -frustumSize;
 	            light.shadow.camera.right = frustumSize;
 	            light.shadow.camera.top = frustumSize;