Spaces:

build-small-hackathon
/

ThreeGen

Running on Zero

App Files Files Community

bolajiev commited on 23 days ago

Commit

5f02e75

1 Parent(s): c3d2108

Add relational layout (stack/row/grid) + burger/snowman/tree templates to DSL

Browse files

Files changed (3) hide show

compiler.py +68 -2
llm.py +30 -0
scene.py +195 -2

compiler.py CHANGED Viewed

@@ -7,8 +7,9 @@ and the "copy code" tab, so what the user sees is exactly what they copy.
 from __future__ import annotations
 import base64
-from scene import Animation, Obj, Scene
 def _hex0x(color: str) -> str:
@@ -70,7 +71,7 @@ def material_js(o: Obj, style: str = "realistic") -> str:
 def objects_js(scene: Scene, style: str = "realistic") -> str:
     lines = []
-    for i, o in enumerate(scene.objects):
         px, py, pz = o.position
         rx, ry, rz = o.rotation
         sx, sy, sz = o.scale
@@ -115,6 +116,71 @@ def animation_js(a: Animation) -> str:
     return ""
 TEMPLATE = """<!DOCTYPE html>
 <html lang="en">
 <head>

 from __future__ import annotations
 import base64
+from typing import Any
+from scene import Animation, LayoutGrid, LayoutRow, LayoutStack, Obj, Scene, _shape_extent
 def _hex0x(color: str) -> str:
 def objects_js(scene: Scene, style: str = "realistic") -> str:
     lines = []
+    for i, o in enumerate(_flatten(scene.objects)):
         px, py, pz = o.position
         rx, ry, rz = o.rotation
         sx, sy, sz = o.scale
     return ""
+# ---- Layout resolver: flattens containers into positioned Obj list ----
+def _node_axis_size(node: Any, axis: int) -> float:
+    """Estimate the bounding-box size of a node along one axis (0=x,1=y,2=z)."""
+    if isinstance(node, Obj):
+        return _shape_extent(node.shape, node.params)[axis]
+    if isinstance(node, LayoutStack):
+        ai = {"x": 0, "y": 1, "z": 2}.get(node.axis, 1)
+        sizes = [_node_axis_size(c, ai) for c in node.children]
+        return sum(sizes) + max(0, len(sizes) - 1) * node.gap if sizes else 1.0
+    return 1.0
+def _flatten(items: list, ox: float = 0.0, oy: float = 0.0, oz: float = 0.0) -> list:
+    """Recursively resolve layout containers into a flat list of positioned Obj."""
+    result = []
+    for item in items:
+        if isinstance(item, Obj):
+            result.append(item.model_copy(update={
+                "position": [item.position[0] + ox,
+                             item.position[1] + oy,
+                             item.position[2] + oz]
+            }))
+        elif isinstance(item, LayoutStack):
+            result.extend(_flatten_stack(item, ox, oy, oz))
+        elif isinstance(item, LayoutRow):
+            # Row = stack along x
+            fake = LayoutStack(axis="x", gap=item.gap,
+                               position=item.position, children=item.children)
+            result.extend(_flatten_stack(fake, ox, oy, oz))
+        elif isinstance(item, LayoutGrid):
+            result.extend(_flatten_grid(item, ox, oy, oz))
+    return result
+def _flatten_stack(stack: LayoutStack, ox: float, oy: float, oz: float) -> list:
+    ai = {"x": 0, "y": 1, "z": 2}.get(stack.axis, 1)
+    base = [stack.position[0] + ox, stack.position[1] + oy, stack.position[2] + oz]
+    sizes = [_node_axis_size(c, ai) for c in stack.children]
+    total = sum(sizes) + max(0, len(sizes) - 1) * stack.gap
+    cursor = -total / 2.0
+    result = []
+    for child, size in zip(stack.children, sizes):
+        off = list(base)
+        off[ai] += cursor + size / 2.0
+        cursor += size + stack.gap
+        result.extend(_flatten([child], *off))
+    return result
+def _flatten_grid(grid: LayoutGrid, ox: float, oy: float, oz: float) -> list:
+    base = [grid.position[0] + ox, grid.position[1] + oy, grid.position[2] + oz]
+    cols = max(1, grid.cols)
+    rows = (len(grid.children) + cols - 1) // cols
+    sx = -(cols - 1) * grid.gap_x / 2.0
+    sz = -(rows - 1) * grid.gap_z / 2.0
+    result = []
+    for i, child in enumerate(grid.children):
+        off = [base[0] + sx + (i % cols) * grid.gap_x,
+               base[1],
+               base[2] + sz + (i // cols) * grid.gap_z]
+        result.extend(_flatten([child], *off))
+    return result
 TEMPLATE = """<!DOCTYPE html>
 <html lang="en">
 <head>

