Refactoring

Author: standardgalactic

history/build_scenes.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -e
+
+BLENDER=${BLENDER:-blender}
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$SCRIPT_DIR/run_scene.py"
+
+SCENES=(
+    ising_descent
+    history_lattice
+    history_dag
+    crdt_convergence
+    entropy_collapse
+)
+
+if [ $# -eq 0 ]; then
+    echo "No scene specified — rendering all scenes."
+    for s in "${SCENES[@]}"; do
+        echo "Rendering $s"
+        $BLENDER -b -P "$SCRIPT" -- "$s"
+    done
+    exit 0
+fi
+
+SCENE="$1"
+
+echo "Rendering $SCENE"
+$BLENDER -b -P "$SCRIPT" -- "$SCENE"

history/run_scene.py

@@ -0,0 +1,93 @@
+import bpy
+import os
+import sys
+import importlib
+import inspect
+
+
+def clear_scene():
+    bpy.ops.object.select_all(action="SELECT")
+    bpy.ops.object.delete(use_global=False)
+
+
+def discover_scenes():
+
+    scenes = {}
+
+    base_dir = os.path.dirname(__file__)
+
+    for fname in os.listdir(base_dir):
+
+        if not fname.startswith("scenes_") or not fname.endswith(".py"):
+            continue
+
+        module_name = fname[:-3]
+
+        module = importlib.import_module(module_name)
+
+        for name, obj in inspect.getmembers(module):
+
+            if inspect.isfunction(obj) and name.startswith("build_"):
+                key = name.replace("build_", "")
+                scenes[key] = obj
+
+    return scenes
+
+
+def parse_args():
+
+    argv = sys.argv
+
+    if "--" not in argv:
+        return None
+
+    argv = argv[argv.index("--") + 1:]
+
+    if len(argv) == 0:
+        return None
+
+    return argv[0]
+
+
+def run_scene(scene_name, anim_dir="./renders"):
+
+    scene = bpy.context.scene
+
+    clear_scene()
+
+    scenes = discover_scenes()
+
+    if scene_name not in scenes:
+        raise ValueError(
+            f"Scene '{scene_name}' not found. Available: {list(scenes.keys())}"
+        )
+
+    builder = scenes[scene_name]
+
+    try:
+        builder(scene, os.path.join(anim_dir, scene_name))
+    except TypeError:
+        builder(scene)
+
+
+def main():
+
+    scene_name = parse_args()
+
+    scenes = discover_scenes()
+
+    # If a scene is specified, run only that
+    if scene_name is not None:
+        run_scene(scene_name)
+        return
+
+    # Otherwise run all scenes
+    print("No scene specified — rendering all scenes\n")
+
+    for name in scenes:
+        print(f"Running {name}")
+        run_scene(name)
+
+
+if __name__ == "__main__":
+    main()

history/scenes_crdt_convergence.py

@@ -1,11 +1,14 @@
 import os
 import random
-from mathutils import Vector
 import bpy
+from mathutils import Vector
 from scene_utils import ensure_collection, make_material, add_sphere, add_cylinder_edge, add_camera_and_light
 
+
 def build_crdt_convergence(scene, anim_dir: str):
+
     random.seed(3)
+
     col = ensure_collection("CRDT")
 
     add_camera_and_light(camera_loc=(12, -12, 8), look_at=(6, 0, 1))
@@ -15,70 +18,129 @@ def build_crdt_convergence(scene, anim_dir: str):
         make_material("rep1", rgba=(0.7, 1.0, 0.7, 1.0), emission=0.25),
         make_material("rep2", rgba=(0.7, 0.8, 1.0, 1.0), emission=0.25),
     ]
+
     mat_edge = make_material("merge_edge", rgba=(0.2, 0.2, 0.25, 1.0), emission=0.0)
 
     replicas = 3
     ops_total = 18
     steps = 90
 
-    ops = list(range(ops_total))
-    random.shuffle(ops)
+    ops_pool = list(range(ops_total))
+    random.shuffle(ops_pool)
 
     op_sets = [set() for _ in range(replicas)]
+
     for r in range(replicas):
         for _ in range(4):
-            op_sets[r].add(ops.pop())
+            op_sets[r].add(ops_pool.pop())
+
+    op_objs = [[None] * ops_total for _ in range(replicas)]
 
