fixed visibility mask and made struct dtypes accessible from python

Author: Felix Igelbrink

optix/build.pyx

@@ -429,7 +429,7 @@ cdef class Instance(OptixObject):
         self.instance.instanceId = instance_id
         self.instance.flags = flags.value
         self.instance.sbtOffset = sbt_offset
-        visibility_mask = int(visibility_mask)
+        visibility_mask = int(visibility_mask) if visibility_mask is not None else 0
         if visibility_mask.bit_length() > self.traversable.context.num_bits_instances_visibility_mask:
             raise ValueError(f"Too many entries in visibility mask. Got {visibility_mask.bit_length()} but supported are only {self.traversable.context.num_bits_instances_visibility_mask}")
         self.instance.visibilityMask = visibility_mask
@@ -464,7 +464,7 @@ cdef class BuildInputInstanceArray(BuildInputArray):
         cdef vector[OptixInstance] c_instances
         c_instances.reserve(len(instances))
         for inst in instances:
-            c_instances.push_back(inst._instance)
+            c_instances.push_back((<Instance>inst).instance)
 
         cp.cuda.runtime.memcpy(self._d_instances.ptr, <size_t>c_instances.data(), size, cp.cuda.runtime.memcpyHostToDevice)
 
@@ -581,7 +581,7 @@ cdef class AccelerationStructure(OptixContextObject):
         if isinstance(build_inputs[0], BuildInputInstanceArray):
             if inputs_size > 1:
                 raise ValueError("Only a single build input allowed for instance builds")
-            self._instances = build_inputs[0].instances # keep the instances so the buffers do not get deleted
+            self._instances = (<BuildInputInstanceArray>build_inputs[0]).instances # keep the instances so the buffers do not get deleted
 
         cdef vector[OptixAccelBuildOptions] accel_options# = vector[OptixAccelBuildOptions](inputs_size)
         self._init_accel_options(inputs_size, self._build_flags, OPTIX_BUILD_OPERATION_BUILD, accel_options)

optix/struct.pxd

@@ -12,7 +12,7 @@ cdef extern from "optix_includes.h" nogil:
 
 
 cdef class _StructHelper(OptixObject):
-    cdef object dtype
+    cdef object _dtype
     cdef dict array_values
     cdef object _array
 

optix/struct.pyx

@@ -81,19 +81,24 @@ cdef class _StructHelper:
         formats = ensure_iterable(formats)
 
         self.array_values = {} # init dict
-        self.dtype = self._convert_to_aligned_dtype(names, formats, alignment)
+        self._dtype = self._convert_to_aligneddtype(names, formats, alignment)
         self._array = self._create(size)
 
         if values is not None:
             for name, value in names, values:
                 if value is not None:
                     self.__setitem__(name, value)
+
+    @property
+    def dtype(self):
+        return self._dtype
+
     @property
     def array(self):
         return self._array
 
     @classmethod
-    def from_dtype(cls, dtype, values=None, size=1, alignment=1):
+    def fromdtype(cls, dtype, values=None, size=1, alignment=1):
         """
         Create the struct from a numpy structured dtype.
 
@@ -153,7 +158,7 @@ cdef class _StructHelper:
                 values.append(v[1])
         return cls(names=names, formats=formats, values=values, size=size, alignment=1)
 
-    def _convert_to_aligned_dtype(self, names, formats, alignment):
+    def _convert_to_aligneddtype(self, names, formats, alignment):
         """
         Construct an aligned dtype from the names and formats
 
@@ -180,14 +185,14 @@ cdef class _StructHelper:
         return array
 
     def _create(self, size):
-        array = np.zeros(size, dtype=self.dtype)
+        array = np.zeros(size, dtype=self._dtype)
         array = self._prepare_array(array)
         return array
 
     def __setitem__(self, key, value):
         value = (value,) if not isinstance(value, (list, tuple)) else value
         # special hook for cupy arrays if a pointer is to be stored
-        if np.issubdtype(self.dtype.fields[key][0], 'u8') and all(isinstance(v, cp.ndarray) for v in value):
+        if np.issubdtype(self._dtype.fields[key][0], 'u8') and all(isinstance(v, cp.ndarray) for v in value):
             self.array_values[key] = value
             value = [v.data.ptr for v in value]
         self.array[key] = value
@@ -196,13 +201,13 @@ cdef class _StructHelper:
         return self.array[key]
 
     def __len__(self):
-        return len(self.dtype.fields)
+        return len(self._dtype.fields)
 
     def __iter__(self):
         yield from self.keys()
 
     def __contains__(self, item):
-        return item in self.dtype.fields
+        return item in self._dtype.fields
 
     def get(self, item, value=None):
         try:
@@ -211,7 +216,7 @@ cdef class _StructHelper:
             return value
 
     def keys(self):
-        yield from self.dtype.fields
+        yield from self._dtype.fields
 
     def values(self):
         for k in self.keys():
@@ -236,19 +241,19 @@ cdef class _StructHelper:
         """
         size = self.array.shape[0]
         mem = array_to_device_memory(self.array, stream=stream)
-        array = cp.ndarray(size, dtype=self.dtype, memptr=mem)
+        array = cp.ndarray(size, dtype=self._dtype, memptr=mem)
         return array
 
     @property
     def itemsize(self):
-        return self.dtype.itemsize
+        return self._dtype.itemsize
 
     @property
     def size(self):
         return self._array.shape[0]
 
     def _repr_details(self):
-        return f"size {self.size}, dtype {self.dtype}"
+        return f"size {self.size}, dtype {self._dtype}"
 
 
 cdef class SbtRecord(_StructHelper):