Merge branch 'readme' of github.com:Devsh-Graphics-Programming/Nabla into readme

Author: AnastaZIuk

cmake/adjust/flags.cmake

@@ -200,6 +200,6 @@ function(nbl_adjust_flags)
 list(APPEND _D_NBL_COMPILE_OPTIONS_ $<$<CONFIG:${NBL_MAP_CONFIGURATION_FROM}>:${NBL_TO_CONFIG_COMPILE_OPTIONS}>)
 endforeach()
 
-set_directory_properties(PROPERTIES COMPILE_OPTIONS ${_D_NBL_COMPILE_OPTIONS_})
+set_directory_properties(PROPERTIES COMPILE_OPTIONS "${_D_NBL_COMPILE_OPTIONS_}")
 endif()
 endfunction()

examples_tests

@@ -37,16 +37,16 @@ class ICPUSampler : public ISampler, public IAsset
 };
 switch (wrapModes[i])
 {
-case ISampler::ETC_REPEAT:
+case ISampler::E_TEXTURE_CLAMP::ETC_REPEAT:
 repeat();
 break;
-case ISampler::ETC_CLAMP_TO_EDGE:
-texelCoord[i] = core::clamp<int32_t,int32_t>(texelCoord[i],0,mipLastCoord[i]);
+case ISampler::E_TEXTURE_CLAMP::ETC_CLAMP_TO_EDGE:
+texelCoord[i] = core::clamp<int32_t, int32_t>(texelCoord[i], 0, mipLastCoord[i]);
 break;
-case ISampler::ETC_MIRROR_CLAMP_TO_EDGE:
-texelCoord[i] = core::clamp<int32_t,int32_t>(texelCoord[i],-int32_t(mipExtent[i]),mipExtent[i]+mipLastCoord[i]);
+case ISampler::E_TEXTURE_CLAMP::ETC_MIRROR_CLAMP_TO_EDGE:
+texelCoord[i] = core::clamp<int32_t, int32_t>(texelCoord[i], -int32_t(mipExtent[i]), mipExtent[i] + mipLastCoord[i]);
 [[fallthrough]];
-case ISampler::ETC_MIRROR:
+case ISampler::E_TEXTURE_CLAMP::ETC_MIRROR:
 {
 int32_t repeatID = (originalWasNegative+texelCoord[i])/int32_t(mipExtent[i]);
 repeat();

include/nbl/asset/ICPUSampler.h

@@ -6,6 +6,7 @@
 #define __NBL_ASSET_I_SAMPLER_H_INCLUDED__
 
 #include "nbl/asset/IDescriptor.h"
+#include "nbl/builtin/hlsl/enums.hlsl"
 
 namespace nbl
 {
@@ -16,23 +17,7 @@ class ISampler : public IDescriptor
 {
 public:
 //! Texture coord clamp mode outside [0.0, 1.0]
-enum E_TEXTURE_CLAMP
-{
-//! Texture repeats
-ETC_REPEAT = 0,
-//! Texture is clamped to the edge pixel
-ETC_CLAMP_TO_EDGE,
-//! Texture is clamped to the border pixel (if exists)
-ETC_CLAMP_TO_BORDER,
-//! Texture is alternatingly mirrored (0..1..0..1..0..)
-ETC_MIRROR,
-//! Texture is mirrored once and then clamped to edge
-ETC_MIRROR_CLAMP_TO_EDGE,
-//! Texture is mirrored once and then clamped to border
-ETC_MIRROR_CLAMP_TO_BORDER,
-
-ETC_COUNT
-};
+using E_TEXTURE_CLAMP = hlsl::TextureClamp;
 
 enum E_TEXTURE_BORDER_COLOR
 {
@@ -75,11 +60,11 @@ class ISampler : public IDescriptor
 {
 struct {
 //! Valeus taken from E_TEXTURE_CLAMP
-uint32_t TextureWrapU : 3 = ETC_REPEAT;
+uint32_t TextureWrapU : 3 = E_TEXTURE_CLAMP::ETC_REPEAT;
 //! Valeus taken from E_TEXTURE_CLAMP
-uint32_t TextureWrapV : 3 = ETC_REPEAT;
+uint32_t TextureWrapV : 3 = E_TEXTURE_CLAMP::ETC_REPEAT;
 //! Valeus taken from E_TEXTURE_CLAMP
-uint32_t TextureWrapW : 3 = ETC_REPEAT;
+uint32_t TextureWrapW : 3 = E_TEXTURE_CLAMP::ETC_REPEAT;
 //! Values taken from E_TEXTURE_BORDER_COLOR
 uint32_t BorderColor : 3 = ETBC_FLOAT_OPAQUE_BLACK;
 //! Values taken from E_TEXTURE_FILTER

include/nbl/asset/ISampler.h

@@ -34,7 +34,7 @@ class CBlitImageFilterBase : public impl::CSwizzleableAndDitherableFilterBase<Sw
 uint8_t*	scratchMemory = nullptr;
 uint32_tscratchMemoryByteSize = 0u;
 _NBL_STATIC_INLINE_CONSTEXPR autoNumWrapAxes = 3;
-ISampler::E_TEXTURE_CLAMP	axisWraps[NumWrapAxes] = { ISampler::ETC_REPEAT,ISampler::ETC_REPEAT,ISampler::ETC_REPEAT };
+ISampler::E_TEXTURE_CLAMP	axisWraps[NumWrapAxes] = { ISampler::E_TEXTURE_CLAMP::ETC_REPEAT,ISampler::E_TEXTURE_CLAMP::ETC_REPEAT,ISampler::E_TEXTURE_CLAMP::ETC_REPEAT };
 ISampler::E_TEXTURE_BORDER_COLOR	borderColor = ISampler::ETBC_FLOAT_TRANSPARENT_BLACK;
 IBlitUtilities::E_ALPHA_SEMANTIC	alphaSemantic = IBlitUtilities::EAS_NONE_OR_PREMULTIPLIED;
 doublealphaRefValue = 0.5; // only required to make sense if `alphaSemantic==EAS_REFERENCE_OR_COVERAGE`
@@ -56,7 +56,7 @@ class CBlitImageFilterBase : public impl::CSwizzleableAndDitherableFilterBase<Sw
 return false;
 
 for (auto i=0; i<CStateBase::NumWrapAxes; i++)
-if (state->axisWraps[i]>=ISampler::ETC_COUNT)
+if (state->axisWraps[i]>=ISampler::E_TEXTURE_CLAMP::ETC_COUNT)
 return false;
 
 if (state->borderColor>=ISampler::ETBC_COUNT)

include/nbl/asset/filters/CBlitImageFilter.h

@@ -30,7 +30,7 @@ class CPaddedCopyImageFilter : public CImageFilter<CPaddedCopyImageFilter>, publ
 virtual ~CState() {}
 
 _NBL_STATIC_INLINE_CONSTEXPR auto NumWrapAxes = 3;
-ISampler::E_TEXTURE_CLAMP axisWraps[NumWrapAxes] = {ISampler::ETC_REPEAT,ISampler::ETC_REPEAT,ISampler::ETC_REPEAT};
+ISampler::E_TEXTURE_CLAMP axisWraps[NumWrapAxes] = {ISampler::E_TEXTURE_CLAMP::ETC_REPEAT,ISampler::E_TEXTURE_CLAMP::ETC_REPEAT,ISampler::E_TEXTURE_CLAMP::ETC_REPEAT};
 ISampler::E_TEXTURE_BORDER_COLOR borderColor;
 VkOffset3D relativeOffset;
 VkExtent3D paddedExtent;
@@ -57,7 +57,7 @@ class CPaddedCopyImageFilter : public CImageFilter<CPaddedCopyImageFilter>, publ
 // TODO: eventually remove when we can encode blocks
 for (auto i=0; i<CState::NumWrapAxes; i++)
 {
-if ((isBlockCompressionFormat(inFormat)||isBlockCompressionFormat(outFormat))&&state->axisWraps[i]!=ISampler::ETC_REPEAT)
+if ((isBlockCompressionFormat(inFormat)||isBlockCompressionFormat(outFormat))&&state->axisWraps[i]!=ISampler::E_TEXTURE_CLAMP::ETC_REPEAT)
 return false;
 }
 

include/nbl/asset/filters/CPaddedCopyImageFilter.h

@@ -0,0 +1,47 @@
+#ifndef _NBL_BUILTIN_HLSL_BITREVERSE_INCLUDED_
+#define _NBL_BUILTIN_HLSL_BITREVERSE_INCLUDED_
+
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename T, uint16_t Bits NBL_FUNC_REQUIRES(is_unsigned_v<T>&& Bits <= sizeof(T) * 8)
+/**
+* @brief Takes the binary representation of `value` as a string of `Bits` bits and returns a value of the same type resulting from reversing the string
+*
+* @tparam T Type of the value to operate on.
+* @tparam Bits The length of the string of bits used to represent `value`.
+*
+* @param [in] value The value to bitreverse.
+*/
+T bitReverseAs(T value)
+{
+return bitReverse<T>(value) >> promote<T, scalar_type_t<T> >(scalar_type_t <T>(sizeof(T) * 8 - Bits));
+}
+
+template<typename T NBL_FUNC_REQUIRES(is_unsigned_v<T>)
+/**
+* @brief Takes the binary representation of `value` and returns a value of the same type resulting from reversing the string of bits as if it was `bits` long.
+* Keep in mind `bits` cannot exceed `8 * sizeof(T)`.
+*
+* @tparam T type of the value to operate on.
+*
+* @param [in] value The value to bitreverse.
+* @param [in] bits The length of the string of bits used to represent `value`.
+*/
+T bitReverseAs(T value, uint16_t bits)
+{
+return bitReverse<T>(value) >> promote<T, scalar_type_t<T> >(scalar_type_t <T>(sizeof(T) * 8 - bits));
+}
+
+
+}
+}
+
+
+
+#endif

include/nbl/builtin/hlsl/bitreverse.hlsl

@@ -5,8 +5,47 @@
 #ifndef _NBL_BUILTIN_HLSL_COMPLEX_INCLUDED_
 #define _NBL_BUILTIN_HLSL_COMPLEX_INCLUDED_
 
-#include "nbl/builtin/hlsl/functional.hlsl"
-#include "nbl/builtin/hlsl/cpp_compat/promote.hlsl"
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/functional.hlsl>
+
+using namespace nbl::hlsl;
+
+// -------------------------------------- CPP VERSION ------------------------------------
+#ifndef __HLSL_VERSION
+
+#include <complex>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename Scalar>
+using complex_t = std::complex<Scalar>;
+
+// Fast mul by i
+template<typename Scalar>
+complex_t<Scalar> rotateLeft(NBL_CONST_REF_ARG(complex_t<Scalar>) value)
+{
+ complex_t<Scalar> retVal = { -value.imag(), value.real() };
+ return retVal;
+}
+
+// Fast mul by -i
+template<typename Scalar>
+complex_t<Scalar> rotateRight(NBL_CONST_REF_ARG(complex_t<Scalar>) value)
+{
+ complex_t<Scalar> retVal = { value.imag(), -value.real() };
+ return retVal;
+}
+
+}
+}
+
+// -------------------------------------- END CPP VERSION ------------------------------------
+
+// -------------------------------------- HLSL VERSION ---------------------------------------
+#else
 
 namespace nbl
 {
@@ -126,6 +165,8 @@ struct complex_t
 template<typename Scalar> 
 struct plus< complex_t<Scalar> > 
 {
+ using type_t = complex_t<Scalar>;
+
  complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
  {
  return lhs + rhs; 
@@ -137,6 +178,8 @@ struct plus< complex_t<Scalar> >
 template<typename Scalar> 
 struct minus< complex_t<Scalar> > 
 {
+ using type_t = complex_t<Scalar>;
+
  complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
  {
  return lhs - rhs; 
@@ -148,6 +191,8 @@ struct minus< complex_t<Scalar> >
 template<typename Scalar> 
 struct multiplies< complex_t<Scalar> > 
 {
+ using type_t = complex_t<Scalar>;
+
  complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
  {
  return lhs * rhs; 
@@ -164,6 +209,8 @@ struct multiplies< complex_t<Scalar> >
 template<typename Scalar> 
 struct divides< complex_t<Scalar> > 
 {
+ using type_t = complex_t<Scalar>;
+
  complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
  {
  return lhs / rhs; 
@@ -379,6 +426,22 @@ complex_t<Scalar> rotateRight(NBL_CONST_REF_ARG(complex_t<Scalar>) value)
  return retVal;
 }
 
+template<typename Scalar>
+struct ternary_operator< complex_t<Scalar> >
+{
+ using type_t = complex_t<Scalar>;
+
+ complex_t<Scalar> operator()(bool condition, NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs)
+ {
+ const vector<Scalar, 2> lhsVector = vector<Scalar, 2>(lhs.real(), lhs.imag());
+ const vector<Scalar, 2> rhsVector = vector<Scalar, 2>(rhs.real(), rhs.imag());
+ const vector<Scalar, 2> resultVector = condition ? lhsVector : rhsVector;
+ const complex_t<Scalar> result = { resultVector.x, resultVector.y };
+ return result;
+ }
+};
+
+
 }
 }
 
@@ -396,4 +459,7 @@ NBL_REGISTER_OBJ_TYPE(complex_t<float64_t2>,::nbl::hlsl::alignment_of_v<float64_
 NBL_REGISTER_OBJ_TYPE(complex_t<float64_t3>,::nbl::hlsl::alignment_of_v<float64_t3>)
 NBL_REGISTER_OBJ_TYPE(complex_t<float64_t4>,::nbl::hlsl::alignment_of_v<float64_t4>)
 
+// -------------------------------------- END HLSL VERSION ---------------------------------------
 #endif
+
+#endif

include/nbl/builtin/hlsl/complex.hlsl

@@ -0,0 +1,69 @@
+#ifndef _NBL_BUILTIN_HLSL_CONCEPTS_ACCESSORS_FFT_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CONCEPTS_ACCESSORS_FFT_INCLUDED_
+
+#include "nbl/builtin/hlsl/concepts.hlsl"
+#include "nbl/builtin/hlsl/fft/common.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace workgroup
+{
+namespace fft
+{
+// The SharedMemoryAccessor MUST provide the following methods:
+// * void get(uint32_t index, inout uint32_t value); 
+// * void set(uint32_t index, in uint32_t value); 
+// * void workgroupExecutionAndMemoryBarrier();
+
+#define NBL_CONCEPT_NAME FFTSharedMemoryAccessor
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (T)
+#define NBL_CONCEPT_PARAM_0 (accessor, T)
+#define NBL_CONCEPT_PARAM_1 (index, uint32_t)
+#define NBL_CONCEPT_PARAM_2 (val, uint32_t)
+NBL_CONCEPT_BEGIN(3)
+#define accessor NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
+#define index NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
+#define val NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
+NBL_CONCEPT_END(
+ ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((accessor.template set<uint32_t, uint32_t>(index, val)), is_same_v, void))
+ ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((accessor.template get<uint32_t, uint32_t>(index, val)), is_same_v, void))
+ ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((accessor.workgroupExecutionAndMemoryBarrier()), is_same_v, void))
+);
+#undef val
+#undef index
+#undef accessor
+#include <nbl/builtin/hlsl/concepts/__end.hlsl>
+
+
+// The Accessor (for a small FFT) MUST provide the following methods:
+// * void get(uint32_t index, inout complex_t<Scalar> value);
+// * void set(uint32_t index, in complex_t<Scalar> value);
+
+#define NBL_CONCEPT_NAME FFTAccessor
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (T)(Scalar)
+#define NBL_CONCEPT_PARAM_0 (accessor, T)
+#define NBL_CONCEPT_PARAM_1 (index, uint32_t)
+#define NBL_CONCEPT_PARAM_2 (val, complex_t<Scalar>)
+NBL_CONCEPT_BEGIN(3)
+#define accessor NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
+#define index NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
+#define val NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
+NBL_CONCEPT_END(
+ ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((accessor.template set<complex_t<Scalar> >(index, val)), is_same_v, void))
+ ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((accessor.template get<complex_t<Scalar> >(index, val)), is_same_v, void))
+);
+#undef val
+#undef index
+#undef accessor
+#include <nbl/builtin/hlsl/concepts/__end.hlsl>
+
+}
+}
+}
+}
+
+#endif

include/nbl/builtin/hlsl/concepts/accessors/fft.hlsl

@@ -41,6 +41,7 @@ inline To _static_cast(From v)
 #define NBL_CONSTEXPR_STATIC constexpr static
 #define NBL_CONSTEXPR_STATIC_INLINE constexpr static inline
 #define NBL_CONSTEXPR_INLINE_FUNC constexpr inline
+#define NBL_CONSTEXPR_FORCED_INLINE_FUNC NBL_FORCE_INLINE constexpr
 #define NBL_CONST_MEMBER_FUNC const
 
 namespace nbl::hlsl
@@ -70,6 +71,7 @@ namespace nbl::hlsl
 #define NBL_CONSTEXPR_STATIC const static
 #define NBL_CONSTEXPR_STATIC_INLINE const static
 #define NBL_CONSTEXPR_INLINE_FUNC inline
+#define NBL_CONSTEXPR_FORCED_INLINE_FUNC inline
 #define NBL_CONST_MEMBER_FUNC 
 
 namespace nbl