@solidrt/3d 0.0.63 → 0.0.65

package/src/model.ts

@@ -13,15 +13,17 @@
 // them and detaches the group. loadGltf / loadModel are the
 // read-then-create conveniences over flux:fs; parseGltf / decodeModel +
 // createModel are the primitives under them, for bytes obtained any other
-// way (a binary import, a fetch).
+// way (a binary import, a fetch). Compressed images (KTX2, what `srt tool
+// 3d/model` bakes) are turned into this device's block format by
+// transcodeModelImages, the one asynchronous step between the two.
 
 import { file } from "flux:fs"
 import * as spatial from "flux:spatial"
-import { decodeImage, getOwner, isDisposed, onCleanup, runWithOwner } from "@solidrt/core"
+import { decodeImage, getOwner, isDisposed, isKtx2, onCleanup, runWithOwner, transcodeTexture } from "@solidrt/core"
 import type { Owner } from "@solidrt/core"
 import { createMutableTexture, createTexture, destroyTexture } from "@solidrt/core/gpu"
 import type { TextureId } from "@solidrt/core/gpu"
-import { gltfExternalUris, parseGltf } from "./gltf.ts"
+import { gltfExternalUris, modelImageUses, parseGltf } from "./gltf.ts"
 import type { ModelClip, ModelData, ModelExtras, ModelMaterial } from "./gltf.ts"
 import { decodeModel } from "./model-file.ts"
 import { disposeGeometry } from "./geometry-gpu.ts"
@@ -144,6 +146,20 @@ export type ModelSkinNodes = {
   jointBounds: Float32Array
 }
 
