Custom types v2 (#48)

* Support auto-creation of textures as output

* Update resourceview

* Fix up all custom types so they function correctly in terms of dimensions

* Start improving the custom types

* Rock solid not dimension locked thread id arg!

* Improved all custom types + make them not locked to dimensions

* Add grid to main namespace

* Fix call dimensionality check

* Fix texture tests

* Update SlangPy->0.19.3, SGL->0.12.4

---------

Co-authored-by: Benedikt Bitterli <[email protected]>

Author: ccummingsNV

docs/changelog.rst

@@ -1,6 +1,11 @@
 Changelog
 ---------
 
+**Version 0.19.3**
+- Update SGL -> 0.12.4
+- Significant improvements to generator types 
+- Support textures as output type
+
 **Version 0.19.2**
 - Update SGL -> 0.12.3
 - Better error messages during generation

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slangpy"
-version = "0.19.2"
+version = "0.19.3"
 authors = [
     {name = "Chris Cummings", email = "[email protected]"},
     {name = "Benedikt Bitterli", email = "[email protected]"},
@@ -17,7 +17,7 @@ requires-python = ">=3.9"
 dependencies = [
   "typing_extensions",
   "numpy",
-  "nv-sgl==0.12.3"
+  "nv-sgl==0.12.4"
 ]
 
 [tool.pyright]

requirements-dev.txt

@@ -1,6 +1,6 @@
 typing_extensions
 numpy
-nv-sgl == 0.12.3
+nv-sgl == 0.12.4
 
 pre-commit
 pytest

requirements.txt

@@ -1,3 +1,3 @@
 typing_extensions
 numpy
-nv-sgl == 0.12.3
+nv-sgl == 0.12.4

slangpy/__init__.py

@@ -11,6 +11,9 @@
 # Bring all shared types into the top level namespace
 from .types import *
 
+# Bring tested experimental types into top level namespace
+from .experimental.gridarg import grid
+
 # Slangpy reflection system
 from . import reflection
 

slangpy/bindings/boundvariable.py

@@ -354,10 +354,15 @@ def _apply_implicit_vectorization(self, context: BindContext):
                     self.vector_mapping.as_tuple())+1
             else:
                 self.call_dimensionality = 0
+        elif self.python.match_call_shape:
+            self.call_dimensionality = -1
         else:
             assert self.vector_type is not None
             self.call_dimensionality = self.python.resolve_dimensionality(
                 context, self, self.vector_type)
+            if self.call_dimensionality is not None and self.call_dimensionality < 0:
+                raise BoundVariableException(
+                    f"Could not resolve dimensionality for {self.path}", self)
 
     def finalize_mappings(self, context: BindContext):
         """
@@ -369,6 +374,9 @@ def finalize_mappings(self, context: BindContext):
         self._finalize_mappings(context)
 
     def _finalize_mappings(self, context: BindContext):
+        if self.call_dimensionality == -1:
+            self.call_dimensionality = context.call_dimensionality
+
         if context.options['strict_broadcasting'] and self.children is None and not self.explicitly_vectorized:
             if self.call_dimensionality != 0 and self.call_dimensionality != context.call_dimensionality:
                 raise BoundVariableException(

slangpy/builtin/resourceview.py

@@ -12,11 +12,18 @@ def _get_or_create_python_type(layout: SlangProgramLayout, value: Any):
     assert isinstance(value, ResourceView)
     if isinstance(value.resource, Texture):
         if value.type == ResourceViewType.shader_resource:
-            return get_or_create_python_texture_type(layout, value.resource, ResourceUsage.shader_resource)
+            usage = ResourceUsage.shader_resource
         elif value.type == ResourceViewType.unordered_access:
-            return get_or_create_python_texture_type(layout, value.resource, ResourceUsage.unordered_access)
+            usage = ResourceUsage.unordered_access
         else:
             raise ValueError(f"Unsupported resource view type {value.type}")
+        desc = value.resource.desc
+        return get_or_create_python_texture_type(layout,
+                                                 desc.format,
+                                                 desc.type,
+                                                 usage,
+                                                 value.resource.array_size,
+                                                 desc.sample_count)
     else:
         raise ValueError(f"Unsupported resource view resource {value.resource}")
 

slangpy/builtin/texture.py

@@ -5,11 +5,23 @@
 from slangpy.backend import TypeReflection
 
 from slangpy.backend import (FormatType, ResourceType, ResourceUsage, Sampler,
-                             Texture, get_format_info)
+                             Texture, Format, get_format_info)
 from slangpy.bindings import (PYTHON_SIGNATURES, PYTHON_TYPES, Marshall,
                               BindContext, BoundVariable, BoundVariableRuntime,
-                              CodeGenBlock)
-from slangpy.reflection.reflectiontypes import SamplerStateType, SlangProgramLayout, SlangType, TextureType
+                              CodeGenBlock, ReturnContext)
+from slangpy.reflection.reflectiontypes import SamplerStateType, SlangProgramLayout, SlangType, TextureType, VectorType, ArrayType, ScalarType
+from typing import Optional
+
+
+SCALARTYPE_TO_TEXTURE_FORMAT = {
+    TypeReflection.ScalarType.float32: (Format.r32_float, Format.rg32_float, Format.rgb32_float, Format.rgba32_float),
+    TypeReflection.ScalarType.float16: (Format.r16_float, Format.rg16_float, None, Format.rgba16_float),
+    TypeReflection.ScalarType.uint32: (Format.r32_uint, Format.rg32_uint, Format.rgb32_uint, Format.rgba32_uint),
+    TypeReflection.ScalarType.uint16: (Format.r16_unorm, Format.rg16_unorm, None, Format.rgba16_unorm),
+    TypeReflection.ScalarType.uint8: (Format.r8_unorm, Format.rg8_unorm, None, Format.rgba8_unorm),
+    TypeReflection.ScalarType.int16: (Format.r16_snorm, Format.rg16_snorm, None, Format.rgba16_snorm),
+    TypeReflection.ScalarType.int8: (Format.r8_snorm, Format.rg8_snorm, None, Format.rgba8_snorm),
+}
 
 
 def has_uav(usage: ResourceUsage):
@@ -22,7 +34,7 @@ def prefix(usage: ResourceUsage):
 
 class TextureMarshall(NativeTextureMarshall):
 
-    def __init__(self, layout: SlangProgramLayout, resource_shape: TypeReflection.ResourceShape, element_type: SlangType, usage: ResourceUsage):
+    def __init__(self, layout: SlangProgramLayout, resource_shape: TypeReflection.ResourceShape, element_type: SlangType, format: Format, usage: ResourceUsage):
         tex_type = ""
         tex_dims = 0
 
@@ -65,7 +77,7 @@ def __init__(self, layout: SlangProgramLayout, resource_shape: TypeReflection.Re
         self.slang_type: 'SlangType'
         self.slang_element_type: 'SlangType'
 
-        super().__init__(st, element_type, resource_shape, usage, tex_dims)
+        super().__init__(st, element_type, resource_shape, format, usage, tex_dims)
 
     def reduce_type(self, context: BindContext, dimensions: int):
         return super().reduce_type(context, dimensions)
@@ -144,57 +156,106 @@ def gen_calldata(self, cgb: CodeGenBlock, context: BindContext, binding: 'BoundV
                 f"Texture {name} has invalid dimensionality {binding.call_dimensionality}")
 
 
-def get_or_create_python_texture_type(layout: SlangProgramLayout, resource: Texture, usage: ResourceUsage):
+def get_or_create_python_texture_type(layout: SlangProgramLayout, format: Format, type: ResourceType, usage: ResourceUsage, array_size: int, sample_count: int):
 
     # Translate format into slang scalar type + channel count, which allows
     # us to build the element type of the texture.
-    fmt_info = get_format_info(resource.desc.format)
+    fmt_info = get_format_info(format)
     if fmt_info.type in [FormatType.float, FormatType.unorm, FormatType.snorm, FormatType.unorm_srgb]:
         scalar_type = TypeReflection.ScalarType.float32
     elif fmt_info.type == FormatType.uint:
         scalar_type = TypeReflection.ScalarType.uint32
     elif fmt_info.type == FormatType.sint:
         scalar_type = TypeReflection.ScalarType.int32
     else:
-        raise ValueError(f"Unsupported format {resource.desc.format}")
+        raise ValueError(f"Unsupported format {format}")
     element_type = layout.vector_type(scalar_type, fmt_info.channel_count)
 
     # Translate resource type + array size into a slang resource shape.
     resource_shape = TypeReflection.ResourceShape.none
-    if resource.array_size == 1:
-        if resource.desc.type == ResourceType.texture_1d:
+    if array_size == 1:
+        if type == ResourceType.texture_1d:
             resource_shape = TypeReflection.ResourceShape.texture_1d
-        elif resource.desc.type == ResourceType.texture_2d:
-            if resource.desc.sample_count == 1:
+        elif type == ResourceType.texture_2d:
+            if sample_count == 1:
                 resource_shape = TypeReflection.ResourceShape.texture_2d
             else:
                 resource_shape = TypeReflection.ResourceShape.texture_2d_multisample
-        elif resource.desc.type == ResourceType.texture_3d:
+        elif type == ResourceType.texture_3d:
             resource_shape = TypeReflection.ResourceShape.texture_3d
-        elif resource.desc.type == ResourceType.texture_cube:
+        elif type == ResourceType.texture_cube:
             resource_shape = TypeReflection.ResourceShape.texture_cube
         else:
-            raise ValueError(f"Unsupported texture type {resource.desc.type}")
+            raise ValueError(f"Unsupported texture type {type}")
     else:
-        if resource.desc.type == ResourceType.texture_1d:
+        if type == ResourceType.texture_1d:
             resource_shape = TypeReflection.ResourceShape.texture_1d_array
-        elif resource.desc.type == ResourceType.texture_2d:
-            if resource.desc.sample_count == 1:
+        elif type == ResourceType.texture_2d:
+            if sample_count == 1:
                 resource_shape = TypeReflection.ResourceShape.texture_2d_array
             else:
                 resource_shape = TypeReflection.ResourceShape.texture_2d_multisample_array
-        elif resource.desc.type == ResourceType.texture_cube:
+        elif type == ResourceType.texture_cube:
             resource_shape = TypeReflection.ResourceShape.texture_cube_array
         else:
-            raise ValueError(f"Unsupported texture type {resource.desc.type}")
+            raise ValueError(f"Unsupported texture type {type}")
+
+    return TextureMarshall(layout, resource_shape, element_type, format, usage)
+
+
+def slang_type_to_texture_format(st: SlangType) -> Optional[Format]:
+    if isinstance(st, VectorType) or isinstance(st, ArrayType):
+        assert st.element_type
+
+        num_channels = st.shape[0]
+        channel_type = st.element_type
+    else:
+        num_channels = 1
+        channel_type = st
 
-    return TextureMarshall(layout, resource_shape, element_type, usage)
+    if not isinstance(channel_type, ScalarType):
+        return None
+    if num_channels == 0 or num_channels > 4:
+        return None
+
+    scalar = channel_type.slang_scalar_type
+    if scalar not in SCALARTYPE_TO_TEXTURE_FORMAT:
+        return None
+
+    return SCALARTYPE_TO_TEXTURE_FORMAT[scalar][num_channels - 1]
 
 
 def _get_or_create_python_type(layout: SlangProgramLayout, value: Any):
-    assert isinstance(value, Texture)
-    usage = value.desc.usage
-    return get_or_create_python_texture_type(layout, value, usage)
+    if isinstance(value, Texture):
+        desc = value.desc
+        return get_or_create_python_texture_type(layout,
+                                                 desc.format,
+                                                 desc.type,
+                                                 desc.usage,
+                                                 value.array_size,
+                                                 desc.sample_count)
+    elif isinstance(value, ReturnContext):
+        format = slang_type_to_texture_format(value.slang_type)
+        if format is None:
+            raise ValueError(f"Can't create output texture: Slang type "
+                             f"\"{value.slang_type.full_name}\" can't be used as a texel type")
+
+        dim = value.bind_context.call_dimensionality
+        if dim == 1:
+            tex_type = ResourceType.texture_1d
+        elif dim == 2:
+            tex_type = ResourceType.texture_2d
+        elif dim == 3:
+            tex_type = ResourceType.texture_3d
+        else:
+            raise ValueError(
+                "Can't create output texture: Call dimensionality has to be 1D, 2D or 3D")
+
+        usage = ResourceUsage.unordered_access | ResourceUsage.shader_resource
+
+        return get_or_create_python_texture_type(layout, format, tex_type, usage, 1, 1)
+    else:
+        raise ValueError(f"Type {type(value)} is unsupported for TextureMarshall")
 
 
 PYTHON_TYPES[Texture] = _get_or_create_python_type

slangpy/slang/callidarg.slang

@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 implementing slangpy;
 
-public struct CallIdArg<let N : int> {
-    public typealias T = vector<uint, N>;
-    public void load(ContextND<N> context, out T value) {
+public struct CallIdArg {
+
+    public void load<let N : int>(ContextND<N> context, out vector<uint,N> value) {
         var t = context.call_id;
         for (int i = 0; i < N; i++) {
             value[i] = t[i];
         }
     }
-    public void load(ContextND<1> context, out uint value) {
-        value = context.call_id[0];
-    }
+
 }

slangpy/slang/core.slang

@@ -372,12 +372,17 @@ namespace impl
 
     // A python int can be passed to any slang integer scalar type
     extension<T : __BuiltinIntegerType> T : IConvertibleFrom<int> {}
+
     // A python float can be passed to any slang float scalar type
     extension<T : __BuiltinFloatingPointType> T : IConvertibleFrom<float> {}
+
     // A python array can be passed to any slang array of the same length, as
     // long as their element types can be safely passed
     extension<S, T : IConvertibleFrom<S>, let N : int, ArrT : ISizedArray<T, N>> ArrT : IConvertibleFrom<Array<S, N>> {}
 
+    // A vector is convertible to another vector of the same length who's element types are convertible
+    extension<S, T : IConvertibleFrom<S>, let N : int> vector<T,N> : IConvertibleFrom<vector<S, N>> {}
+
     // This function allows us to check if type A is convertible to type B.
     // We attempt to specialize allowedConversionWitness with types [A, B]
     // If it succeeds, the interface requirements are satisfied.