draft of backport to uint32_t2

Author: devsh

include/nbl/builtin/hlsl/bda/__ptr.hlsl

@@ -1,7 +1,6 @@
 // Copyright (C) 2018-2024 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
-
 #include "nbl/builtin/hlsl/type_traits.hlsl"
 #include "nbl/builtin/hlsl/bda/__ref.hlsl"
 
@@ -17,32 +16,63 @@ namespace bda
 template<typename T>
 struct __ptr
 {
-    using this_t = __ptr <T>;
-    uint64_t addr;
+    using this_t = __ptr<T>;
+    uint32_t2 addr;
 
-    static this_t create(const uint64_t _addr)
+    static this_t create(const uint32_t2 _addr)
     {
         this_t retval;
         retval.addr = _addr;
         return retval;
     }
 
+    // in non-64bit mode we only support "small" arithmetic on pointers (just offsets no arithmetic on pointers)
+#if 0 // TODO: @Przemog1
+    __ptr operator+(uint32_t i)
+    {
+        i *= sizeof(T);
+        uint32_t2 newAddr = addr;
+        uint32_t2 diff = spirv::OpIAddCarry(addr[0],i);
+        newAddr[0] = diff[0];
+        newAddr[1] += diff[1];
+        return __ptr::create(newAddr);
+    }
+    __ptr operator-(uint32_t i)
+    {
+        i *= sizeof(T);
+        uint32_t2 newAddr = addr;
+        uint32_t2 diff = spirv::OpISubBorrow(addr[0],i);
+        newAddr[0] = diff[0];
+        newAddr[1] -= diff[1];
+        return __ptr::create(newAddr);
+    }
+#endif
+
     template< uint64_t alignment=alignment_of_v<T> >
     __ref<T,alignment,false> deref()
     {
         // TODO: assert(addr&uint64_t(alignment-1)==0);
-        using retval_t = __ref < T, alignment, false>;
-        retval_t retval;
-        retval.__init(addr);
+        __ref<T,alignment,false> retval;
+        retval.__init(spirv::bitcast<__spv_ptr_t<T>,uint32_t2>(addr));
         return retval;
     }
 
-    __ptr operator +(int64_t i) {
-        return __ptr::create(addr + sizeof(T) * i);
+    //! Dont use these, to avoid emitting shaderUint64 capability when compiling for crappy mobile GPUs
+    static this_t create(const uint64_t _addr)
+    {
+        this_t retval;
+        retval.addr = spirv::bitcast<uint32_t2>(_addr);
+        return retval;
     }
-
-    __ptr operator-(int64_t i) {
-        return __ptr::create(addr - sizeof(T) * i);
+    __ptr operator+(int64_t i)
+    {
+        i *= sizeof(T);
+        return __ptr::create(spirv::bitcast<uint64_t>(addr) + i);
+    }
+    __ptr operator-(int64_t i)
+    {
+        i *= sizeof(T);
+        return __ptr::create(spirv::bitcast<uint64_t>(addr) - i);
     }
 };
 

include/nbl/builtin/hlsl/bda/__ref.hlsl

@@ -12,31 +12,23 @@ namespace hlsl
 {
 namespace bda
 {
-template<typename T>
-using __spv_ptr_t __NBL_CAPABILITY_PhysicalStorageBufferAddresses = spirv::pointer_t<spv::StorageClassPhysicalStorageBuffer,T>;
 
-template<typename T>
-struct __ptr;
-
-// TODO: refactor this in terms of `nbl::hlsl::` when they fix the composite struct inline SPIR-V BDA issue
 template<typename T, uint32_t alignment, bool _restrict>
-struct __base_ref
+struct __base_ref;
+template<typename T, uint32_t alignment>
+struct __base_ref<T,alignment,false>
 {
-// TODO:
-// static_assert(alignment>=alignof(T));
-
-    using spv_ptr_t = uint64_t;
-    spv_ptr_t ptr;
+    [[vk::ext_decorate(spv::DecorationAliasedPointer)]] spirv::bda_pointer_t<T> ptr;
 
-    __spv_ptr_t<T> __get_spv_ptr()
+    void __init(const spirv::bda_pointer_t<T> _ptr)
     {
-        return spirv::bitcast < __spv_ptr_t<T> > (ptr);
+        ptr = _ptr;
     }
 
-    // TODO: Would like to use `spv_ptr_t` or OpAccessChain result instead of `uint64_t`
-    void __init(const spv_ptr_t _ptr)
+    spirv::bda_pointer_t<T> __get_spv_ptr()
     {
-        ptr = _ptr;
+        // BUG: if I don't launder the pointer through this I get ""
+        return spirv::bitcast<spirv::bda_pointer_t<T> >(spirv::bitcast<uint32_t2>(ptr));
     }
 
     T load()
@@ -46,22 +38,47 @@ struct __base_ref
 
     void store(const T val)
     {
-        spirv::store<T,alignment>(__get_spv_ptr(),val);
+        spirv::store<T,alignment>(__get_spv_ptr(), val);
     }
 };
-
-template<typename T, uint32_t alignment=alignment_of_v<T>, bool _restrict = false>
-struct __ref : __base_ref<T,alignment,_restrict>
+template<typename T, uint32_t alignment>
+struct __base_ref<T,alignment,true>
 {
-    using base_t = __base_ref < T, alignment, _restrict>;
-    using this_t = __ref < T, alignment, _restrict>;
+    [[vk::ext_decorate(spv::DecorationRestrictPointer)]] spirv::bda_pointer_t<T> ptr;
 
-    __spv_ptr_t<T> get_ptr()
+    void __init(const spirv::bda_pointer_t<T> _ptr)
     {
-        return base_t::__get_spv_ptr();
+        ptr = _ptr;
+    }
+
+    spirv::bda_pointer_t<T> __get_spv_ptr()
+    {
+        // BUG: if I don't launder the pointer through this I get ""
+        return spirv::bitcast<spirv::bda_pointer_t<T> >(spirv::bitcast<uint32_t2>(ptr));
+    }
+
+    T load()
+    {
+        return spirv::load<T,alignment>(__get_spv_ptr() );
+    }
+
+    void store(const T val)
+    {
+        spirv::store<T,alignment>(__get_spv_ptr(), val);
     }
 };
+
+// TODO: I wish HLSL had some things like C++ which would allow you to make a "stack only"/non-storable type
+template<typename T, uint32_t alignment=alignment_of_v<T>, bool _restrict=false>
+struct __ref : __base_ref<T,alignment,_restrict>
+{
+    using base_t = __base_ref< T,alignment,_restrict>;
+    using this_t = __ref<T,alignment,_restrict>;
+};
 }
 }
 }
+
+// time for some macros!
+// Sequence of (variableName,Type)
 #endif

include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl

@@ -29,6 +29,7 @@ namespace hlsl
 // TODO: some poor soul needs to study rest of https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_capability
 #define __NBL_CAPABILITY_ShaderLayer [[vk::ext_capability(spv::CapabilityShaderLayer)]]
 #define __NBL_CAPABILITY_ShaderViewportIndex [[vk::ext_capability(spv::CapabilityShaderViewportIndex)]]
+// there's a whole lot more of them
 
 #else
 
@@ -44,6 +45,10 @@ namespace hlsl
 #define __NBL_SPIRV_SUPERSET_1_6__
 
 // 1.6 core caps
+// UniformDecoration
+// Demote to helper invocation
+// Some integer dot product stuff
+// 
 
 #else
 
@@ -87,12 +92,25 @@ template<uint32_t StorageClass, typename T>
 using pointer_t = vk::SpirvOpaqueType<spv::OpTypePointer,vk::Literal<vk::integral_constant<uint32_t,StorageClass> >,T>;
 
 //! General Operations
+ 
+//
+template<typename M, uint32_t StorageClass, typename T>
+[[vk::ext_instruction(spv::OpAccessChain)]]
+pointer_t<StorageClass,M> accessChain(pointer_t<StorageClass,T> v, int32_t index);
 
 // The holy operation that makes addrof possible
 template<uint32_t StorageClass, typename T>
 [[vk::ext_instruction(spv::OpCopyObject)]]
 pointer_t<StorageClass,T> copyObject([[vk::ext_reference]] T v);
 
+// unfortunately without reflection we can't validate that objects "logically match" in a concept
+template<typename T, typename U>
+[[vk::ext_instruction(spv::OpCopyLogical)]]
+enable_if_t<!is_same_v<T,U>,T> copyLogical([[vk::ext_reference]] U v);
+template<typename T, typename Ptr_U>
+[[vk::ext_instruction(spv::OpCopyLogical)]]
+enable_if_t<is_spirv_type_v<Ptr_U>/* && !is_same_v<T,U>*/,T> copyLogical(Ptr_U v);
+
 // Here's the thing with atomics, it's not only the data type that dictates whether you can do an atomic or not.
 // It's the storage class that has the most effect (shared vs storage vs image) and we can't check that easily
 template<typename T> // integers operate on 2s complement so same op for signed and unsigned
@@ -204,10 +222,14 @@ template<typename T, typename Ptr_T> // DXC Workaround
 enable_if_t<is_spirv_type_v<Ptr_T>, T> atomicCompareExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator);
 
 
