Merge branch 'master' into sparse-textures-spirv-sample

Author: csyonghe

.github/workflows/ci.yml

@@ -85,7 +85,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: "recursive"
-          fetch-depth: "0"
+          fetch-depth: "2"
       - id: filter
         run: |
           # This step prevents subsequent steps from running if only documentation was changed

cmake/CompilerFlags.cmake

@@ -205,6 +205,7 @@ function(set_default_compile_options target)
             $<$<BOOL:${SLANG_ENABLE_FULL_DEBUG_VALIDATION}>:SLANG_ENABLE_FULL_IR_VALIDATION>
             $<$<BOOL:${SLANG_ENABLE_IR_BREAK_ALLOC}>:SLANG_ENABLE_IR_BREAK_ALLOC>
             $<$<BOOL:${SLANG_ENABLE_DX_ON_VK}>:SLANG_CONFIG_DX_ON_VK>
+            $<$<STREQUAL:${SLANG_LIB_TYPE},STATIC>:STB_IMAGE_STATIC>
     )
 
     if(SLANG_ENABLE_ASAN)

docs/building.md

@@ -321,6 +321,21 @@ cmake -B build -G Ninja
 cmake --build build -j
 ```
 
+## Static linking against libslang
+
+If linking against a static `libslang.a` you will need to link against some
+dependencies also if you're not already incorporating them into your project.
+
+You will need to link against:
+
+```
+${SLANG_DIR}/build/Release/lib/libslang.a
+${SLANG_DIR}/build/Release/lib/libcompiler-core.a
+${SLANG_DIR}/build/Release/lib/libcore.a
+${SLANG_DIR}/build/external/miniz/libminiz.a
+${SLANG_DIR}/build/external/lz4/build/cmake/liblz4.a
+```
+
 ## Notes
 
 [^1] below 3.25, CMake lacks the ability to mark directories as being

docs/design/stdlib-intrinsics.md

@@ -114,12 +114,6 @@ Sections of the `expansion` string that are to be replaced are prefixed by the `
 * $XH - Ray tracing hit object attribute
 * $P - Type-based prefix as used for CUDA and C++ targets (I8 for int8_t, F32 - float etc)
 
-## __specialized_for_target(target)
-
-Specialized for target allows defining an implementation *body* for a particular target. The target is the same as is used for [__target_intrinsic](#target-intrinsic). 
-
-A declaration can consist of multiple definitions with bodies (for each target) using, `specialized_for_target`, as well as having `target_intrinsic` if that is applicable for a target.
-
 ## __attributeTarget(astClassName)
 
 For an attribute, specifies the AST class (and derived class) the attribute can be applied to.

examples/reflection-api/compute-simple.slang

@@ -1,5 +1,8 @@
 // compute-simple.slang
 
+static const uint THREADGROUP_SIZE_X = 8;
+static const uint THREADGROUP_SIZE_Y = THREADGROUP_SIZE_X;
+
 struct ImageProcessingOptions
 {
     float3 tintColor;
@@ -10,7 +13,7 @@ struct ImageProcessingOptions
 }
 
 [shader("compute")]
-[numthreads(8, 8)]
+[numthreads(THREADGROUP_SIZE_X, THREADGROUP_SIZE_Y)]
 void processImage(
     uint3 threadID : SV_DispatchThreadID,
     uniform Texture2D inputImage,

examples/reflection-api/main.cpp

@@ -114,6 +114,21 @@ struct ReflectingPrinting
 
         List<ComPtr<slang::IComponentType>> componentsToLink;
 
+        // ### Variable decls
+        //
+        key("global constants");
+        WITH_ARRAY()
+        for (auto decl : module->getModuleReflection()->getChildren())
+        {
+            if (auto varDecl = decl->asVariable(); varDecl &&
+                                                   varDecl->findModifier(slang::Modifier::Const) &&
+                                                   varDecl->findModifier(slang::Modifier::Static))
+            {
+                element();
+                printVariable(varDecl);
+            }
+        }
+
         // ### Finding Entry Points
         //
 
@@ -213,6 +228,13 @@ struct ReflectingPrinting
         printQuotedString(name);
         key("type");
         printType(type);
+
+        int64_t value;
+        if (SLANG_SUCCEEDED(variable->getDefaultValueInt(&value)))
+        {
+            key("value");
+            printf("%" PRId64, value);
+        }
     }
 
     // ### Types

external/CMakeLists.txt

@@ -89,11 +89,19 @@ endif()
 
 # imgui
 add_library(imgui INTERFACE)
-target_include_directories(imgui INTERFACE "${CMAKE_CURRENT_LIST_DIR}/imgui")
+target_include_directories(
+    imgui
+    ${system}
+    INTERFACE "${CMAKE_CURRENT_LIST_DIR}/imgui"
+)
 
 # stb
 add_library(stb INTERFACE)
-target_include_directories(stb INTERFACE "${CMAKE_CURRENT_LIST_DIR}/stb")
+target_include_directories(
+    stb
+    ${system}
+    INTERFACE "${CMAKE_CURRENT_LIST_DIR}/stb"
+)
 
 # slang-rhi
 if(SLANG_ENABLE_SLANG_RHI)

include/slang-deprecated.h

@@ -659,6 +659,8 @@ extern "C"
         SlangSession* globalSession,
         char const* name);
     SLANG_API bool spReflectionVariable_HasDefaultValue(SlangReflectionVariable* inVar);
