pyforge3d 2.1.0__tar.gz → 2.1.1__tar.gz

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyforge3d
-Version: 2.1.0
+Version: 2.1.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Rust
 Classifier: Intended Audience :: Developers
@@ -46,7 +46,7 @@ Provides-Extra: docs
 Provides-Extra: render
 Provides-Extra: rl
 License-File: LICENSE
-Summary: Pure-Python 3D physics game engine — fast like native, beautiful like simulation.
+Summary: Pure-Python 3D physics game engine — own dynamics, own rules, no compromises.
 Keywords: game-engine,physics,simulation,3d,rigid-body,collision,rendering,robotics,reinforcement-learning,numpy,jax
 Author-email: iruki <me@iruki.dev>
 Requires-Python: >=3.12
@@ -59,7 +59,7 @@ Project-URL: Repository, https://github.com/iruki-dev/forge3d
 
 # forge3d
 
-> **Pure-Python 3D game engine — easy like pygame, beautiful like simulation.**
+> **Pure-Python 3D physics game engine — own dynamics, own rules, no compromises.**
 
 [![PyPI version](https://img.shields.io/pypi/v/pyforge3d.svg)](https://pypi.org/project/pyforge3d/)
 [![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue.svg)](https://www.python.org/)

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/README.md

@@ -1,6 +1,6 @@
 # forge3d
 
-> **Pure-Python 3D game engine — easy like pygame, beautiful like simulation.**
+> **Pure-Python 3D physics game engine — own dynamics, own rules, no compromises.**
 
 [![PyPI version](https://img.shields.io/pypi/v/pyforge3d.svg)](https://pypi.org/project/pyforge3d/)
 [![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue.svg)](https://www.python.org/)

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/pyproject.toml

@@ -6,8 +6,8 @@ build-backend = "maturin"
 
 [project]
 name = "pyforge3d"
-version = "2.1.0"
-description = "Pure-Python 3D physics game engine — fast like native, beautiful like simulation."
+version = "2.1.1"
+description = "Pure-Python 3D physics game engine — own dynamics, own rules, no compromises."
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.12"

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/__init__.py

@@ -1,6 +1,6 @@
 """forge3d — pure-Python 3D game engine.
 
-"Fast like native, beautiful like simulation."
+"Pure-Python 3D physics game engine — own dynamics, own rules, no compromises."
 Coordinate system: z-up, SI units (metres, kg, seconds).
 
 Minimal example (14 lines)::
@@ -121,7 +121,7 @@ from forge3d.scene import Prefab, SceneManager, SceneNode
 from forge3d.ui import Canvas, DebugPanel, HierarchyPanel, InspectorPanel, UISystem
 from forge3d.viewer import Viewer
 
-__version__ = "2.1.0"
+__version__ = "2.1.1"
 
 # ── API 안정성 선언 ───────────────────────────────────────────────────────────
 # Stable (v3까지 Breaking change 없음):

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/animation/ik_fabrik.py

@@ -1,6 +1,7 @@
 """FABRIK IK 솔버 — Forward And Backward Reaching Inverse Kinematics.
 
-참고: Aristidou & Lasenby (2011), "FABRIK: A fast, iterative solver for the Inverse Kinematics problem"
+참고: Aristidou & Lasenby (2011),
+"FABRIK: A fast, iterative solver for the Inverse Kinematics problem"
 """
 
 from __future__ import annotations

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/animation/system.py

@@ -33,11 +33,9 @@ class AnimationSystem(System):
 
             # AnimationPlayer가 있으면 체인 위치 읽기
             try:
-                player = ew.get_component(e, AnimationPlayer)  # type: ignore[assignment]
+                anim_player: AnimationPlayer = ew.get_component(e, AnimationPlayer)
             except KeyError:
                 continue
-
-            anim_player: AnimationPlayer = player
             joint_positions = anim_player.skeleton.joint_positions()
             if len(joint_positions) < 2:
                 continue

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/audio/clip.py

@@ -69,7 +69,7 @@ def _load_wav_stdlib(path: Path) -> tuple[np.ndarray, int]:
         sr = wf.getframerate()
         raw = wf.readframes(n_frames)
 
-    dtype_map = {1: np.int8, 2: np.int16, 4: np.int32}
+    dtype_map: dict[int, type[np.signedinteger]] = {1: np.int8, 2: np.int16, 4: np.int32}
     dtype = dtype_map.get(sampwidth, np.int16)
     data = np.frombuffer(raw, dtype=dtype).astype(np.float32)
     # 정규화

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/character.py

@@ -50,6 +50,7 @@ class CharacterController:
         height: float,
         radius: float,
         ground_layer_mask: int = 0xFFFF,
+        ground_check_hz: float = 60.0,
     ) -> None:
         self._world = world
         self.body = body
@@ -57,7 +58,16 @@ class CharacterController:
         self._radius = float(radius)
         self._ground_layer_mask = ground_layer_mask
         self._grounded = False
-        self._vertical_vel = 0.0  # m/s, used for jump/glide tracking
+        self._vertical_vel = 0.0
+
+        # Throttle ground-detection raycast. At 10 Hz (bots) this cuts the
+        # per-move cost from ~1 ms to ~0.017 ms with no gameplay difference.
+        self._ground_check_interval = 1.0 / max(1.0, float(ground_check_hz))
+        self._ground_check_timer    = 0.0
+
+        # Jump cooldown prevents infinite jumping when the capsule is still
+        # close to the ground in the frame right after a jump.
+        self._jump_cooldown: float = 0.0
 
     # ── State queries ─────────────────────────────────────────────────────────
 
@@ -117,11 +127,12 @@ class CharacterController:
         ----------
         impulse : Upward speed added in m/s (think: initial jump velocity).
         """
-        if self._grounded:
+        if self._grounded and self._jump_cooldown <= 0.0:
             vel = self.body.velocity.copy()
             vel[2] = float(impulse)
             self.body.set_velocity(vel)
             self._grounded = False
+            self._jump_cooldown = 0.40  # 400 ms before the next jump is allowed
 
     def glide(self, target_fall_speed: float = -1.5, dt: float = 1 / 60) -> None:
         """Reduce falling speed to *target_fall_speed* for a glide effect.
@@ -141,7 +152,17 @@ class CharacterController:
     # ── Internal ──────────────────────────────────────────────────────────────
 
     def _update_ground(self, dt: float) -> None:
-        """Update is_grounded via downward raycast."""
+        """Update is_grounded via downward raycast (throttled + jump-cooldown aware)."""
+        # Decrement jump cooldown unconditionally every call
+        if self._jump_cooldown > 0.0:
+            self._jump_cooldown = max(0.0, self._jump_cooldown - dt)
+            self._grounded = False   # never re-ground during cooldown
+            return
+
+        self._ground_check_timer += dt
+        if self._ground_check_timer < self._ground_check_interval:
+            return
+        self._ground_check_timer = 0.0
         pos = self.body.position
         ray_len = self._height / 2.0 + self._radius + self._GROUND_RAY_EXTRA
         hit = self._world.raycast(

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/collision/detection.py

@@ -586,10 +586,7 @@ def _capsule_vs_sphere(cap: Any, ia: int, sph: Any, ib: int) -> list[ContactPoin
     if depth <= 0.0:
         return []
     # Normal from body_b (sphere) to body_a (capsule) = opposite of to_sphere
-    if dist > 1e-10:
-        normal = -to_sphere / dist  # from sphere toward capsule
-    else:
-        normal = np.array([0.0, 0.0, 1.0])
+    normal = -to_sphere / dist if dist > 1e-10 else np.array([0.0, 0.0, 1.0])
     # Contact position on capsule surface in direction of sphere
     contact_pos = closest + float(cap.shape_params["radius"]) * (-normal)
     return [ContactPoint(ia, ib, contact_pos.copy(), normal.copy(), float(depth))]

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/collision/gjk.py

@@ -61,7 +61,18 @@ def _body_support(body: Any, d: np.ndarray) -> np.ndarray:
     if body.shape_type == "box":
         R = quat_to_rot(body.quat)
         return _support_box(body.pos, R, body.shape_params["half_extents"], d)
-    if body.shape_type in ("mesh", "capsule"):
+    if body.shape_type == "capsule":
+        # Capsule: cylinder swept by sphere.  Axis = local Z, half-length hl.
+        # Support = sphere_centre_along_d + radius*d_hat
+        # where sphere_centre = pos ± hl * body_z_axis
+        R  = quat_to_rot(body.quat)
+        r  = float(body.shape_params["radius"])
+        hl = float(body.shape_params["half_length"])
+        d_local = R.T @ d
+        # tip in direction of d — R[:,2] is a zero-copy column view, no allocation
+        tip = body.pos + float(np.sign(d_local[2] + 1e-300)) * hl * R[:, 2]
+        return _support_sphere(tip, r, d)
+    if body.shape_type == "mesh":
         R = quat_to_rot(body.quat)
         hull_verts = body.shape_params["hull_vertices"]
         return _support_convex_hull(body.pos, R, hull_verts, d)

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/ecs/entity.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import itertools
 from collections.abc import Iterator
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from forge3d.ecs.component import Component
 from forge3d.errors import Forge3dError
@@ -91,7 +91,7 @@ class EntityWorld:
         for e in list(smallest.keys()):
             if e not in self._alive:
                 continue
-            row: list[object] = [e]
+            row: list[Any] = [e]
             ok = True
             for t in types:
                 store = self._components.get(t, {})

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/facade.py

@@ -1,6 +1,6 @@
 """forge3d public Facade — World, Body, Shape, Material.
 
-"Fast like native, beautiful like simulation."
+"Pure-Python 3D physics game engine — own dynamics, own rules, no compromises."
 Coordinate system: z-up, SI units.
 
 Users only need::
@@ -448,7 +448,7 @@ class World:
         self._materials: dict[str, Material] = {}
         self._camera: tuple | None = None
         self._robots: list[Any] = []
-        self._welds: dict[int, tuple[int, np.ndarray]] = {}
+        self._welds: dict[int, tuple[int, np.ndarray, np.ndarray]] = {}
         # Event system
         from forge3d.events import EventDispatcher
 
@@ -615,9 +615,16 @@ class World:
         restitution: float = 0.3,
         friction: float = 0.5,
         static: bool = False,
+        collision_layer: int = 0x0001,
+        collision_mask: int = 0xFFFF,
     ) -> Body:
         """Add a convex-hull rigid body from a MeshData object.
 
+        Use ``collision_mask=0`` for visual-only decorative bodies that should
+        not participate in physics collision checks (trees, rocks, props).
+        This is important for performance: mesh GJK is expensive and decorative
+        bodies with large AABBs would otherwise be checked every frame.
+
         Typical use::
 
             from forge3d.io import load_obj
@@ -637,6 +644,8 @@ class World:
             restitution=restitution,
             friction=friction,
             static=static,
+            collision_layer=collision_layer,
+            collision_mask=collision_mask,
         )
         body = Body(self._physics, bid)
         self._register_body(body)
@@ -736,6 +745,7 @@ class World:
         mass: float = 70.0,
         name: str = "character",
         ground_layer_mask: int = 0xFFFF,
+        ground_check_hz: float = 60.0,
     ) -> Any:
         """Add a capsule-based character controller.
 
@@ -781,6 +791,7 @@ class World:
             height=height,
             radius=radius,
             ground_layer_mask=ground_layer_mask,
+            ground_check_hz=ground_check_hz,
         )
 
     def add(self, obj: Any) -> Any:
@@ -1299,20 +1310,14 @@ class World:
         from forge3d.math.quaternion import quat_multiply, quat_to_rot
 
         _ZEROS3 = np.zeros(3)
-        for body_id, weld_data in self._welds.items():
-            # Support both old 2-tuple format (pos only) and new 3-tuple (pos + rot)
-            if len(weld_data) == 2:
-                anchor_id, offset = weld_data
-                rel_q = None
-            else:
-                anchor_id, offset, rel_q = weld_data
+        for body_id, (anchor_id, offset, rel_q) in self._welds.items():
             try:
                 anchor = self._physics._get_body(anchor_id)
             except RuntimeError:
                 continue
             R_anchor = quat_to_rot(anchor.quat)
             new_pos = anchor.pos + R_anchor @ offset
-            new_quat = quat_multiply(anchor.quat, rel_q) if rel_q is not None else anchor.quat
+            new_quat = quat_multiply(anchor.quat, rel_q)
             self._physics.update_body_pose(body_id, new_pos, new_quat, vel=_ZEROS3, omega=_ZEROS3)
 
     def _sync_robot(self, robot: Any) -> None:

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/input.py

@@ -222,9 +222,11 @@ class _InputBuilder:
         "_keys_pressed",
         "_keys_released",
         "_mouse_pos",
-        "_prev_mouse_pos",
+        "_frame_mdx",   # accumulated delta-x across all events this frame
+        "_frame_mdy",   # accumulated delta-y across all events this frame
         "_mouse_buttons",
         "_scroll_accum",
+        "_skip_next_delta",  # discard first delta after cursor warp
     )
 
     def __init__(self) -> None:
@@ -232,9 +234,11 @@ class _InputBuilder:
         self._keys_pressed: set[str] = set()
         self._keys_released: set[str] = set()
         self._mouse_pos: tuple[float, float] = (0.0, 0.0)
-        self._prev_mouse_pos: tuple[float, float] = (0.0, 0.0)
+        self._frame_mdx: float = 0.0
+        self._frame_mdy: float = 0.0
         self._mouse_buttons: set[int] = set()
         self._scroll_accum: float = 0.0
+        self._skip_next_delta: bool = True   # skip first event (cursor may jump)
 
     # ── Event handlers (called by the windowing layer) ────────────────────────
 
@@ -249,9 +253,25 @@ class _InputBuilder:
         self._keys_released.add(key)
 
     def on_mouse_move(self, x: float, y: float) -> None:
-        self._prev_mouse_pos = self._mouse_pos
+        # Accumulate all sub-frame events instead of only keeping the last.
+        # Previously _prev_mouse_pos was overwritten each call, discarding all
+        # but the final event's delta — losing up to 90% of motion at high refresh.
+        if not self._skip_next_delta:
+            self._frame_mdx += x - self._mouse_pos[0]
+            self._frame_mdy += y - self._mouse_pos[1]
+        self._skip_next_delta = False
         self._mouse_pos = (x, y)
 
+    def reset_mouse_delta(self) -> None:
+        """Discard any accumulated delta and skip the next warp event.
+
+        Call this immediately after enabling/disabling cursor capture so the
+        large position jump from GLFW's cursor warp doesn't cause a view lurch.
+        """
+        self._frame_mdx = 0.0
+        self._frame_mdy = 0.0
+        self._skip_next_delta = True
+
     def on_mouse_down(self, button: int) -> None:
         self._mouse_buttons.add(button)
 
@@ -265,14 +285,12 @@ class _InputBuilder:
 
     def build(self) -> Input:
         """Return an immutable :class:`Input` for the current frame."""
-        dx = self._mouse_pos[0] - self._prev_mouse_pos[0]
-        dy = self._mouse_pos[1] - self._prev_mouse_pos[1]
         return Input(
             _keys_held=frozenset(self._keys_held),
             _keys_pressed=frozenset(self._keys_pressed),
             _keys_released=frozenset(self._keys_released),
             _mouse_pos=self._mouse_pos,
-            _mouse_delta=(dx, dy),
+            _mouse_delta=(self._frame_mdx, self._frame_mdy),
             _mouse_buttons=frozenset(self._mouse_buttons),
             _scroll_delta=self._scroll_accum,
         )
@@ -282,7 +300,8 @@ class _InputBuilder:
         self._keys_pressed.clear()
         self._keys_released.clear()
         self._scroll_accum = 0.0
-        self._prev_mouse_pos = self._mouse_pos
+        self._frame_mdx = 0.0
+        self._frame_mdy = 0.0
 
     def feed_pygame_event(self, event: Any) -> None:
         """Feed a pygame event into the builder (deprecated — use glfw callbacks).

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/particle/emitter.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Any
 
 from forge3d.ecs.component import Component
 
@@ -27,7 +28,7 @@ class ParticleEmitter(Component):
     active: bool = True
 
     @classmethod
-    def preset(cls, name: str, **kwargs: object) -> ParticleEmitter:
+    def preset(cls, name: str, **kwargs: Any) -> ParticleEmitter:
         """VFX 프리셋 팩토리."""
         presets = {
             "sparks": {
@@ -71,6 +72,6 @@ class ParticleEmitter(Component):
                 "color_end": (0.5, 0.7, 1.0, 0.0),
             },
         }
-        base = presets.get(name, {})
+        base: dict[str, Any] = dict(presets.get(name, {}))
         base.update(kwargs)
         return cls(**base)

{pyforge3d-2.1.0 → pyforge3d-2.1.1}/src/forge3d/render/realtime/shaders.py

@@ -21,7 +21,7 @@ void main() {
 
 SHADOW_FRAG = """
 #version 330 core
-void main() { }   // depth written automatically
+void main() { }   // depth written automatically to depth attachment
 """
 
 # ── Main PBR pass (Cook-Torrance BRDF + PCF shadows + optional texture) ──────
@@ -65,6 +65,7 @@ uniform vec3 u_ambient_color;    // ambient RGB
 uniform vec3  u_mat_color;       // base albedo (linear RGB [0,1])
 uniform float u_metallic;        // 0 = dielectric, 1 = metal
 uniform float u_roughness;       // 0 = mirror, 1 = fully diffuse
+uniform float u_emissive;        // emissive multiplier (0 = none, 3+ = bright glow)
 
 // Camera
 uniform vec3  u_eye;
@@ -74,7 +75,7 @@ uniform float u_fog_density;
 uniform vec3  u_fog_color;
 
 // Textures
-uniform sampler2D u_shadow_map;
+uniform sampler2DShadow u_shadow_map;  // hardware PCF comparison
 uniform sampler2D u_albedo_map;
 uniform int       u_has_texture; // 1 = sample albedo_map, 0 = use u_mat_color
 
@@ -85,19 +86,24 @@ in vec4 v_shadow_coord;
 
 out vec4 frag_color;
 
-// ── PCF shadow factor ─────────────────────────────────────────────────────────
-float shadow_factor() {
+// ── PCF shadow factor (hardware sampler2DShadow) ──────────────────────────────
+// N and L are pre-normalised in main() — pass them in to avoid redundant work.
+float shadow_factor(vec3 N, vec3 L) {
     vec3 proj = v_shadow_coord.xyz / v_shadow_coord.w;
     proj = proj * 0.5 + 0.5;
     if (proj.x < 0.0 || proj.x > 1.0 || proj.y < 0.0 || proj.y > 1.0 || proj.z > 1.0)
         return 1.0;
+    // Normal-based bias prevents acne on faces parallel to light
+    float cos_theta = clamp(dot(N, L), 0.0, 1.0);
+    float bias = max(0.008 * (1.0 - cos_theta), 0.002);
+    float ref = proj.z - bias;
+    // 3×3 PCF using hardware comparison — sampler2DShadow returns 0 or 1
     float shadow = 0.0;
-    float texel  = 1.0 / 2048.0;
+    float texel  = 1.0 / float(textureSize(u_shadow_map, 0).x);
     for (int dx = -1; dx <= 1; dx++) {
         for (int dy = -1; dy <= 1; dy++) {
-            float closest = texture(u_shadow_map,
-                                    proj.xy + vec2(float(dx), float(dy)) * texel).r;
-            shadow += (proj.z - 0.003 > closest) ? 0.0 : 1.0;
+            vec2 off = proj.xy + vec2(float(dx), float(dy)) * texel;
+            shadow += texture(u_shadow_map, vec3(off, ref));
         }
     }
     return shadow / 9.0;
@@ -160,13 +166,14 @@ void main() {
     vec3 kD = (1.0 - kS) * (1.0 - metallic);
     vec3 specular = D * G * F / max(4.0 * NdotV * NdotL, 0.001);
 
-    float sf  = shadow_factor();
+    float sf  = shadow_factor(N, L);
     vec3  Lo  = (kD * albedo / PI + specular) * u_light_color * NdotL * sf;
 
     // Ambient: simple Lambertian (no IBL in this pass)
     vec3 ambient = u_ambient_color * albedo * (0.2 + 0.8 * (1.0 - metallic));
 
-    vec3 color = ambient + Lo;
+    // Emissive: added before tonemapping so bright values stay bright
+    vec3 color = ambient + Lo + albedo * u_emissive;
 
     // Reinhard HDR tone mapping + gamma correction
     color = color / (color + vec3(1.0));