Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain

1 files changed, 227 insertions, 0 deletions

diff --git a/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h b/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h
new file mode 100644
index 0000000..bc8672c
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h
@@ -0,0 +1,227 @@
+// Copyright (c) 2024 Google LLC
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _HLSL_VK_KHR_OPCODE_SELECTOR_H_
+#define _HLSL_VK_KHR_OPCODE_SELECTOR_H_
+
+#define DECLARE_UNARY_OP(name, opcode)                                         \
+  template <typename ResultType>                                               \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      ResultType a)
+
+DECLARE_UNARY_OP(CopyObject, 83);
+DECLARE_UNARY_OP(SNegate, 126);
+DECLARE_UNARY_OP(FNegate, 127);
+
+#define DECLARE_CONVERSION_OP(name, opcode)                                    \
+  template <typename ResultType, typename OperandType>                         \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      OperandType a)
+
+DECLARE_CONVERSION_OP(ConvertFtoU, 109);
+DECLARE_CONVERSION_OP(ConvertFtoS, 110);
+DECLARE_CONVERSION_OP(ConvertSToF, 111);
+DECLARE_CONVERSION_OP(ConvertUToF, 112);
+DECLARE_CONVERSION_OP(UConvert, 113);
+DECLARE_CONVERSION_OP(SConvert, 114);
+DECLARE_CONVERSION_OP(FConvert, 115);
+DECLARE_CONVERSION_OP(Bitcast, 124);
+
+#undef DECLARY_UNARY_OP
+
+#define DECLARE_BINOP(name, opcode)                                            \
+  template <typename ResultType>                                               \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      ResultType a, ResultType b)
+
+DECLARE_BINOP(IAdd, 128);
+DECLARE_BINOP(FAdd, 129);
+DECLARE_BINOP(ISub, 130);
+DECLARE_BINOP(FSub, 131);
+DECLARE_BINOP(IMul, 132);
+DECLARE_BINOP(FMul, 133);
+DECLARE_BINOP(UDiv, 134);
+DECLARE_BINOP(SDiv, 135);
+DECLARE_BINOP(FDiv, 136);
+
+#undef DECLARE_BINOP
+namespace vk {
+namespace util {
+
+template <class ComponentType> class ArithmeticSelector;
+
+#define ARITHMETIC_SELECTOR(BaseType, OpNegate, OpAdd, OpSub, OpMul, OpDiv,    \
+                            SIGNED_INTEGER_TYPE)                               \
+  template <> class ArithmeticSelector<BaseType> {                             \
+    template <class T> static T Negate(T a) { return OpNegate(a); }            \
+    template <class T> static T Add(T a, T b) { return OpAdd(a, b); }          \
+    template <class T> static T Sub(T a, T b) { return OpSub(a, b); }          \
+    template <class T> static T Mul(T a, T b) { return OpMul(a, b); }          \
+    template <class T> static T Div(T a, T b) { return OpDiv(a, b); }          \
+  };
+
+ARITHMETIC_SELECTOR(half, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+ARITHMETIC_SELECTOR(float, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+ARITHMETIC_SELECTOR(double, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+
+#if __HLSL_ENABLE_16_BIT
+ARITHMETIC_SELECTOR(int16_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(uint16_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+#endif // __HLSL_ENABLE_16_BIT
+
+ARITHMETIC_SELECTOR(int32_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(int64_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(uint32_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+ARITHMETIC_SELECTOR(uint64_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+
+// The conversion selector is will be used to convert one type to another
+// using the SPIR-V conversion instructions. See
+// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_conversion_instructions.
+// SourceType and TargetType must be integer or floating point scalar type.
+
+// ConversionSelector::Convert converts an object of type S to an object of type
+// T. S must be SourceType, a vector of SourceType, or a cooperative matrix of
+// SourceType. T must be TargetType, a vector of TargetType, or a cooperative
+// matrix of TargetType. T must have the same number of components as S. T is a
+// cooperative matrix if and only if S is a cooperative matrix.
+template <class SourceType, class TargetType> class ConversionSelector;
+
+#define CONVERSION_SELECTOR(SourceType, TargetType, OpConvert)                 \
+  template <> class ConversionSelector<SourceType, TargetType> {               \
+    template <class T, class S> static T Convert(S a) {                        \
+      return OpConvert<T>(a);                                                  \
+    }                                                                          \
+  };
+
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(uint16_t, uint16_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint16_t, int16_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint16_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint16_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint16_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint16_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint16_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint16_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint16_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int16_t, uint16_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int16_t, int16_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int16_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int16_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int16_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int16_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int16_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int16_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int16_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(uint32_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint32_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(int32_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int32_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(uint64_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint64_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(int64_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int64_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(half, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int16_t, __builtin_spv_ConvertFtoS);
+
+CONVERSION_SELECTOR(float, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int16_t, __builtin_spv_ConvertFtoS);
+
+CONVERSION_SELECTOR(double, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int16_t, __builtin_spv_ConvertFtoS);
+#endif
+
+CONVERSION_SELECTOR(uint32_t, uint32_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint32_t, int32_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint32_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint32_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint32_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint32_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint32_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int32_t, uint32_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int32_t, int32_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int32_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int32_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int32_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int32_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int32_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(uint64_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint64_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint64_t, uint64_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint64_t, int64_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint64_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint64_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint64_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int64_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int64_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int64_t, uint64_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int64_t, int64_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int64_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int64_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int64_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(half, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(half, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int64_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(half, half, __builtin_spv_CopyObject);
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(half, float, __builtin_spv_FConvert);
+#else
+CONVERSION_SELECTOR(half, float, __builtin_spv_CopyObject);
+#endif
+
+CONVERSION_SELECTOR(half, double, __builtin_spv_FConvert);
+
+CONVERSION_SELECTOR(float, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(float, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int64_t, __builtin_spv_ConvertFtoS);
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(float, half, __builtin_spv_FConvert);
+#else
+CONVERSION_SELECTOR(float, half, __builtin_spv_CopyObject);
+#endif
+CONVERSION_SELECTOR(float, float, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(float, double, __builtin_spv_FConvert);
+
+CONVERSION_SELECTOR(double, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(double, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int64_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(double, half, __builtin_spv_FConvert);
+CONVERSION_SELECTOR(double, float, __builtin_spv_FConvert);
+CONVERSION_SELECTOR(double, double, __builtin_spv_CopyObject);
+}; // namespace util
+} // namespace vk
+
+#endif // _HLSL_VK_KHR_OPCODE_SELECTOR_H_