rayd 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rayd
-Version: 0.2.1
+Version: 0.2.2
 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.1 → rayd-0.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "rayd"
-version = "0.2.1"
+version = "0.2.2"
 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.1 → rayd-0.2.2}/src/rayd.cpp

@@ -502,6 +502,61 @@ NB_MODULE(rayd, m) {
     bind_section("mesh", [&]() {
         nb::class_<Mesh>(m, "Mesh")
             .def(nb::init<>())
+            .def("__init__",
+                 [](Mesh *mesh,
+                    nb::handle v_obj,
+                    const Vector3iDetached &f,
+                    nb::handle uv_obj,
+                    const Vector3iDetached &f_uv,
+                    bool verbose) {
+                     const std::string v_module_name =
+                         nb::cast<std::string>(v_obj.type().attr("__module__"));
+                     const std::string v_type_name =
+                         nb::cast<std::string>(v_obj.type().attr("__name__"));
+                     const std::string uv_module_name =
+                         nb::cast<std::string>(uv_obj.type().attr("__module__"));
+                     const std::string uv_type_name =
+                         nb::cast<std::string>(uv_obj.type().attr("__name__"));
+
+                     const bool has_live_v =
+                         v_module_name == "drjit.cuda.ad" && v_type_name == "Array3f";
+                     const bool has_live_uv =
+                         uv_module_name == "drjit.cuda.ad" && uv_type_name == "Array2f";
+                     if (!has_live_v && !has_live_uv) {
+                         throw nb::next_overload();
+                     }
+
+                     Vector3fDetached v_detached;
+                     if (has_live_v) {
+                         const Vector3f v_live = nb::cast<Vector3f>(v_obj);
+                         v_detached = detach<false>(v_live);
+                     } else if (!drjit_try_load<Vector3fDetached>(v_obj, v_detached, true)) {
+                         throw nb::next_overload();
+                     }
+
+                     Vector2fDetached uv_detached;
+                     if (has_live_uv) {
+                         const Vector2f uv_live = nb::cast<Vector2f>(uv_obj);
+                         uv_detached = detach<false>(uv_live);
+                     } else if (!drjit_try_load<Vector2fDetached>(uv_obj, uv_detached, true)) {
+                         throw nb::next_overload();
+                     }
+
+                     new (mesh) Mesh(v_detached, f, uv_detached, f_uv, verbose);
+                     if (has_live_v) {
+                         const Vector3f v_live = nb::cast<Vector3f>(v_obj);
+                         mesh->set_vertex_positions(v_live);
+                     }
+                     if (has_live_uv) {
+                         const Vector2f uv_live = nb::cast<Vector2f>(uv_obj);
+                         mesh->set_vertex_uv(uv_live);
+                     }
+                 },
+                 "v"_a,
+                 "f"_a,
+                 "uv"_a = Vector2fDetached(),
+                 "f_uv"_a = Vector3iDetached(),
+                 "verbose"_a = false)
             .def("__init__",
                  [](Mesh *mesh,
                     const Vector3fDetached &v,

{rayd-0.2.1 → rayd-0.2.2}/tests/drjit/test_geometry.py

@@ -654,6 +654,46 @@ class GeometryCoreTests(unittest.TestCase):
         self.assertAlmostEqual(data["t"], 1.0, places=5)
         self.assertGreater(data["grad_z_sum"], 0.0)
 
+    def test_trace_reflections_preserves_gradients_for_ad_mesh_constructor_inputs(self):
+        data = run_json_case(
+            """
+            import json
+            import rayd as pj
+            import drjit as dr
+            import drjit.cuda as cuda
+            import drjit.cuda.ad as ad
+
+            verts = ad.Array3f([0.0, 1.0, 0.0],
+                               [0.0, 0.0, 1.0],
+                               [0.0, 0.0, 0.0])
+            dr.enable_grad(verts)
+
+            mesh = pj.Mesh(verts, cuda.Array3i([0], [1], [2]))
+
+            scene = pj.Scene()
+            scene.add_mesh(mesh)
+            scene.build()
+
+            ray = pj.Ray(ad.Array3f([0.25], [0.25], [-1.0]),
+                         ad.Array3f([0.0], [0.0], [1.0]))
+            chain = scene.trace_reflections(ray, max_bounces=1, symbolic=False)
+            dr.backward(dr.sum(chain.t))
+            grad = dr.grad(verts)
+
+            print(json.dumps({
+                "bounce_count": int(chain.bounce_count[0]),
+                "valid": bool(chain.is_valid()[0]),
+                "t": float(chain.t[0]),
+                "grad_z_sum": float(grad[2][0] + grad[2][1] + grad[2][2]),
+            }))
+            """
+        )
+
+        self.assertEqual(data["bounce_count"], 1)
+        self.assertTrue(data["valid"])
+        self.assertAlmostEqual(data["t"], 1.0, places=5)
+        self.assertGreater(data["grad_z_sum"], 0.0)
+
     def test_trace_reflections_supports_multi_bounce_symbolic_trace(self):
         data = run_json_case(
             """