anythreejs 0.0.1__py3-none-any.whl

anythreejs/__init__.py

@@ -0,0 +1,153 @@
+"""
+anythreejs - A modern Python/Three.js bridge for Jupyter
+
+Quick start:
+    from anythreejs import Renderer, Scene, PerspectiveCamera, OrbitControls
+    from anythreejs import Mesh, BoxGeometry, MeshStandardMaterial, AmbientLight
+
+    scene = Scene(background="#1a1a2e")
+    scene.add(Mesh(BoxGeometry(1, 1, 1), MeshStandardMaterial(color="#ff6600")))
+    scene.add(AmbientLight(intensity=0.5))
+
+    camera = PerspectiveCamera(position=(0, 0, 5))
+    controls = OrbitControls(controlling=camera)
+
+    renderer = Renderer(camera=camera, scene=scene, controls=[controls])
+    renderer  # Display in notebook
+
+For pythreejs-style namespace imports:
+    import anythreejs as p3
+    # Then use p3.Scene, p3.Renderer, etc.
+"""
+
+from .renderer import Renderer
+from .core import (
+    # Base
+    ThreeJSBase,
+    Object3D,
+    # Scene
+    Scene,
+    # Cameras
+    PerspectiveCamera,
+    OrthographicCamera,
+    # Controls
+    OrbitControls,
+    TrackballControls,
+    # Geometry
+    BufferGeometry,
+    BoxGeometry,
+    BoxBufferGeometry,
+    SphereGeometry,
+    SphereBufferGeometry,
+    PlaneGeometry,
+    PlaneBufferGeometry,
+    CylinderGeometry,
+    CylinderBufferGeometry,
+    TorusGeometry,
+    EdgesGeometry,
+    # Material
+    Material,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    MeshPhongMaterial,
+    MeshLambertMaterial,
+    PointsMaterial,
+    LineBasicMaterial,
+    LineDashedMaterial,
+    SpriteMaterial,
+    # Objects
+    Mesh,
+    Points,
+    Line,
+    LineSegments,
+    Group,
+    Sprite,
+    # Lights
+    AmbientLight,
+    DirectionalLight,
+    PointLight,
+    HemisphereLight,
+    SpotLight,
+    # Helpers
+    AxesHelper,
+    GridHelper,
+    # Buffer
+    BufferAttribute,
+    Float32BufferAttribute,
+    Uint32BufferAttribute,
+    Uint16BufferAttribute,
+    Int32BufferAttribute,
+    # Textures
+    TextTexture,
+)
+
+# Convenience alias for pythreejs-style imports: `import anythreejs as p3`
+import sys as _sys
+
+p3 = _sys.modules[__name__]
+
+__version__ = "0.0.1"
+
+__all__ = [
+    # Renderer
+    "Renderer",
+    # Base
+    "ThreeJSBase",
+    "Object3D",
+    # Scene
+    "Scene",
+    # Cameras
+    "PerspectiveCamera",
+    "OrthographicCamera",
+    # Controls
+    "OrbitControls",
+    "TrackballControls",
+    # Geometry
+    "BufferGeometry",
+    "BoxGeometry",
+    "BoxBufferGeometry",
+    "SphereGeometry",
+    "SphereBufferGeometry",
+    "PlaneGeometry",
+    "PlaneBufferGeometry",
+    "CylinderGeometry",
+    "CylinderBufferGeometry",
+    "TorusGeometry",
+    "EdgesGeometry",
+    # Material
+    "Material",
+    "MeshBasicMaterial",
+    "MeshStandardMaterial",
+    "MeshPhongMaterial",
+    "MeshLambertMaterial",
+    "PointsMaterial",
+    "LineBasicMaterial",
+    "LineDashedMaterial",
+    "SpriteMaterial",
+    # Objects
+    "Mesh",
+    "Points",
+    "Line",
+    "LineSegments",
+    "Group",
+    "Sprite",
+    # Lights
+    "AmbientLight",
+    "DirectionalLight",
+    "PointLight",
+    "HemisphereLight",
+    "SpotLight",
+    # Helpers
+    "AxesHelper",
+    "GridHelper",
+    # Buffer
+    "BufferAttribute",
+    "Float32BufferAttribute",
+    "Uint32BufferAttribute",
+    "Uint16BufferAttribute",
+    "Int32BufferAttribute",
+    # Textures
+    "TextTexture",
+    # Convenience alias
+    "p3",
+]

