warp-lang 1.9.0__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/examples/fem/utils.py

@@ -535,7 +535,7 @@ def _compute_schur_inverse_diagonal(
         S = B * Ai * wp.transpose(B)
         schur += S
 
-    P_diag[row] = fem.utils.inverse_qr(schur)
+    P_diag[row] = fem.linalg.inverse_qr(schur)
 
 
 def invert_diagonal_bsr_matrix(A: BsrMatrix):
@@ -556,7 +556,7 @@ def invert_diagonal_bsr_matrix(A: BsrMatrix):
 @wp.kernel(enable_backward=False)
 def _block_diagonal_invert(values: wp.array(dtype=Any)):
     i = wp.tid()
-    values[i] = fem.utils.inverse_qr(values[i])
+    values[i] = fem.linalg.inverse_qr(values[i])
 
 
 #

warp/examples/interop/example_jax_callable.py

@@ -25,7 +25,7 @@ import jax
 import jax.numpy as jnp
 
 import warp as wp
-from warp.jax_experimental.ffi import jax_callable
+from warp.jax_experimental import jax_callable
 
 
 @wp.kernel

warp/examples/interop/example_jax_ffi_callback.py

@@ -26,7 +26,7 @@ import numpy as np
 
 import warp as wp
 from warp.jax import get_jax_device
-from warp.jax_experimental.ffi import register_ffi_callback
+from warp.jax_experimental import register_ffi_callback
 
 
 @wp.kernel

warp/examples/interop/example_jax_kernel.py

@@ -26,7 +26,7 @@ import jax
 import jax.numpy as jnp
 
 import warp as wp
-from warp.jax_experimental.ffi import jax_kernel
+from warp.jax_experimental import jax_kernel
 
 
 @wp.kernel
@@ -45,7 +45,8 @@ def sincos_kernel(angle: wp.array(dtype=float), sin_out: wp.array(dtype=float),
 @wp.kernel
 def diagonal_kernel(output: wp.array(dtype=wp.mat33)):
     tid = wp.tid()
-    output[tid] = wp.mat33(1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0)
+    d = float(tid + 1)
+    output[tid] = wp.mat33(d, 0.0, 0.0, 0.0, d * 2.0, 0.0, 0.0, 0.0, d * 3.0)
 
 
 @wp.kernel

warp/examples/tile/example_tile_mcgp.py

@@ -0,0 +1,191 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#############################################################################
+# Example Tile Monte Carlo Geometry Processing
+#
+# Shows how to use the built-in wp.Mesh data structure and
+# wp.mesh_eval_position() function to implement a tile-based, grid-free
+# Laplace solver using a Monte Carlo approach.
+#
+# References:
+#   Rohan Sawhney and Keenan Crane. Monte Carlo Geometry Processing:
+#   A Grid-Free Approach to PDE-Based Methods on Volumetric Domains.
+#   ACM Trans. Graph., Vol. 38, No. 4, Article 1. Published July 2020
+#
+##############################################################################
+
+import os
+
+import numpy as np
+from pxr import Usd, UsdGeom
+
+import warp as wp
+import warp.examples
+
+TILE_SIZE = wp.constant(64)  # number of samples for random walk
+STEPS = wp.constant(8)
+SEED = wp.constant(42)
+TOL = wp.constant(0.001)
+
+wp.config.enable_backward = False
+
+
+@wp.func
+def update_radius(p: wp.vec3):
+    """new radius is the distance to the closest point on the mesh"""
+    radius = 0.0
+    query = wp.mesh_query_point(MESH_ID, p, 1e6)
+
+    if query.result:
+        q = wp.mesh_eval_position(MESH_ID, query.face, query.u, query.v)
+        radius = -wp.length(q - p) * query.sign
+
+    return radius
+
+
+@wp.func
+def get_boundary_value(p: wp.vec3):
+    """analytic boundary condition on the surface of the mesh"""
+    return wp.abs(wp.sin(5.0 * wp.length(p)))
+
+
+@wp.func
+def walk(p: wp.vec3, rand_offset: int):
+    """random walk on spheres"""
+    rng = wp.rand_init(SEED, rand_offset)
+    for _ in range(0, STEPS):
+        r = update_radius(p)
+        if r < 0.0:  # outside the mesh
+            return 0.0
+        elif r < TOL:  # within the epsilon boundary
+            return get_boundary_value(p)
+        pr = wp.sample_unit_sphere_surface(rng) * r
+        p += pr
+    return get_boundary_value(p)  # closest choice if epsilon boundary not reached
+
+
+@wp.kernel
+def sphere_walk(delta_z: float, samples: wp.array2d(dtype=wp.vec3), solutions: wp.array2d(dtype=float)):
+    i, j = wp.tid()
+
+    sample_origin = samples[i, j] + wp.vec3(0.0, 0.0, delta_z)
+
+    rand_samples = wp.tile_full(TILE_SIZE, value=sample_origin, dtype=wp.vec3)
+
+    # every random sample gets a unique offset for rng
+    rand_offsets = wp.tile_arange(TILE_SIZE, dtype=int)
+    rand_offsets += wp.tile_full(TILE_SIZE, value=(i * TILE_SIZE + j) * TILE_SIZE, dtype=int)
+
+    # mcgp
+    walk_results = wp.tile_map(walk, rand_samples, rand_offsets)
+
+    # solution is an average of all walks originating from this position
+    walk_sum = wp.tile_sum(walk_results)
+    result = walk_sum * (1.0 / wp.float32(TILE_SIZE))
+
+    wp.tile_store(solutions[i], result, offset=(j,))
+
+
+class Example:
+    def __init__(self, height=256, slices=60):
+        usd_stage = Usd.Stage.Open(os.path.join(warp.examples.get_asset_directory(), "bunny.usd"))
+        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/bunny"))
+
+        self.mesh = wp.Mesh(
+            points=wp.array(usd_geom.GetPointsAttr().Get(), dtype=wp.vec3),
+            indices=wp.array(usd_geom.GetFaceVertexIndicesAttr().Get(), dtype=int),
+            bvh_leaf_size=1,
+        )
+
+        # z-slice scanning grid
+        self.height = height
+        self.width = self.height
+
+        x = np.linspace(-1.15, 0.85, self.width)
+        y = np.linspace(-0.2, 1.8, self.height)
+        xv, yv = np.meshgrid(x, y, indexing="ij")
+        zv = np.zeros_like(xv)
+        grid = np.stack((xv, yv, zv), axis=-1)
+
+        self.grid = wp.array(grid, dtype=wp.vec3)
+        self.pixels = wp.zeros((self.height, self.width), dtype=float)
+
+        self.slices = slices
+        self.z = np.linspace(-0.6, 0.8, self.slices)
+
+        # storage for animation
+        self.images = np.zeros((self.slices, self.height, self.width))
+
+    def render(self, slice):
+        wp.launch_tiled(
+            sphere_walk,
+            dim=[self.height, self.width],
+            inputs=[self.z[slice], self.grid],
+            outputs=[self.pixels],
+            block_dim=TILE_SIZE,
+        )
+
+        self.images[slice] = self.pixels.numpy()
+        print(f"slice: {slice}")
+
+    def get_animation(self):
+        fig, ax = plt.subplots()
+        plt.axis("off")
+        plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
+        plt.margins(0, 0)
+
+        slices = []
+        for i in range(self.slices):
+            slice = ax.imshow(np.flip(self.images[i, :, :].T), animated=True)
+            slices.append([slice])
+
+        ani = animation.ArtistAnimation(fig, slices, interval=60, blit=True, repeat_delay=1000)
+        return ani
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("--device", type=str, default=None, help="Override the default Warp device.")
+    parser.add_argument("--height", type=int, default=256, help="Height of rendered image in pixels.")
+    parser.add_argument("--slices", type=int, default=60, help="Number of planar z-slices to scan.")
+    parser.add_argument(
+        "--headless",
+        action="store_true",
+        help="Run in headless mode, suppressing the opening of any graphical windows.",
+    )
+
+    args = parser.parse_known_args()[0]
+
+    with wp.ScopedDevice(args.device):
+        example = Example(height=args.height, slices=args.slices)
+
+        # todo: permit runtime constants to be passed to tile map functions
+        MESH_ID = wp.constant(wp.uint64(example.mesh.id))
+
+        for i in range(args.slices):
+            example.render(i)
+
+        if not args.headless:
+            import matplotlib.animation as animation
+            import matplotlib.pyplot as plt
+
+            print("Creating the animation")
+            anim = example.get_animation()
+            anim_filename = "example_tile_mcgp_animation.gif"
+            anim.save(anim_filename, dpi=300, writer=animation.PillowWriter(fps=5))
+            print(f"Saved the animation at `{anim_filename}`")

warp/fabric.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,343 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import ctypes
-import math
-from typing import Any
+# TODO: Remove after cleaning up the public API.
 
-import warp
-from warp.types import *
+from warp._src import fabric as _fabric
 
 
-class fabricbucket_t(ctypes.Structure):
-    _fields_ = (
-        ("index_start", ctypes.c_size_t),
-        ("index_end", ctypes.c_size_t),
-        ("ptr", ctypes.c_void_p),
-        ("lengths", ctypes.c_void_p),
-    )
+def __getattr__(name):
+    from warp._src.utils import get_deprecated_api
 
-    def __init__(self, index_start=0, index_end=0, ptr=None, lengths=None):
-        self.index_start = index_start
-        self.index_end = index_end
-        self.ptr = ctypes.c_void_p(ptr)
-        self.lengths = ctypes.c_void_p(lengths)
-
-
-class fabricarray_t(ctypes.Structure):
-    _fields_ = (
-        ("buckets", ctypes.c_void_p),  # array of fabricbucket_t on the correct device
-        ("nbuckets", ctypes.c_size_t),
-        ("size", ctypes.c_size_t),
-    )
-
-    def __init__(self, buckets=None, nbuckets=0, size=0):
-        self.buckets = ctypes.c_void_p(buckets)
-        self.nbuckets = nbuckets
-        self.size = size
-
-
-class indexedfabricarray_t(ctypes.Structure):
-    _fields_ = (
-        ("fa", fabricarray_t),
-        ("indices", ctypes.c_void_p),
-        ("size", ctypes.c_size_t),
-    )
-
-    def __init__(self, fa=None, indices=None):
-        if fa is None:
-            self.fa = fabricarray_t()
-        else:
-            self.fa = fa.__ctype__()
-
-        if indices is None:
-            self.indices = ctypes.c_void_p(None)
-            self.size = 0
-        else:
-            self.indices = ctypes.c_void_p(indices.ptr)
-            self.size = indices.size
-
-
-def fabric_to_warp_dtype(type_info, attrib_name):
-    if not type_info[0]:
-        raise RuntimeError(f"Attribute '{attrib_name}' cannot be used in Warp")
-
-    base_type_dict = {
-        "b": warp.bool,  # boolean
-        "i1": warp.int8,
-        "i2": warp.int16,
-        "i4": warp.int32,
-        "i8": warp.int64,
-        "u1": warp.uint8,
-        "u2": warp.uint16,
-        "u4": warp.uint32,
-        "u8": warp.uint64,
-        "f2": warp.float16,
-        "f4": warp.float32,
-        "f8": warp.float64,
-    }
-
-    base_dtype = base_type_dict.get(type_info[1])
-    if base_dtype is None:
-        raise RuntimeError(f"Attribute '{attrib_name}' base data type '{type_info[1]}' is not supported in Warp")
-
-    elem_count = type_info[2]
-    role = type_info[4]
-
-    if role in ("text", "path"):
-        raise RuntimeError(f"Attribute '{attrib_name}' role '{role}' is not supported in Warp")
-
-    if elem_count > 1:
-        # vector or matrix type
-        if role == "quat" and elem_count == 4:
-            return quaternion(base_dtype)
-        elif role in ("matrix", "transform", "frame"):
-            # only square matrices are currently supported
-            mat_size = int(math.sqrt(elem_count))
-            assert mat_size * mat_size == elem_count
-            return matrix((mat_size, mat_size), base_dtype)
-        else:
-            return vector(elem_count, base_dtype)
-    else:
-        # scalar type
-        return base_dtype
-
-
-class fabricarray(noncontiguous_array_base[T]):
-    # member attributes available during code-gen (e.g.: d = arr.shape[0])
-    # (initialized when needed)
-    _vars = None
-
-    def __new__(cls, *args, **kwargs):
-        instance = super().__new__(cls)
-        instance.deleter = None
-        return instance
-
-    def __init__(self, data=None, attrib=None, dtype=Any, ndim=None):
-        super().__init__(ARRAY_TYPE_FABRIC)
-
-        if data is not None:
-            from .context import runtime
-
-            # ensure the attribute name was also specified
-            if not isinstance(attrib, str):
-                raise ValueError(f"Invalid attribute name: {attrib}")
-
-            # get the fabric interface dictionary
-            if isinstance(data, dict):
-                iface = data
-            elif hasattr(data, "__fabric_arrays_interface__"):
-                iface = data.__fabric_arrays_interface__
-            else:
-                raise ValueError(
-                    "Invalid data argument for fabricarray: expected dict or object with __fabric_arrays_interface__"
-                )
-
-            version = iface.get("version")
-            if version != 1:
-                raise ValueError(f"Unsupported Fabric interface version: {version}")
-
-            device = iface.get("device")
-            if not isinstance(device, str):
-                raise ValueError(f"Invalid Fabric interface device: {device}")
-
-            self.device = runtime.get_device(device)
-
-            attribs = iface.get("attribs")
-            if not isinstance(attribs, dict):
-                raise ValueError("Failed to get Fabric interface attributes")
-
-            # look up attribute info by name
-            attrib_info = attribs.get(attrib)
-            if not isinstance(attrib_info, dict):
-                raise ValueError(f"Failed to get attribute '{attrib}'")
-
-            type_info = attrib_info["type"]
-            assert len(type_info) == 5
-
-            self.dtype = fabric_to_warp_dtype(type_info, attrib)
-
-            self.access = attrib_info["access"]
-
-            pointers = attrib_info["pointers"]
-            counts = attrib_info["counts"]
-
-            if not (hasattr(pointers, "__len__") and hasattr(counts, "__len__") and len(pointers) == len(counts)):
-                raise RuntimeError("Attribute pointers and counts must be lists of the same size")
-
-            # check whether it's an array
-            array_depth = type_info[3]
-            if array_depth == 0:
-                self.ndim = 1
-                array_lengths = None
-            elif array_depth == 1:
-                self.ndim = 2
-                array_lengths = attrib_info["array_lengths"]
-                if not hasattr(array_lengths, "__len__") or len(array_lengths) != len(pointers):
-                    raise RuntimeError(
-                        "Attribute `array_lengths` must be a list of the same size as `pointers` and `counts`"
-                    )
-            else:
-                raise ValueError(f"Invalid attribute array depth: {array_depth}")
-
-            num_buckets = len(pointers)
-            size = 0
-            buckets = (fabricbucket_t * num_buckets)()
-
-            if num_buckets > 0:
-                for i in range(num_buckets):
-                    buckets[i].index_start = size
-                    buckets[i].index_end = size + counts[i]
-                    buckets[i].ptr = pointers[i]
-                    if array_lengths:
-                        buckets[i].lengths = array_lengths[i]
-                    size += counts[i]
-
-                if self.device.is_cuda:
-                    # copy bucket info to device
-                    buckets_size = ctypes.sizeof(buckets)
-                    allocator = self.device.get_allocator()
-                    buckets_ptr = allocator.alloc(buckets_size)
-                    cuda_stream = self.device.stream.cuda_stream
-                    runtime.core.wp_memcpy_h2d(
-                        self.device.context, buckets_ptr, ctypes.addressof(buckets), buckets_size, cuda_stream
-                    )
-                    self.deleter = allocator.deleter
-                else:
-                    buckets_ptr = ctypes.addressof(buckets)
-            else:
-                buckets_ptr = None
-
-            self.buckets = buckets
-            self.size = size
-            self.shape = (size,)
-
-            self.ctype = fabricarray_t(buckets_ptr, num_buckets, size)
-
-        else:
-            # empty array or type annotation
-            self.dtype = dtype
-            self.ndim = ndim or 1
-            self.device = None
-            self.access = None
-            self.buckets = None
-            self.size = 0
-            self.shape = (0,)
-            self.ctype = fabricarray_t()
-
-    def __del__(self):
-        # release the bucket info if needed
-        if self.deleter is None:
-            return
-
-        buckets_size = ctypes.sizeof(self.buckets)
-        with self.device.context_guard:
-            self.deleter(self.ctype.buckets, buckets_size)
-
-    def __ctype__(self):
-        return self.ctype
-
-    def __len__(self):
-        return self.size
-
-    def __str__(self):
-        if self.device is None:
-            # type annotation
-            return f"fabricarray{self.dtype}"
-        else:
-            return str(self.numpy())
-
-    def __getitem__(self, key):
-        if isinstance(key, array):
-            return indexedfabricarray(fa=self, indices=key)
-        else:
-            raise ValueError(f"Fabric arrays only support indexing using index arrays, got key of type {type(key)}")
-
-    @property
-    def vars(self):
-        # member attributes available during code-gen (e.g.: d = arr.shape[0])
-        # Note: we use a shared dict for all fabricarray instances
-        if fabricarray._vars is None:
-            fabricarray._vars = {"size": warp.codegen.Var("size", uint64)}
-        return fabricarray._vars
-
-    def fill_(self, value):
-        # TODO?
-        # filling Fabric arrays of arrays is not supported, because they are jagged arrays of arbitrary lengths
-        if self.ndim > 1:
-            raise RuntimeError("Filling Fabric arrays of arrays is not supported")
-
-        super().fill_(value)
-
-
-# special case for fabric array of arrays
-# equivalent to calling fabricarray(..., ndim=2)
-def fabricarrayarray(**kwargs):
-    kwargs["ndim"] = 2
-    return fabricarray(**kwargs)
-
-
-class indexedfabricarray(noncontiguous_array_base[T]):
-    # member attributes available during code-gen (e.g.: d = arr.shape[0])
-    # (initialized when needed)
-    _vars = None
-
-    def __init__(self, fa=None, indices=None, dtype=None, ndim=None):
-        super().__init__(ARRAY_TYPE_FABRIC_INDEXED)
-
-        if fa is not None:
-            check_index_array(indices, fa.device)
-            self.fa = fa
-            self.indices = indices
-            self.dtype = fa.dtype
-            self.ndim = fa.ndim
-            self.device = fa.device
-            self.size = indices.size
-            self.shape = (indices.size,)
-            self.ctype = indexedfabricarray_t(fa, indices)
-        else:
-            # allow empty indexedarrays in type annotations
-            self.fa = None
-            self.indices = None
-            self.dtype = dtype
-            self.ndim = ndim or 1
-            self.device = None
-            self.size = 0
-            self.shape = (0,)
-            self.ctype = indexedfabricarray_t()
-
-    def __ctype__(self):
-        return self.ctype
-
-    def __len__(self):
-        return self.size
-
-    def __str__(self):
-        if self.device is None:
-            # type annotation
-            return f"indexedfabricarray{self.dtype}"
-        else:
-            return str(self.numpy())
-
-    @property
-    def vars(self):
-        # member attributes available during code-gen (e.g.: d = arr.shape[0])
-        # Note: we use a shared dict for all indexedfabricarray instances
-        if indexedfabricarray._vars is None:
-            indexedfabricarray._vars = {"size": warp.codegen.Var("size", uint64)}
-        return indexedfabricarray._vars
-
-    def fill_(self, value):
-        # TODO?
-        # filling Fabric arrays of arrays is not supported, because they are jagged arrays of arbitrary lengths
-        if self.ndim > 1:
-            raise RuntimeError("Filling indexed Fabric arrays of arrays is not supported")
-
-        super().fill_(value)
-
-
-# special case for indexed fabric array of arrays
-# equivalent to calling fabricarray(..., ndim=2)
-def indexedfabricarrayarray(**kwargs):
-    kwargs["ndim"] = 2
-    return indexedfabricarray(**kwargs)
+    return get_deprecated_api(_fabric, "wp", name)