-    op_objs = [[None]*ops_total for _ in range(replicas)]
+    def op_position(replica, op_id):
 
-    def op_position(r, op_id):
-        x = r * 3.0
-        y = (op_id - (ops_total-1)/2) * 0.22
+        x = replica * 3.0
+        y = (op_id - (ops_total - 1) / 2) * 0.22
         z = 0.0
+
         return Vector((x, y, z))
 
-    for r in range(replicas):
-        for op_id in range(ops_total):
-            p = op_position(r, op_id)
-            obj = add_sphere(p, radius=0.11, name=f"op_{r}_{op_id}", material=mat_ops[r], collection=col)
-            obj.hide_render = True
-            obj.hide_viewport = True
-            op_objs[r][op_id] = obj
-
-    def reveal_ops(frame):
+    def create_operation_objects():
+
         for r in range(replicas):
+            for op_id in range(ops_total):
+
+                pos = op_position(r, op_id)
+
+                obj = add_sphere(
+                    pos,
+                    radius=0.11,
+                    name=f"op_{r}_{op_id}",
+                    material=mat_ops[r],
+                    collection=col,
+                )
+
+                obj.hide_render = True
+                obj.hide_viewport = True
+
+                op_objs[r][op_id] = obj
+
+    def reveal_operations(frame):
+
+        for r in range(replicas):
+
             for op_id in op_sets[r]:
+
                 obj = op_objs[r][op_id]
+
                 obj.hide_render = False
                 obj.hide_viewport = False
-                obj.keyframe_insert(data_path="hide_render", frame=frame)
-                obj.keyframe_insert(data_path="hide_viewport", frame=frame)
+
+                obj.keyframe_insert("hide_render", frame=frame)
+                obj.keyframe_insert("hide_viewport", frame=frame)
+
+    def merge(a, b):
+
+        before = set(op_sets[b])
+
+        op_sets[b] |= op_sets[a]
+
+        return before != op_sets[b]
+
+    def inject_operation():
+
+        if not ops_pool:
+            return
+
+        r = random.randrange(replicas)
+        op_sets[r].add(ops_pool.pop())
+
+    def converged():
+
+        base = op_sets[0]
+
+        for r in range(1, replicas):
+            if op_sets[r] != base:
+                return False
+
+        return not ops_pool
+
+    create_operation_objects()
 
     scene.frame_start = 1
     scene.frame_end = steps
 
-    reveal_ops(1)
+    reveal_operations(1)
+
+    for frame in range(2, steps + 1):
 
-    for f in range(2, steps+1):
         if random.random() < 0.55:
+
             a, b = random.sample(range(replicas), 2)
-            before = set(op_sets[b])
-            op_sets[b] |= op_sets[a]
-            if before != op_sets[b]:
-                add_cylinder_edge((a*3.0, 0, 0.4), (b*3.0, 0, 0.4), radius=0.03, material=mat_edge, collection=col)
 
-        if ops and random.random() < 0.25:
-            r = random.randrange(replicas)
-            op_sets[r].add(ops.pop())
+            if merge(a, b):
+
+                add_cylinder_edge(
+                    (a * 3.0, 0, 0.4),
+                    (b * 3.0, 0, 0.4),
+                    radius=0.03,
+                    material=mat_edge,
+                    collection=col,
+                )
 
-        reveal_ops(f)
+        if random.random() < 0.25:
+            inject_operation()
 
-        if all(op_sets[0] == op_sets[r] for r in range(1, replicas)) and not ops:
-            scene.frame_end = f
+        reveal_operations(frame)
+
+        if converged():
+            scene.frame_end = frame
             break
-        if anim_dir:
-            os.makedirs(anim_dir, exist_ok=True)
-    
-    scene.render.image_settings.file_format = "PNG"
-    scene.render.filepath = os.path.join(anim_dir, "frame_")
-    bpy.ops.render.render(animation=True, write_still=True)
+
+    if anim_dir:
+
+        os.makedirs(anim_dir, exist_ok=True)
+
+        scene.render.image_settings.file_format = "PNG"
+        scene.render.filepath = os.path.join(anim_dir, "frame_")
+
+        bpy.ops.render.render(animation=True, write_still=True)