anythreejs/core/__init__.py

@@ -0,0 +1,109 @@
+"""
+Core Three.js components.
+"""
+
+from .base import ThreeJSBase, Object3D
+from .scene import Scene
+from .camera import PerspectiveCamera, OrthographicCamera
+from .controls import OrbitControls, TrackballControls
+from .geometry import (
+    BufferGeometry,
+    BoxGeometry,
+    BoxBufferGeometry,
+    SphereGeometry,
+    SphereBufferGeometry,
+    PlaneGeometry,
+    PlaneBufferGeometry,
+    CylinderGeometry,
+    CylinderBufferGeometry,
+    TorusGeometry,
+    EdgesGeometry,
+)
+from .material import (
+    Material,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    MeshPhongMaterial,
+    MeshLambertMaterial,
+    PointsMaterial,
+    LineBasicMaterial,
+    LineDashedMaterial,
+    SpriteMaterial,
+)
+from .objects import Mesh, Points, Line, LineSegments, Group, Sprite
+from .lights import (
+    AmbientLight,
+    DirectionalLight,
+    PointLight,
+    HemisphereLight,
+    SpotLight,
+)
+from .helpers import AxesHelper, GridHelper
+from .buffer import (
+    BufferAttribute,
+    Float32BufferAttribute,
+    Uint32BufferAttribute,
+    Uint16BufferAttribute,
+    Int32BufferAttribute,
+)
+from .textures import TextTexture
+
+__all__ = [
+    # Base
+    "ThreeJSBase",
+    "Object3D",
+    # Scene
+    "Scene",
+    # Cameras
+    "PerspectiveCamera",
+    "OrthographicCamera",
+    # Controls
+    "OrbitControls",
+    "TrackballControls",
+    # Geometry
+    "BufferGeometry",
+    "BoxGeometry",
+    "BoxBufferGeometry",
+    "SphereGeometry",
+    "SphereBufferGeometry",
+    "PlaneGeometry",
+    "PlaneBufferGeometry",
+    "CylinderGeometry",
+    "CylinderBufferGeometry",
+    "TorusGeometry",
+    "EdgesGeometry",
+    # Material
+    "Material",
+    "MeshBasicMaterial",
+    "MeshStandardMaterial",
+    "MeshPhongMaterial",
+    "MeshLambertMaterial",
+    "PointsMaterial",
+    "LineBasicMaterial",
+    "LineDashedMaterial",
+    "SpriteMaterial",
+    # Objects
+    "Mesh",
+    "Points",
+    "Line",
+    "LineSegments",
+    "Group",
+    "Sprite",
+    # Lights
+    "AmbientLight",
+    "DirectionalLight",
+    "PointLight",
+    "HemisphereLight",
+    "SpotLight",
+    # Helpers
+    "AxesHelper",
+    "GridHelper",
+    # Buffer
+    "BufferAttribute",
+    "Float32BufferAttribute",
+    "Uint32BufferAttribute",
+    "Uint16BufferAttribute",
+    "Int32BufferAttribute",
+    # Textures
+    "TextTexture",
+]

anythreejs/core/base.py