+    SLANG_API SlangResult
+    spReflectionVariable_GetDefaultValueInt(SlangReflectionVariable* inVar, int64_t* rs);
     SLANG_API SlangReflectionGeneric* spReflectionVariable_GetGenericContainer(
         SlangReflectionVariable* var);
     SLANG_API SlangReflectionVariable* spReflectionVariable_applySpecializations(

include/slang.h

@@ -2832,6 +2832,11 @@ struct VariableReflection
         return spReflectionVariable_HasDefaultValue((SlangReflectionVariable*)this);
     }
 
+    SlangResult getDefaultValueInt(int64_t* value)
+    {
+        return spReflectionVariable_GetDefaultValueInt((SlangReflectionVariable*)this, value);
+    }
+
     GenericReflection* getGenericContainer()
     {
         return (GenericReflection*)spReflectionVariable_GetGenericContainer(

source/core/slang-string.h

@@ -790,6 +790,57 @@ class SLANG_RT_API String
     UnownedStringSlice getUnownedSlice() const { return StringRepresentation::asSlice(m_buffer); }
 };
 
+class ImmutableHashedString
+{
+public:
+    String slice;
+    HashCode64 hashCode;
+    ImmutableHashedString()
+        : hashCode(0)
+    {
+    }
+    ImmutableHashedString(const UnownedStringSlice& slice)
+        : slice(slice), hashCode(slice.getHashCode())
+    {
+    }
+    ImmutableHashedString(const char* begin, const char* end)
+        : slice(begin, end), hashCode(slice.getHashCode())
+    {
+    }
+    ImmutableHashedString(const char* begin, size_t len)
+        : slice(UnownedStringSlice(begin, len)), hashCode(slice.getHashCode())
+    {
+    }
+    ImmutableHashedString(const char* begin)
+        : slice(begin), hashCode(slice.getHashCode())
+    {
+    }
+    ImmutableHashedString(const String& str)
+        : slice(str), hashCode(str.getHashCode())
+    {
+    }
+    ImmutableHashedString(String&& str)
+        : slice(_Move(str)), hashCode(str.getHashCode())
+    {
+    }
+    ImmutableHashedString(const ImmutableHashedString& other) = default;
+    ImmutableHashedString& operator=(const ImmutableHashedString& other) = default;
+    bool operator==(const ImmutableHashedString& other) const
+    {
+        return hashCode == other.hashCode && slice == other.slice;
+    }
+    bool operator!=(const ImmutableHashedString& other) const
+    {
+        return hashCode != other.hashCode || slice != other.slice;
+    }
+    bool operator==(const UnownedStringSlice& other) const { return slice == other; }
+    bool operator!=(const UnownedStringSlice& other) const { return slice != other; }
+    bool operator==(const String& other) const { return slice == other.getUnownedSlice(); }
+    bool operator!=(const String& other) const { return slice != other.getUnownedSlice(); }
+    bool operator==(const char* other) const { return slice == UnownedStringSlice(other); }
+    HashCode64 getHashCode() const { return hashCode; }
+};
+
 class SLANG_RT_API StringBuilder : public String
 {
 private:

source/slang-glslang/slang-glslang.cpp

@@ -175,6 +175,7 @@ extern "C"
 
     spvtools::ValidatorOptions options;
     options.SetScalarBlockLayout(true);
+    options.SetFriendlyNames(true);
 
     spvtools::SpirvTools tools(target_env);
     tools.SetMessageConsumer(validationMessageConsumer);
@@ -197,6 +198,7 @@ extern "C"
     options |= SPV_BINARY_TO_TEXT_OPTION_COMMENT;
     options |= SPV_BINARY_TO_TEXT_OPTION_PRINT;
     options |= SPV_BINARY_TO_TEXT_OPTION_COLOR;
+    options |= SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES;
 
     spv_diagnostic diagnostic = nullptr;
     spv_context context = spvContextCreate(kDefaultEnvironment);

source/slang/core.meta.slang

@@ -1,4 +1,4 @@
-//public module core;
+public module core;
 
 // Slang `core` library
 
@@ -603,6 +603,7 @@ void static_assert(constexpr bool condition, NativeString errorMessage);
 ///
 /// 
 __magic_type(DifferentiableType)
+[KnownBuiltin("IDifferentiable")]
 interface IDifferentiable
 {
     // Note: the compiler implementation requires the `Differential` associated type to be defined
@@ -645,6 +646,7 @@ interface IDifferentiable
 /// @remarks Support for this interface is still experimental and subject to change.
 ///
 __magic_type(DifferentiablePtrType)
+[KnownBuiltin("IDifferentiablePtr")]
 interface IDifferentiablePtrType
 {
     __builtin_requirement($( (int)BuiltinRequirementKind::DifferentialPtrType) )
@@ -2367,49 +2369,6 @@ __generic<T> __extension vector<T, 4>
 
 ${{{{
 
-// The above extensions are generic in the *type* of the vector,
-// but explicit in the *size*. We will now declare an extension
-// for each builtin type that is generic in the size.
-//
-for (int tt = 0; tt < kBaseTypeCount; ++tt)
-{
-    if(kBaseTypes[tt].tag == BaseType::Void) continue;
-
-    sb << "__generic<let N : int> __extension vector<"
-        << kBaseTypes[tt].name << ",N>\n{\n";
-
-    for (int ff = 0; ff < kBaseTypeCount; ++ff)
-    {
-        if(kBaseTypes[ff].tag == BaseType::Void) continue;
-
-
-        if( tt != ff )
-        {
-            auto cost = getBaseTypeConversionCost(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-            auto op = getBaseTypeConversionOp(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-
-			// Implicit conversion from a vector of the same
-			// size, but different element type.
-            sb << "    __implicit_conversion(" << cost << ")\n";
-            sb << "    __intrinsic_op(" << int(op) << ")\n";
-            sb << "    __init(vector<" << kBaseTypes[ff].name << ",N> value);\n";
-
-			// Constructor to make a vector from a scalar of another type.
-            if (cost != kConversionCost_Impossible)
-            {
-                cost += kConversionCost_ScalarToVector;
-                sb << "    __implicit_conversion(" << cost << ")\n";
-                sb << "    [__unsafeForceInlineEarly]\n";
-                sb << "    __init(" << kBaseTypes[ff].name << " value) { this = vector<" << kBaseTypes[tt].name << ",N>( " << kBaseTypes[tt].name << "(value)); }\n";
-            }
-        }
-    }
-    sb << "}\n";
-}
 
 for( int R = 1; R <= 4; ++R )
 for( int C = 1; C <= 4; ++C )
@@ -2464,38 +2423,36 @@ for( int C = 1; C <= 4; ++C )
     sb << "}\n";
 }
 
-for (int tt = 0; tt < kBaseTypeCount; ++tt)
-{
-    if(kBaseTypes[tt].tag == BaseType::Void) continue;
-    auto toType = kBaseTypes[tt].name;
 }}}}
 
-__generic<let R : int, let C : int, let L : int> extension matrix<$(toType),R,C,L>
+//@hidden:
+__intrinsic_op($(kIROp_BuiltinCast))
+internal T __builtin_cast<T, U>(U u);
+
+// If T is implicitly convertible to U, then vector<T,N> is implicitly convertible to vector<U,N>.
+__generic<ToType, let N : int> extension vector<ToType,N>
 {
-${{{{
-    for (int ff = 0; ff < kBaseTypeCount; ++ff)
-    {
-        if(kBaseTypes[ff].tag == BaseType::Void) continue;
-        if( tt == ff ) continue;
+    __implicit_conversion(constraint)
+    __intrinsic_op(BuiltinCast)
+    __init<FromType>(vector<FromType,N> value) where ToType(FromType) implicit;
 
-        auto cost = getBaseTypeConversionCost(
-            kBaseTypes[tt],
-            kBaseTypes[ff]);
-        auto fromType = kBaseTypes[ff].name;
-        auto op = getBaseTypeConversionOp(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-}}}}
-    __implicit_conversion($(cost))
-    __intrinsic_op($(op))
-    __init(matrix<$(fromType),R,C,L> value);
-${{{{
+    __implicit_conversion(constraint+)
+    [__unsafeForceInlineEarly]
+    [__readNone]
+    [TreatAsDifferentiable]
+    __init<FromType>(FromType value) where ToType(FromType) implicit
+    {
+        this = __builtin_cast<vector<ToType,N>>(vector<FromType,N>(value));
     }
-}}}}
 }
-${{{{
+
+// If T is implicitly convertible to U, then matrix<T,R,C,L> is implicitly convertible to matrix<U,R,C,L>.
+__generic<ToType, let R : int, let C : int, let L : int> extension matrix<ToType,R,C,L>
+{
+    __implicit_conversion(constraint)
+    __intrinsic_op(BuiltinCast)
+    __init<FromType>(matrix<FromType,R,C,L> value) where ToType(FromType) implicit;
 }
-}}}}
 
 //@ hidden:
 __generic<T, U>
@@ -2643,20 +2600,20 @@ for(auto fixity : kIncDecFixities)
 $(fixity.qual)
 __generic<T : __BuiltinArithmeticType>
 [__unsafeForceInlineEarly]
-T operator$(op.name)(in out T value)
-{$(fixity.bodyPrefix) value = value $(op.binOp) T(1); return $(fixity.returnVal); }
+T operator$(op.name)( in out T value)
+{ $(fixity.bodyPrefix) value = value $(op.binOp) __builtin_cast<T>(1); return $(fixity.returnVal); }
 
 $(fixity.qual)
 __generic<T : __BuiltinArithmeticType, let N : int>
 [__unsafeForceInlineEarly]
 vector<T,N> operator$(op.name)(in out vector<T,N> value)
-{$(fixity.bodyPrefix) value = value $(op.binOp) T(1); return $(fixity.returnVal); }
+{$(fixity.bodyPrefix) value = value $(op.binOp) __builtin_cast<T>(1); return $(fixity.returnVal); }
 
 $(fixity.qual)
 __generic<T : __BuiltinArithmeticType, let R : int, let C : int, let L : int>
 [__unsafeForceInlineEarly]
 matrix<T,R,C> operator$(op.name)(in out matrix<T,R,C,L> value)
-{$(fixity.bodyPrefix) value = value $(op.binOp) T(1); return $(fixity.returnVal); }
+{$(fixity.bodyPrefix) value = value $(op.binOp) __builtin_cast<T>(1); return $(fixity.returnVal); }
 
 $(fixity.qual)
 __generic<T, let addrSpace : uint64_t>