@xviewer.js/core 1.0.0-alpha.23 → 1.0.0-alpha.26

package/dist/main.js

@@ -3182,7 +3182,19 @@ const vert_Reflector = `
 uniform mat4 textureMatrix;
 varying vec4 vUv4;
 varying vec2 vUv;
-varying vec2 vUv1;
+
+#ifdef USE_UV1
+    varying vec2 vUv1;
+#endif
+
+#ifdef USE_UV2
+    varying vec2 vUv2;
+#endif
+
+#ifdef USE_UV3
+    varying vec2 vUv3;
+#endif
+
 varying vec3 vViewPosition;
 
 #include <common>
@@ -3197,7 +3209,19 @@ void main() {
     vec4 mvPosition = viewMatrix * positionWS;
 
     vUv = uv;
+
+#ifdef USE_UV1   
     vUv1 = uv1;
+#endif
+
+#ifdef USE_UV2   
+    vUv2 = uv2;
+#endif
+
+#ifdef USE_UV3   
+    vUv3 = uv2;
+#endif
+
     vUv4 = textureMatrix * vec4(position, 1.0);
 
     vViewPosition = -mvPosition.xyz;
@@ -3215,13 +3239,25 @@ uniform sampler2D tDiffuse;
 uniform sampler2D normalMap;
 uniform sampler2D roughnessMap;
 uniform sampler2D aoMap;
-uniform float aoMapIntensity;
+uniform float     aoMapIntensity;
 uniform sampler2D lightMap;
-uniform float lightMapIntensity;
+uniform float     lightMapIntensity;
 
-varying vec4 vUv4;
 varying vec2 vUv;
-varying vec2 vUv1;
+
+#ifdef USE_UV1
+    varying vec2 vUv1;
+#endif
+
+#ifdef USE_UV2
+    varying vec2 vUv2;
+#endif
+
+#ifdef USE_UV3
+    varying vec2 vUv3;
+#endif
+
+varying vec4 vUv4;
 varying vec3 vViewPosition;
 varying vec3 vNormal;
 
@@ -3232,10 +3268,9 @@ varying vec3 vNormal;
 void main() {
     #include <logdepthbuf_fragment>
 
-    vec4 uv4 = vUv4;
-    vec4 texelNormal = texture2D(normalMap, vUv);
+    vec4 texelNormal = texture2D(normalMap, UV_NORMAL);
     vec3 normal = normalize(vec3(texelNormal.r * 2.0 - 1.0, texelNormal.b,  texelNormal.g * 2.0 - 1.0));
-    vec3 coord = uv4.xyz / uv4.w;
+    vec3 coord = vUv4.xyz / vUv4.w;
     vec2 reflectUv = coord.xy + coord.z * normal.xz * 0.05;
 
     vec3 geometryNormal = normalize(vNormal);
@@ -3249,7 +3284,7 @@ void main() {
     vec3  specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
     float specularF90 = 1.0;
 
-    float roughnessFactor = texture2D(roughnessMap, vUv).g * roughness;
+    float roughnessFactor = texture2D(roughnessMap, UV_ROUGHNESS).g * roughness;
 
     computeMultiscattering( geometryNormal, geometryViewDir, specularColor, specularF90, roughnessFactor, singleScattering, multiScattering );
 
@@ -3257,7 +3292,7 @@ void main() {
 	vec3 diffuse = diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );
 
     vec3 irradiance = vec3(0.);
-    irradiance += texture2D(lightMap, vUv).rgb * lightMapIntensity;
+    irradiance += texture2D(lightMap, UV_LIGHTMAP).rgb * lightMapIntensity;
 
     float lod = roughnessFactor * (1.7 - 0.7 * roughnessFactor) * 6.;
     vec4  reflectColor = textureLod(tDiffuse, reflectUv, lod);
@@ -3268,7 +3303,7 @@ void main() {
     f_specular += reflectColor.rgb * (1.0 - roughnessFactor * roughnessFactor) + multiScattering * irradiance;
     f_diffuse += diffuse * irradiance;
 
-    float ambientOcclusion = mix(1., texture2D(aoMap, vUv1).r, aoMapIntensity);
+    float ambientOcclusion = mix(1., texture2D(aoMap, UV_AO).r, aoMapIntensity);
     float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );
     f_specular *= computeSpecularOcclusion(dotNV, ambientOcclusion, roughnessFactor);
 
@@ -3279,6 +3314,36 @@ void main() {
 }
 `;
 class ReflectorMaterial extends three.ShaderMaterial {
+    onBeforeCompile(shader, renderer) {
+        const channels = [];
+        if (this.aoMap && this.aoMap.channel) {
+            channels.push([
+                "UV_AO",
+                this.aoMap.channel
+            ]);
+        }
+        if (this.lightMap && this.lightMap.channel) {
+            channels.push([
+                "UV_LIGHTMAP",
+                this.lightMap.channel
+            ]);
+        }
+        if (this.roughnessMap && this.roughnessMap.channel) {
+            channels.push([
+                "UV_ROUGHNESS",
+                this.roughnessMap.channel
+            ]);
+        }
+        if (this.normalMap && this.normalMap.channel) {
+            channels.push([
+                "UV_NORMAL",
+                this.normalMap.channel
+            ]);
+        }
+        channels.forEach(([key, channel])=>{
+            this.defines[key] = "vUv" + channel;
+        });
+    }
     get metalness() {
         return this.uniforms.metalness.value;
     }
@@ -3296,29 +3361,39 @@ class ReflectorMaterial extends three.ShaderMaterial {
     }
     set roughnessMap(v) {
         this.uniforms.roughnessMap.value = v;
+        this.needsUpdate = true;
     }
     get normalMap() {
         return this.uniforms.normalMap.value;
     }
     set normalMap(v) {
         this.uniforms.normalMap.value = v;
+        this.needsUpdate = true;
     }
     get aoMap() {
         return this.uniforms.aoMap.value;
     }
     set aoMap(v) {
         this.uniforms.aoMap.value = v;
+        this.needsUpdate = true;
     }
     get lightMap() {
         return this.uniforms.lightMap.value;
     }
     set lightMap(v) {
         this.uniforms.lightMap.value = v;
+        this.needsUpdate = true;
     }
     constructor(...args){
         super(...args);
         this.vertexShader = vert_Reflector;
         this.fragmentShader = frag_Reflector;
+        this.defines = {
+            UV_AO: "vUv",
+            UV_LIGHTMAP: "vUv",
+            UV_ROUGHNESS: "vUv",
+            UV_NORMAL: "vUv"
+        };
         this.uniforms = {
             color: {
                 value: new three.Color(0xffffff)
@@ -4246,14 +4321,14 @@ class Viewer extends EventEmitter {
         }
         return shadow;
     }
-    static CompileMaterial(renderer, scene, camera, target) {
+    static compileMaterial(renderer, scene, camera, target) {
         Viewer.fullscreenMesh.material = target;
         renderer.compile(Viewer.fullscreenMesh, camera, scene);
     }
-    static CompileObject3D(renderer, scene, camera, target) {
+    static compileObject3D(renderer, scene, camera, target) {
         renderer.compile(target, camera, scene);
     }
-    static CompileTexture(renderer, target) {
+    static compileTexture(renderer, target) {
         if (Array.isArray(target)) {
             for (let v of target){
                 renderer.initTexture(v);
@@ -4269,7 +4344,7 @@ class Viewer extends EventEmitter {
         renderer.render(Viewer.fullscreenMesh, Viewer.fullscreenCamera);
         renderer.setRenderTarget(RT);
     }
-    static CreateFullscreenTriangle() {
+    static createFullscreenTriangle() {
         let geometry = new three.BufferGeometry();
         geometry.setAttribute('position', new three.Float32BufferAttribute([
             -1,
@@ -4292,10 +4367,24 @@ class Viewer extends EventEmitter {
         ], 2));
         return geometry;
     }
-    static GetChildByName(node, name) {
-        return Viewer.GetObject(node, (v)=>v.name === name && v);
+    static findChild(node, path) {
+        let child = null;
+        let parts = path.split("/");
+        let children = node.children;
+        for (let part of parts){
+            child = children.find((v)=>v.name === part);
+            if (child) {
+                children = child.children;
+            } else {
+                return null;
+            }
+        }
+        return child;
+    }
+    static getChildByName(node, name) {
+        return Viewer.getObject(node, (v)=>v.name === name && v);
     }
-    static GetObject(node, filter) {
+    static getObject(node, filter) {
         const queue = [
             node
         ];
@@ -4308,7 +4397,7 @@ class Viewer extends EventEmitter {
             object.children.forEach((v)=>queue.push(v));
         }
     }
-    static GetObjects(node, filter) {
+    static getObjects(node, filter) {
         const queue = [
             node
         ];
@@ -4517,7 +4606,7 @@ class Viewer extends EventEmitter {
         this._tweenManager.killTweensOf(target);
     }
     traverseMaterials(callback) {
-        Viewer.GetObjects(this._scene, (item)=>{
+        Viewer.getObjects(this._scene, (item)=>{
             if (item.isMesh) {
                 if (Array.isArray(item.material)) item.material.forEach(callback);
                 else callback(item.material);
@@ -4651,28 +4740,28 @@ class Viewer extends EventEmitter {
     compile(target) {
         if (Array.isArray(target)) {
             if (target.every((v)=>v.isMaterial)) {
-                Viewer.CompileMaterial(this._renderer, this._scene, this._camera, target);
+                Viewer.compileMaterial(this._renderer, this._scene, this._camera, target);
             } else {
                 throw Error("Viewer.compile: unsuport material");
             }
         } else if (typeof target === "object") {
             if (target.isMaterial) {
-                Viewer.CompileMaterial(this._renderer, this._scene, this._camera, target);
+                Viewer.compileMaterial(this._renderer, this._scene, this._camera, target);
             } else if (target.isObject3D) {
                 if (target.meshData.materials) {
-                    Viewer.CompileMaterial(this._renderer, this._scene, this._camera, Object.values(target.meshData.materials));
+                    Viewer.compileMaterial(this._renderer, this._scene, this._camera, Object.values(target.meshData.materials));
                 }
                 if (target.meshData.textures) {
-                    Viewer.CompileTexture(this._renderer, Object.values(target.meshData.textures));
+                    Viewer.compileTexture(this._renderer, Object.values(target.meshData.textures));
                 }
                 if (!target.meshData.meshes) {
-                    Viewer.CompileObject3D(this._renderer, this._scene, this._camera, target);
+                    Viewer.compileObject3D(this._renderer, this._scene, this._camera, target);
                 }
             } else if (target.isTexture) {
-                Viewer.CompileTexture(this._renderer, target);
+                Viewer.compileTexture(this._renderer, target);
             }
         } else {
-            Viewer.CompileObject3D(this._renderer, this._scene, this._camera, this._scene);
+            Viewer.compileObject3D(this._renderer, this._scene, this._camera, this._scene);
         }
     }
     constructor({ root, canvas, autoStart = true, autoResize = true, shadows = false, camera = {
@@ -4750,7 +4839,7 @@ Viewer._shadowCameraKeys = [
     "near",
     "far"
 ];
-Viewer.fullscreenMesh = new three.Mesh(Viewer.CreateFullscreenTriangle());
+Viewer.fullscreenMesh = new three.Mesh(Viewer.createFullscreenTriangle());
 Viewer.fullscreenCamera = new three.OrthographicCamera(-1, 1, 1, -1, 0, 1);
 
 class MergeRefectPass {