nanovdb-editor 0.0.3__tar.gz

nanovdb_editor-0.0.3/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.2
+Name: nanovdb-editor
+Version: 0.0.3
+Summary: NanoVDB Editor Python Module
+Keywords: nanovdb,volume,rendering,gaussian,splatting,3d
+Author: The OpenVDB Project contributors
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/openvdb/nanovdb-editor
+Project-URL: Repository, https://github.com/openvdb/nanovdb-editor
+Project-URL: Documentation, https://github.com/openvdb/nanovdb-editor/tree/main/pymodule
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+##  NanoVDB Editor
+
+WIP
+
+### Shader Parameters
+Shaders can have defined struct with shader parameters which are intended to be shown in the editor's UI:
+```hlsl
+struct shader_params_t
+{
+    float4 color;
+    bool use_color;
+    bool3 _pad1;
+    int _pad2;
+};
+ConstantBuffer<shader_params_t> shader_params;
+```
+
+Shader parameters can have defined default values in the json file:
+```json
+{
+    "ShaderParams": {
+        "color": {
+            "value": [1.0, 0.0, 1.0, 1.0],
+            "min": 0.0,
+            "max": 1.0,
+            "step": 0.01
+        }
+    }
+}
+```
+Supported types: `bool`, `int`, `uint`, `int64`, `uint64`, `float` and its vectors and 4x4 matrix.
+Variables with `_pad` in the name are not shown in the UI.
+Those parameters can be interactively changed with generated UI in the editor's Params tab.
+
+To display a group of shader parameters from different shaders define a json file with various shader paths:
+```json
+{
+    "ShaderParams": [
+        "editor/editor.slang",
+        "test/test.slang"
+    ]
+}
+```

nanovdb_editor-0.0.3/README.md

@@ -0,0 +1,43 @@
+##  NanoVDB Editor
+
+WIP
+
+### Shader Parameters
+Shaders can have defined struct with shader parameters which are intended to be shown in the editor's UI:
+```hlsl
+struct shader_params_t
+{
+    float4 color;
+    bool use_color;
+    bool3 _pad1;
+    int _pad2;
+};
+ConstantBuffer<shader_params_t> shader_params;
+```
+
+Shader parameters can have defined default values in the json file:
+```json
+{
+    "ShaderParams": {
+        "color": {
+            "value": [1.0, 0.0, 1.0, 1.0],
+            "min": 0.0,
+            "max": 1.0,
+            "step": 0.01
+        }
+    }
+}
+```
+Supported types: `bool`, `int`, `uint`, `int64`, `uint64`, `float` and its vectors and 4x4 matrix.
+Variables with `_pad` in the name are not shown in the UI.
+Those parameters can be interactively changed with generated UI in the editor's Params tab.
+
+To display a group of shader parameters from different shaders define a json file with various shader paths:
+```json
+{
+    "ShaderParams": [
+        "editor/editor.slang",
+        "test/test.slang"
+    ]
+}
+```

nanovdb_editor-0.0.3/VERSION.txt

@@ -0,0 +1 @@
+0.0.3

nanovdb_editor-0.0.3/dev_environment.yml

@@ -0,0 +1,12 @@
+name: nanovdb_editor
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.11
+  - pip
+  - numpy<2.3.0,>=2
+  - scikit-build-core
+  - pytest
+  - parameterized
+  - black

nanovdb_editor-0.0.3/environment.yml

@@ -0,0 +1,8 @@
+name: nanovdb_editor
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.11
+  - numpy<2.3.0,>=2
+

nanovdb_editor-0.0.3/nanovdb_editor/__init__.py

@@ -0,0 +1,30 @@
+# Copyright Contributors to the OpenVDB Project
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+
+from .compiler import Compiler, pnanovdb_CompileTarget, MemoryBuffer
+from .compute import Compute
+from .device import DeviceInterface
+from .editor import Editor, pnanovdb_EditorConfig
+from .raster import Raster
+
+if sys.platform == "win32":
+    lib_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")
+    if os.path.exists(lib_dir):
+        from .utils import add_dll_search_directory
+
+        add_dll_search_directory(lib_dir)
+
+
+__all__ = [
+    "Compiler",
+    "Compute",
+    "DeviceInterface",
+    "Editor",
+    "Raster",
+    "pnanovdb_CompileTarget",
+    "MemoryBuffer",
+    "pnanovdb_EditorConfig",
+]