+
+template<typename T>
+using bda_pointer_t __NBL_CAPABILITY_PhysicalStorageBufferAddresses = vk::SpirvType<spv::OpTypePointer,sizeof(uint64_t),/*alignof(uint64_t)*/8,vk::Literal<vk::integral_constant<uint32_t,spv::StorageClassPhysicalStorageBuffer> >,T>;
+
 template<typename T, uint32_t alignment>
 __NBL_CAPABILITY_PhysicalStorageBufferAddresses
 [[vk::ext_instruction(spv::OpLoad)]]
-T load(pointer_t<spv::StorageClassPhysicalStorageBuffer,T> pointer, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);
+T load(bda_pointer_t<T> pointer, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);
 
 template<typename T, typename P>
 [[vk::ext_instruction(spv::OpLoad)]]
@@ -216,7 +238,7 @@ enable_if_t<is_spirv_type_v<P>,T> load(P pointer);
 template<typename T, uint32_t alignment>
 __NBL_CAPABILITY_PhysicalStorageBufferAddresses
 [[vk::ext_instruction(spv::OpStore)]]
-void store(pointer_t<spv::StorageClassPhysicalStorageBuffer,T>  pointer, T obj, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);
+void store(bda_pointer_t<T> pointer, T obj, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment);
 
 template<typename T, typename P>
 [[vk::ext_instruction(spv::OpStore)]]