@@ -0,0 +1,210 @@
+"""
+Base classes for Three.js objects with observable properties.
+
+All Three.js objects inherit from these base classes which provide:
+- Property change observation (like ipywidgets traitlets)
+- Serialization to dict for JSON transport to JavaScript
+- UUID for object identification
+"""
+
+from typing import Any, Callable, Optional
+import uuid
+
+
+class ThreeJSBase:
+    """
+    Base class for all Three.js object representations.
+
+    Provides observable properties and serialization.
+    """
+
+    _type: str = "Object3D"
+
+    def __init__(self):
+        self._uuid = str(uuid.uuid4())
+        self._observers: dict[str, list[Callable]] = {}
+        self._parent_renderer: Optional[Any] = None
+
+    @property
+    def uuid(self) -> str:
+        return self._uuid
+
+    def observe(self, handler: Callable, names: list[str] | str = None):
+        """Register an observer for property changes."""
+        if isinstance(names, str):
+            names = [names]
+        if names is None:
+            names = ["_all"]
+        for name in names:
+            if name not in self._observers:
+                self._observers[name] = []
+            self._observers[name].append(handler)
+
+    def unobserve(self, handler: Callable, names: list[str] | str = None):
+        """Unregister an observer."""
+        if isinstance(names, str):
+            names = [names]
+        if names is None:
+            names = list(self._observers.keys())
+        for name in names:
+            if name in self._observers and handler in self._observers[name]:
+                self._observers[name].remove(handler)
+
+    def _notify(self, name: str, old: Any, new: Any):
+        """Notify observers of a property change."""
+        change = {"name": name, "old": old, "new": new, "owner": self}
+
+        for handler in self._observers.get(name, []):
+            handler(change)
+        for handler in self._observers.get("_all", []):
+            handler(change)
+
+        if self._parent_renderer is not None:
+            self._parent_renderer._request_render()
+
+    def _set_renderer(self, renderer):
+        """Set the parent renderer for sync."""
+        self._parent_renderer = renderer
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dictionary for JSON transport."""
+        return {"type": self._type, "uuid": self._uuid}
+
+
+class Object3D(ThreeJSBase):
+    """
+    Base class for all 3D objects with transform properties.
+    """
+
+    _type = "Object3D"
+
+    def __init__(
+        self,
+        position: tuple | list = (0, 0, 0),
+        rotation: tuple | list = (0, 0, 0),
+        scale: tuple | list = (1, 1, 1),
+        visible: bool = True,
+        name: str = "",
+        **kwargs,
+    ):
+        super().__init__()
+        self._position = list(position)
+        self._rotation = list(rotation)
+        self._scale = list(scale)
+        self._visible = visible
+        self._name = name
+        self._children: list["Object3D"] = []
+
+    @property
+    def position(self) -> tuple:
+        return tuple(self._position)
+
+    @position.setter
+    def position(self, value):
+        old = self._position
+        self._position = list(value)
+        self._notify("position", old, self._position)
+
+    @property
+    def rotation(self) -> list:
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, value):
+        old = self._rotation
+        self._rotation = list(value)
+        self._notify("rotation", old, self._rotation)
+
+    @property
+    def scale(self) -> list:
+        return self._scale
+
+    @scale.setter
+    def scale(self, value):
+        old = self._scale
+        self._scale = list(value)
+        self._notify("scale", old, self._scale)
+
+    @property
+    def visible(self) -> bool:
+        return self._visible
+
+    @visible.setter
+    def visible(self, value: bool):
+        old = self._visible
+        self._visible = value
+        self._notify("visible", old, value)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str):
+        old = self._name
+        self._name = value
+        self._notify("name", old, value)
+
+    def rotateX(self, angle: float) -> "Object3D":
+        """Rotate around X axis by angle (radians)."""
+        self._rotation[0] += angle
+        self._notify("rotation", None, self._rotation)
+        return self
+
+    def rotateY(self, angle: float) -> "Object3D":
+        """Rotate around Y axis by angle (radians)."""
+        self._rotation[1] += angle
+        self._notify("rotation", None, self._rotation)
+        return self
+
+    def rotateZ(self, angle: float) -> "Object3D":
+        """Rotate around Z axis by angle (radians)."""
+        self._rotation[2] += angle
+        self._notify("rotation", None, self._rotation)
+        return self
+
+    @property
+    def children(self) -> list:
+        return self._children
+
+    def add(self, *objects: "Object3D"):
+        """Add child objects. Handles both individual objects and lists."""
+        for obj in objects:
+            if isinstance(obj, (list, tuple)):
+                self.add(*obj)
+            elif obj not in self._children:
+                self._children.append(obj)
+                if self._parent_renderer:
+                    obj._set_renderer(self._parent_renderer)
+        self._notify("children", None, self._children)
+
+    def remove(self, *objects: "Object3D"):
+        """Remove child objects. Handles both individual objects and lists."""
+        for obj in objects:
+            if isinstance(obj, (list, tuple)):
+                self.remove(*obj)
+            elif obj in self._children:
+                self._children.remove(obj)
+                obj._set_renderer(None)
+        self._notify("children", None, self._children)
+
+    def _set_renderer(self, renderer):
+        """Recursively set renderer on self and children."""
+        super()._set_renderer(renderer)
+        for child in self._children:
+            child._set_renderer(renderer)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = super().to_dict()
+        data.update(
+            {
+                "position": self._position,
+                "rotation": self._rotation,
+                "scale": self._scale,
+                "visible": self._visible,
+                "name": self._name,
+            }
+        )
+        if self._children:
+            data["children"] = [child.to_dict() for child in self._children]
+        return data

anythreejs/core/buffer.py

@@ -0,0 +1,89 @@
+"""
+Buffer attribute classes for custom geometry data.
+"""
+
+from typing import Any, Optional, Callable, Union
+import numpy as np
+
+
+class BufferAttribute:
+    """Stores data for BufferGeometry attributes."""
+
+    def __init__(
+        self,
+        array: Union[list, np.ndarray],
+        itemSize: int = 3,
+        normalized: bool = False,
+        dtype: str = "float32",
+    ):
+        self._array = (
+            np.array(array, dtype=dtype) if not isinstance(array, np.ndarray) else array
+        )
+        self._itemSize = itemSize
+        self._normalized = normalized
+        self._dtype = dtype
+        self._on_change: Optional[Callable] = None
+
+    def _set_on_change(self, callback: Optional[Callable]):
+        self._on_change = callback
+
+    def _notify_change(self):
+        if self._on_change:
+            self._on_change()
+
+    @property
+    def array(self) -> np.ndarray:
+        return self._array
+
+    @array.setter
+    def array(self, value):
+        self._array = (
+            np.array(value, dtype=self._dtype)
+            if not isinstance(value, np.ndarray)
+            else value
+        )
+        self._notify_change()
+
+    @property
+    def itemSize(self) -> int:
+        return self._itemSize
+
+    @property
+    def normalized(self) -> bool:
+        return self._normalized
+
+    @property
+    def count(self) -> int:
+        return len(self._array) // self._itemSize
+
+    def to_dict(self) -> dict[str, Any]:
+        arr = (
+            self._array.flatten().tolist()
+            if hasattr(self._array, "tolist")
+            else self._array
+        )
+        return {
+            "array": arr,
+            "itemSize": self._itemSize,
+            "normalized": self._normalized,
+        }
+
+
+class Float32BufferAttribute(BufferAttribute):
+    def __init__(self, array, itemSize: int = 3, normalized: bool = False):
+        super().__init__(array, itemSize, normalized, dtype="float32")
+
+
+class Uint32BufferAttribute(BufferAttribute):
+    def __init__(self, array, itemSize: int = 1, normalized: bool = False):
+        super().__init__(array, itemSize, normalized, dtype="uint32")
+
+
+class Uint16BufferAttribute(BufferAttribute):
+    def __init__(self, array, itemSize: int = 1, normalized: bool = False):
+        super().__init__(array, itemSize, normalized, dtype="uint16")
+
+
+class Int32BufferAttribute(BufferAttribute):
+    def __init__(self, array, itemSize: int = 1, normalized: bool = False):
+        super().__init__(array, itemSize, normalized, dtype="int32")