nanovdb_editor-0.0.3/nanovdb_editor/compiler.py

@@ -0,0 +1,178 @@
+# Copyright Contributors to the OpenVDB Project
+# SPDX-License-Identifier: Apache-2.0
+
+from ctypes import *
+from enum import Enum
+import numpy as np
+from typing import Tuple
+from .utils import load_library
+
+COMPILER_LIB = "pnanovdbcompiler"
+
+# Match pnanovdb_bool_t (int32_t)
+pnanovdb_bool_t = c_int32
+
+
+class pnanovdb_CompileTarget(Enum):
+    UNDEFINED = 0
+    VULKAN = 1
+    CPU = 2
+
+
+class pnanovdb_CompilerSettings(Structure):
+    """Definition equivalent to pnanovdb_compiler_settings_t."""
+
+    _fields_ = [
+        ("is_row_major", c_int32),
+        ("use_glslang", c_int32),
+        ("hlsl_output", c_int32),
+        ("compile_target", c_uint32),
+        ("entry_point_name", c_char * 64),
+    ]
+
+
+class pnanovdb_CompilerInstance(Structure):
+    """Definition equivalent to pnanovdb_compiler_instance_t."""
+
+
+class pnanovdb_Compiler(Structure):
+    """Definition equivalent to pnanovdb_compiler_t."""
+
+    _fields_ = [
+        ("interface_pnanovdb_reflect_data_type", c_void_p),  # PNANOVDB_REFLECT_INTERFACE()
+        ("create_instance", CFUNCTYPE(POINTER(pnanovdb_CompilerInstance))),
+        ("set_diagnostic_callback", CFUNCTYPE(None, POINTER(pnanovdb_CompilerInstance), CFUNCTYPE(None, c_char_p))),
+        (
+            "compile_shader_from_file",
+            CFUNCTYPE(
+                pnanovdb_bool_t,
+                POINTER(pnanovdb_CompilerInstance),
+                c_char_p,
+                POINTER(pnanovdb_CompilerSettings),
+                POINTER(pnanovdb_bool_t),
+            ),
+        ),
+        (
+            "execute_cpu",
+            CFUNCTYPE(
+                pnanovdb_bool_t,
+                POINTER(pnanovdb_CompilerInstance),
+                c_char_p,
+                c_uint32,
+                c_uint32,
+                c_uint32,
+                c_void_p,
+                c_void_p,
+            ),
+        ),
+        ("destroy_instance", CFUNCTYPE(None, POINTER(pnanovdb_CompilerInstance))),
+        ("module", c_void_p),
+    ]
+
+
+class MemoryBuffer(Structure):
+    """Python wrapper for memory buffer passed to the shader function run on CPU."""
+
+    _fields_ = [
+        ("data", c_void_p),
+        ("size", c_uint64),
+    ]
+
+    def __init__(self, data: np.ndarray):
+        """Initialize the MemoryBuffer with a numpy array."""
+        self.data = data.ctypes.data_as(c_void_p)
+        self.size = data.size
+
+    def to_ndarray(self, dtype):
+        """Convert memory buffer to numpy array of specified dtype."""
+        if not self.data or not self.size:
+            return np.array([], dtype=dtype)
+
+        # Create array from buffer without copying
+        return np.frombuffer((c_byte * (self.size * np.dtype(dtype).itemsize)).from_address(self.data), dtype=dtype)
+
+
+class Compiler:
+    """Python wrapper for pnanovdb_compiler_t."""
+
+    def __init__(self):
+        """Mirrors what is in pnanovdb_compiler_load"""
+        self._lib = load_library(COMPILER_LIB)
+
+        get_compiler = self._lib.pnanovdb_get_compiler
+        get_compiler.restype = POINTER(pnanovdb_Compiler)
+        get_compiler.argtypes = []
+        self._compiler = get_compiler()
+        if not self._compiler:
+            raise RuntimeError("Failed to get compiler interface")
+
+        self._instance = None
+        self._compiler.contents.module = self._lib._handle
+
+    def get_compiler(self) -> POINTER(pnanovdb_Compiler):
+        return self._compiler
+
+    def create_instance(self) -> None:
+        if self._instance:
+            raise RuntimeError("Compiler instance already exists")
+
+        create_func = self._compiler.contents.create_instance
+        self._instance = create_func()
+
+        if not self._instance:
+            raise RuntimeError("Failed to create compiler instance")
+
+    def compile_shader(
+        self, filename: str, entry_point_name="main", is_row_major=False, compile_target=pnanovdb_CompileTarget.VULKAN
+    ) -> bool:
+        if not self._instance:
+            raise RuntimeError("No compiler instance exists")
+
+        settings = pnanovdb_CompilerSettings(
+            entry_point_name=entry_point_name.encode("utf-8"),
+            is_row_major=is_row_major,
+            use_glslang=False,
+            hlsl_output=False,
+            compile_target=(c_uint32)(compile_target.value),
+        )
+
+        compile_func = self._compiler.contents.compile_shader_from_file
+        return compile_func(self._instance, filename.encode("utf-8"), byref(settings), None)
+
+    def execute_cpu(
+        self,
+        filename: str,
+        grid_dims: Tuple[int, int, int],
+        uniform_params: POINTER(c_void_p),
+        uniform_state: POINTER(c_void_p),
+    ) -> bool:
+        if not self._instance:
+            raise RuntimeError("No compiler instance exists")
+
+        execute_func = self._compiler.contents.execute_cpu
+        return execute_func(
+            self._instance,
+            filename.encode("utf-8"),
+            c_uint32(grid_dims[0]),
+            c_uint32(grid_dims[1]),
+            c_uint32(grid_dims[2]),
+            uniform_params,
+            uniform_state,
+        )
+
+    def destroy_instance(self) -> None:
+        if not self._instance:
+            return
+
+        destroy_func = self._compiler.contents.destroy_instance
+        destroy_func(self._instance)
+
+        self._instance = None
+
+    def __del__(self):
+        # Do not call into native library from Python finalizer; just drop refs
+        try:
+            self._instance = None
+            self._compiler = None
+        except Exception:
+            pass

