Add gfx interface definition in Slang. (shader-slang#2364)

* Add gfx interface definition in Slang.

- add gfx interface definitons in Slang.
- fix slang compiler to correctly type-check `out` interface argument.
- modify gfx interface to be fully COM compatible
- add convenient ShaderProgram creation methods to gfx.

* Fix compile errors and warnings.

* Update project files

* Fix cuda.

* Properly implement queryInterface in command encoder impls.

Co-authored-by: Yong He <yhe@nvidia.com>

Author: csyonghe

build/visual-studio/gfx/gfx.vcxproj

@@ -538,6 +538,10 @@
     <ClCompile Include="..\..\..\tools\gfx\vulkan\vk-transient-heap.cpp" />
     <ClCompile Include="..\..\..\tools\gfx\vulkan\vk-util.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\tools\gfx\gfx.slang" />
+    <None Include="..\..\..\tools\gfx\slang.slang" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\core\core.vcxproj">
       <Project>{F9BE7957-8399-899E-0C49-E714FDDD4B65}</Project>

build/visual-studio/gfx/gfx.vcxproj.filters

@@ -720,4 +720,12 @@
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\tools\gfx\gfx.slang">
+      <Filter>Source Files</Filter>
+    </None>
+    <None Include="..\..\..\tools\gfx\slang.slang">
+      <Filter>Source Files</Filter>
+    </None>
+  </ItemGroup>
 </Project>

examples/ray-tracing/main.cpp

@@ -404,13 +404,13 @@ Slang::Result initialize()
         IBufferResource::Desc asBufferDesc;
         asBufferDesc.type = IResource::Type::Buffer;
         asBufferDesc.defaultState = ResourceState::AccelerationStructure;
-        asBufferDesc.sizeInBytes = compactedSize;
+        asBufferDesc.sizeInBytes = (Size)compactedSize;
         gBLASBuffer = gDevice->createBufferResource(asBufferDesc);
         IAccelerationStructure::CreateDesc createDesc;
         createDesc.buffer = gBLASBuffer;
         createDesc.kind = IAccelerationStructure::Kind::BottomLevel;
         createDesc.offset = 0;
-        createDesc.size = compactedSize;
+        createDesc.size = (Size)compactedSize;
         gDevice->createAccelerationStructure(createDesc, gBLAS.writeRef());
 
         commandBuffer = gTransientHeaps[0]->createCommandBuffer();

prelude/slang-cpp-host-prelude.h

@@ -5,6 +5,8 @@
 #include <cmath>
 #include <cstring>
 
+#define SLANG_COM_PTR_ENABLE_REF_OPERATOR 1
+
 #include "../source/slang-rt/slang-rt.h"
 #include "../slang-com-ptr.h"
 #include "slang-cpp-types.h"

slang-com-ptr.h

@@ -111,7 +111,9 @@ class ComPtr
 protected:
 	/// Gets the address of the dumb pointer.
     // Disabled: use writeRef and readRef to get a reference based on usage.
+#ifndef SLANG_COM_PTR_ENABLE_REF_OPERATOR
 	SLANG_FORCE_INLINE T** operator&() = delete;
+#endif
 
 	T* m_ptr;
 };

slang-gfx.h

@@ -130,6 +130,14 @@ const GfxCount kMaxRenderTargetCount = 8;
 
 class ITransientResourceHeap;
 
+enum class ShaderModuleSourceType
+{
+    SlangSource, // a slang source string in memory.
+    SlangModuleBinary, // a slang module binary code in memory.
+    SlangSourceFile, // a slang source from file.
+    SlangModuleBinaryFile, // a slang module binary code from file.
+};
+
 class IShaderProgram: public ISlangUnknown
 {
 public:
@@ -162,6 +170,22 @@ class IShaderProgram: public ISlangUnknown
         // Each element must define only 1 Slang EntryPoint.
         slang::IComponentType** slangEntryPoints = nullptr;
     };
