rayd 0.2.2__tar.gz → 0.2.3__tar.gz

{rayd-0.2.2 → rayd-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rayd
-Version: 0.2.2
+Version: 0.2.3
 Summary: RayD: minimalist differentiable ray tracing package wrapping Dr.Jit and OptiX.
 Author-Email: Xingyu Chen <xic063@ucsd.edu>
 License: BSD-3-Clause

{rayd-0.2.2 → rayd-0.2.3}/docs/api_reference.md

@@ -16,10 +16,14 @@ Public top-level exports:
 - `Camera`
 - `Ray`
 - `Intersection`
+- `ReflectionChain`
 - `NearestPointEdge`
 - `NearestRayEdge`
 - `PrimaryEdgeSample`
 - `SecondaryEdgeInfo`
+- `SceneEdgeInfo`
+- `SceneEdgeTopology`
+- `SceneGlobalGeometry`
 
 All array-valued inputs and outputs use Dr.Jit CUDA arrays or tensors.
 
@@ -137,8 +141,15 @@ Methods:
 - `is_ready() -> bool`
 - `has_pending_updates() -> bool`
 - `intersect(ray, active=True) -> Intersection`
+- `trace_reflections(ray, max_bounces, active=True, *, deduplicate=False, canonical_prim_table=None, image_source_tolerance=1e-5) -> ReflectionChain`
 - `nearest_edge(point, active=True) -> NearestPointEdge`
 - `nearest_edge(ray, active=True) -> NearestRayEdge`
+- `edge_info() -> SceneEdgeInfo`
+- `edge_topology() -> SceneEdgeTopology`
+- `global_geometry() -> SceneGlobalGeometry`
+- `mesh_face_offsets()`
+- `mesh_edge_offsets()`
+- `mesh_vertex_offsets()`
 
 Properties:
 
@@ -251,11 +262,58 @@ Fields:
 - `barycentric`
 - `shape_id`
 - `prim_id`
+- `local_prim_id`
+- `global_prim_id`
 
 Methods:
 
 - `is_valid()`
 
+Notes:
+
+- `prim_id` is kept as the mesh-local triangle id for compatibility.
+- `local_prim_id` is identical to `prim_id`.
+- `global_prim_id` is the scene-global triangle id.
+
+### `ReflectionChain`
+
+Result of `Scene.trace_reflections(...)`.
+
+Fields:
+
+- `bounce_count`
+- `discovery_count`
+- `representative_ray_index`
+- `t`
+- `hit_points`
+- `geo_normals`
+- `image_sources`
+- `plane_points`
+- `plane_normals`
+- `shape_ids`
+- `prim_ids`
+- `local_prim_ids`
+- `global_prim_ids`
+
+Notes:
+
+- `prim_ids` remains mesh-local for compatibility.
+- `local_prim_ids` is identical to `prim_ids`.
+- `global_prim_ids` is the scene-global triangle id chain.
+
+### `SceneGlobalGeometry`
+
+Canonical scene-global geometry cache exposed by `Scene.global_geometry()`.
+
+Fields:
+
+- `vertices`
+- `faces`
+- `face_normal`
+- `shape_id`
+- `local_prim_id`
+- `global_prim_id`
+
 ## Nearest-Edge Types
 
 ### `NearestPointEdge`

{rayd-0.2.2 → rayd-0.2.3}/docs/multi_bounce_reflection_trace.md

@@ -46,12 +46,19 @@ ReflectionChain trace_reflections(const RayDetached &ray,
                                   MaskDetached active = true) const;
 ```
 
+Current API note:
+
+- `prim_ids` is mesh-local for compatibility.
+- `local_prim_ids` is identical to `prim_ids`.
+- `global_prim_ids` is the scene-global triangle-id chain.
+
 ### Python (nanobind)
 
 ```python
 chain = scene.trace_reflections(ray, max_bounces=3)
 chain.bounce_count   # drjit.cuda.Int    [N]
 chain.prim_ids       # drjit.cuda.Int    [N*B]
+chain.global_prim_ids# drjit.cuda.Int    [N*B]
 chain.hit_points     # drjit.cuda.Array3f [N*B]
 chain.image_sources  # drjit.cuda.Array3f [N*B]
 # ...
@@ -63,6 +70,7 @@ chain.image_sources  # drjit.cuda.Array3f [N*B]
 chain = scene.trace_reflections(ray, max_bounces=3)
 chain.bounce_count   # torch.Tensor int32   [N]
 chain.prim_ids       # torch.Tensor int32   [N, B]
+chain.global_prim_ids# torch.Tensor int32   [N, B]
 chain.hit_points     # torch.Tensor float32 [N, B, 3]
 chain.image_sources  # torch.Tensor float32 [N, B, 3]
 # ...
@@ -1036,4 +1044,3 @@ file(WRITE "${OUTPUT_FILE}"
 )
 ```
 
-

{rayd-0.2.2 → rayd-0.2.3}/docs/reflection_trace_gpu_dedup.md

@@ -91,7 +91,8 @@ chain = scene.trace_reflections(ray, max_bounces=3,
 # PyTorch
 chain = scene.trace_reflections(ray, max_bounces=3, deduplicate=True)
 chain.ray_count        # M (unique paths, not input ray count)
-chain.prim_ids         # [M, B]
+chain.prim_ids         # [M, B]  (mesh-local)
+chain.global_prim_ids  # [M, B]  (scene-global)
 chain.image_sources    # [M, B, 3]
 chain.discovery_count  # [M]
 ```
@@ -110,8 +111,8 @@ New CUDA kernel: `reflection_dedup_build_keys`
 
 For each ray `i`:
 1. If `bounce_count[i] == 0` → key = `UINT64_MAX` (dead lane, sorted last)
-2. Optionally remap prim_ids through `canonical_prim_table`
-3. Hash the prim_id chain into a 64-bit key:
+2. Build / remap the scene-global prim chain through `canonical_prim_table`
+3. Hash the global prim-id chain into a 64-bit key:
 
 ```cuda
 __global__ void reflection_dedup_build_keys(

{rayd-0.2.2 → rayd-0.2.3}/include/rayd/edge.h

@@ -173,24 +173,32 @@ struct SceneEdgeInfo {
 struct SceneEdgeTopology {
     IntDetached v0;
     IntDetached v1;
+    IntDetached v0_global;
+    IntDetached v1_global;
     IntDetached face0_local;
     IntDetached face1_local;
     IntDetached face0_global;
     IntDetached face1_global;
     IntDetached opposite_vertex0;
     IntDetached opposite_vertex1;
+    IntDetached opposite_vertex0_global;
+    IntDetached opposite_vertex1_global;
 
     int size() const { return v0.size(); }
 
     DRJIT_STRUCT(SceneEdgeTopology,
                  v0,
                  v1,
+                 v0_global,
+                 v1_global,
                  face0_local,
                  face1_local,
                  face0_global,
                  face1_global,
                  opposite_vertex0,
-                 opposite_vertex1)
+                 opposite_vertex1,
+                 opposite_vertex0_global,
+                 opposite_vertex1_global)
 };
 
 } // namespace rayd

{rayd-0.2.2 → rayd-0.2.3}/include/rayd/intersection.h

@@ -43,8 +43,20 @@ struct IntersectionData {
     Vec3f barycentric = zeros<Vec3f>(1);
     Int_ shape_id = full<Int_>(-1, 1);
     Int_ prim_id = full<Int_>(-1, 1);
-
-    DRJIT_STRUCT(IntersectionData, t, p, n, geo_n, uv, barycentric, shape_id, prim_id)
+    Int_ local_prim_id = full<Int_>(-1, 1);
+    Int_ global_prim_id = full<Int_>(-1, 1);
+
+    DRJIT_STRUCT(IntersectionData,
+                 t,
+                 p,
+                 n,
+                 geo_n,
+                 uv,
+                 barycentric,
+                 shape_id,
+                 prim_id,
+                 local_prim_id,
+                 global_prim_id)
 };
 
 } // namespace rayd

{rayd-0.2.2 → rayd-0.2.3}/include/rayd/reflection.h

@@ -32,6 +32,8 @@ struct ReflectionBounceData {
     Vec3f plane_normals = zeros<Vec3f>(1);
     Int_ shape_ids = full<Int_>(-1, 1);
     Int_ prim_ids = full<Int_>(-1, 1);
+    Int_ local_prim_ids = full<Int_>(-1, 1);
+    Int_ global_prim_ids = full<Int_>(-1, 1);
 
     DRJIT_STRUCT(ReflectionBounceData,
                  t,
@@ -41,7 +43,9 @@ struct ReflectionBounceData {
                  plane_points,
                  plane_normals,
                  shape_ids,
-                 prim_ids)
+                 prim_ids,
+                 local_prim_ids,
+                 global_prim_ids)
 };
 
 template <typename Float_>
@@ -70,6 +74,8 @@ struct ReflectionChainData {
     Vec3f plane_normals = zeros<Vec3f>(1);
     Int_ shape_ids = full<Int_>(-1, 1);
     Int_ prim_ids = full<Int_>(-1, 1);
+    Int_ local_prim_ids = full<Int_>(-1, 1);
+    Int_ global_prim_ids = full<Int_>(-1, 1);
 
     DRJIT_STRUCT(ReflectionChainData,
                  bounce_count,
@@ -82,7 +88,9 @@ struct ReflectionChainData {
                  plane_points,
                  plane_normals,
                  shape_ids,
-                 prim_ids)
+                 prim_ids,
+                 local_prim_ids,
+                 global_prim_ids)
 };
 
 template <typename Float_>

{rayd-0.2.2 → rayd-0.2.3}/include/rayd/scene/scene.h

@@ -57,6 +57,8 @@ public:
     const MaskDetached &edge_mask() const;
     const IntDetached &mesh_face_offsets() const { return face_offsets_; }
     const IntDetached &mesh_edge_offsets() const { return edge_offsets_; }
+    const IntDetached &mesh_vertex_offsets() const { return vertex_offsets_; }
+    const SceneGlobalGeometry &global_geometry() const;
     uint64_t version() const { return scene_version_; }
     uint64_t edge_version() const { return edge_version_; }
     VectoriT<3, true> triangle_edge_indices(const IntDetached &prim_id, bool global = true) const;
@@ -107,6 +109,7 @@ private:
         bool vertices_dirty = false;
         bool transform_dirty = false;
         mutable bool edge_dirty = false;
+        int vertex_offset = 0;
         int face_offset = 0;
         int edge_offset = 0;
     };
@@ -126,12 +129,14 @@ private:
 
     IntDetached face_offsets_;
     IntDetached edge_offsets_;
+    IntDetached vertex_offsets_;
     TriangleInfo triangle_info_;
     TriangleInfoDetached triangle_info_detached_;
     TriangleUV triangle_uv_;
     TriangleUVDetached triangle_uv_detached_;
     Mask triangle_face_normal_mask_;
     MaskDetached triangle_face_normal_mask_detached_;
+    SceneGlobalGeometry global_geometry_;
     SecondaryEdgeInfo edge_info_;
     SceneEdgeTopology edge_topology_;
     IntDetached edge_shape_ids_;

{rayd-0.2.2 → rayd-0.2.3}/include/rayd/types.h

@@ -130,4 +130,24 @@ using TriangleUVDetached = TriangleUvData<FloatDetached>;
 template <bool Detached_>
 using TriangleUVT = std::conditional_t<Detached_, TriangleUVDetached, TriangleUV>;
 
+struct SceneGlobalGeometry {
+    Vector3f vertices;
+    Vector3iDetached faces;
+    Vector3f face_normal;
+    IntDetached shape_id;
+    IntDetached local_prim_id;
+    IntDetached global_prim_id;
+
+    int vertex_count() const { return vertices.x().size(); }
+    int face_count() const { return global_prim_id.size(); }
+
+    DRJIT_STRUCT(SceneGlobalGeometry,
+                 vertices,
+                 faces,
+                 face_normal,
+                 shape_id,
+                 local_prim_id,
+                 global_prim_id)
+};
+
 } // namespace rayd

{rayd-0.2.2 → rayd-0.2.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "rayd"
-version = "0.2.2"
+version = "0.2.3"
 description = "RayD: minimalist differentiable ray tracing package wrapping Dr.Jit and OptiX."
 readme = "README.md"
 authors = [{ name = "Xingyu Chen", email = "xic063@ucsd.edu" }]

{rayd-0.2.2 → rayd-0.2.3}/rayd/torch/__init__.py

@@ -24,6 +24,7 @@ from .types import (
     SceneSyncProfile,
     SceneEdgeInfo,
     SceneEdgeTopology,
+    SceneGlobalGeometry,
     SecondaryEdgeInfo,
 )
 from .mesh import Mesh
@@ -50,6 +51,7 @@ __all__ = [
     "SceneSyncProfile",
     "SceneEdgeInfo",
     "SceneEdgeTopology",
+    "SceneGlobalGeometry",
     "SecondaryEdgeInfo",
     "set_device",
 ]

{rayd-0.2.2 → rayd-0.2.3}/rayd/torch/_native.py

@@ -37,6 +37,7 @@ from .types import (
     Ray,
     SceneEdgeInfo,
     SceneEdgeTopology,
+    SceneGlobalGeometry,
     SecondaryEdgeInfo,
 )
 from ._state import _MeshState, _CameraState
@@ -319,6 +320,8 @@ def _intersection_from_native(its: Any) -> Intersection:
         barycentric=_vec3_to_tensor(its.barycentric),
         shape_id=_scalar_array_to_tensor(its.shape_id),
         prim_id=_scalar_array_to_tensor(its.prim_id),
+        local_prim_id=_scalar_array_to_tensor(its.local_prim_id),
+        global_prim_id=_scalar_array_to_tensor(its.global_prim_id),
     )
 
 
@@ -337,6 +340,8 @@ def _reflection_chain_from_native(chain: Any) -> ReflectionChain:
     plane_normals = _vec3_to_tensor(chain.plane_normals)
     shape_ids = _scalar_array_to_tensor(chain.shape_ids)
     prim_ids = _scalar_array_to_tensor(chain.prim_ids)
+    local_prim_ids = _scalar_array_to_tensor(chain.local_prim_ids)
+    global_prim_ids = _scalar_array_to_tensor(chain.global_prim_ids)
 
     if ray_count <= 0 and hasattr(bounce_count, "numel"):
         ray_count = int(bounce_count.numel())
@@ -358,6 +363,8 @@ def _reflection_chain_from_native(chain: Any) -> ReflectionChain:
     plane_normals = dr.reshape(type(plane_normals), plane_normals, shape=(ray_count, max_bounces, 3))
     shape_ids = dr.reshape(type(shape_ids), shape_ids, shape=(ray_count, max_bounces))
     prim_ids = dr.reshape(type(prim_ids), prim_ids, shape=(ray_count, max_bounces))
+    local_prim_ids = dr.reshape(type(local_prim_ids), local_prim_ids, shape=(ray_count, max_bounces))
+    global_prim_ids = dr.reshape(type(global_prim_ids), global_prim_ids, shape=(ray_count, max_bounces))
 
     return ReflectionChain(
         bounce_count=bounce_count,
@@ -371,6 +378,8 @@ def _reflection_chain_from_native(chain: Any) -> ReflectionChain:
         plane_normals=plane_normals,
         shape_ids=shape_ids,
         prim_ids=prim_ids,
+        local_prim_ids=local_prim_ids,
+        global_prim_ids=global_prim_ids,
         max_bounces=max_bounces,
         ray_count=ray_count,
     )
@@ -433,12 +442,27 @@ def _scene_edge_topology_from_native(info: Any) -> SceneEdgeTopology:
     return SceneEdgeTopology(
         v0=_scalar_array_to_tensor(info.v0),
         v1=_scalar_array_to_tensor(info.v1),
+        v0_global=_scalar_array_to_tensor(info.v0_global),
+        v1_global=_scalar_array_to_tensor(info.v1_global),
         face0_local=_scalar_array_to_tensor(info.face0_local),
         face1_local=_scalar_array_to_tensor(info.face1_local),
         face0_global=_scalar_array_to_tensor(info.face0_global),
         face1_global=_scalar_array_to_tensor(info.face1_global),
         opposite_vertex0=_scalar_array_to_tensor(info.opposite_vertex0),
         opposite_vertex1=_scalar_array_to_tensor(info.opposite_vertex1),
+        opposite_vertex0_global=_scalar_array_to_tensor(info.opposite_vertex0_global),
+        opposite_vertex1_global=_scalar_array_to_tensor(info.opposite_vertex1_global),
+    )
+
+
+def _scene_global_geometry_from_native(geometry: Any) -> SceneGlobalGeometry:
+    return SceneGlobalGeometry(
+        vertices=_vec3_to_tensor(geometry.vertices),
+        faces=_vec3_to_tensor(geometry.faces),
+        face_normal=_vec3_to_tensor(geometry.face_normal),
+        shape_id=_scalar_array_to_tensor(geometry.shape_id),
+        local_prim_id=_scalar_array_to_tensor(geometry.local_prim_id),
+        global_prim_id=_scalar_array_to_tensor(geometry.global_prim_id),
     )
 
 

{rayd-0.2.2 → rayd-0.2.3}/rayd/torch/scene.py

@@ -12,11 +12,20 @@ from ._util import (
     _normalize_vector_tensor,
 )
 from ._convert import _scalar_array_to_tensor, _tensor_to_mask, _tensor_to_matrix4, _tensor_to_vec3, _to_torch_struct
-from .types import ReflectionChain, Intersection, Ray, SceneSyncProfile, SceneEdgeInfo, SceneEdgeTopology
+from .types import (
+    ReflectionChain,
+    Intersection,
+    Ray,
+    SceneSyncProfile,
+    SceneEdgeInfo,
+    SceneEdgeTopology,
+    SceneGlobalGeometry,
+)
 from ._state import _MeshState
 from ._native import (
     _allocate_native_scene_cache_id,
     _build_native_mesh,
+    _prepare_native_scene_cache,
     _scene_cache_refresh_policy,
     _mesh_to_world_tensor,
     _ray_batch_size,
@@ -25,6 +34,7 @@ from ._native import (
     _scene_cache_tokens,
     _scene_edge_info_from_native,
     _scene_edge_topology_from_native,
+    _scene_global_geometry_from_native,
     _scene_intersect_impl,
     _scene_trace_reflections_impl,
     _scene_nearest_point_impl,
@@ -250,6 +260,28 @@ class Scene:
             raise RuntimeError("Scene.mesh_edge_offsets(): internal detached scene is unavailable.")
         return _scalar_array_to_tensor(self._native_scene.mesh_edge_offsets()).torch()
 
+    def mesh_vertex_offsets(self) -> _torch.Tensor:
+        self._require_ready()
+        if self._native_scene is None:
+            raise RuntimeError("Scene.mesh_vertex_offsets(): internal detached scene is unavailable.")
+        return _scalar_array_to_tensor(self._native_scene.mesh_vertex_offsets()).torch()
+
+    def global_geometry(self) -> SceneGlobalGeometry:
+        self._require_query_ready()
+        mesh_states, topology_token, rebuild_token, vertex_tokens, left_tokens, right_tokens, refresh_policy, edge_mask = self._query_cache_inputs()
+        scene = _prepare_native_scene_cache(
+            self._query_cache_id,
+            mesh_states,
+            topology_token,
+            rebuild_token,
+            vertex_tokens,
+            left_tokens,
+            right_tokens,
+            refresh_policy,
+            edge_mask,
+        )
+        return _to_torch_struct(_scene_global_geometry_from_native(scene.global_geometry()))
+
     def triangle_edge_indices(self, prim_id: Any, global_: bool = True, **kwargs: Any) -> tuple[_torch.Tensor, _torch.Tensor, _torch.Tensor]:
         self._require_ready()
         if "global" in kwargs:

{rayd-0.2.2 → rayd-0.2.3}/rayd/torch/types.py

@@ -33,6 +33,8 @@ class Intersection(_StructRepr):
         "barycentric": object,
         "shape_id": object,
         "prim_id": object,
+        "local_prim_id": object,
+        "global_prim_id": object,
     }
 
     def __init__(
@@ -45,6 +47,8 @@ class Intersection(_StructRepr):
         barycentric: Any = None,
         shape_id: Any = None,
         prim_id: Any = None,
+        local_prim_id: Any = None,
+        global_prim_id: Any = None,
     ):
         self.t = t
         self.p = p
@@ -54,6 +58,8 @@ class Intersection(_StructRepr):
         self.barycentric = barycentric
         self.shape_id = shape_id
         self.prim_id = prim_id
+        self.local_prim_id = local_prim_id
+        self.global_prim_id = global_prim_id
 
     def is_valid(self) -> Any:
         return self.prim_id >= 0
@@ -72,6 +78,8 @@ class ReflectionChain(_StructRepr):
         "plane_normals": object,
         "shape_ids": object,
         "prim_ids": object,
+        "local_prim_ids": object,
+        "global_prim_ids": object,
     }
 
     def __init__(
@@ -87,6 +95,8 @@ class ReflectionChain(_StructRepr):
         plane_normals: Any = None,
         shape_ids: Any = None,
         prim_ids: Any = None,
+        local_prim_ids: Any = None,
+        global_prim_ids: Any = None,
         max_bounces: int = 0,
         ray_count: int = 0,
     ):
@@ -101,6 +111,8 @@ class ReflectionChain(_StructRepr):
         self.plane_normals = plane_normals
         self.shape_ids = shape_ids
         self.prim_ids = prim_ids
+        self.local_prim_ids = local_prim_ids
+        self.global_prim_ids = global_prim_ids
         self._max_bounces_hint = int(max_bounces)
         self._ray_count_hint = int(ray_count)
 
@@ -311,33 +323,45 @@ class SceneEdgeTopology(_StructRepr):
     DRJIT_STRUCT = {
         "v0": object,
         "v1": object,
+        "v0_global": object,
+        "v1_global": object,
         "face0_local": object,
         "face1_local": object,
         "face0_global": object,
         "face1_global": object,
         "opposite_vertex0": object,
         "opposite_vertex1": object,
+        "opposite_vertex0_global": object,
+        "opposite_vertex1_global": object,
     }
 
     def __init__(
         self,
         v0: Any = None,
         v1: Any = None,
+        v0_global: Any = None,
+        v1_global: Any = None,
         face0_local: Any = None,
         face1_local: Any = None,
         face0_global: Any = None,
         face1_global: Any = None,
         opposite_vertex0: Any = None,
         opposite_vertex1: Any = None,
+        opposite_vertex0_global: Any = None,
+        opposite_vertex1_global: Any = None,
     ):
         self.v0 = v0
         self.v1 = v1
+        self.v0_global = v0_global
+        self.v1_global = v1_global
         self.face0_local = face0_local
         self.face1_local = face1_local
         self.face0_global = face0_global
         self.face1_global = face1_global
         self.opposite_vertex0 = opposite_vertex0
         self.opposite_vertex1 = opposite_vertex1
+        self.opposite_vertex0_global = opposite_vertex0_global
+        self.opposite_vertex1_global = opposite_vertex1_global
 
     def size(self) -> int:
         if self.v0 is None:
@@ -346,6 +370,47 @@ class SceneEdgeTopology(_StructRepr):
         return int(_shape_tuple(self.v0)[0])
 
 
+class SceneGlobalGeometry(_StructRepr):
+    DRJIT_STRUCT = {
+        "vertices": object,
+        "faces": object,
+        "face_normal": object,
+        "shape_id": object,
+        "local_prim_id": object,
+        "global_prim_id": object,
+    }
+
+    def __init__(
+        self,
+        vertices: Any = None,
+        faces: Any = None,
+        face_normal: Any = None,
+        shape_id: Any = None,
+        local_prim_id: Any = None,
+        global_prim_id: Any = None,
+    ):
+        self.vertices = vertices
+        self.faces = faces
+        self.face_normal = face_normal
+        self.shape_id = shape_id
+        self.local_prim_id = local_prim_id
+        self.global_prim_id = global_prim_id
+
+    def vertex_count(self) -> int:
+        if self.vertices is None:
+            return 0
+        from ._util import _shape_tuple
+        shape = _shape_tuple(self.vertices)
+        return int(shape[0]) if len(shape) >= 1 else 0
+
+    def face_count(self) -> int:
+        if self.global_prim_id is None:
+            return 0
+        from ._util import _shape_tuple
+        shape = _shape_tuple(self.global_prim_id)
+        return int(shape[0]) if len(shape) >= 1 else 0
+
+
 class SceneSyncProfile:
     _FIELDS = (
         "mesh_update_ms",