nanovdb_editor-0.0.3/nanovdb_editor/compute.py

@@ -0,0 +1,275 @@
+# Copyright Contributors to the OpenVDB Project
+# SPDX-License-Identifier: Apache-2.0
+
+from ctypes import *
+from typing import Tuple
+import numpy as np
+
+from .utils import load_library
+from .device import DeviceInterface, pnanovdb_DeviceInterface, pnanovdb_Device
+from .compiler import Compiler, pnanovdb_Compiler
+
+COMPUTE_LIB = "pnanovdbcompute"
+
+# Match pnanovdb_bool_t (int32_t)
+pnanovdb_bool_t = c_int32
+
+VULKAN_API = 1
+PNANOVDB_TRUE = 1
+
+
+class pnanovdb_ComputeShaderSource(Structure):
+    pass
+
+
+class pnanovdb_ComputeShaderBuild(Structure):
+    pass
+
+
+class pnanovdb_ShaderInterface(Structure):
+    """Definition equivalent to pnanovdb_compute_shader_interface_t."""
+
+    _fields_ = [
+        ("interface_pnanovdb_reflect_data_type", c_void_p),  # PNANOVDB_REFLECT_INTERFACE()
+        ("create_shader", CFUNCTYPE(c_void_p, POINTER(pnanovdb_ComputeShaderSource))),
+        ("map_shader_build", CFUNCTYPE(pnanovdb_bool_t, c_void_p, POINTER(POINTER(pnanovdb_ComputeShaderBuild)))),
+        ("destroy_shader", CFUNCTYPE(None, c_void_p)),
+    ]
+
+
+class pnanovdb_ComputeArray(Structure):
+    """Definition equivalent to pnanovdb_compute_array_t."""
+
+    _fields_ = [("data", c_void_p), ("element_size", c_uint64), ("element_count", c_uint64), ("filepath", c_char_p)]
+
+    def __init__(self, data=None, element_size=0, element_count=0, filepath=None):
+        super().__init__()
+        self.data = data
+        self.element_size = element_size
+        self.element_count = element_count
+        self.filepath = filepath.encode("utf-8") if isinstance(filepath, str) else filepath
+
+
+class pnanovdb_Compute(Structure):
+    """Definition equivalent to pnanovdb_compute_t."""
+
+    _fields_ = [
+        ("interface_pnanovdb_reflect_data_type", c_void_p),  # PNANOVDB_REFLECT_INTERFACE()
+        ("module", c_void_p),
+        ("compiler", POINTER(pnanovdb_Compiler)),
+        ("shader_interface", pnanovdb_ShaderInterface),
+        ("device_interface", pnanovdb_DeviceInterface),
+        ("load_nanovdb", CFUNCTYPE(POINTER(pnanovdb_ComputeArray), c_char_p)),
+        ("save_nanovdb", CFUNCTYPE(pnanovdb_bool_t, POINTER(pnanovdb_ComputeArray), c_char_p)),
+        ("create_shader_context", CFUNCTYPE(c_void_p, c_char_p)),
+        ("destroy_shader_context", CFUNCTYPE(None, c_void_p)),
+        (
+            "init_shader",
+            CFUNCTYPE(
+                pnanovdb_bool_t,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                c_void_p,  # pnanovdb_compute_queue_t*
+                c_void_p,  # pnanovdb_shader_context_t*
+                c_void_p,
+            ),
+        ),  # pnanovdb_compiler_settings_t*
+        (
+            "destroy_shader",
+            CFUNCTYPE(
+                None,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                POINTER(pnanovdb_ShaderInterface),
+                c_void_p,  # pnanovdb_compute_context_t*
+                c_void_p,
+            ),
+        ),  # pnanovdb_shader_context_t*
+        (
+            "dispatch_shader",
+            CFUNCTYPE(
+                None,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                c_void_p,  # pnanovdb_compute_context_t*
+                c_void_p,  # const pnanovdb_shader_context_t*
+                c_void_p,  # pnanovdb_compute_resource_t*
+                c_uint32,  # grid_dim_x
+                c_uint32,  # grid_dim_y
+                c_uint32,  # grid_dim_z
+                c_char_p,
+            ),
+        ),  # debug_label
+        (
+            "dispatch_shader_on_array",
+            CFUNCTYPE(
+                pnanovdb_bool_t,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                POINTER(pnanovdb_Device),
+                c_char_p,
+                c_uint32,
+                c_uint32,
+                c_uint32,
+                POINTER(pnanovdb_ComputeArray),
+                POINTER(pnanovdb_ComputeArray),
+                POINTER(pnanovdb_ComputeArray),
+                c_uint32,
+                c_uint64,
+                c_uint64,
+            ),
+        ),
+        (
+            "dispatch_shader_on_nanovdb_array",
+            CFUNCTYPE(
+                pnanovdb_bool_t,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                c_void_p,  # const pnanovdb_compute_device_t*
+                c_void_p,  # const pnanovdb_shader_context_t*
+                POINTER(pnanovdb_ComputeArray),  # nanovdb_array
+                c_int32,  # image_width
+                c_int32,  # image_height
+                c_void_p,  # background_image
+                c_void_p,  # upload_buffer
+                c_void_p,  # user_upload_buffer
+                POINTER(c_void_p),  # nanovdb_buffer
+                POINTER(c_void_p),
+            ),
+        ),  # readback_buffer
+        ("create_array", CFUNCTYPE(POINTER(pnanovdb_ComputeArray), c_size_t, c_uint64, c_void_p)),
+        ("destroy_array", CFUNCTYPE(None, POINTER(pnanovdb_ComputeArray))),
+        ("map_array", CFUNCTYPE(c_void_p, POINTER(pnanovdb_ComputeArray))),
+        ("unmap_array", CFUNCTYPE(None, POINTER(pnanovdb_ComputeArray))),
+        (
+            "compute_array_print_range",
+            CFUNCTYPE(
+                None,
+                c_void_p,  # POINTER(pnanovdb_Compute)
+                c_void_p,  # pnanovdb_compute_log_print_t
+                c_char_p,  # name
+                POINTER(pnanovdb_ComputeArray),  # arr
+                c_uint32,
+            ),
+        ),  # channel_count
+    ]
+
+
+class Compute:
+    """Python wrapper for pnanovdb_compute_t."""
+
+    def __init__(self, compiler: Compiler):
+        """Mirrors what is in pnanovdb_compute_load"""
+        self._compiler = compiler
+
+        self._lib = load_library(COMPUTE_LIB)
+
+        # only vulkan is supported for now
+        self._device_interface = DeviceInterface(VULKAN_API)
+
+        get_compute = self._lib.pnanovdb_get_compute
+        get_compute.restype = POINTER(pnanovdb_Compute)
+        get_compute.argtypes = []
+
+        self._compute = get_compute()
+        if not self._compute:
+            raise RuntimeError("Failed to get compute interface")
+
+        compiler_ptr = compiler.get_compiler()
+        if not compiler_ptr:
+            raise RuntimeError("Failed to get compiler interface")
+
+        self._compute.contents.compiler = compiler_ptr
+        self._compute.contents.device_interface = self._device_interface.get_device_interface().contents
+        self._compute.contents.module = self._lib._handle
+
+        get_shader_interface = self._lib.pnanovdb_get_compute_shader_interface
+        get_shader_interface.restype = POINTER(pnanovdb_ShaderInterface)
+        get_shader_interface.argtypes = []
+
+        self._compute.contents.shader_interface = get_shader_interface().contents
+
+    def get_compute(self) -> POINTER(pnanovdb_Compute):
+        return self._compute
+
+    def compiler(self) -> Compiler:
+        return self._compiler
+
+    def device_interface(self) -> DeviceInterface:
+        return self._device_interface
+
+    def load_nanovdb(self, filepath: str) -> pnanovdb_ComputeArray:
+        load_func = self._compute.contents.load_nanovdb
+        array = load_func(filepath.encode("utf-8"))
+        if not array:
+            raise RuntimeError(f"Failed to load NanoVDB file: {filepath}")
+        return array.contents
+
+    def save_nanovdb(self, array: pnanovdb_ComputeArray, filepath: str) -> None:
+        save_func = self._compute.contents.save_nanovdb
+        save_func(pointer(array), filepath.encode("utf-8"))
+
+    def create_array(self, data: np.ndarray) -> pnanovdb_ComputeArray:
+        create_func = self._compute.contents.create_array
+        array = create_func(data.itemsize, data.size, data.ctypes.data_as(c_void_p))
+        if not array:
+            raise RuntimeError("Failed to create compute array")
+        return array.contents
+
+    def destroy_array(self, array: pnanovdb_ComputeArray) -> None:
+        destroy_func = self._compute.contents.destroy_array
+        destroy_func(pointer(array))
+
+    def dispatch_shader_on_array(
+        self,
+        shader_path: str,
+        grid_dims: Tuple[int, int, int],
+        data_in: pnanovdb_ComputeArray,
+        constants: pnanovdb_ComputeArray,
+        data_out: pnanovdb_ComputeArray,
+        dispatch_count: int = 1,
+        scratch_size: int = 0,
+        scratch_clear_size: int = 0,
+    ) -> bool:
+        if not data_in or not constants or not data_out:
+            raise ValueError("ComputeArray parameters cannot be None")
+
+        dispatch_func = self._compute.contents.dispatch_shader_on_array
+        result = dispatch_func(
+            self._compute,
+            self._device_interface.get_device(),
+            shader_path.encode("utf-8"),
+            c_uint32(grid_dims[0]),
+            c_uint32(grid_dims[1]),
+            c_uint32(grid_dims[2]),
+            pointer(data_in),
+            pointer(constants),
+            pointer(data_out),
+            c_uint32(dispatch_count),
+            c_uint64(scratch_size),
+            c_uint64(scratch_clear_size),
+        )
+
+        return result == PNANOVDB_TRUE
+
+    def map_array(self, array: pnanovdb_ComputeArray, np_dtype: np.dtype) -> np.ndarray:
+        if array.element_size != np_dtype.itemsize:
+            raise ValueError("Array element size mismatches the provided dtype")
+
+        map_func = self._compute.contents.map_array
+        data_ptr = map_func(pointer(array))
+        if not data_ptr:
+            raise RuntimeError("Failed to map array")
+
+        buffer = (c_byte * (array.element_size * array.element_count)).from_address(data_ptr)
+        return np.frombuffer(buffer, dtype=np_dtype)
+
+    def unmap_array(self, array: pnanovdb_ComputeArray) -> None:
+        unmap_func = self._compute.contents.unmap_array
+        unmap_func(pointer(array))
+
+    def array_exists(self, array: pnanovdb_ComputeArray) -> bool:
+        return array and array.data is not None
+
+    def __del__(self):
+        try:
+            self._compute = None
+            self._compiler = None
+            self._device_interface = None
+        except Exception:
+            pass