babylon.quarks 0.18.0 → 0.19.0

package/src/QuarksLoader.ts

@@ -1,17 +1,14 @@
-import {Scene} from '@babylonjs/core/scene';
-import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
-import {Mesh} from '@babylonjs/core/Meshes/mesh';
-import {VertexData} from '@babylonjs/core/Meshes/mesh.vertexData';
+import {Constants} from '@babylonjs/core/Engines/constants';
 import {Texture} from '@babylonjs/core/Materials/Textures/texture';
 import {StandardMaterial} from '@babylonjs/core/Materials/standardMaterial';
-import {Constants} from '@babylonjs/core/Engines/constants';
 import {Matrix, Quaternion, Vector3} from '@babylonjs/core/Maths/math.vector';
-import {
-    Behavior,
-    EmitSubParticleSystem,
-} from 'quarks.core';
-import {ParticleSystem} from './ParticleSystem';
+import {Mesh} from '@babylonjs/core/Meshes/mesh';
+import {VertexData} from '@babylonjs/core/Meshes/mesh.vertexData';
+import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import {Scene} from '@babylonjs/core/scene';
+import {Behavior, EmitSubParticleSystem} from 'quarks.core';
 import {ParticleEmitter} from './ParticleEmitter';
+import {ParticleSystem} from './ParticleSystem';
 import {QuarksPrefab} from './QuarksPrefab';
 import {ensureTriangleIndices} from './geometryUtil';
 
