added lfs and files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.glb filter=lfs diff=lfs merge=lfs -text

backend/tools/environment_tools.py

@@ -0,0 +1,278 @@
+"""
+Environment Tools
+Skybox, particles, and other environmental effects
+"""
+from typing import Dict, Any, Optional
+from backend.storage import storage
+
+
+# =============================================================================
+# Skybox Tools
+# =============================================================================
+
+def add_skybox(
+    scene_id: str,
+    preset: str = "day",
+    turbidity: float = 10.0,
+    rayleigh: float = 2.0,
+    sun_elevation: float = 45.0,
+    sun_azimuth: float = 180.0
+) -> Dict[str, Any]:
+    """
+    Add a procedural sky to the scene using Three.js Sky shader.
+
+    The sky simulates atmospheric scattering for realistic outdoor environments.
+
+    Args:
+        scene_id: ID of the scene
+        preset: Quick preset - "day", "sunset", "noon", "dawn", "night" (overrides other params)
+        turbidity: Haziness of the atmosphere (2.0=clear, 10.0=hazy, 20.0=foggy)
+        rayleigh: Amount of Rayleigh scattering (affects blue color of sky)
+        sun_elevation: Sun angle from horizon in degrees (0=horizon, 90=overhead)
+        sun_azimuth: Sun compass direction in degrees (0=north, 90=east, 180=south)
+
+    Returns:
+        Dictionary with skybox settings and message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "environment" not in scene:
+        scene["environment"] = {}
+
+    # Apply presets
+    presets = {
+        "day": {"turbidity": 10.0, "rayleigh": 2.0, "sun_elevation": 45.0, "sun_azimuth": 180.0},
+        "noon": {"turbidity": 8.0, "rayleigh": 1.5, "sun_elevation": 85.0, "sun_azimuth": 180.0},
+        "sunset": {"turbidity": 4.0, "rayleigh": 4.0, "sun_elevation": 5.0, "sun_azimuth": 180.0},
+        "dawn": {"turbidity": 4.0, "rayleigh": 4.0, "sun_elevation": 5.0, "sun_azimuth": 0.0},
+        "night": {"turbidity": 20.0, "rayleigh": 0.1, "sun_elevation": -10.0, "sun_azimuth": 180.0},
+    }
+
+    if preset in presets:
+        params = presets[preset]
+        turbidity = params["turbidity"]
+        rayleigh = params["rayleigh"]
+        sun_elevation = params["sun_elevation"]
+        sun_azimuth = params["sun_azimuth"]
+
+    # Validate ranges
+    turbidity = max(0.1, min(20.0, turbidity))
+    rayleigh = max(0.0, min(4.0, rayleigh))
+    sun_elevation = max(-90.0, min(90.0, sun_elevation))
+    sun_azimuth = sun_azimuth % 360.0
+
+    skybox = {
+        "enabled": True,
+        "type": "procedural",
+        "turbidity": turbidity,
+        "rayleigh": rayleigh,
+        "sun_elevation": sun_elevation,
+        "sun_azimuth": sun_azimuth,
+        "preset": preset
+    }
+
+    scene["environment"]["skybox"] = skybox
+    storage.save(scene)
+
+    return {
+        "scene_id": scene_id,
+        "message": f"Added {preset} sky (sun at {sun_elevation}° elevation)",
+        "skybox": skybox
+    }
+
+
+def remove_skybox(scene_id: str) -> Dict[str, Any]:
+    """
+    Remove the skybox from the scene, reverting to solid background color.
+
+    Args:
+        scene_id: ID of the scene
+
+    Returns:
+        Dictionary with confirmation message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "environment" not in scene:
+        scene["environment"] = {}
+
+    # Check if skybox exists
+    had_skybox = scene["environment"].get("skybox", {}).get("enabled", False)
+
+    scene["environment"]["skybox"] = {"enabled": False}
+    storage.save(scene)
+
+    if had_skybox:
+        return {
+            "scene_id": scene_id,
+            "message": "Removed skybox, reverted to solid background color"
+        }
+    else:
+        return {
+            "scene_id": scene_id,
+            "message": "No skybox was active"
+        }
+
+
+# =============================================================================
+# Particle System Tools
+# =============================================================================
+
+def add_particles(
+    scene_id: str,
+    preset: str,
+    position: Optional[Dict[str, float]] = None,
+    particle_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Add a particle effect to the scene using preset configurations.
+
+    Args:
+        scene_id: ID of the scene
+        preset: Effect type - "fire", "smoke", "sparkle", "rain", "snow"
+        position: {x, y, z} position for localized effects (fire, smoke, sparkle)
+                  For weather effects (rain, snow), position is ignored (covers world)
+        particle_id: Optional unique identifier for this particle system
+
+    Returns:
+        Dictionary with particle system info and message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    valid_presets = ["fire", "smoke", "sparkle", "rain", "snow"]
+    if preset not in valid_presets:
+        raise ValueError(f"Invalid preset '{preset}'. Must be one of: {valid_presets}")
+
+    if "particles" not in scene:
+        scene["particles"] = []
+
+    # Generate ID if not provided
+    if not particle_id:
+        particle_id = f"{preset}_{len(scene['particles'])}"
+
+    # Check for duplicate ID
+    for p in scene["particles"]:
+        if p.get("id") == particle_id:
+            raise ValueError(f"Particle system with id '{particle_id}' already exists")
+
+    # Default position for localized effects
+    if position is None:
+        position = {"x": 0, "y": 1, "z": 0}
+
+    # Preset configurations
+    preset_configs = {
+        "fire": {
+            "count": 200,
+            "size": 0.3,
+            "color_start": "#ff6600",
+            "color_end": "#ff0000",
+            "velocity": {"x": 0, "y": 2, "z": 0},
+            "lifetime": 1.5,
+            "spread": 0.5,
+            "localized": True
+        },
+        "smoke": {
+            "count": 100,
+            "size": 0.8,
+            "color_start": "#666666",
+            "color_end": "#333333",
+            "velocity": {"x": 0, "y": 1, "z": 0},
+            "lifetime": 3.0,
+            "spread": 1.0,
+            "localized": True
+        },
+        "sparkle": {
+            "count": 50,
+            "size": 0.1,
+            "color_start": "#ffffff",
+            "color_end": "#ffff00",
+            "velocity": {"x": 0, "y": 0.5, "z": 0},
+            "lifetime": 2.0,
+            "spread": 2.0,
+            "localized": True
+        },
+        "rain": {
+            "count": 1000,
+            "size": 0.05,
+            "color_start": "#aaccff",
+            "color_end": "#88aadd",
+            "velocity": {"x": 0, "y": -15, "z": 0},
+            "lifetime": 2.0,
+            "spread": 50.0,
+            "localized": False
+        },
+        "snow": {
+            "count": 500,
+            "size": 0.15,
+            "color_start": "#ffffff",
+            "color_end": "#eeeeff",
+            "velocity": {"x": 0.5, "y": -2, "z": 0.3},
+            "lifetime": 8.0,
+            "spread": 50.0,
+            "localized": False
+        }
+    }
+
+    config = preset_configs[preset]
+
+    particle_system = {
+        "id": particle_id,
+        "preset": preset,
+        "position": position,
+        "enabled": True,
+        **config
+    }
+
+    scene["particles"].append(particle_system)
+    storage.save(scene)
+
+    if config["localized"]:
+        pos_str = f" at ({position['x']}, {position['y']}, {position['z']})"
+    else:
+        pos_str = " (world-wide weather effect)"
+
+    return {
+        "scene_id": scene_id,
+        "particle_id": particle_id,
+        "message": f"Added {preset} particle effect{pos_str}",
+        "particle_system": particle_system
+    }
+
+
+def remove_particles(scene_id: str, particle_id: str) -> Dict[str, Any]:
+    """
+    Remove a particle system from the scene.
+
+    Args:
+        scene_id: ID of the scene
+        particle_id: ID of the particle system to remove
+
+    Returns:
+        Dictionary with confirmation message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "particles" not in scene or not scene["particles"]:
+        raise ValueError("Scene has no particle systems")
+
+    original_count = len(scene["particles"])
+    scene["particles"] = [p for p in scene["particles"] if p.get("id") != particle_id]
+
+    if len(scene["particles"]) == original_count:
+        raise ValueError(f"Particle system '{particle_id}' not found")
+
+    storage.save(scene)
+
+    return {
+        "scene_id": scene_id,
+        "message": f"Removed particle system '{particle_id}'",
+        "particle_id": particle_id
+    }

backend/tools/ui_tools.py

@@ -0,0 +1,224 @@
+"""
+UI Tools
+2D overlay elements for text, bars, and HUD components
+"""
+from typing import Dict, Any, Optional
+from backend.storage import storage
+
+
+def render_text_on_screen(
+    scene_id: str,
+    text: str,
+    x: float = 50.0,
+    y: float = 10.0,
+    font_size: int = 24,
+    color: str = "#ffffff",
+    text_id: Optional[str] = None,
+    font_family: str = "Arial",
+    text_align: str = "center",
+    background_color: Optional[str] = None,
+    padding: int = 8
+) -> Dict[str, Any]:
+    """
+    Render text on the screen as a 2D overlay.
+
+    Args:
+        scene_id: ID of the scene
+        text: The text to display
+        x: Horizontal position in percentage (0=left edge, 50=center, 100=right edge)
+        y: Vertical position in percentage (0=top edge, 50=center, 100=bottom edge)
+        font_size: Font size in pixels (default: 24)
+        color: Text color as hex (default: "#ffffff")
+        text_id: Optional unique identifier for this text element (for updates/removal)
+        font_family: CSS font family (default: "Arial")
+        text_align: Text alignment - "left", "center", "right" (default: "center")
+        background_color: Optional background color (e.g., "#000000" for black box behind text)
+        padding: Padding around text in pixels when background is set (default: 8)
+
+    Returns:
+        Dictionary with text element info and message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "ui_elements" not in scene:
+        scene["ui_elements"] = []
+
+    # Generate ID if not provided
+    if not text_id:
+        text_id = f"text_{len([e for e in scene['ui_elements'] if e.get('element_type') == 'text'])}"
+
+    # Remove existing element with same ID (update behavior)
+    scene["ui_elements"] = [e for e in scene["ui_elements"] if e.get("id") != text_id]
+
+    # Clamp position values
+    x = max(0.0, min(100.0, x))
+    y = max(0.0, min(100.0, y))
+
+    text_element = {
+        "id": text_id,
+        "element_type": "text",
+        "text": text,
+        "x": x,
+        "y": y,
+        "font_size": font_size,
+        "color": color,
+        "font_family": font_family,
+        "text_align": text_align,
+        "background_color": background_color,
+        "padding": padding,
+        "visible": True
+    }
+
+    scene["ui_elements"].append(text_element)
+    storage.save(scene)
+
+    return {
+        "scene_id": scene_id,
+        "text_id": text_id,
+        "message": f"Rendered text '{text[:30]}{'...' if len(text) > 30 else ''}' at ({x}%, {y}%)",
+        "text_element": text_element
+    }
+
+
+def render_bar_on_screen(
+    scene_id: str,
+    x: float = 10.0,
+    y: float = 10.0,
+    width: float = 200.0,
+    height: float = 20.0,
+    value: float = 100.0,
+    max_value: float = 100.0,
+    bar_color: str = "#00ff00",
+    background_color: str = "#333333",
+    border_color: Optional[str] = "#ffffff",
+    bar_id: Optional[str] = None,
+    label: Optional[str] = None,
+    show_value: bool = False
+) -> Dict[str, Any]:
+    """
+    Render a progress/health bar on the screen as a 2D overlay.
+
+    Args:
+        scene_id: ID of the scene
+        x: Horizontal position in percentage (0=left edge, 50=center, 100=right edge)
+        y: Vertical position in percentage (0=top edge, 50=center, 100=bottom edge)
+        width: Bar width in pixels (default: 200)
+        height: Bar height in pixels (default: 20)
+        value: Current value (default: 100)
+        max_value: Maximum value (default: 100)
+        bar_color: Fill color for the bar (default: "#00ff00" green)
+        background_color: Background color (default: "#333333" dark gray)
+        border_color: Optional border color (default: "#ffffff" white)
+        bar_id: Optional unique identifier for this bar (for updates/removal)
+        label: Optional label text above the bar
+        show_value: Show numeric value on the bar (default: False)
+
+    Returns:
+        Dictionary with bar element info and message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "ui_elements" not in scene:
+        scene["ui_elements"] = []
+
+    # Generate ID if not provided
+    if not bar_id:
+        bar_id = f"bar_{len([e for e in scene['ui_elements'] if e.get('element_type') == 'bar'])}"
+
+    # Remove existing element with same ID (update behavior)
+    scene["ui_elements"] = [e for e in scene["ui_elements"] if e.get("id") != bar_id]
+
+    # Clamp values
+    x = max(0.0, min(100.0, x))
+    y = max(0.0, min(100.0, y))
+    value = max(0.0, min(max_value, value))
+    percentage = (value / max_value) * 100.0 if max_value > 0 else 0.0
+
+    bar_element = {
+        "id": bar_id,
+        "element_type": "bar",
+        "x": x,
+        "y": y,
+        "width": width,
+        "height": height,
+        "value": value,
+        "max_value": max_value,
+        "percentage": percentage,
+        "bar_color": bar_color,
+        "background_color": background_color,
+        "border_color": border_color,
+        "label": label,
+        "show_value": show_value,
+        "visible": True
+    }
+
+    scene["ui_elements"].append(bar_element)
+    storage.save(scene)
+
+    label_str = f"'{label}' " if label else ""
+    return {
+        "scene_id": scene_id,
+        "bar_id": bar_id,
+        "message": f"Rendered {label_str}bar at ({x}%, {y}%) - {value}/{max_value} ({percentage:.0f}%)",
+        "bar_element": bar_element
+    }
+
+
+def remove_ui_element(scene_id: str, element_id: str) -> Dict[str, Any]:
+    """
+    Remove a UI element from the screen.
+
+    Args:
+        scene_id: ID of the scene
+        element_id: ID of the UI element to remove (text_id or bar_id)
+
+    Returns:
+        Dictionary with confirmation message
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    if "ui_elements" not in scene or not scene["ui_elements"]:
+        raise ValueError("Scene has no UI elements")
+
+    original_count = len(scene["ui_elements"])
+    scene["ui_elements"] = [e for e in scene["ui_elements"] if e.get("id") != element_id]
+
+    if len(scene["ui_elements"]) == original_count:
+        raise ValueError(f"UI element '{element_id}' not found")
+
+    storage.save(scene)
+
+    return {
+        "scene_id": scene_id,
+        "message": f"Removed UI element '{element_id}'",
+        "element_id": element_id
+    }
+
+
+def get_ui_elements(scene_id: str) -> Dict[str, Any]:
+    """
+    Get all UI elements in the scene.
+
+    Args:
+        scene_id: ID of the scene
+
+    Returns:
+        Dictionary with all UI elements
+    """
+    scene = storage.get(scene_id)
+    if not scene:
+        raise ValueError(f"Scene '{scene_id}' not found")
+
+    ui_elements = scene.get("ui_elements", [])
+
+    return {
+        "scene_id": scene_id,
+        "ui_elements": ui_elements,
+        "count": len(ui_elements)
+    }

models/Norod78/huggingface_emoji.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca45de5f071b4e818d832940bf6fc59ff18fd0a94227d2c0e9e04722ed5b4524
+size 953016

models/kenney/brick_kit/brick_1x1.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:766918841cedaf66bf15360e3e69225f8835b43a5e12eb32b900cbc0c07301ef
+size 4756

models/kenney/brick_kit/brick_1x2.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb44790d950228bd44f37a9241375a13f958259a90772902caa52811be435c14
+size 6152

models/kenney/brick_kit/brick_1x4.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55c687e131221895acd02c9f655562ec340c9c6f4e25c483cbc611478d4d2961
+size 8956

models/kenney/brick_kit/brick_2x2.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:478bffd9580ca8d1a20334ff362ff4eb9a0f94ed048c1dadf7952cc5ff670366
+size 8956

models/kenney/brick_kit/brick_2x4.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc06ca10036ff13f3afa83bcb7462fa239c8468ea67881f16d5c38b5dd7e8ca6
+size 15044

models/kenney/brick_kit/plate_1x2.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59cdc39c6c2b10cc0a2182375f5db524a4b7c7ed5affb63cc2045ce8f5485902
+size 6156

models/kenney/brick_kit/plate_2x2.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c39e29ae9aaa218ebd68db5639b65f3648508de72811f80df50c82df6949989
+size 8956

models/kenney/brick_kit/plate_2x4.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ba7dc2b828ca9315d70d0bbe68a277f3676238802c5d96550cdb3818aa7fe30
+size 15044

models/kenney/brick_kit/plate_4x4.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eee58211ba9bf9e0ea192585bd8cb4f3f3708f29d2ff4a8bb9336f758e72f59
+size 26660

models/kenney/brick_kit/slope_2x2.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:342da3ab77e3c92724942584b036e74d4b19af1629cf17488ad2a1fc089f539d
+size 6472