llm.py CHANGED Viewed

@@ -97,6 +97,36 @@ FEWSHOT = [
         ],
         "animation": {"type": "float", "speed": 0.8, "axis": "y"},
     })},
 ]
 _tok = None

         ],
         "animation": {"type": "float", "speed": 0.8, "axis": "y"},
     })},
+    {"role": "user", "content": "a classic burger"},
+    {"role": "assistant", "content": json.dumps({
+        "background": "#1a1209",
+        "objects": [{
+            "type": "stack",
+            "axis": "y",
+            "gap": 0.02,
+            "children": [
+                {"shape": "sphere",   "color": "#c8a96e", "params": {"radius": 0.45}},
+                {"shape": "cylinder", "color": "#3a8a3a", "params": {"radiusTop": 0.52, "radiusBottom": 0.52, "height": 0.1}},
+                {"shape": "cylinder", "color": "#5a3a1a", "params": {"radiusTop": 0.5, "radiusBottom": 0.5, "height": 0.18}},
+                {"shape": "cylinder", "color": "#c8a96e", "params": {"radiusTop": 0.52, "radiusBottom": 0.55, "height": 0.32}},
+            ]
+        }],
+        "lights": [
+            {"type": "ambient", "intensity": 0.5},
+            {"type": "directional", "intensity": 1.3, "position": [5, 8, 6]},
+        ],
+        "animation": {"type": "rotate", "speed": 0.8, "axis": "y"},
+    })},
+    {"role": "user", "content": "build me a snowman"},
+    {"role": "assistant", "content": json.dumps({
+        "background": "#0d1b2a",
+        "template": {"name": "snowman", "color_body": "#e8e8e8", "color_hat": "#1a1a1a"},
+        "lights": [
+            {"type": "ambient", "intensity": 0.5},
+            {"type": "directional", "intensity": 1.3, "position": [5, 8, 6]},
+        ],
+        "animation": {"type": "rotate", "speed": 0.5, "axis": "y"},
+    })},
 ]
 _tok = None

scene.py CHANGED Viewed

@@ -10,7 +10,7 @@ from __future__ import annotations
 import json
 import logging
 import re
-from typing import Any, Dict, List, Optional
 from pydantic import BaseModel, Field, field_validator
@@ -30,6 +30,30 @@ def _clamp(v: float, lo: float, hi: float) -> float:
     return max(lo, min(hi, v))
 class Obj(BaseModel):
     shape: str = "box"
     position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
@@ -163,9 +187,163 @@ class Animation(BaseModel):
         return v if v in {"x", "y", "z"} else "y"
 class Scene(BaseModel):
     background: str = "#0b0e14"
-    objects: List[Obj] = Field(default_factory=list)
     lights: List[Light] = Field(default_factory=list)
     animation: Animation = Field(default_factory=Animation)
@@ -175,6 +353,13 @@ class Scene(BaseModel):
         v = str(v)
         return v if HEX.match(v) else "#0b0e14"
 def extract_json(text: str) -> Optional[dict]:
     """Pull the first balanced JSON object out of a raw model response."""
@@ -198,6 +383,14 @@ def build_scene(data: Optional[dict]) -> Scene:
     if not isinstance(data, dict):
         log.warning("build_scene: no valid dict, using empty scene")
         data = {}
     try:
         scene = Scene(**data)
     except Exception as e:

 import json
 import logging
 import re
+from typing import Any, Dict, List, Literal, Optional, Union
 from pydantic import BaseModel, Field, field_validator
     return max(lo, min(hi, v))
