three-zoo 0.11.2 → 0.11.3

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { DualFovCamera } from "./DualFovCamera";
+export { BasicToPhysicalConverter } from "./materialConverters/BasicToPhysicalConverter";
 export { StandardToBasicConverter } from "./materialConverters/StandardToBasicConverter";
 export { StandardToLambertConverter } from "./materialConverters/StandardToLambertConverter";
 export { StandardToPhongConverter } from "./materialConverters/StandardToPhongConverter";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { PerspectiveCamera, MathUtils, Vector3, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, Color, MeshPhysicalMaterial, MeshToonMaterial, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical } from 'three';
+import { PerspectiveCamera, MathUtils, Vector3, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical } from 'three';
 
 /** Default horizontal field of view in degrees */
 const DEFAULT_HORIZONTAL_FOV = 90;
@@ -242,6 +242,111 @@ class DualFovCamera extends PerspectiveCamera {
     }
 }
 
+class BasicToPhysicalConverter {
+    static convert(material, options = {}) {
+        const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false }, options);
+        const physicalMaterial = new MeshPhysicalMaterial();
+        this.copyBasicProperties(material, physicalMaterial, config);
+        this.convertColorAndPBRProperties(material, physicalMaterial, config);
+        this.convertTextureMaps(material, physicalMaterial);
+        this.convertTransparencyProperties(material, physicalMaterial);
+        this.applyPhysicalProperties(physicalMaterial, config);
+        if (config.disposeOriginal) {
+            material.dispose();
+        }
+        physicalMaterial.needsUpdate = true;
+        return physicalMaterial;
+    }
+    static copyBasicProperties(source, target, config) {
+        if (config.preserveName) {
+            target.name = source.name;
+        }
+        target.side = source.side;
+        target.visible = source.visible;
+        target.fog = source.fog;
+        target.wireframe = source.wireframe;
+        target.wireframeLinewidth = source.wireframeLinewidth;
+        target.wireframeLinecap = source.wireframeLinecap;
+        target.wireframeLinejoin = source.wireframeLinejoin;
+        target.vertexColors = source.vertexColors;
+        if (config.copyUserData && source.userData) {
+            target.userData = Object.assign({}, source.userData);
+        }
+    }
+    static convertColorAndPBRProperties(source, target, config) {
+        if (source.color) {
+            target.color = source.color.clone();
+        }
+        if (config.emissive !== undefined) {
+            if (config.emissive instanceof Color) {
+                target.emissive.copy(config.emissive);
+            }
+            else {
+                target.emissive.set(config.emissive);
+            }
+        }
+        if (config.emissiveIntensity !== undefined) {
+            target.emissiveIntensity = config.emissiveIntensity;
+        }
+        if (config.metalness !== undefined) {
+            target.metalness = config.metalness;
+        }
+        if (config.roughness !== undefined) {
+            target.roughness = config.roughness;
+        }
+    }
+    static convertTextureMaps(source, target) {
+        if (source.map) {
+            target.map = source.map;
+        }
+        if (source.alphaMap) {
+            target.alphaMap = source.alphaMap;
+        }
+        if (source.lightMap) {
+            target.lightMap = source.lightMap;
+            target.lightMapIntensity = source.lightMapIntensity;
+        }
+        if (source.aoMap) {
+            target.aoMap = source.aoMap;
+            target.aoMapIntensity = source.aoMapIntensity;
+        }
+        if (source.envMap) {
+            target.envMap = source.envMap;
+        }
+    }
+    static convertTransparencyProperties(source, target) {
+        target.transparent = source.transparent;
+        target.opacity = source.opacity;
+        target.alphaTest = source.alphaTest;
+        target.depthTest = source.depthTest;
+        target.depthWrite = source.depthWrite;
+        target.blending = source.blending;
+        target.blendSrc = source.blendSrc;
+        target.blendDst = source.blendDst;
+        target.blendEquation = source.blendEquation;
+        target.blendSrcAlpha = source.blendSrcAlpha;
+        target.blendDstAlpha = source.blendDstAlpha;
+        target.blendEquationAlpha = source.blendEquationAlpha;
+    }
+    static applyPhysicalProperties(target, config) {
+        if (config.clearcoat !== undefined) {
+            target.clearcoat = config.clearcoat;
+        }
+        if (config.clearcoatRoughness !== undefined) {
+            target.clearcoatRoughness = config.clearcoatRoughness;
+        }
+        if (config.sheen !== undefined) {
+            target.sheen = config.sheen;
+        }
+        if (config.transmission !== undefined) {
+            target.transmission = config.transmission;
+        }
+        if (config.ior !== undefined) {
+            target.ior = config.ior;
+        }
+    }
+}
+
 /** Factor for metalness brightness adjustment */
 const METALNESS_BRIGHTNESS_FACTOR = 0.3;
 /** Factor for emissive color contribution when combining with base color */
@@ -1660,5 +1765,5 @@ class Sun extends DirectionalLight {
     }
 }
 
-export { DualFovCamera, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
+export { BasicToPhysicalConverter, DualFovCamera, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
 //# sourceMappingURL=index.js.map