@@ -194,7 +191,8 @@ export class QuarksLoader {
                 if (data.attributes.position?.isInterleavedBufferAttribute) {
                     const attr = data.attributes.position;
                     const buf = buffers[attr.data];
-                    if (buf) positions = this.extractInterleavedAttribute(buf.data, buf.stride, attr.offset, attr.itemSize);
+                    if (buf)
+                        positions = this.extractInterleavedAttribute(buf.data, buf.stride, attr.offset, attr.itemSize);
                 }
                 if (data.attributes.uv?.isInterleavedBufferAttribute) {
                     const attr = data.attributes.uv;
@@ -204,7 +202,8 @@ export class QuarksLoader {
                 if (data.attributes.normal?.isInterleavedBufferAttribute) {
                     const attr = data.attributes.normal;
                     const buf = buffers[attr.data];
-                    if (buf) normals = this.extractInterleavedAttribute(buf.data, buf.stride, attr.offset, attr.itemSize);
+                    if (buf)
+                        normals = this.extractInterleavedAttribute(buf.data, buf.stride, attr.offset, attr.itemSize);
                 }
             }
         } else if (data.attributes) {
@@ -255,8 +254,43 @@ export class QuarksLoader {
     private parseImages(images: any[], baseUrl: string, _meta: LoadedMeta): void {
         (this as any)._images = {};
         for (const img of images) {
-            (this as any)._images[img.uuid] = img.url ? baseUrl + img.url : null;
+            if (img.url) {
+                QuarksLoader.warnIfNotAnImageUrl(img.url);
+            }
+            (this as any)._images[img.uuid] = img.url ? this.resolveImageUrl(baseUrl, img.url) : null;
+        }
+    }
+
+    /**
+     * Flags an image entry that is plainly not an image, which otherwise only
+     * shows up as a texture that silently fails to load.
+     *
+     * The case worth naming: an exporter that could not embed a texture falls
+     * back to writing the source asset's path, and a Unity built-in texture
+     * reports a virtual path such as `Resources/unity_builtin_extra` that no
+     * file backs.
+     */
+    private static warnIfNotAnImageUrl(url: string): void {
+        if (/^(data|blob):/i.test(url) || /\.(png|jpe?g|webp|gif|bmp|ktx2?|dds|env|basis)(\?|#|$)/i.test(url)) {
+            return;
         }
+        console.warn(
+            `[QuarksLoader] Image "${url}" does not look like an image; its texture will fail to load. ` +
+                'This usually means the effect was exported without embedding that texture.'
+        );
+    }
+
+    /**
+     * `img.url` is already absolute for data/blob URIs and full http(s) URLs — common for
+     * "portable" exports that embed textures as base64 (see ensurePortableTextureUrl in
+     * babylon.quarks-editor). Prepending baseUrl to those turns e.g.
+     * "data:image/png;base64,AAAA" into an invalid path like "/some/dir/data:image/png;base64,AAAA".
+     */
+    private resolveImageUrl(baseUrl: string, url: string): string {
+        if (/^(data|blob):/i.test(url) || /^[a-z][a-z0-9+.-]*:\/\//i.test(url) || url.startsWith('/')) {
+            return url;
+        }
+        return baseUrl + url;
     }
 
     private parseTextures(textures: any[], meta: LoadedMeta): void {
@@ -264,7 +298,13 @@ export class QuarksLoader {
         for (const texDef of textures) {
             const imageUrl = images[texDef.image];
             if (imageUrl) {
-                const texture = new Texture(imageUrl, this.scene);
+                const invertY = texDef.invertY !== undefined ? !!texDef.invertY : true;
+                const noMipmap = !!texDef.noMipmap;
+                const texture = new Texture(imageUrl, this.scene, {
+                    noMipmap,
+                    invertY,
+                    samplingMode: typeof texDef.samplingMode === 'number' ? texDef.samplingMode : undefined,
+                });
                 if (Array.isArray(texDef.wrap)) {
                     texture.wrapU = this.mapWrapMode(texDef.wrap[0]);
                     texture.wrapV = this.mapWrapMode(texDef.wrap[1] ?? texDef.wrap[0]);
@@ -319,6 +359,14 @@ export class QuarksLoader {
                 matInfo.texture = meta.textures[textureRef] || null;
             }
 
+            const reflectionAtlasRef = matDef.reflectionAtlas;
+            if (reflectionAtlasRef) {
+                matInfo.reflectionAtlas = meta.textures[reflectionAtlasRef] || null;
+            }
+            if (typeof matDef.reflectionLevel === 'number') {
+                matInfo.reflectionLevel = matDef.reflectionLevel;
+            }
+
             // QuarksMaterial (what ParticleSystem.ensureMaterialMeta emits) writes `alphaMode`
             // directly as a Babylon alpha-mode constant; three.js materials (MeshBasicMaterial
             // etc.) instead use `blending` with three.js's own 1..4 numbering, which does NOT
@@ -451,7 +499,12 @@ export class QuarksLoader {
             if (data.position) node.position.set(data.position[0], data.position[1], data.position[2]);
             if (data.scale) node.scaling.set(data.scale[0], data.scale[1], data.scale[2]);
             if (data.quaternion) {
-                node.rotationQuaternion = new Quaternion(data.quaternion[0], data.quaternion[1], data.quaternion[2], data.quaternion[3]);
+                node.rotationQuaternion = new Quaternion(
+                    data.quaternion[0],
+                    data.quaternion[1],
+                    data.quaternion[2],
+                    data.quaternion[3]
+                );
             } else if (data.rotation) {
                 node.rotation.set(data.rotation[0], data.rotation[1], data.rotation[2]);
             }

package/src/QuarksPrefab.ts

@@ -1,8 +1,8 @@
-import {IAnimationData, IPrefab} from 'quarks.core';
 import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
 import {Scene} from '@babylonjs/core/scene';
-import {ParticleEmitter} from './ParticleEmitter';
+import {IAnimationData, IPrefab} from 'quarks.core';
 import {BatchedRenderer} from './BatchedRenderer';
+import {ParticleEmitter} from './ParticleEmitter';
 
 export interface QuarksTimelineClip {
     uuid?: string;
@@ -50,12 +50,7 @@ export class QuarksPrefab extends TransformNode implements IPrefab {
         this._batchedRenderer = renderer;
     }
 
-    addParticleSystemAnimation(
-        emitter: ParticleEmitter,
-        startTime = 0,
-        duration = 0,
-        loop = false
-    ): AnimationData {
+    addParticleSystemAnimation(emitter: ParticleEmitter, startTime = 0, duration = 0, loop = false): AnimationData {
         const animationDuration = duration > 0 ? duration : emitter.system.duration;
         const data: AnimationData = {
             startTime,
@@ -78,7 +73,7 @@ export class QuarksPrefab extends TransformNode implements IPrefab {
         loop = false,
         clipUUID?: string
     ): AnimationData {
-        const animationDuration = duration > 0 ? duration : clip?.duration ?? 0;
+        const animationDuration = duration > 0 ? duration : (clip?.duration ?? 0);
         const data: AnimationData = {
             startTime,
             duration: animationDuration,
@@ -260,7 +255,7 @@ export class QuarksPrefab extends TransformNode implements IPrefab {
                 duration: animation.duration,
                 type: animation.type,
                 targetUUID: (animation.target as any)._quarksUUID ?? animation.target.uniqueId.toString(),
-                clipUUID: animation.type === 'three' ? animation.clipUUID ?? animation.clip?.uuid : undefined,
+                clipUUID: animation.type === 'three' ? (animation.clipUUID ?? animation.clip?.uuid) : undefined,
                 loop: animation.loop,
             })),
         };
@@ -269,7 +264,9 @@ export class QuarksPrefab extends TransformNode implements IPrefab {
     static fromJSON(json: any, scene?: Scene): QuarksPrefab {
         const prefab = new QuarksPrefab(json.name || 'QuarksPrefab', scene);
         if (Array.isArray(json.animationData)) {
-            prefab._tempAnimationJSON = json.animationData.filter((item: any) => item?.type === 'ps' || item?.type === 'three');
+            prefab._tempAnimationJSON = json.animationData.filter(
+                (item: any) => item?.type === 'ps' || item?.type === 'three'
+            );
         }
         return prefab;
     }

package/src/QuarksUtil.ts

@@ -1,9 +1,7 @@
 import {Node} from '@babylonjs/core/node';
-import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import {BatchedRenderer} from './BatchedRenderer';
 import {ParticleEmitter} from './ParticleEmitter';
 import {ParticleSystem} from './ParticleSystem';
-import {BatchedRenderer} from './BatchedRenderer';
-import {IParticleSystem} from 'quarks.core';
 
 export class QuarksUtil {
     static runOnAllParticleEmitters(root: Node, callback: (emitter: ParticleEmitter) => void): void {