+
+    struct CreateDesc2
+    {
+        ShaderModuleSourceType sourceType;
+        void* sourceData;
+        Size sourceDataSize;
+
+        // Number of entry points to include in the shader program. 0 means include all entry points
+        // defined in the module.
+        GfxCount entryPointCount = 0;
+        // Names of entry points to include in the shader program. The size of the array must be
+        // `entryPointCount`.
+        const char** entryPointNames = nullptr;
+    };
+
+    virtual SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL findTypeByName(const char* name) = 0;
 };
 #define SLANG_UUID_IShaderProgram                                                       \
     {                                                                                  \
@@ -1516,8 +1540,9 @@ class IQueryPool : public ISlangUnknown
     { 0xc2cc3784, 0x12da, 0x480a, { 0xa8, 0x74, 0x8b, 0x31, 0x96, 0x1c, 0xa4, 0x36 } }
 
 
-class ICommandEncoder
+class ICommandEncoder : public ISlangUnknown
 {
+    SLANG_COM_INTERFACE( 0x77ea6383, 0xbe3d, 0x40aa, { 0x8b, 0x45, 0xfd, 0xf0, 0xd7, 0x5b, 0xfa, 0x34 });
 public:
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() = 0;
     virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* queryPool, GfxIndex queryIndex) = 0;
@@ -1566,6 +1591,9 @@ struct ClearResourceViewFlags
 
 class IResourceCommandEncoder : public ICommandEncoder
 {
+    // {F99A00E9-ED50-4088-8A0E-3B26755031EA}
+    SLANG_COM_INTERFACE(0xf99a00e9, 0xed50, 0x4088, { 0x8a, 0xe, 0x3b, 0x26, 0x75, 0x50, 0x31, 0xea });
+
 public:
     virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
         IBufferResource* dst,
@@ -1646,6 +1674,8 @@ class IResourceCommandEncoder : public ICommandEncoder
 
 class IRenderCommandEncoder : public IResourceCommandEncoder
 {
+    // {7A8D56D0-53E6-4AD6-85F7-D14DC110FDCE}
+    SLANG_COM_INTERFACE(0x7a8d56d0, 0x53e6, 0x4ad6, { 0x85, 0xf7, 0xd1, 0x4d, 0xc1, 0x10, 0xfd, 0xce })
 public:
     // Sets the current pipeline state. This method returns a transient shader object for
     // writing shader parameters. This shader object will not retain any resources or
@@ -1728,6 +1758,9 @@ class IRenderCommandEncoder : public IResourceCommandEncoder
 
 class IComputeCommandEncoder : public IResourceCommandEncoder
 {
+    // {88AA9322-82F7-4FE6-A68A-29C7FE798737}
+    SLANG_COM_INTERFACE(0x88aa9322, 0x82f7, 0x4fe6, { 0xa6, 0x8a, 0x29, 0xc7, 0xfe, 0x79, 0x87, 0x37 })
+
 public:
     // Sets the current pipeline state. This method returns a transient shader object for
     // writing shader parameters. This shader object will not retain any resources or
@@ -1765,6 +1798,7 @@ struct AccelerationStructureQueryDesc
 
 class IRayTracingCommandEncoder : public IResourceCommandEncoder
 {
+    SLANG_COM_INTERFACE(0x9a672b87, 0x5035, 0x45e3, { 0x96, 0x7c, 0x1f, 0x85, 0xcd, 0xb3, 0x63, 0x4f })
 public:
     virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
         const IAccelerationStructure::BuildDesc& desc,
@@ -1799,10 +1833,6 @@ class IRayTracingCommandEncoder : public IResourceCommandEncoder
         GfxCount height,
         GfxCount depth) = 0;
 };
-#define SLANG_UUID_IRayTracingCommandEncoder                                           \
-    {                                                                                  \
-        0x9a672b87, 0x5035, 0x45e3, { 0x96, 0x7c, 0x1f, 0x85, 0xcd, 0xb3, 0x63, 0x4f } \
-    }
 
 class ICommandBuffer : public ISlangUnknown
 {
@@ -2356,6 +2386,11 @@ class IDevice: public ISlangUnknown
         return program;
     }
 
+    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram2(
+        const IShaderProgram::CreateDesc2& createDesc,
+        IShaderProgram** outProgram,
+        ISlangBlob** outDiagnosticBlob = nullptr) = 0;
+
     virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
         const GraphicsPipelineStateDesc&    desc,
         IPipelineState**                    outState) = 0;

slang.h

@@ -4449,6 +4449,15 @@ namespace slang
         virtual SLANG_NO_THROW SlangResult SLANG_MCALL findEntryPointByName(
             char const*     name,
             IEntryPoint**   outEntryPoint) = 0;
+
+        /// Get number of entry points defined in the module. An entry point defined in a module
+        /// is by default not included in the linkage, so calls to `IComponentType::getEntryPointCount`
+        /// on an `IModule` instance will always return 0. However `IModule::getDefinedEntryPointCount`
+        /// will return the number of defined entry points.
+        virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDefinedEntryPointCount() = 0;
+        /// Get the name of an entry point defined in the module.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+            getDefinedEntryPoint(SlangInt32 index, IEntryPoint** outEntryPoint) = 0;
     };
 
     #define SLANG_UUID_IModule IModule::getTypeGuid()

source/slang/core.meta.slang

@@ -428,20 +428,29 @@ extension bool
     __implicit_conversion($(kConversionCost_PtrToBool))
     __intrinsic_op($(kIROp_CastPtrToBool))
     __init(Ptr<T> ptr);
+
+    static bool maxValue = true;
+    static bool minValue = false;
 }
 
 extension uint64_t
 {
     __generic<T>
     __intrinsic_op($(kIROp_Construct))
     __init(Ptr<T> ptr);
+
+    static uint64_t maxValue = 0xFFFFFFFFFFFFFFFFULL;
+    static uint64_t minValue = 0;
 }
 
 extension int64_t
 {
     __generic<T>
     __intrinsic_op($(kIROp_Construct))
     __init(Ptr<T> ptr);
+
+    static int64_t maxValue =  0x7FFFFFFFFFFFFFFFLL;
+    static int64_t minValue = -0x8000000000000000LL;
 }
 
 __generic<T>