+/**
+ * Transcode the model's compressed images (KTX2) into this device's block
+ * format, off the JS thread (all are started at once; the runtime runs a
+ * few at a time), and return the data with them as `textures`; the images that are PNG or JPEG are left for
+ * createModel to decode. The step between a parse (or decodeModel) and
+ * createModel for data that may hold KTX2 images; loadModel and loadGltf
+ * run it. Data with no KTX2 image comes back as it is.
+ */
+export async function transcodeModelImages(data: ModelData): Promise<ModelData> {
+  if (!data.images.some((image) => isKtx2(image.bytes))) return data
+  let textures = await Promise.all(data.images.map((image) => (isKtx2(image.bytes) ? transcodeTexture(image.bytes) : undefined)))
+  return { ...data, textures }
+}
+
 /**
  * Build the scene object for parsed model data: upload its images (repeat
  * wrap, mipmapped, MODEL_ANISOTROPY; the base color and emissive images
@@ -151,24 +167,26 @@ export type ModelSkinNodes = {
  * rgba8), make a material per glTF material, the file's node hierarchy as
  * nested Groups, and a mesh per part under its node. Synchronous - the
  * data is already in memory.
+ *
+ * A compressed image uploads as transcodeModelImages left it: at the
+ * format and color space its file names, with the mip chain the file
+ * carries (none can be generated for compressed storage). Data holding a
+ * KTX2 image that was not transcoded throws.
  */
 export function createModel(data: ModelData, opts: ModelOptions = {}): Model {
   let label = opts.label
-  let colorImages = new Set<number>()
-  for (let m of data.materials) {
-    if (m.map !== null) colorImages.add(m.map)
-    if (m.emissiveMap !== null) colorImages.add(m.emissiveMap)
-  }
-  let textures: TextureId[] = data.images.map((bytes, i) => {
-    let image = decodeImage(bytes)
-    return createTexture(image.data, image.width, image.height, {
-      format: colorImages.has(i) ? "rgba8-srgb" : "rgba8",
-      wrap: "repeat",
-      mipmap: true,
-      anisotropy: MODEL_ANISOTROPY,
-      autoFree: false,
-      label: label ? label + "-image" + i : undefined,
-    })
+  let uses = modelImageUses(data)
+  let textures: TextureId[] = data.images.map((image, i) => {
+    let sampling = { wrap: "repeat" as const, anisotropy: MODEL_ANISOTROPY, autoFree: false, label: label ? label + "-" + image.name : image.name }
+    let ready = data.textures?.[i]
+    if (ready !== undefined) {
+      return createTexture(ready.data, ready.width, ready.height, { ...sampling, format: ready.format, mipmap: ready.mipmap })
+    }
+    if (isKtx2(image.bytes)) {
+      throw new Error("createModel: image '" + image.name + "' is a KTX2 compressed texture, which is transcoded before the model is created: await transcodeModelImages(data) first (loadModel and loadGltf do)")
+    }
+    let decoded = decodeImage(image.bytes)
+    return createTexture(decoded.data, decoded.width, decoded.height, { ...sampling, format: uses[i]!.srgb ? "rgba8-srgb" : "rgba8", mipmap: true })
   })
   let make = opts.material ?? ((m: ModelMaterial, maps: ModelMaps, skinned: boolean, vertexColors: boolean, morphed: boolean, instanced: boolean): Material => {
     // An emissive factor of zero is emission OFF (the glTF product rule:
@@ -434,7 +452,8 @@ export async function loadGltf(path: string, opts?: ModelOptions): Promise<Model
   for (let uri of gltfExternalUris(bytes)) {
     if (!files.has(uri)) files.set(uri, await file(dir + decodeURIComponent(uri)).bytes())
   }
-  return buildOwned(owner, opts, () => createModel(parseGltf(bytes, (uri) => files.get(uri)!), opts))
+  let data = await transcodeModelImages(parseGltf(bytes, (uri) => files.get(uri)!))
+  return buildOwned(owner, opts, () => createModel(data, opts))
 }
 
 /** Read a baked .srtm model (`srt tool 3d/model`) and build it: no parsing,
@@ -442,5 +461,6 @@ export async function loadGltf(path: string, opts?: ModelOptions): Promise<Model
 export async function loadModel(path: string, opts?: ModelOptions): Promise<Model> {
   let owner = getOwner()
   let bytes = await file(path).bytes()
-  return buildOwned(owner, opts, () => createModel(decodeModel(bytes), opts))
+  let data = await transcodeModelImages(decodeModel(bytes))
+  return buildOwned(owner, opts, () => createModel(data, opts))
 }

package/src/node.ts

@@ -163,6 +163,9 @@ export type SceneHooks = {
   _setLayers(mesh: Mesh): void
   /** A light's castShadow/shadow options changed. */
   _shadowChanged(light: CastingLight): void
+  /** A light's layers mask changed: re-filter its shadow views' casters
+   * (the uniform rewrite rides the _lightChanged that follows). */
+  _lightLayersChanged(light: Light): void
   _reorder(mesh: Mesh): void
   /** The node's transform changed (for the sort and light bookkeeping). */
   _moved(node: SceneNode): void
@@ -270,6 +273,11 @@ export type SceneEventBase = {
    * (a view's own pixels under a view leaf). */
   x: number
   y: number
+  /** When the event happened, ms: the element event's `timeStamp`. */
+  timeStamp: number
+  /** The element event's `predicted`: a move the pointer was never
+   * reported at. Draw with it, do not measure with it. */
+  predicted: boolean
   pointerId: number
   pointerType: string
   button?: number

package/src/scene-pointer.ts

@@ -19,7 +19,7 @@
 // dispatch.ts is the same model one dimension down.
 //
 // Pure BY DESIGN (types only, nothing with GPU imports) so
-// checks/dispatch-check.ts drives it headless with a fake pick.
+// tests/dispatch.test.ts drives it headless with a fake pick.
 
 import type { PointerEvent as ElementPointerEvent, PointerFeed } from "@solidrt/core"
 import type { NodePointerEvent, SceneNode, ScenePointerListener } from "./node.ts"
@@ -58,6 +58,8 @@ type InternalEvent = {
   distance: number | null
   x: number
   y: number
+  timeStamp: number
+  predicted: boolean
   pointerId: number
   pointerType: string
   button?: number
@@ -95,8 +97,6 @@ export type PointerInputDeps = {
   root: Scene | ViewHandle
   /** The root's listeners, in registration order. */
   listeners: Set<ScenePointerListener>
-  /** The clock for tap repeats (default performance.now; checks inject). */
-  now?: () => number
 }
 
 export type PointerInput = {
@@ -108,7 +108,6 @@ export type PointerInput = {
 }
 
 export function makePointerInput(deps: PointerInputDeps): PointerInput {
-  let now = deps.now ?? (() => performance.now())
   let presses = new Map<number, Press>()
   let hover = new Map<number, Target>()
   let lastTap: { time: number; cx: number; cy: number; target: Target | null; count: number } | null = null
@@ -170,6 +169,8 @@ export function makePointerInput(deps: PointerInputDeps): PointerInput {
         distance: hit === null ? null : hit.distance,
         x,
         y,
+        timeStamp: e.timeStamp,
+        predicted: e.predicted,
         pointerId: e.pointerId,
         pointerType: e.pointerType,
         button: e.button,
@@ -245,7 +246,7 @@ export function makePointerInput(deps: PointerInputDeps): PointerInput {
         if (press.moved || !press.alone) return
         let release = nearest(x, y)
         if (press.target === null ? release !== null : release === null || !sameHit(release, press.target)) return
-        let time = now()
+        let time = e.timeStamp
         let repeat = lastTap !== null && time - lastTap.time <= TAP_INTERVAL_MS && sameTarget(lastTap.target, press.target) && Math.hypot(e.clientX - lastTap.cx, e.clientY - lastTap.cy) <= TAP_REPEAT_SLOP
         let count = repeat ? lastTap!.count + 1 : 1
         lastTap = { time, cx: e.clientX, cy: e.clientY, target: press.target, count }

package/src/scene-shadows.ts

@@ -80,8 +80,9 @@ export type ShadowSystemDeps<V extends ShadowView> = {
   targetSize(): { width: number; height: number }
   /** Base debug label ("scene" by default). */
   label: string
-  /** Make one shadow view: a tile of `into` drawing `filter`'s meshes
-   * with the depth override (the scene's makeView). */
+  /** Make one shadow view for `light`: a tile of `into` drawing the
+   * casting meshes the light's layers admit with the depth override (the
+   * scene's makeView derives the caster filter and the layer mask). */
   makeView(
     vopts: {
       width: number
@@ -93,7 +94,7 @@ export type ShadowSystemDeps<V extends ShadowView> = {
       clearColor: [number, number, number, number]
       label: string
     },
-    filter: (mesh: Mesh) => boolean,
+    light: CastingLight,
   ): V
   disposeView(view: V): void
   /** The light set changed shape: the scene owes a writeLights. */
@@ -203,9 +204,9 @@ export function makeShadowSystem<V extends ShadowView>(deps: ShadowSystemDeps<V>
     deps.schedule()
   }
   // A caster's views: one square tile of the shadow atlas per map,
-  // drawing the casting meshes with the depth override from that map's
-  // frustum. The light rewrite writes the rects in the light's slots on
-  // every receiving target.
+  // drawing the casting meshes the light's layers admit with the depth
+  // override from that map's frustum. The light rewrite writes the rects
+  // in the light's slots on every receiving target.
   let createShadow = (light: CastingLight, rects: ShadowRect[]) => {
     let atlas = shadowAtlas!
     let views = rects.map(rect =>
@@ -220,7 +221,7 @@ export function makeShadowSystem<V extends ShadowView>(deps: ShadowSystemDeps<V>
           clearColor: [1, 1, 1, 1],
           label: deps.label + "-shadow",
         },
-        m => m.castShadow,
+        light,
       ),
     )
     shadows.set(light, { light, views, lastWorld: mat4(), dirty: true, rects })