@woosh/meep-engine 3.57.0 → 3.58.0

package/src/generation/foliage/material/leaf_geometry.js

@@ -47,6 +47,8 @@ const PETIOLE_WIDTH = 0.02;
  *           start of a needle shoot's stretch
  * @property {number} tip_y where the organ ends along `y` (m), for the shading that runs base to tip
  * @property {number} finest smallest feature of the outline (m): a tooth, a sinus, the blade's width
+ * @property {number} outline smallest feature of the outline's shape (m), its margin's teeth aside: a sinus, a lobe,
+ *           the blade's width; what tells the leaf from another seen whole
  */
 
 /**
@@ -192,13 +194,14 @@ function serrate(xs, ys, period, depth, orders, sign, s_from) {
  * @param {number} L blade length (m)
  * @param {number} W blade width (m)
  * @param {number} depth_scale ontogeny of the lobes' and teeth's depth
- * @returns {{xs: number[], ys: number[], lobes: number[], finest: number}} `lobes`: `(vein origin y, length, half
- *          width)` of each lateral lobe on a side
+ * @returns {{xs: number[], ys: number[], lobes: number[], finest: number, outline: number}} `lobes`: `(vein origin
+ *          y, length, half width)` of each lateral lobe on a side; `outline` is `finest` but for the teeth
  */
 function blade_half(arch, L, W, depth_scale) {
     const envelope = blade_envelope(arch, L, W);
     const xs = [], ys = [];
     let finest = W;
+    let outline = W;
 
     // the base: cordate and lobate bases reach below the top of the petiole
     const lobe_drop = (arch.base_shape === LeafBaseShape.Cordate || arch.base_shape === LeafBaseShape.Lobate)
@@ -246,6 +249,7 @@ function blade_half(arch, L, W, depth_scale) {
             ys.push(y);
         }
         finest = Math.min(finest, lobe_drop);
+        outline = Math.min(outline, lobe_drop);
     } else {
         for (let k = 0; k <= SIDE_SAMPLES; k++) {
             const y = L * k / SIDE_SAMPLES;
@@ -280,7 +284,9 @@ function blade_half(arch, L, W, depth_scale) {
             const length = Math.hypot(x, y - y0);
             lobes.push(y0, length, Math.min(half_width, 0.5 * length));
         }
-        finest = Math.min(finest, 2 * (1 - LOBE_FILL) * spacing * Math.sin(arch.secondary_angle) + half_width);
+        const gap = 2 * (1 - LOBE_FILL) * spacing * Math.sin(arch.secondary_angle) + half_width;
+        finest = Math.min(finest, gap);
+        outline = Math.min(outline, gap);
     }
 
     if (arch.teeth_per_cm > 0 && arch.tooth_depth > 0) {
@@ -289,7 +295,7 @@ function blade_half(arch, L, W, depth_scale) {
         serrate(xs, ys, period, arch.tooth_depth * depth_scale, arch.tooth_orders, 1, 0.08 * L);
         finest = Math.min(finest, period / (arch.tooth_orders > 1 ? 3 : 1));
     }
-    return { xs, ys, lobes, finest };
+    return { xs, ys, lobes, finest, outline };
 }
 
 /**
@@ -337,7 +343,8 @@ function push_segment(list, x0, y0, x1, y1, half_width, angle, ox, oy) {
 }
 
 /**
- * Appends one simple blade, rotated by `angle` and set at `(ox, oy)`, with its veins.
+ * Appends one simple blade, rotated by `angle` and set at `(ox, oy)`, with its veins, and lowers `out.outline` to its
+ * outline's finest feature.
  *
  * @returns {number} its finest feature (m)
  */
@@ -348,6 +355,7 @@ function push_blade(out, arch, L, W, depth_scale, angle, ox, oy) {
     push_segment(out.midveins, 0, 0, 0, L * 0.97, mid_w, angle, ox, oy);
     const sec_w = 0.5 * SECONDARY_WIDTH * L;
     let finest = half.finest;
+    out.outline = Math.min(out.outline, half.outline);
     if (half.lobes.length > 0) {
         // each lobe, both sides, along its secondary vein, which runs most of its length
         const lobe_arch = lobe_architecture(arch);
@@ -356,6 +364,7 @@ function push_blade(out, arch, L, W, depth_scale, angle, ox, oy) {
             const y0 = half.lobes[k], length = half.lobes[k + 1], hw = half.lobes[k + 2];
             const lobe = blade_half(lobe_arch, length, 2 * hw, depth_scale);
             finest = Math.min(finest, lobe.finest);
+            out.outline = Math.min(out.outline, lobe.outline);
             // the vein's origin in the blade's frame, turned and moved as the blade is
             const vx = ox + y0 * sn, vy = oy + y0 * c;
             for (const side of [1, -1]) {
@@ -400,7 +409,7 @@ export function leaf_geometry(arch, maturity, shape_var) {
     const og = leaf_ontogeny(maturity, shape_var);
     const L = arch.blade_length * og.length;
     const W = L / arch.length_width_ratio * og.width;
-    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [] };
+    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [], outline: W };
     let finest = W;
     let tip_y = L;
     const petiole = arch.petiole_length * og.length;
@@ -452,6 +461,7 @@ export function leaf_geometry(arch, maturity, shape_var) {
         }
         out.contours.push(first, count);
         finest = Math.min(finest, (1 - floor) * L);
+        out.outline = Math.min(out.outline, (1 - floor) * L);
         tip_y = L;
         out.stems.push(0, -petiole, 0, 0, petiole_w);
     } else {
@@ -474,7 +484,8 @@ export function leaf_geometry(arch, maturity, shape_var) {
         stems: out.stems,
         attach_y: -petiole,
         tip_y,
-        finest
+        finest,
+        outline: out.outline
     };
 }
 
@@ -497,7 +508,7 @@ export function needle_shoot_geometry(arch, needles, shoot_length, needle_angle,
     const og = leaf_ontogeny(maturity, shape_var);
     const L = arch.blade_length * og.length;
     const W = L / arch.length_width_ratio * og.width;
-    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [] };
+    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [], outline: W };
     let finest = W;
     const sector = Math.PI / (2 * Math.max(1, planes));
     const sin_a = Math.sin(needle_angle), cos_a = Math.cos(needle_angle);
@@ -523,6 +534,7 @@ export function needle_shoot_geometry(arch, needles, shoot_length, needle_angle,
         stems: out.stems,
         attach_y: 0,
         tip_y: shoot_length + L * Math.cos(needle_angle),
-        finest
+        finest,
+        outline: out.outline
     };
 }

package/src/generation/foliage/material/make_foliage_material.d.ts

@@ -13,8 +13,7 @@
  *
  * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
  * @param {import("./FoliageAtlasCutout.js").FoliageAtlasCutout|null} [out_cutout]
- * @returns {StandardShadeMaterial}
+ * @returns {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
  */
-export function make_foliage_material(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, out_cutout?: import("./FoliageAtlasCutout.js").FoliageAtlasCutout | null): StandardShadeMaterial;
-import { StandardShadeMaterial } from "../../../shade/renderer/material/StandardShadeMaterial.js";
+export function make_foliage_material(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, out_cutout?: import("./FoliageAtlasCutout.js").FoliageAtlasCutout | null): import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
 //# sourceMappingURL=make_foliage_material.d.ts.map

package/src/generation/foliage/material/make_foliage_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_foliage_material.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/make_foliage_material.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,yBAAyB,EAAE,kBAAkB,GAAC,IAAI,GACvD,qBAAqB,CA2TjC;sCA5VqC,2DAA2D"}
+{"version":3,"file":"make_foliage_material.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/make_foliage_material.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,yBAAyB,EAAE,kBAAkB,GAAC,IAAI,GACvD,OAAO,2DAA2D,EAAE,qBAAqB,CA6QrG"}

package/src/generation/foliage/material/make_foliage_material.js

@@ -4,21 +4,13 @@ import { sdnoise3_array } from "../../../core/math/noise/sdnoise.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { smoothStep } from "../../../core/math/smoothStep.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
-import { ShadeDrawSide } from "../../../shade/renderer/material/ShadeDrawSide.js";
-import { StandardShadeMaterial } from "../../../shade/renderer/material/StandardShadeMaterial.js";
-import { TransparencyMode } from "../../../shade/renderer/material/TransparencyMode.js";
-import { ColorSpace } from "../../../shade/renderer/texture/ColorSpace.js";
-import { ShadeTexture } from "../../../shade/renderer/texture/ShadeTexture.js";
-import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
-import { TextureWrapType } from "../../../shade/renderer/texture/TextureWrapType.js";
-import { AlphaMode } from "../../../shade/renderer/texture/source/AlphaMode.js";
-import { ShadeImage } from "../../../shade/renderer/texture/source/ShadeImage.js";
 import {
 	FOLIAGE_CHLOROPHYLL_LOSS_RATE,
 	foliage_variant_senescence
 } from "../skeleton/foliage_senescence.js";
 import { compute_foliage_variant_atlas_layout } from "./compute_foliage_variant_atlas_layout.js";
 import { foliage_atlas_cutout_fit_alpha } from "./foliage_atlas_cutout.js";
+import { foliage_material_from_samplers } from "./foliage_material_from_samplers.js";
 import { foliage_tile_layout, foliage_tile_raster } from "./foliage_tile.js";
 
 const SCRATCH_NOISE = new Float32Array(4);
@@ -38,7 +30,7 @@ const SCRATCH_NOISE = new Float32Array(4);
  *
  * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
  * @param {import("./FoliageAtlasCutout.js").FoliageAtlasCutout|null} [out_cutout]
- * @returns {StandardShadeMaterial}
+ * @returns {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
  */
 export function make_foliage_material(species, out_cutout = null) {
 	const cfg = species.foliage_material;
@@ -305,52 +297,6 @@ export function make_foliage_material(species, out_cutout = null) {
 		}
 	}
 
-	const albedo_image = ShadeImage.fromSampler2D(albedo_sampler);
-	albedo_image.color_space = ColorSpace.SRGB;
-	// CRITICAL: Keep AlphaMode.Straight so texture_write_to_gpu premultiplies once on upload
-	// and G-buffer albedo_unpremultiply recovers clean dilated leaf color at cutout boundaries.
-	albedo_image.alpha_mode = AlphaMode.Straight;
-	const texture_albedo = ShadeTexture.from(albedo_image);
-	texture_albedo.label = "foliage_leaf_albedo";
-	texture_albedo.color_space = ColorSpace.SRGB;
-	texture_albedo.mipmapGenerationFilter = TextureFilterType.MagicKernelSharp;
-	texture_albedo.wrapS = TextureWrapType.ClampToEdge;
-	texture_albedo.wrapT = TextureWrapType.ClampToEdge;
-
-	const normal_image = ShadeImage.fromSampler2D(normal_sampler);
-	normal_image.color_space = ColorSpace.None;
-	normal_image.alpha_mode = AlphaMode.Opaque;
-	const texture_normal = ShadeTexture.from(normal_image);
-	texture_normal.label = "foliage_leaf_normal";
-	texture_normal.color_space = ColorSpace.LinearSRGB;
-	texture_normal.mipmapGenerationFilter = TextureFilterType.LinearNormal;
-	texture_normal.wrapS = TextureWrapType.ClampToEdge;
-	texture_normal.wrapT = TextureWrapType.ClampToEdge;
-
-	const orm_image = ShadeImage.fromSampler2D(orm_sampler);
-	orm_image.color_space = ColorSpace.None;
-	orm_image.alpha_mode = AlphaMode.Opaque;
-	const texture_orm = ShadeTexture.from(orm_image);
-	texture_orm.label = "foliage_leaf_orm";
-	texture_orm.color_space = ColorSpace.LinearSRGB;
-	texture_orm.wrapS = TextureWrapType.ClampToEdge;
-	texture_orm.wrapT = TextureWrapType.ClampToEdge;
-
-	const material = new StandardShadeMaterial();
-	material.name = "foliage_leaf_material";
-	material.texture_albedo = texture_albedo;
-	material.texture_normal = texture_normal;
-	material.texture_orm = texture_orm;
-	material.roughness_factor = 1.0;
-	material.metallic_factor = 0.0;
-	// CRITICAL: Keep transmission_factor = 0 on AlphaTested cards so transparent card corners
-	// do not act as refractive glass in the path tracer!
-	material.transmission_factor = 0.0;
-	material.ambient_factors.a = 1.0;
-	material.ambient_factors.b = 0.0;
-	material.transparency_mode = TransparencyMode.AlphaTested;
-	material.transparency = TransparencyMode.AlphaTested;
-	material.draw_side = ShadeDrawSide.Double;
-
+	const material = foliage_material_from_samplers(albedo_sampler, normal_sampler, orm_sampler, "foliage_leaf");
 	return material;
 }

package/src/generation/foliage/material/tree_cluster_atlas_pack.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Packs tiles into one atlas (`MaxRectanglesPacker`), growing it from the side their area needs until they fit.
+ *
+ * @param {Int32Array|number[]} sizes width and height of each tile, texels
+ * @param {number} count tiles
+ * @returns {{boxes: AABB2[], atlas_w: number, atlas_h: number}} where each tile lies, and the atlas's size, texels
+ */
+export function tree_cluster_atlas_pack(sizes: Int32Array | number[], count: number): {
+    boxes: AABB2[];
+    atlas_w: number;
+    atlas_h: number;
+};
+import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+//# sourceMappingURL=tree_cluster_atlas_pack.d.ts.map

package/src/generation/foliage/material/tree_cluster_atlas_pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_cluster_atlas_pack.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/tree_cluster_atlas_pack.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,+CAJW,UAAU,GAAC,MAAM,EAAE,SACnB,MAAM,GACJ;IAAC,KAAK,EAAE,KAAK,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB9D;kBA3BiB,qCAAqC"}

package/src/generation/foliage/material/tree_cluster_atlas_pack.js

@@ -0,0 +1,28 @@
+import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+import { MaxRectanglesPacker } from "../../../core/geom/packing/max-rect/MaxRectanglesPacker.js";
+
+/**
+ * Packs tiles into one atlas (`MaxRectanglesPacker`), growing it from the side their area needs until they fit.
+ *
+ * @param {Int32Array|number[]} sizes width and height of each tile, texels
+ * @param {number} count tiles
+ * @returns {{boxes: AABB2[], atlas_w: number, atlas_h: number}} where each tile lies, and the atlas's size, texels
+ */
+export function tree_cluster_atlas_pack(sizes, count) {
+    let area = 0;
+    for (let i = 0; i < count; i++) area += sizes[i * 2] * sizes[i * 2 + 1];
+    let side = Math.max(1, Math.ceil(Math.sqrt(area)));
+    const boxes = new Array(count);
+    for (; ;) {
+        for (let i = 0; i < count; i++) boxes[i] = new AABB2(0, 0, sizes[i * 2], sizes[i * 2 + 1]);
+        const packer = new MaxRectanglesPacker(side, side);
+        if (packer.addMany(boxes)) break;
+        side = Math.ceil(side * 1.0625) + 1;
+    }
+    let atlas_w = 0, atlas_h = 0;
+    for (const box of boxes) {
+        atlas_w = Math.max(atlas_w, box.x1);
+        atlas_h = Math.max(atlas_h, box.y1);
+    }
+    return { boxes, atlas_w: Math.max(1, Math.ceil(atlas_w)), atlas_h: Math.max(1, Math.ceil(atlas_h)) };
+}

package/src/generation/foliage/material/tree_cluster_bake.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @typedef {Object} TreeClusterBake
+ * @property {Sampler2D} albedo uint8 RGBA, straight alpha, sRGB
+ * @property {Sampler2D} normal uint8, 2 channels: the card-space normal's x and y
+ * @property {Sampler2D} orm uint8 RGBA: AO, roughness, metalness 0
+ * @property {Float32Array} uv_rects per card, `[u0, v0, u1, v1]` of its tile in the atlas
+ * @property {FoliageAtlasCutout} cutout per card, the hull of what its tile draws, in the tile's `[0, 1]^2`
+ * @property {Float64Array} frames per card, 12: its origin, and its axes `e1` (along the tile's u), `e2` (along v)
+ *           and normal `n`
+ * @property {Float64Array} extents per card, 4: where the tile's corners `(0, 0)` and `(1, 1)` lie on the card's
+ *           plane, along `e1` and `e2` from its origin, m
+ */
+/**
+ * Bakes each card (`tree_cluster_cards`) into a tile of one atlas: its leaves (the tree's per-leaf geometry, as
+ * `tree_mesh_build_foliage` draws it, with its leaf material) and its twig segments, drawn orthographically onto it.
+ *
+ * Each leaf is first pressed onto the card: turned about where it attaches until it lies parallel to the card (the
+ * least turn that takes its normal, or its other face's, to the card's), so the tile holds the leaf's whole area.
+ * Each card has its own texel, `texels` m; its tile holds what it draws, on its plane, with a texel to spare on every
+ * side (`tree_cluster_tiles`). Fragments
+ * are composited back to front along the card's normal, one leaf or twig segment at a time,
+ * {@link BAKE_SUPERSAMPLING} samples to a side per texel: colour in linear light, tinted as the leaf's vertex colour
+ * and the attachments' `tint_scale` tint it, the leaf's normal map turned into the card's frame, a twig's normal
+ * across its round stem.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/tree_cluster_cards.js").TreeClusterCard[]} cards
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments the leaves
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} leaves every leaf's card, in attachment order
+ * @param {{texture_albedo: *, texture_normal: *, texture_orm: *}} leaf_material the leaves' material
+ * @param {ArrayLike<number>} texels per card, m, a texel's side
+ * @returns {TreeClusterBake}
+ */
+export function tree_cluster_bake(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, cards: import("../mesh/tree_cluster_cards.js").TreeClusterCard[], attachments: import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet, leaves: import("../../../shade/renderer/geometry/Geometry.js").Geometry, leaf_material: {
+    texture_albedo: any;
+    texture_normal: any;
+    texture_orm: any;
+}, texels: ArrayLike<number>): TreeClusterBake;
+export type TreeClusterBake = {
+    /**
+     * uint8 RGBA, straight alpha, sRGB
+     */
+    albedo: Sampler2D;
+    /**
+     * uint8, 2 channels: the card-space normal's x and y
+     */
+    normal: Sampler2D;
+    /**
+     * uint8 RGBA: AO, roughness, metalness 0
+     */
+    orm: Sampler2D;
+    /**
+     * per card, `[u0, v0, u1, v1]` of its tile in the atlas
+     */
+    uv_rects: Float32Array;
+    /**
+     * per card, the hull of what its tile draws, in the tile's `[0, 1]^2`
+     */
+    cutout: FoliageAtlasCutout;
+    /**
+     * per card, 12: its origin, and its axes `e1` (along the tile's u), `e2` (along v)
+     * and normal `n`
+     */
+    frames: Float64Array;
+    /**
+     * per card, 4: where the tile's corners `(0, 0)` and `(1, 1)` lie on the card's
+     * plane, along `e1` and `e2` from its origin, m
+     */
+    extents: Float64Array;
+};
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { FoliageAtlasCutout } from "./FoliageAtlasCutout.js";
+//# sourceMappingURL=tree_cluster_bake.d.ts.map

package/src/generation/foliage/material/tree_cluster_bake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_cluster_bake.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/tree_cluster_bake.js"],"names":[],"mappings":"AA0IA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CATW,OAAO,6BAA6B,EAAE,YAAY,WAClD,OAAO,gCAAgC,EAAE,iBAAiB,SAC1D,OAAO,+BAA+B,EAAE,eAAe,EAAE,eACzD,OAAO,wCAAwC,EAAE,oBAAoB,UACrE,OAAO,8CAA8C,EAAE,QAAQ,iBAC/D;IAAC,cAAc,MAAI;IAAC,cAAc,MAAI;IAAC,WAAW,MAAG;CAAC,UACtD,UAAU,MAAM,CAAC,GACf,eAAe,CAmP3B;;;;;YAlRa,SAAS;;;;YACT,SAAS;;;;SACT,SAAS;;;;cACT,YAAY;;;;YACZ,kBAAkB;;;;;YAClB,YAAY;;;;;aAEZ,YAAY;;0BAhJA,uDAAuD;mCAG9C,yBAAyB"}