@@ -234,20 +256,22 @@ void controlBarrier(uint32_t executionScope, uint32_t memoryScope, uint32_t memo
 void memoryBarrier(uint32_t memoryScope, uint32_t memorySemantics);
 
 // Add specializations if you need to emit a `ext_capability` (this means that the instruction needs to forward through an `impl::` struct and so on)
+// TODO: better constraints, one should only be able to cast fundamental types, etc. https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpBitcast
+#if 0
 template<typename T, typename U>
 [[vk::ext_instruction(spv::OpBitcast)]]
 enable_if_t<is_spirv_type_v<T> && is_spirv_type_v<U>, T> bitcast(U);
 
-template<typename T>
+template<typename U, typename T>
 __NBL_CAPABILITY_PhysicalStorageBufferAddresses
 [[vk::ext_instruction(spv::OpBitcast)]]
-uint64_t bitcast(pointer_t<spv::StorageClassPhysicalStorageBuffer,T>);
+enable_if_t<is_same_v<U,uint64_t2>||is_same_v<U,uint32_t2>,U> bitcast(bda_pointer_t<T>);
 
-template<typename T>
+template<typename T, typename U>
 __NBL_CAPABILITY_PhysicalStorageBufferAddresses
 [[vk::ext_instruction(spv::OpBitcast)]]
-pointer_t<spv::StorageClassPhysicalStorageBuffer,T> bitcast(uint64_t);
-
+enable_if_t<is_same_v<U,uint64_t2>||is_same_v<U,uint32_t2>,bda_pointer_t<T> > bitcast(U);
+#endif
 template<class T, class U>
 [[vk::ext_instruction(spv::OpBitcast)]]
 T bitcast(U);

include/nbl/builtin/hlsl/type_traits.hlsl

@@ -294,6 +294,7 @@ struct is_signed : bool_constant<
 
 }
 
+// TODO: struct & trait is named wrong
 template<class T>
 struct is_spirv_type : false_type {};
 template<class T, class Storage>