@threenative/core 0.3.3 → 0.3.4

package/gpl/fixtures/make_world_fixture.py

@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# Copyright (C) 2026 ThreeNative contributors
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version. See ../LICENSE.GPL.
+#
+# Build the tiny, deterministic, CC0-primitives-only world that the export_world spec runs. It
+# exercises every convention the recipe understands: a marked terrain, two tn_asset_id scatter
+# sources and a ground-cover asset with tn_max_distance, a render-density scatter switched by an
+# Is Viewport node, and a tn_world_chunk collection straddling a cell boundary.
+#
+#   blender -b --factory-startup --python make_world_fixture.py -- --out /tmp/world.blend
+
+import math
+import os
+import sys
+
+import bpy
+from mathutils import Matrix
+
+
+def fail(message):
+    sys.stderr.write("TN_BLENDER_ERROR: %s\n" % message)
+    sys.stderr.flush()
+    os._exit(2)
+
+
+def parse_args():
+    argv = sys.argv[sys.argv.index("--") + 1 :] if "--" in sys.argv else []
+    payload = {}
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        if token.startswith("--"):
+            key = token[2:]
+            if "=" in key:
+                key, value = key.split("=", 1)
+            else:
+                index += 1
+                if index >= len(argv):
+                    fail("'--%s' needs a value" % key)
+                value = argv[index]
+            payload[key] = value
+        index += 1
+    return payload
+
+
+def displace(terrain):
+    for vertex in terrain.data.vertices:
+        x, y = vertex.co.x, vertex.co.y
+        vertex.co.z = (
+            3.0 * math.sin(x * 0.11) * math.cos(y * 0.13)
+            + 1.5 * math.sin(x * 0.031 + y * 0.047)
+            + 0.5 * math.cos((x + y) * 0.21)
+        )
+
+
+def scatter_group(asset, render_density, viewport_density, seed):
+    group = bpy.data.node_groups.new("TNScatter_%s" % asset.name, "GeometryNodeTree")
+    group.interface.new_socket(name="Geometry", in_out="INPUT", socket_type="NodeSocketGeometry")
+    group.interface.new_socket(name="Geometry", in_out="OUTPUT", socket_type="NodeSocketGeometry")
+    source = group.nodes.new("NodeGroupInput")
+    output = group.nodes.new("NodeGroupOutput")
+    distribute = group.nodes.new("GeometryNodeDistributePointsOnFaces")
+    distribute.distribute_method = "RANDOM"
+    distribute.inputs["Seed"].default_value = seed
+    instance = group.nodes.new("GeometryNodeInstanceOnPoints")
+    info = group.nodes.new("GeometryNodeObjectInfo")
+    info.inputs["Object"].default_value = asset
+    # Object-level instancing: the depsgraph reports the asset object itself for every point, which
+    # is what lets the exporter read tn_asset_id off `instance_object`. Realised geometry instances
+    # report the emitter instead, and the asset id is lost.
+    info.inputs["As Instance"].default_value = True
+    is_viewport = group.nodes.new("GeometryNodeIsViewport")
+    switch = group.nodes.new("GeometryNodeSwitch")
+    switch.input_type = "FLOAT"
+    switch.inputs["False"].default_value = render_density
+    switch.inputs["True"].default_value = viewport_density
+    group.links.new(source.outputs["Geometry"], distribute.inputs["Mesh"])
+    group.links.new(is_viewport.outputs["Is Viewport"], switch.inputs["Switch"])
+    group.links.new(switch.outputs["Output"], distribute.inputs["Density"])
+    group.links.new(distribute.outputs["Points"], instance.inputs["Points"])
+    group.links.new(info.outputs["Geometry"], instance.inputs["Instance"])
+    group.links.new(instance.outputs["Instances"], output.inputs["Geometry"])
+    return group
+
+
+def make_emitter(asset, render_density, viewport_density, seed):
+    bpy.ops.mesh.primitive_grid_add(x_subdivisions=8, y_subdivisions=8, size=200, location=(0, 0, 0))
+    emitter = bpy.context.object
+    emitter.name = "scatter_%s" % asset.name
+    modifier = emitter.modifiers.new("TNScatter", "NODES")
+    modifier.node_group = scatter_group(asset, render_density, viewport_density, seed)
+    return emitter
+
+
+def move_to_collection(instance, collection):
+    for existing in list(instance.users_collection):
+        existing.objects.unlink(instance)
+    collection.objects.link(instance)
+
+
+def main():
+    payload = parse_args()
+    out = payload.get("out")
+    if not isinstance(out, str) or not out:
+        fail("make_world_fixture requires an '--out' .blend path")
+    out = os.path.abspath(out)
+    directory = os.path.dirname(out)
+    if directory and not os.path.isdir(directory):
+        os.makedirs(directory, exist_ok=True)
+
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+
+    bpy.ops.mesh.primitive_grid_add(x_subdivisions=64, y_subdivisions=64, size=256)
+    terrain = bpy.context.object
+    terrain.name = "terrain"
+    displace(terrain)
+    terrain["tn_world_terrain"] = 1
+
+    bpy.ops.mesh.primitive_cone_add(vertices=8, radius1=1.0, radius2=0.0, depth=4.0)
+    pine = bpy.context.object
+    pine.name = "pine"
+    pine["tn_asset_id"] = "pine"
+    make_emitter(pine, 0.02, 0.002, 7)
+
+    bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=1, radius=1.0)
+    rock = bpy.context.object
+    rock.name = "rock"
+    rock["tn_asset_id"] = "rock"
+    make_emitter(rock, 0.02, 0.002, 11)
+
+    bpy.ops.mesh.primitive_circle_add(vertices=8, radius=0.5, fill_type="NGON")
+    cover = bpy.context.object
+    cover.name = "ground_cover"
+    cover["tn_asset_id"] = "ground_cover"
+    cover["tn_max_distance"] = 30.0
+    make_emitter(cover, 0.05, 0.005, 13)
+
+    # Real worlds keep scatter sources in an excluded collection so only their instances show.
+    sources = bpy.data.collections.new("_src")
+    bpy.context.scene.collection.children.link(sources)
+    for source in (pine, cover):
+        move_to_collection(source, sources)
+    bpy.context.view_layer.layer_collection.children["_src"].exclude = True
+
+    # Other real worlds nest a source in a visible collection under a hidden one, which is a
+    # different shape from an excluded collection: the object is in the view layer, so the glTF
+    # exporter skips it for not being in any visible collection unless the recipe stages it.
+    hidden = bpy.data.collections.new("hidden_sources")
+    hidden.hide_viewport = True
+    hidden.hide_render = True
+    bpy.context.scene.collection.children.link(hidden)
+    nested = bpy.data.collections.new("_src nested")
+    hidden.children.link(nested)
+    move_to_collection(rock, nested)
+
+    yard = bpy.data.collections.new("yard")
+    yard["tn_world_chunk"] = 1
+    bpy.context.scene.collection.children.link(yard)
+
+    bpy.ops.mesh.primitive_cube_add(size=2, location=(-100, 0, 1))
+    first = bpy.context.object
+    first.name = "yard_crate_a"
+    move_to_collection(first, yard)
+
+    bpy.ops.mesh.primitive_cube_add(size=2, location=(-30, 20, 1))
+    second = bpy.context.object
+    second.name = "yard_crate_b"
+    move_to_collection(second, yard)
+
+    # A unit-scale sanity anchor: this object crosses no convention and must not disturb a count.
+    bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 3))
+    anchor = bpy.context.object
+    anchor.name = "anchor"
+    anchor.matrix_world = Matrix.Identity(4)
+
+    bpy.ops.wm.save_as_mainfile(filepath=out)
+
+
+if __name__ == "__main__":
+    main()

