diff --git a/include/nbl/builtin/hlsl/ext/FullScreenTriangle/default.vert.hlsl b/include/nbl/builtin/hlsl/ext/FullScreenTriangle/default.vert.hlsl index 8e8195ff2a..a5b39de7fd 100644 --- a/include/nbl/builtin/hlsl/ext/FullScreenTriangle/default.vert.hlsl +++ b/include/nbl/builtin/hlsl/ext/FullScreenTriangle/default.vert.hlsl @@ -26,9 +26,9 @@ SVertexAttributes main() { using namespace ::nbl::hlsl::glsl; - spirv::Position.xy = SurfaceTransform::applyToNDC((SurfaceTransform::FLAG_BITS)SwapchainTransform,pos[gl_VertexIndex()]); - spirv::Position.z = 0.f; - spirv::Position.w = 1.f; + spirv::builtin::Position.xy = SurfaceTransform::applyToNDC((SurfaceTransform::FLAG_BITS)SwapchainTransform,pos[gl_VertexIndex()]); + spirv::builtin::Position.z = 0.f; + spirv::builtin::Position.w = 1.f; SVertexAttributes retval; retval.uv = tc[gl_VertexIndex()]; diff --git a/include/nbl/builtin/hlsl/glsl_compat/core.hlsl b/include/nbl/builtin/hlsl/glsl_compat/core.hlsl index ef04616b3b..70dea9aa9d 100644 --- a/include/nbl/builtin/hlsl/glsl_compat/core.hlsl +++ b/include/nbl/builtin/hlsl/glsl_compat/core.hlsl @@ -135,21 +135,21 @@ SquareMatrix inverse(NBL_CONST_REF_ARG(SquareMatrix) mat) */ // TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `&` :( //void gl_Position() {spirv::} -uint32_t gl_VertexIndex() {return spirv::VertexIndex;} -uint32_t gl_InstanceIndex() {return spirv::InstanceIndex;} +uint32_t gl_VertexIndex() {return spirv::builtin::VertexIndex;} +uint32_t gl_InstanceIndex() {return spirv::builtin::InstanceIndex;} /** * For Compute Shaders */ // TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `const&` :( -uint32_t3 gl_NumWorkGroups() {return spirv::NumWorkGroups;} +uint32_t3 gl_NumWorkGroups() {return spirv::builtin::NumWorkgroups;} // TODO: DXC BUG prevents us from defining this! uint32_t3 gl_WorkGroupSize(); -uint32_t3 gl_WorkGroupID() {return spirv::WorkgroupId;} -uint32_t3 gl_LocalInvocationID() {return spirv::LocalInvocationId;} -uint32_t3 gl_GlobalInvocationID() {return spirv::GlobalInvocationId;} -uint32_t gl_LocalInvocationIndex() {return spirv::LocalInvocationIndex;} +uint32_t3 gl_WorkGroupID() {return spirv::builtin::WorkgroupId;} +uint32_t3 gl_LocalInvocationID() {return spirv::builtin::LocalInvocationId;} +uint32_t3 gl_GlobalInvocationID() {return spirv::builtin::GlobalInvocationId;} +uint32_t gl_LocalInvocationIndex() {return spirv::builtin::LocalInvocationIndex;} void barrier() { spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask); @@ -187,7 +187,7 @@ struct bitfieldExtract { static T __call( T val, uint32_t offsetBits, uint32_t numBits ) { - return spirv::bitFieldSExtract( val, offsetBits, numBits ); + return spirv::bitFieldSExtract( val, offsetBits, numBits ); } }; @@ -196,7 +196,7 @@ struct bitfieldExtract { static T __call( T val, uint32_t offsetBits, uint32_t numBits ) { - return spirv::bitFieldUExtract( val, offsetBits, numBits ); + return spirv::bitFieldUExtract( val, offsetBits, numBits ); } }; diff --git a/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl b/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl index bce30aa9c0..b643462fb9 100644 --- a/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl +++ b/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl @@ -4,7 +4,7 @@ #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_ #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_ -#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl" +#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" namespace nbl { @@ -17,93 +17,224 @@ namespace glsl // TODO: Furthermore you'll need `bitfieldExtract`-like struct dispatcher to choose between int/float add/mul and sint/uint/float min/max template T subgroupAdd(T value) { - return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } template T subgroupInclusiveAdd(T value) { - return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } template T subgroupExclusiveAdd(T value) { - return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); } template T subgroupMul(T value) { - return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformIMul_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } template T subgroupInclusiveMul(T value) { - return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformIMul_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } template T subgroupExclusiveMul(T value) { - return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformIMul_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); } template T subgroupAnd(T value) { - return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } template T subgroupInclusiveAnd(T value) { - return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } template T subgroupExclusiveAnd(T value) { - return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); } template T subgroupOr(T value) { - return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } template T subgroupInclusiveOr(T value) { - return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } template T subgroupExclusiveOr(T value) { - return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); } template T subgroupXor(T value) { - return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } template T subgroupInclusiveXor(T value) { - return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } template T subgroupExclusiveXor(T value) { - return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); +} + +namespace impl +{ + +template +struct subgroupMin {}; + +template +struct subgroupMin +{ + static T __call(T val) + { + return spirv::groupNonUniformSMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, val); + } +}; + +template +struct subgroupMin +{ + static T __call(T val) + { + return spirv::groupNonUniformUMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, val); + } +}; + +template +struct subgroupInclusiveMin {}; + +template +struct subgroupInclusiveMin +{ + static T __call(T val) + { + return spirv::groupNonUniformSMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val); + } +}; + +template +struct subgroupInclusiveMin +{ + static T __call(T val) + { + return spirv::groupNonUniformUMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val); + } +}; + +template +struct subgroupExclusiveMin {}; + +template +struct subgroupExclusiveMin +{ + static T __call(T val) + { + return spirv::groupNonUniformSMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val); + } +}; + +template +struct subgroupExclusiveMin +{ + static T __call(T val) + { + return spirv::groupNonUniformUMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val); + } +}; + +template +struct subgroupMax {}; + +template +struct subgroupMax +{ + static T __call(T val) + { + return spirv::groupNonUniformSMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, val); + } +}; + +template +struct subgroupMax +{ + static T __call(T val) + { + return spirv::groupNonUniformUMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, val); + } +}; + +template +struct subgroupInclusiveMax {}; + +template +struct subgroupInclusiveMax +{ + static T __call(T val) + { + return spirv::groupNonUniformSMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val); + } +}; + +template +struct subgroupInclusiveMax +{ + static T __call(T val) + { + return spirv::groupNonUniformUMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val); + } +}; + +template +struct subgroupExclusiveMax {}; + +template +struct subgroupExclusiveMax +{ + static T __call(T val) + { + return spirv::groupNonUniformSMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val); + } +}; + +template +struct subgroupExclusiveMax +{ + static T __call(T val) + { + return spirv::groupNonUniformUMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val); + } +}; + } template -T subgroupMin(T value) { - return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationReduce, value); +T subgroupMin(T val) { + return impl::subgroupMin::value>::__call(val); } template -T subgroupInclusiveMin(T value) { - return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); +T subgroupInclusiveMin(T val) { + return impl::subgroupInclusiveMin::value>::__call(val); } template -T subgroupExclusiveMin(T value) { - return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); +T subgroupExclusiveMin(T val) { + return impl::subgroupExclusiveMin::value>::__call(val); } template -T subgroupMax(T value) { - return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationReduce, value); +T subgroupMax(T val) { + return impl::subgroupMax::value>::__call(val); } template -T subgroupInclusiveMax(T value) { - return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); +T subgroupInclusiveMax(T val) { + return impl::subgroupInclusiveMax::value>::__call(val); } template -T subgroupExclusiveMax(T value) { - return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); +T subgroupExclusiveMax(T val) { + return impl::subgroupExclusiveMax::value>::__call(val); } } diff --git a/include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl b/include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl index ecd888ae2c..949d20fc77 100644 --- a/include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl +++ b/include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl @@ -4,7 +4,7 @@ #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_ #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_ -#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl" +#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" #include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl" namespace nbl @@ -15,62 +15,62 @@ namespace glsl { // TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :( -uint32_t4 gl_SubgroupEqMask() {return spirv::BuiltInSubgroupEqMask;} -uint32_t4 gl_SubgroupGeMask() {return spirv::BuiltInSubgroupGeMask;} -uint32_t4 gl_SubgroupGtMask() {return spirv::BuiltInSubgroupGtMask;} -uint32_t4 gl_SubgroupLeMask() {return spirv::BuiltInSubgroupLeMask;} -uint32_t4 gl_SubgroupLtMask() {return spirv::BuiltInSubgroupLtMask;} +uint32_t4 gl_SubgroupEqMask() {return spirv::builtin::SubgroupEqMask;} +uint32_t4 gl_SubgroupGeMask() {return spirv::builtin::SubgroupGeMask;} +uint32_t4 gl_SubgroupGtMask() {return spirv::builtin::SubgroupGtMask;} +uint32_t4 gl_SubgroupLeMask() {return spirv::builtin::SubgroupLeMask;} +uint32_t4 gl_SubgroupLtMask() {return spirv::builtin::SubgroupLtMask;} template T subgroupBroadcastFirst(T value) { - return spirv::subgroupBroadcastFirst(spv::ScopeSubgroup, value); + return spirv::groupNonUniformBroadcastFirst(spv::ScopeSubgroup, value); } template T subgroupBroadcast(T value, const uint32_t invocationId) { - return spirv::subgroupBroadcast(spv::ScopeSubgroup, value, invocationId); + return spirv::groupNonUniformBroadcast(spv::ScopeSubgroup, value, invocationId); } uint32_t4 subgroupBallot(bool value) { - return spirv::subgroupBallot(spv::ScopeSubgroup, value); + return spirv::groupNonUniformBallot(spv::ScopeSubgroup, value); } bool subgroupInverseBallot(uint32_t4 value) { - return spirv::subgroupInverseBallot(spv::ScopeSubgroup, value); + return spirv::groupNonUniformInverseBallot(spv::ScopeSubgroup, value); } bool subgroupBallotBitExtract(uint32_t4 value, uint32_t index) { - return spirv::subgroupBallotBitExtract(spv::ScopeSubgroup, value, index); + return spirv::groupNonUniformBallotBitExtract(spv::ScopeSubgroup, value, index); } uint32_t subgroupBallotBitCount(uint32_t4 value) { - return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value); + return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value); } uint32_t subgroupBallotInclusiveBitCount(uint32_t4 value) { - return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); + return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value); } uint32_t subgroupBallotExclusiveBitCount(uint32_t4 value) { - return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); + return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value); } uint32_t subgroupBallotFindLSB(uint32_t4 value) { - return spirv::subgroupBallotFindLSB(spv::ScopeSubgroup, value); + return spirv::groupNonUniformBallotFindLSB(spv::ScopeSubgroup, value); } uint32_t subgroupBallotFindMSB(uint32_t4 value) { - return spirv::subgroupBallotFindMSB(spv::ScopeSubgroup, value); + return spirv::groupNonUniformBallotFindMSB(spv::ScopeSubgroup, value); } } } diff --git a/include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl b/include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl index 2504a34480..b9f11f4109 100644 --- a/include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl +++ b/include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl @@ -5,7 +5,7 @@ #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BASIC_INCLUDED_ #include "nbl/builtin/hlsl/glsl_compat/core.hlsl" -#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl" +#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" namespace nbl { @@ -16,16 +16,16 @@ namespace glsl #ifdef __HLSL_VERSION // TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :( // NOTE: These are not `uint16_t` even though they could be, because IIUtSC they're `uint32_t` in SPIR-V -uint32_t gl_SubgroupSize() {return spirv::SubgroupSize;} -uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::SubgroupSize);} -uint32_t gl_SubgroupInvocationID() {return spirv::SubgroupLocalInvocationId;} +uint32_t gl_SubgroupSize() {return spirv::builtin::SubgroupSize;} +uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::builtin::SubgroupSize);} +uint32_t gl_SubgroupInvocationID() {return spirv::builtin::SubgroupLocalInvocationId;} // only available in compute -uint32_t gl_NumSubgroups() {return spirv::NumSubgroups;} -uint32_t gl_SubgroupID() {return spirv::SubgroupId;} +uint32_t gl_NumSubgroups() {return spirv::builtin::NumSubgroups;} +uint32_t gl_SubgroupID() {return spirv::builtin::SubgroupId;} bool subgroupElect() { - return spirv::subgroupElect(spv::ScopeSubgroup); + return spirv::groupNonUniformElect(spv::ScopeSubgroup); } void subgroupBarrier() { diff --git a/include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl b/include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl index 6246ee3292..837447d924 100644 --- a/include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl +++ b/include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl @@ -4,7 +4,7 @@ #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_ #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_ -#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl" +#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" namespace nbl { @@ -15,25 +15,25 @@ namespace glsl template T subgroupShuffle(T value, uint32_t invocationId) { - return spirv::groupShuffle(spv::ScopeSubgroup, value, invocationId); + return spirv::groupNonUniformShuffle(spv::ScopeSubgroup, value, invocationId); } template T subgroupShuffleXor(T value, uint32_t mask) { - return spirv::groupShuffleXor(spv::ScopeSubgroup, value, mask); + return spirv::groupNonUniformShuffleXor(spv::ScopeSubgroup, value, mask); } template T subgroupShuffleUp(T value, uint32_t delta) { - return spirv::groupShuffleUp(spv::ScopeSubgroup, value, delta); + return spirv::groupNonUniformShuffleUp(spv::ScopeSubgroup, value, delta); } template T subgroupShuffleDown(T value, uint32_t delta) { - return spirv::groupShuffleDown(spv::ScopeSubgroup, value, delta); + return spirv::groupNonUniformShuffleDown(spv::ScopeSubgroup, value, delta); } diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl deleted file mode 100644 index ee6df03e5d..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl +++ /dev/null @@ -1,245 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_CORE_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_CORE_INCLUDED_ - - -#ifdef __HLSL_VERSION // TODO: AnastZIuk fix public search paths so we don't choke -#include "spirv/unified1/spirv.hpp" -#include "spirv/unified1/GLSL.std.450.h" -#endif - -#include "nbl/builtin/hlsl/type_traits.hlsl" - -namespace nbl -{ -namespace hlsl -{ -#ifdef __HLSL_VERSION -namespace spirv -{ -//! General -[[vk::ext_builtin_input(spv::BuiltInHelperInvocation)]] -static const bool HelperInvocation; - -//! Vertex Inputs -[[vk::ext_builtin_input(spv::BuiltInVertexIndex)]] -static const uint32_t VertexIndex; -[[vk::ext_builtin_input(spv::BuiltInInstanceIndex)]] -static const uint32_t InstanceIndex; - -//! Vertex and friends -[[vk::ext_builtin_output(spv::BuiltInPosition)]] -static float32_t4 Position; - -//! Compute Shader Builtins -[[vk::ext_builtin_input(spv::BuiltInNumWorkgroups)]] -static const uint32_t3 NumWorkGroups; -// TODO: Doesn't work, find out why and file issue on DXC! -//[[vk::ext_builtin_input(spv::BuiltInWorkgroupSize)]] -//static const uint32_t3 WorkgroupSize; -[[vk::ext_builtin_input(spv::BuiltInWorkgroupId)]] -static const uint32_t3 WorkgroupId; -[[vk::ext_builtin_input(spv::BuiltInLocalInvocationId)]] -static const uint32_t3 LocalInvocationId; -[[vk::ext_builtin_input(spv::BuiltInGlobalInvocationId)]] -static const uint32_t3 GlobalInvocationId; -[[vk::ext_builtin_input(spv::BuiltInLocalInvocationIndex)]] -static const uint32_t LocalInvocationIndex; - -//! General Types -template -using pointer_t = vk::SpirvOpaqueType >,T>; - -//! General Operations - -// The holy operation that makes addrof possible -template -[[vk::ext_instruction(spv::OpCopyObject)]] -pointer_t copyObject([[vk::ext_reference]] T 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 // integers operate on 2s complement so same op for signed and unsigned -[[vk::ext_instruction(spv::OpAtomicIAdd)]] -enable_if_t || is_same_v, T> atomicIAdd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicIAdd)]] -enable_if_t && (is_same_v || is_same_v), T> atomicIAdd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // integers operate on 2s complement so same op for signed and unsigned -[[vk::ext_capability(spv::CapabilityInt64Atomics)]] -[[vk::ext_instruction(spv::OpAtomicIAdd)]] -enable_if_t || is_same_v, T> atomicIAdd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_capability(spv::CapabilityInt64Atomics)]] -[[vk::ext_instruction(spv::OpAtomicIAdd)]] -enable_if_t && (is_same_v || is_same_v), T> atomicIAdd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // integers operate on 2s complement so same op for signed and unsigned -[[vk::ext_instruction(spv::OpAtomicISub)]] -enable_if_t || is_same_v, T> atomicISub([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicISub)]] -enable_if_t && (is_same_v || is_same_v), T> atomicISub(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // integers operate on 2s complement so same op for signed and unsigned -[[vk::ext_capability(spv::CapabilityInt64Atomics)]] -[[vk::ext_instruction(spv::OpAtomicISub)]] -enable_if_t || is_same_v, T> atomicISub([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_capability(spv::CapabilityInt64Atomics)]] -[[vk::ext_instruction(spv::OpAtomicISub)]] -enable_if_t && (is_same_v || is_same_v), T> atomicISub(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template -[[vk::ext_instruction(spv::OpAtomicAnd)]] -enable_if_t || is_same_v, T> atomicAnd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicAnd)]] -enable_if_t && (is_same_v || is_same_v), T> atomicAnd(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template -[[vk::ext_instruction(spv::OpAtomicOr)]] -enable_if_t || is_same_v, T> atomicOr([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicOr)]] -enable_if_t && (is_same_v || is_same_v), T> atomicOr(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template -[[vk::ext_instruction(spv::OpAtomicXor)]] -enable_if_t || is_same_v, T> atomicXor([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicXor)]] -enable_if_t && (is_same_v || is_same_v), T> atomicXor(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template -[[vk::ext_instruction( spv::OpAtomicSMin )]] -enable_if_t, Signed> atomicSMin([[vk::ext_reference]] int32_t ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicSMin)]] -enable_if_t && is_same_v, Signed> atomicSMin(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value); - -template -[[vk::ext_instruction( spv::OpAtomicUMin )]] -enable_if_t, Unsigned> atomicUMin([[vk::ext_reference]] Unsigned ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicUMin)]] -enable_if_t && is_same_v, Unsigned> atomicUMin(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value); - -template -[[vk::ext_instruction( spv::OpAtomicSMax )]] -enable_if_t, Signed> atomicSMax([[vk::ext_reference]] Signed ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicSMax)]] -enable_if_t && is_same_v, Signed> atomicSMax(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Signed value); - -template -[[vk::ext_instruction( spv::OpAtomicUMax )]] -enable_if_t, Unsigned> atomicUMax([[vk::ext_reference]] uint32_t ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicUMax)]] -enable_if_t && is_same_v, Unsigned> atomicUMax(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, Unsigned value); - -template -[[vk::ext_instruction(spv::OpAtomicExchange)]] -T atomicExchange([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicExchange)]] -enable_if_t, T> atomicExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value); - -template -[[vk::ext_instruction(spv::OpAtomicCompareExchange)]] -T atomicCompareExchange([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator); - -template // DXC Workaround -[[vk::ext_instruction(spv::OpAtomicCompareExchange)]] -enable_if_t, T> atomicCompareExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator); - - -template -[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] -[[vk::ext_instruction(spv::OpLoad)]] -T load(pointer_t pointer, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment); - -template -[[vk::ext_instruction(spv::OpLoad)]] -enable_if_t,T> load(P pointer); - -template -[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] -[[vk::ext_instruction(spv::OpStore)]] -void store(pointer_t pointer, T obj, [[vk::ext_literal]] uint32_t __aligned = /*Aligned*/0x00000002, [[vk::ext_literal]] uint32_t __alignment = alignment); - -template -[[vk::ext_instruction(spv::OpStore)]] -enable_if_t,void> store(P pointer, T obj); - -//! Std 450 Extended set operations -template -[[vk::ext_instruction(GLSLstd450MatrixInverse)]] -SquareMatrix matrixInverse(NBL_CONST_REF_ARG(SquareMatrix) mat); - -// Memory Semantics link here: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#Memory_Semantics_-id- - -// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id -// By providing memory semantics None we do both control and memory barrier as is done in GLSL - -[[vk::ext_instruction( spv::OpControlBarrier )]] -void controlBarrier(uint32_t executionScope, uint32_t memoryScope, uint32_t memorySemantics); - -[[vk::ext_instruction( spv::OpMemoryBarrier )]] -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) -template -[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] -[[vk::ext_instruction(spv::OpBitcast)]] -enable_if_t && is_spirv_type_v, T> bitcast(U); - -template -[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] -[[vk::ext_instruction(spv::OpBitcast)]] -uint64_t bitcast(pointer_t); - -template -[[vk::ext_capability(spv::CapabilityPhysicalStorageBufferAddresses)]] -[[vk::ext_instruction(spv::OpBitcast)]] -pointer_t bitcast(uint64_t); - -template -[[vk::ext_instruction(spv::OpBitcast)]] -T bitcast(U); - -template -[[vk::ext_instruction( spv::OpBitFieldUExtract )]] -enable_if_t, Unsigned> bitFieldUExtract( Unsigned val, uint32_t offsetBits, uint32_t numBits ); - -template -[[vk::ext_instruction( spv::OpBitFieldSExtract )]] -enable_if_t, Signed> bitFieldSExtract( Signed val, uint32_t offsetBits, uint32_t numBits ); - -template -[[vk::ext_instruction( spv::OpBitFieldInsert )]] -Integral bitFieldInsert( Integral base, Integral insert, uint32_t offset, uint32_t count ); - -} - -#endif - } -} - -#endif \ No newline at end of file diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/fragment_shader_pixel_interlock.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/fragment_shader_pixel_interlock.hlsl deleted file mode 100644 index 6362e025be..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/fragment_shader_pixel_interlock.hlsl +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_FRAGMENT_SHADER_PIXEL_INTERLOCK_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_FRAGMENT_SHADER_PIXEL_INTERLOCK_INCLUDED_ - -#include "spirv/unified1/spirv.hpp" - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ - -namespace execution_mode -{ - void PixelInterlockOrderedEXT() - { - vk::ext_execution_mode(spv::ExecutionModePixelInterlockOrderedEXT); - } -} - -[[vk::ext_capability(spv::CapabilityFragmentShaderPixelInterlockEXT)]] -[[vk::ext_extension("SPV_EXT_fragment_shader_interlock")]] -[[vk::ext_instruction(spv::OpBeginInvocationInterlockEXT)]] -void beginInvocationInterlockEXT(); - -[[vk::ext_capability(spv::CapabilityFragmentShaderPixelInterlockEXT)]] -[[vk::ext_extension("SPV_EXT_fragment_shader_interlock")]] -[[vk::ext_instruction(spv::OpEndInvocationInterlockEXT)]] -void endInvocationInterlockEXT(); - -} -} -} - -#endif diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl deleted file mode 100644 index f64fc95359..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_ARITHMETIC_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_ARITHMETIC_INCLUDED_ - -// For all WaveMultiPrefix* ops, an example can be found here https://github.com/microsoft/DirectXShaderCompiler/blob/4e5440e1ee1f30d1164f90445611328293de08fa/tools/clang/test/HLSLFileCheck/hlsl/intrinsics/wave/prefix/sm_6_5_wave.hlsl -// However, we prefer to implement them with SPIRV intrinsics to avoid DXC changes in the compiler's emitted code - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ - -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformIAdd )]] -int32_t groupAdd(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, int32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformIAdd )]] -uint32_t groupAdd(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, uint32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformFAdd )]] -float32_t groupAdd(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, float32_t value); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformIMul )]] -int32_t groupMul(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, int32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformIMul )]] -uint32_t groupMul(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, uint32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformFMul )]] -float32_t groupMul(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, float32_t value); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBitwiseAnd )]] -T groupBitwiseAnd(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, T value); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBitwiseOr )]] -T groupBitwiseOr(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, T value); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBitwiseXor )]] -T groupBitwiseXor(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, T value); - -// The MIN and MAX operations in SPIR-V have different Ops for each arithmetic type -// so we implement them distinctly -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformSMin )]] -int32_t groupBitwiseMin(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, int32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformUMin )]] -uint32_t groupBitwiseMin(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, uint32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformFMin )]] -float32_t groupBitwiseMin(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, float32_t value); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformSMax )]] -int32_t groupBitwiseMax(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, int32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformUMax )]] -uint32_t groupBitwiseMax(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, uint32_t value); -[[vk::ext_capability( spv::CapabilityGroupNonUniformArithmetic )]] -[[vk::ext_instruction( spv::OpGroupNonUniformFMax )]] -float32_t groupBitwiseMax(uint32_t groupScope, [[vk::ext_literal]] uint32_t operation, float32_t value); - -} -} -} - -#endif diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl deleted file mode 100644 index 64c696d3f9..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_BALLOT_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_BALLOT_INCLUDED_ - - -#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" -#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl" - - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ -[[vk::ext_builtin_input(spv::BuiltInSubgroupEqMask)]] -static const uint32_t4 BuiltInSubgroupEqMask; -[[vk::ext_builtin_input(spv::BuiltInSubgroupGeMask)]] -static const uint32_t4 BuiltInSubgroupGeMask; -[[vk::ext_builtin_input(spv::BuiltInSubgroupGtMask)]] -static const uint32_t4 BuiltInSubgroupGtMask; -[[vk::ext_builtin_input(spv::BuiltInSubgroupLeMask)]] -static const uint32_t4 BuiltInSubgroupLeMask; -[[vk::ext_builtin_input(spv::BuiltInSubgroupLtMask)]] -static const uint32_t4 BuiltInSubgroupLtMask; - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBroadcastFirst )]] -T subgroupBroadcastFirst(uint32_t executionScope, T value); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBroadcast )]] -T subgroupBroadcast(uint32_t executionScope, T value, uint32_t invocationId); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBallot )]] -uint32_t4 subgroupBallot(uint32_t executionScope, bool value); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformInverseBallot )]] -bool subgroupInverseBallot(uint32_t executionScope, uint32_t4 value); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBallotBitExtract )]] -bool subgroupBallotBitExtract(uint32_t executionScope, uint32_t4 value, uint32_t id); - -[[vk::ext_capability( spv::CapabilityGroupNonUniformBallot )]] -[[vk::ext_instruction( spv::OpGroupNonUniformBallotBitCount )]] -uint32_t subgroupBallotBitCount(uint32_t executionScope, [[vk::ext_literal]] uint32_t operation, uint32_t4 value); - -[[vk::ext_capability(spv::CapabilityGroupNonUniformBallot)]] -[[vk::ext_instruction(spv::OpGroupNonUniformBallotFindLSB)]] -uint32_t subgroupBallotFindLSB(uint32_t executionScope, uint32_t4 value); - -[[vk::ext_capability(spv::CapabilityGroupNonUniformBallot)]] -[[vk::ext_instruction(spv::OpGroupNonUniformBallotFindMSB)]] -uint32_t subgroupBallotFindMSB(uint32_t executionScope, uint32_t4 value); -} -} -} - -#endif diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl deleted file mode 100644 index 08d493b87a..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_BASIC_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_BASIC_INCLUDED_ - - -#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" - - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ -[[vk::ext_builtin_input(spv::BuiltInSubgroupSize)]] -static const uint32_t SubgroupSize; -[[vk::ext_builtin_input(spv::BuiltInNumSubgroups)]] -static const uint32_t NumSubgroups; -[[vk::ext_builtin_input(spv::BuiltInSubgroupId)]] -static const uint32_t SubgroupId; -[[vk::ext_builtin_input(spv::BuiltInSubgroupLocalInvocationId)]] -static const uint32_t SubgroupLocalInvocationId; - -[[vk::ext_instruction( spv::OpGroupNonUniformElect )]] -bool subgroupElect(uint32_t executionScope); -} -} -} - -#endif diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl deleted file mode 100644 index cc5a2d6256..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_SHUFFLE_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_SHUFFLE_INCLUDED_ - - -#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl" - - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffle )]] -[[vk::ext_instruction( spv::OpGroupNonUniformShuffle )]] -T groupShuffle(uint32_t executionScope, T value, uint32_t invocationId); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffle )]] -[[vk::ext_instruction( spv::OpGroupNonUniformShuffleXor )]] -T groupShuffleXor(uint32_t executionScope, T value, uint32_t mask); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]] -[[vk::ext_instruction( spv::OpGroupNonUniformShuffleUp )]] -T groupShuffleUp(uint32_t executionScope, T value, uint32_t delta); - -template -[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]] -[[vk::ext_instruction( spv::OpGroupNonUniformShuffleDown )]] -T groupShuffleDown(uint32_t executionScope, T value, uint32_t delta); - -} -} -} - -#endif diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_vote.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_vote.hlsl deleted file mode 100644 index 314f9aebc3..0000000000 --- a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_vote.hlsl +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (C) 2023 - 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 -#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_VOTE_INCLUDED_ -#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_SUBGROUP_VOTE_INCLUDED_ - - -#include "nbl/builtin/hlsl/spirv_intrinsics/basic.hlsl" - - -namespace nbl -{ -namespace hlsl -{ -namespace spirv -{ - -[[vk::ext_instruction( spv::OpGroupNonUniformAll)]] -bool subgroupAll(uint32_t groupScope, bool value); - -[[vk::ext_instruction(spv::OpGroupNonUniformAny)]] -bool subgroupAny(uint32_t groupScope, bool value); - -template -[[vk::ext_instruction(spv::OpGroupNonUniformAllEqual)]] -bool subgroupAllEqual(uint32_t groupScope, T value); - -} -} -} - -#endif diff --git a/include/nbl/config/BuildConfigOptions.h.in b/include/nbl/config/BuildConfigOptions.h.in index ff6f08a9c8..11c32ef4f3 100644 --- a/include/nbl/config/BuildConfigOptions.h.in +++ b/include/nbl/config/BuildConfigOptions.h.in @@ -86,6 +86,7 @@ #define SPIRV_BUILTIN_RESOURCES_DIRECTORY_PATH "@SPIRV_BUILTIN_RESOURCES_DIRECTORY_PATH@" #define BOOST_BUILTIN_RESOURCES_DIRECTORY_PATH "@BOOST_BUILTIN_RESOURCES_DIRECTORY_PATH@" #define DEVICEGEN_BUILTIN_RESOURCES_DIRECTORY_PATH "@DEVICEGEN_BUILTIN_RESOURCES_DIRECTORY_PATH@" +#define NBL_SPRIV_INTRINSICS_GEN_RESOURCES_TO_EMBED "@NBL_SPRIV_INTRINSICS_GEN_RESOURCES_TO_EMBED@" // DDL exports #cmakedefine _NBL_SHARED_BUILD_ diff --git a/src/nbl/CMakeLists.txt b/src/nbl/CMakeLists.txt index fe290b4057..b3f5765222 100755 --- a/src/nbl/CMakeLists.txt +++ b/src/nbl/CMakeLists.txt @@ -670,6 +670,7 @@ if(NBL_EMBED_BUILTIN_RESOURCES) spirvBuiltinResourceData boostBuiltinResourceData deviceGenBuiltinResourceData + sprivIntrinsicsGenBuiltinResourceData ) NBL_HOOK_INTERNAL_BUILTIN_RESOURCES("${NBL_INTERNAL_BUILTIN_TARGETS}") diff --git a/src/nbl/builtin/CMakeLists.txt b/src/nbl/builtin/CMakeLists.txt index 824e7a545d..4103c5d175 100644 --- a/src/nbl/builtin/CMakeLists.txt +++ b/src/nbl/builtin/CMakeLists.txt @@ -232,13 +232,7 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "glsl/blit/normalization/shared_nor # HLSL LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/macros.h") #spirv intrinsics -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/core.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/fragment_shader_pixel_interlock.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_ballot.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_basic.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_shuffle.hlsl") -LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_vote.hlsl") +# LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/core.hlsl") #C++ compatibility LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat.hlsl") LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/basic.h") @@ -328,3 +322,30 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/memory_accessor.hlsl") LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/enums.hlsl") ADD_CUSTOM_BUILTIN_RESOURCES(nblBuiltinResourceData NBL_RESOURCES_TO_EMBED "${NBL_ROOT_PATH}/include" "nbl/builtin" "nbl::builtin" "${NBL_ROOT_PATH_BINARY}/include" "${NBL_ROOT_PATH_BINARY}/src" "STATIC" "INTERNAL") + +get_filename_component(NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include" ABSOLUTE) +set(NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR "${NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR}") + +set(NBL_OUTPUT_FILE "${NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR}/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl") +file(MAKE_DIRECTORY "${NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR}/nbl/builtin/hlsl/spirv_intrinsics") + +set(NBL_GEN_PY "${NBL_ROOT_PATH}/3rdparty/dxc/dxc/external/SPIRV-Headers/tools/hlsl_generator/gen.py") +set(NBL_COMMAND + "${_Python3_EXECUTABLE}" + "${NBL_GEN_PY}" + "${NBL_OUTPUT_FILE}" +) + +add_custom_command(OUTPUT "${NBL_OUTPUT_FILE}" + DEPENDS ${NBL_GEN_PY} + COMMAND ${NBL_COMMAND} + VERBATIM +) + +add_custom_target(SprivIntrinsics DEPENDS "${NBL_OUTPUT_FILE}") + +if(NBL_EMBED_BUILTIN_RESOURCES) + LIST_BUILTIN_RESOURCE(NBL_SPRIV_INTRINSICS_GEN_RESOURCES_TO_EMBED "core.hlsl") + ADD_CUSTOM_BUILTIN_RESOURCES(sprivIntrinsicsGenBuiltinResourceData NBL_SPRIV_INTRINSICS_GEN_RESOURCES_TO_EMBED "${NBL_SPRIV_INTRINSICS_GEN_INCLUDE_DIR}" "nbl/builtin/hlsl/spirv_intrinsics" "nbl::builtin::hlsl::spirv_intrinsics" "${CMAKE_CURRENT_BINARY_DIR}/include" "${CMAKE_CURRENT_BINARY_DIR}/include/nbl/builtin/hlsl/spirv_intrinsics" "STATIC" "INTERNAL") + add_dependencies(sprivIntrinsicsGenBuiltinResourceData SprivIntrinsics) +endif() diff --git a/src/nbl/system/ISystem.cpp b/src/nbl/system/ISystem.cpp index 7e86d15cb0..00e1a61d09 100644 --- a/src/nbl/system/ISystem.cpp +++ b/src/nbl/system/ISystem.cpp @@ -6,6 +6,7 @@ #include "spirv/builtin/CArchive.h" #include "boost/builtin/CArchive.h" #include "nbl/devicegen/builtin/CArchive.h" +#include "nbl/builtin/hlsl/spirv_intrinsics/CArchive.h" #endif // NBL_EMBED_BUILTIN_RESOURCES #include "nbl/system/CArchiveLoaderZip.h" @@ -25,12 +26,14 @@ ISystem::ISystem(core::smart_refctd_ptr&& caller) : m_dispatch mount(core::make_smart_refctd_ptr(nullptr)); mount(core::make_smart_refctd_ptr(nullptr)); mount(core::make_smart_refctd_ptr(nullptr)); + mount(core::make_smart_refctd_ptr(nullptr)); #else // TODO: absolute default entry paths? we should do something with it mount(core::make_smart_refctd_ptr(NBL_BUILTIN_RESOURCES_DIRECTORY_PATH, nullptr, this), "nbl/builtin"); mount(core::make_smart_refctd_ptr(SPIRV_BUILTIN_RESOURCES_DIRECTORY_PATH, nullptr, this), "spirv"); mount(core::make_smart_refctd_ptr(BOOST_BUILTIN_RESOURCES_DIRECTORY_PATH, nullptr, this), "boost"); mount(core::make_smart_refctd_ptr(DEVICEGEN_BUILTIN_RESOURCES_DIRECTORY_PATH, nullptr, this), "nbl/video"); + mount(core::make_smart_refctd_ptr(NBL_SPRIV_INTRINSICS_GEN_RESOURCES_TO_EMBED, nullptr, this), "nbl/builtin/hlsl/spirv_intrinsics"); #endif }