+def _shape_extent(shape: str, params: Dict[str, float]) -> tuple:
+    """Return (width, height, depth) bounding box for layout size computations."""
+    def p(k, d): return float(params.get(k, d))
+    if shape == "box":
+        return (p("width", 1.0), p("height", 1.0), p("depth", 1.0))
+    if shape == "sphere":
+        d = p("radius", 0.6) * 2
+        return (d, d, d)
+    if shape == "cylinder":
+        r = max(p("radiusTop", 0.5), p("radiusBottom", 0.5)) * 2
+        return (r, p("height", 1.0), r)
+    if shape == "cone":
+        return (p("radius", 0.5) * 2, p("height", 1.0), p("radius", 0.5) * 2)
+    if shape in ("torus", "torusKnot"):
+        r = (p("radius", 0.5) + p("tube", 0.2)) * 2
+        return (r, r, r)
+    if shape in ("tetrahedron", "icosahedron", "dodecahedron", "octahedron"):
+        d = p("radius", 0.6) * 2
+        return (d, d, d)
+    if shape == "plane":
+        return (p("width", 5.0), 0.01, p("height", 5.0))
+    return (1.0, 1.0, 1.0)
 class Obj(BaseModel):
     shape: str = "box"
     position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
         return v if v in {"x", "y", "z"} else "y"