@@ -509,6 +518,28 @@ bool operator!=(__none_t noneVal, Optional<T> val)
     return val.hasValue;
 }
 
+__generic<T>
+__magic_type(NativeRefType)
+__intrinsic_type($(kIROp_NativePtrType))
+struct NativeRef
+{
+    __intrinsic_op($(kIROp_GetNativePtr))
+    __init(T val);
+};
+
+__generic<T>
+__intrinsic_op($(kIROp_ManagedPtrAttach))
+void __managed_ptr_attach(__ref T val, NativeRef<T> nativeVal);
+
+__generic<T>
+[__unsafeForceInlineEarly]
+T __attachToNativeRef(NativeRef<T> nativeVal)
+{
+    T result;
+    __managed_ptr_attach(result, nativeVal);
+    return result;
+}
+
 __magic_type(StringType)
 __intrinsic_type($(kIROp_StringType))
 struct String
@@ -524,6 +555,52 @@ __intrinsic_type($(kIROp_DynamicType))
 struct __Dynamic
 {};
 
+extension float
+{
+    static float maxValue = 340282346638528859811704183484516925440.0f;
+}
+
+extension double
+{
+    static double maxValue = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
+}
+
+extension int
+{
+    static int maxValue = 2147483647;
+    static int minValue = -2147483648;
+}
+
+extension uint
+{
+    static uint maxValue = 4294967295;
+    static uint minValue = 0;
+}
+
+extension int8_t
+{
+    static int8_t maxValue = 127;
+    static int8_t minValue = -128;
+}
+
+extension uint16_t
+{
+    static uint16_t maxValue = 255;
+    static uint16_t minValue = 0;
+}
+
+extension int16_t
+{
+    static int16_t maxValue = 32767;
+    static int16_t minValue = -32768;
+}
+
+extension uint16_t
+{
+    static uint16_t maxValue = 65535;
+    static uint16_t minValue = 0;
+}
+
     /// An `N` component vector with elements of type `T`.
 __generic<T = float, let N : int = 4>
 __magic_type(Vector)

source/slang/slang-ast-type.h

@@ -583,6 +583,13 @@ class OptionalType : public BuiltinType
     Type* getValueType();
 };
 
+// A raw-pointer reference to an managed value.
+class NativeRefType : public BuiltinType
+{
+    SLANG_AST_CLASS(NativeRefType)
+    Type* getValueType();
+};
+
 // A type alias of some kind (e.g., via `typedef`)
 class NamedExpressionType : public Type 
 {

source/slang/slang-check-decl.cpp

@@ -3063,10 +3063,37 @@ namespace Slang
         InheritanceDecl*            inheritanceDecl,
         ContainerDecl*              parentDecl)
     {
+        auto superType = inheritanceDecl->base.type;
+
         if( auto declRefType = as<DeclRefType>(subType) )
         {
             auto declRef = declRefType->declRef;
 
+            if (auto superDeclRefType = as<DeclRefType>(superType))
+            {
+                auto superTypeDecl = superDeclRefType->declRef.getDecl();
+                if (superTypeDecl->findModifier<ComInterfaceAttribute>())
+                {
+                    // A struct cannot implement a COM Interface.
+                    if (auto classDecl = as<ClassDecl>(superTypeDecl))
+                    {
+                        // OK.
+                        SLANG_UNUSED(classDecl);
+                    }
+                    else if (auto subInterfaceDecl = as<InterfaceDecl>(superTypeDecl))
+                    {
+                        if (!subInterfaceDecl->findModifier<ComInterfaceAttribute>())
+                        {
+                            getSink()->diagnose(inheritanceDecl, Diagnostics::interfaceInheritingComMustBeCom);
+                        }
+                    }
+                    else if (auto structDecl = as<StructDecl>(superTypeDecl))
+                    {
+                        getSink()->diagnose(inheritanceDecl, Diagnostics::structCannotImplementComInterface);
+                    }
+                }
+            }
+
             // Don't check conformances for abstract types that
             // are being used to express *required* conformances.
             if (auto assocTypeDeclRef = declRef.as<AssocTypeDecl>())
@@ -3089,11 +3116,12 @@ namespace Slang
                 // code to work.
                 return true;
             }
+
+            
         }
 
         // Look at the type being inherited from, and validate
         // appropriately.
-        auto superType = inheritanceDecl->base.type;
 
         DeclaredSubtypeWitness* subIsSuperWitness = m_astBuilder->create<DeclaredSubtypeWitness>();
         subIsSuperWitness->declRef = makeDeclRef(inheritanceDecl);

source/slang/slang-check-overload.cpp

@@ -1443,8 +1443,15 @@ namespace Slang
             arg = maybeOpenRef(arg);
         }
 
-        for (auto& arg : expr->arguments)
+        auto funcType = as<FuncType>(funcExprType);
+        for (Index i = 0; i < expr->arguments.getCount(); i++)
         {
+            auto& arg = expr->arguments[i];
+            if (funcType && i < (Index)funcType->getParamCount())
+            {
+                if (funcType->getParamDirection(i) == kParameterDirection_Out)
+                    continue;
+            }
             arg = maybeOpenExistential(arg);
         }