package/gpl/recipes/_common.py

@@ -81,6 +81,17 @@ def uv_layers():
     return sum(len(item.data.uv_layers) for item in meshes())
 
 
+def collapse_decimate(item, ratio):
+    """Add the collapse-decimate modifier `decimate` uses, so other recipes reuse that recipe's
+    operation instead of copying it. It measures nothing and writes nothing; the caller decides
+    what to export."""
+    modifier = item.modifiers.new(name="TNDecimate", type="DECIMATE")
+    modifier.decimate_type = "COLLAPSE"
+    modifier.ratio = float(ratio)
+    modifier.use_collapse_triangulate = True
+    return modifier
+
+
 def export(out):
     directory = os.path.dirname(out)
     if directory and not os.path.isdir(directory):

package/gpl/recipes/decimate.py

@@ -23,7 +23,16 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 import bpy  # noqa: E402
 
-from _common import export, fail, load, meshes, request, triangles, emit  # noqa: E402
+from _common import (
+    collapse_decimate,
+    emit,
+    export,
+    fail,
+    load,
+    meshes,
+    request,
+    triangles,
+)  # noqa: E402
 
 payload = request()
 source = payload.get("source")
@@ -43,10 +52,7 @@ if before == 0:
     fail("'%s' has no triangles to decimate" % source)
 
 for item in meshes():
-    modifier = item.modifiers.new(name="TNDecimate", type="DECIMATE")
-    modifier.decimate_type = "COLLAPSE"
-    modifier.ratio = float(ratio)
-    modifier.use_collapse_triangulate = True
+    collapse_decimate(item, ratio)
 
 after = triangles()
 export(out)