+def _vec3_field(v: Any, default: float = 0.0) -> List[float]:
+    out: List[float] = []
+    try:
+        for x in list(v)[:3]:
+            out.append(float(x))
+    except Exception:
+        out = []
+    while len(out) < 3:
+        out.append(default)
+    return out
+class LayoutStack(BaseModel):
+    """Stack children along an axis, centering the total extent at the node's position."""
+    type: Literal["stack"] = "stack"
+    axis: str = "y"
+    gap: float = 0.05
+    position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
+    children: List[Any] = Field(default_factory=list)
+    @field_validator("axis")
+    @classmethod
+    def _axis(cls, v: Any) -> str:
+        return str(v) if str(v) in {"x", "y", "z"} else "y"
+    @field_validator("gap")
+    @classmethod
+    def _gap(cls, v: Any) -> float:
+        try: return max(0.0, float(v))
+        except Exception: return 0.05
+    @field_validator("position", mode="before")
+    @classmethod
+    def _pos(cls, v: Any) -> List[float]:
+        return _vec3_field(v)
+    @field_validator("children", mode="before")
+    @classmethod
+    def _children(cls, v: Any) -> List[Any]:
+        return [_parse_scene_item(c) for c in v] if isinstance(v, list) else []
+class LayoutRow(BaseModel):
+    """Lay out children in a row along the x-axis."""
+    type: Literal["row"] = "row"
+    gap: float = 0.3
+    position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
+    children: List[Any] = Field(default_factory=list)
+    @field_validator("gap")
+    @classmethod
+    def _gap(cls, v: Any) -> float:
+        try: return max(0.0, float(v))
+        except Exception: return 0.3
+    @field_validator("position", mode="before")
+    @classmethod
+    def _pos(cls, v: Any) -> List[float]:
+        return _vec3_field(v)
+    @field_validator("children", mode="before")
+    @classmethod
+    def _children(cls, v: Any) -> List[Any]:
+        return [_parse_scene_item(c) for c in v] if isinstance(v, list) else []
+class LayoutGrid(BaseModel):
+    """Lay out children in a grid on the x-z plane."""
+    type: Literal["grid"] = "grid"
+    cols: int = 2
+    gap_x: float = 0.3
+    gap_z: float = 0.3
+    position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
+    children: List[Any] = Field(default_factory=list)
+    @field_validator("cols")
+    @classmethod
+    def _cols(cls, v: Any) -> int:
+        try: return max(1, int(v))
+        except Exception: return 2
+    @field_validator("position", mode="before")
+    @classmethod
+    def _pos(cls, v: Any) -> List[float]:
+        return _vec3_field(v)
+    @field_validator("children", mode="before")
+    @classmethod
+    def _children(cls, v: Any) -> List[Any]:
+        return [_parse_scene_item(c) for c in v] if isinstance(v, list) else []
+def _parse_scene_item(v: Any) -> Any:
+    """Parse a dict (or existing model) into the correct scene node type."""
+    if isinstance(v, (Obj, LayoutStack, LayoutRow, LayoutGrid)):
+        return v
+    if not isinstance(v, dict):
+        return Obj()
+    t = v.get("type", "")
+    try:
+        if t == "stack":
+            return LayoutStack(**v)
+        if t == "row":
+            return LayoutRow(**v)
+        if t == "grid":
+            return LayoutGrid(**v)
+        return Obj(**v)
+    except Exception:
+        return Obj()
+# ---- Composite templates (deterministic Python expansions) ----
+def _template_burger(params: Dict[str, Any]) -> List[Obj]:
+    bun = params.get("color_bun", "#c8a96e")
+    patty = params.get("color_patty", "#5a3a1a")
+    lettuce = params.get("color_lettuce", "#3a8a3a")
+    return [
+        Obj(shape="sphere",   color=bun,    position=[0,  0.65, 0], params={"radius": 0.45}, roughness=0.7),
+        Obj(shape="cylinder", color=lettuce, position=[0,  0.28, 0], params={"radiusTop": 0.52, "radiusBottom": 0.52, "height": 0.1}, roughness=0.9),
+        Obj(shape="cylinder", color=patty,  position=[0,  0.12, 0], params={"radiusTop": 0.5,  "radiusBottom": 0.5,  "height": 0.18}, roughness=0.8),
+        Obj(shape="cylinder", color=bun,    position=[0, -0.18, 0], params={"radiusTop": 0.52, "radiusBottom": 0.55, "height": 0.32}, roughness=0.7),
+    ]
+def _template_snowman(params: Dict[str, Any]) -> List[Obj]:
+    body = params.get("color_body", "#e8e8e8")
+    hat  = params.get("color_hat",  "#1a1a1a")
+    return [
+        Obj(shape="sphere",   color=body, position=[0, -0.55, 0], params={"radius": 0.5},  roughness=0.9),
+        Obj(shape="sphere",   color=body, position=[0,  0.2,  0], params={"radius": 0.35}, roughness=0.9),
+        Obj(shape="sphere",   color=body, position=[0,  0.82, 0], params={"radius": 0.24}, roughness=0.9),
+        Obj(shape="cylinder", color=hat,  position=[0,  1.18, 0], params={"radiusTop": 0.16, "radiusBottom": 0.26, "height": 0.34}),
+    ]
+def _template_tree(params: Dict[str, Any]) -> List[Obj]:
+    leaves = params.get("color_leaves", "#2e8b57")
+    trunk  = params.get("color_trunk",  "#8b5a2b")
+    return [
+        Obj(shape="cylinder", color=trunk,  position=[0, -0.6,  0], params={"radiusTop": 0.12, "radiusBottom": 0.15, "height": 0.8}, roughness=0.9),
+        Obj(shape="cone",     color=leaves, position=[0,  0.2,  0], params={"radius": 0.7, "height": 1.0}, roughness=0.8),
+        Obj(shape="cone",     color=leaves, position=[0,  0.72, 0], params={"radius": 0.55, "height": 0.8}, roughness=0.8),
+        Obj(shape="cone",     color=leaves, position=[0,  1.14, 0], params={"radius": 0.4,  "height": 0.65}, roughness=0.8),
+    ]
+TEMPLATES: Dict[str, Any] = {
+    "burger":  _template_burger,
+    "snowman": _template_snowman,
+    "tree":    _template_tree,
+}
 class Scene(BaseModel):
     background: str = "#0b0e14"
+    objects: List[Union[Obj, LayoutStack, LayoutRow, LayoutGrid]] = Field(default_factory=list)
     lights: List[Light] = Field(default_factory=list)
     animation: Animation = Field(default_factory=Animation)
         v = str(v)
         return v if HEX.match(v) else "#0b0e14"
+    @field_validator("objects", mode="before")
+    @classmethod
+    def _objects(cls, v: Any) -> List[Any]:
+        if not isinstance(v, list):
+            return []
+        return [_parse_scene_item(item) for item in v]
 def extract_json(text: str) -> Optional[dict]:
     """Pull the first balanced JSON object out of a raw model response."""
     if not isinstance(data, dict):
         log.warning("build_scene: no valid dict, using empty scene")
         data = {}
+    # Expand named templates into flat object lists before schema validation
+    tmpl = data.get("template")
+    if isinstance(tmpl, dict) and not data.get("objects"):
+        name = tmpl.get("name", "")
+        if name in TEMPLATES:
+            log.info("Expanding template: %s", name)
+            data = {k: v for k, v in data.items() if k != "template"}
+            data["objects"] = [o.model_dump() for o in TEMPLATES[name](tmpl)]
     try:
         scene = Scene(**data)
     except Exception as e: