CAD emulated float64

02_HelloCompute/main.cpp

@@ -148,8 +148,8 @@ class HelloComputeApp final : public nbl::application_templates::MonoSystemMonoL
 						.binding=0,
 						.type=nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
 						.createFlags=IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE, // not is not the time for descriptor indexing
-						.stageFlags=IGPUShader::E_SHADER_STAGE::ESS_COMPUTE,
-						.count=1,
+						.stageFlags=nbl::hlsl::ShaderStage::ESS_COMPUTE,
+						.count=1
 					}
 				};
 				smart_refctd_ptr<IGPUDescriptorSetLayout> dsLayout = device->createDescriptorSetLayout(bindings);

03_DeviceSelectionAndSharedSources/app_resources/float64_t_test.hlsl

@@ -0,0 +1,15 @@
+#pragma wave shader_stage(compute)
+#include "common.hlsl"
+#include <nbl/builtin/hlsl/emulated_float64_t.hlsl>
+
+[numthreads(256,1,1)]
+void main() 
+{
+    const emulated::float64_t a = _static_cast<emulated::float64_t>(6.9f);
+    const emulated::float64_t b = _static_cast<emulated::float64_t>(4.5f);
+
+    vk::RawBufferStore<emulated::float64_t::storage_t>(0,(a*b).data);
+
+    const float asdf = 1.0f;
+    const float asdff = 1.0f;
+}

62_CAD/shaders/geotexture/common.hlsl

@@ -9,7 +9,7 @@ NBL_CONSTEXPR uint32_t MaxGeoTextures = 256;
 // GeoTexture Oriented Bounding Box
 struct GeoTextureOBB
 {
-    float64_t2 topLeft; // 2 * 8 = 16 bytes
+    pfloat64_t2 topLeft; // 2 * 8 = 16 bytes
     float32_t2 dirU; // 2 * 4 = 8 bytes (24)
     float32_t aspectRatio; // 4 bytes (32)
 };

62_CAD/shaders/geotexture/vertex_shader.hlsl

@@ -11,9 +11,9 @@ PSInput main(uint vertexID : SV_VertexID)
     outV.position.z = 0.0;
 
     const float32_t2 dirV = float32_t2(geoTextureOBB.dirU.y, -geoTextureOBB.dirU.x) * geoTextureOBB.aspectRatio;
-    const float2 screenTopLeft = (float2) transformPointNdc(clipProjectionData.projectionToNDC, geoTextureOBB.topLeft);
-    const float2 screenDirU = (float2) transformVectorNdc(clipProjectionData.projectionToNDC, geoTextureOBB.dirU);
-    const float2 screenDirV = (float2) transformVectorNdc(clipProjectionData.projectionToNDC, dirV);
+    const float2 screenTopLeft = _static_cast<float2>(transformPointNdc(clipProjectionData.projectionToNDC, geoTextureOBB.topLeft));
+    const float2 screenDirU = _static_cast<float2>(transformVectorNdc(clipProjectionData.projectionToNDC, _static_cast<pfloat64_t2>(geoTextureOBB.dirU)));
+    const float2 screenDirV = _static_cast<float2>(transformVectorNdc(clipProjectionData.projectionToNDC, _static_cast<pfloat64_t2>(dirV)));
 
     const float2 corner = float2(bool2(vertexIdx & 0x1u, vertexIdx >> 1)); // corners of square from (0, 0) to (1, 1)
 

62_CAD/shaders/globals.hlsl

@@ -1,15 +1,38 @@
 #ifndef _CAD_EXAMPLE_GLOBALS_HLSL_INCLUDED_
 #define _CAD_EXAMPLE_GLOBALS_HLSL_INCLUDED_
 
+#include <nbl/builtin/hlsl/portable/float64_t.hlsl>
+#include <nbl/builtin/hlsl/portable/vector_t.hlsl>
+#include <nbl/builtin/hlsl/portable/matrix_t.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/basic.h>
 #include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
 
+#ifdef __HLSL_VERSION
+#include <nbl/builtin/hlsl/math/equations/quadratic.hlsl>
+#include <nbl/builtin/hlsl/jit/device_capabilities.hlsl>
+#endif
+
+using namespace nbl::hlsl;
+
+// because we can't use jit/device_capabilities.hlsl in c++ code
+#ifdef __HLSL_VERSION
+using pfloat64_t = portable_float64_t<jit::device_capabilities>;
+using pfloat64_t2 = portable_float64_t2<jit::device_capabilities>;
+using pfloat64_t3 = portable_float64_t3<jit::device_capabilities>;
+using pfloat64_t3x3 = portable_float64_t3x3<jit::device_capabilities>;
+#else
+using pfloat64_t = float64_t;
+using pfloat64_t2 = nbl::hlsl::vector<float64_t, 2>;
+using pfloat64_t3 = nbl::hlsl::vector<float64_t, 3>;
+using pfloat64_t3x3 = portable_float64_t3x3<>;
+#endif
+
 // TODO: Compute this in a compute shader from the world counterparts
 //      because this struct includes NDC coordinates, the values will change based camera zoom and move
 //      of course we could have the clip values to be in world units and also the matrix to transform to world instead of ndc but that requires extra computations(matrix multiplications) per vertex
 struct ClipProjectionData
 {
-    float64_t3x3 projectionToNDC; // 72 -> because we use scalar_layout
+    pfloat64_t3x3 projectionToNDC; // 72 -> because we use scalar_layout
     float32_t2 minClipNDC; // 80
     float32_t2 maxClipNDC; // 88
 };
@@ -23,8 +46,8 @@ static_assert(offsetof(ClipProjectionData, maxClipNDC) == 80u);
 struct Globals
 {
     ClipProjectionData defaultClipProjection; // 88
-    double screenToWorldRatio; // 96
-    double worldToScreenRatio; // 100
+    pfloat64_t screenToWorldRatio; // 96
+    pfloat64_t worldToScreenRatio; // 100
     uint32_t2 resolution; // 108
     float antiAliasingFactor; // 112
     float miterLimit; // 116
@@ -40,13 +63,39 @@ static_assert(offsetof(Globals, antiAliasingFactor) == 112u);
 static_assert(offsetof(Globals, miterLimit) == 116u);
 #endif
 
-inline float64_t2 transformPointNdc(float64_t3x3 transformation, float64_t2 point2d)
+// TODO[Przemek]: remove `#ifdef __HLSL_VERSION` and mul shouldn't use jit::device_caps, preferably do this with nbl::hlsl::mul  instead of portableMul64
+#ifdef __HLSL_VERSION
+pfloat64_t2 transformPointNdc(pfloat64_t3x3 transformation, pfloat64_t2 point2d)
 {
-    return mul(transformation, float64_t3(point2d, 1)).xy;
+    pfloat64_t3 point3d;
+    point3d.x = point2d.x;
+    point3d.y = point2d.y;
+    point3d.z = _static_cast < pfloat64_t > (1.0f);
+
+    pfloat64_t3 transformationResult = portableMul64 < pfloat64_t3x3, pfloat64_t3, jit::
+    device_capabilities > (transformation, point3d);
+    pfloat64_t2 output;
+    output.x = transformationResult.x;
+    output.y = transformationResult.y;
+
+    return output;
 }
-inline float64_t2 transformVectorNdc(float64_t3x3 transformation, float64_t2 vector2d)
+pfloat64_t2 transformVectorNdc(pfloat64_t3x3 transformation, pfloat64_t2 vector2d)
 {
-    return mul(transformation, float64_t3(vector2d, 0)).xy;
+    pfloat64_t3 vector3d;
+    vector3d.x = vector2d.x;
+    vector3d.y = vector2d.y;
+    vector3d.z = _static_cast < pfloat64_t > (0.0f);
+
+    pfloat64_t3 transformationResult = portableMul64 < pfloat64_t3x3, pfloat64_t3, jit::
+    device_capabilities > (transformation, vector3d);
+    pfloat64_t2 output;
+    output.x = transformationResult.x;
+    output.y = transformationResult.y;
+
+    return output;
 }
+#endif
+
 
 #endif

62_CAD/shaders/main_pipeline/common.hlsl

@@ -5,9 +5,6 @@
 #include <nbl/builtin/hlsl/limits.hlsl>
 #include <nbl/builtin/hlsl/glsl_compat/core.hlsl>
 #include <nbl/builtin/hlsl/shapes/beziers.hlsl>
-#ifdef __HLSL_VERSION
-#include <nbl/builtin/hlsl/math/equations/quadratic.hlsl>
-#endif
 
 enum class ObjectType : uint32_t
 {
@@ -42,14 +39,14 @@ struct DrawObject
 
 struct LinePointInfo
 {
-    float64_t2 p;
+    pfloat64_t2 p;
     float32_t phaseShift;
     float32_t stretchValue;
 };
 
 struct QuadraticBezierInfo
 {
-    nbl::hlsl::shapes::QuadraticBezier<float64_t> shape; // 48bytes = 3 (control points) x 16 (float64_t2)
+    shapes::QuadraticBezier<pfloat64_t> shape; // 48bytes = 3 (control points) x 16 (emulated_float64_t)
     float32_t phaseShift;
     float32_t stretchValue;
 };
@@ -59,7 +56,7 @@ static_assert(offsetof(QuadraticBezierInfo, phaseShift) == 48u);
 
 struct GlyphInfo
 {
-    float64_t2 topLeft; // 2 * 8 = 16 bytes
+    pfloat64_t2 topLeft; // 2 * 8 = 16 bytes
     float32_t2 dirU; // 2 * 4 = 8 bytes (24)
     float32_t aspectRatio; // 4 bytes (32)
     // unorm8 minU;
@@ -68,12 +65,12 @@ struct GlyphInfo
     uint32_t minUV_textureID_packed; // 4 bytes (36)
 
 #ifndef __HLSL_VERSION
-    GlyphInfo(float64_t2 topLeft, float32_t2 dirU, float32_t aspectRatio, uint16_t textureId, float32_t2 minUV) :
+    GlyphInfo(pfloat64_t2 topLeft, float32_t2 dirU, float32_t aspectRatio, uint16_t textureId, float32_t2 minUV) :
         topLeft(topLeft),
         dirU(dirU),
         aspectRatio(aspectRatio)
     {
-        assert(textureId < nbl::hlsl::numeric_limits<uint16_t>::max);
+        assert(textureId < numeric_limits<uint16_t>::max);
         packMinUV_TextureID(minUV, textureId);
     }
 #endif
@@ -90,20 +87,20 @@ struct GlyphInfo
     float32_t2 getMinUV()
     {
         return float32_t2(
-            float32_t(nbl::hlsl::glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 16, 8)) / 255.0,
-            float32_t(nbl::hlsl::glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 24, 8)) / 255.0
+            float32_t(glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 16, 8)) / 255.0,
+            float32_t(glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 24, 8)) / 255.0
         );
     }
 
     uint16_t getTextureID()
     {
-        return uint16_t(nbl::hlsl::glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 0, 16));
+        return uint16_t(glsl::bitfieldExtract<uint32_t>(minUV_textureID_packed, 0, 16));
     }
 };
 
 struct ImageObjectInfo
 {
-    float64_t2 topLeft; // 2 * 8 = 16 bytes (16)
+    pfloat64_t2 topLeft; // 2 * 8 = 16 bytes (16)
     float32_t2 dirU; // 2 * 4 = 8 bytes (24)
     float32_t aspectRatio; // 4 bytes (28)
     uint32_t textureID; // 4 bytes (32)
@@ -143,7 +140,7 @@ static float32_t3 unpackR11G11B10_UNORM(uint32_t packed)
 
 struct PolylineConnector
 {
-    float64_t2 circleCenter;
+    pfloat64_t2 circleCenter;
     float32_t2 v;
     float32_t cosAngleDifferenceHalf;
     float32_t _reserved_pad;
@@ -153,8 +150,8 @@ struct PolylineConnector
 struct CurveBox
 {
     // will get transformed in the vertex shader, and will be calculated on the cpu when generating these boxes
-    float64_t2 aabbMin; // 16
-    float64_t2 aabbMax; // 32 , TODO: we know it's a square/box -> we save 8 bytes if we needed to store extra data
+    pfloat64_t2 aabbMin; // 16
+    pfloat64_t2 aabbMax; // 32 , TODO: we know it's a square/box -> we save 8 bytes if we needed to store extra data
     float32_t2 curveMin[3]; // 56
     float32_t2 curveMax[3]; // 80
 };
@@ -168,7 +165,7 @@ static_assert(sizeof(CurveBox) == 80u);
 #endif
 
 NBL_CONSTEXPR uint32_t InvalidRigidSegmentIndex = 0xffffffff;
-NBL_CONSTEXPR float InvalidStyleStretchValue = nbl::hlsl::numeric_limits<float>::infinity;
+NBL_CONSTEXPR float InvalidStyleStretchValue = numeric_limits<float>::infinity;
 
 // The color parameter is also used for styling non-curve objects such as text glyphs and hatches with solid color
 struct LineStyle
@@ -250,8 +247,8 @@ NBL_CONSTEXPR uint32_t AlphaBits = 32u - MainObjectIdxBits;
 NBL_CONSTEXPR uint32_t MaxIndexableMainObjects = (1u << MainObjectIdxBits) - 1u;
 NBL_CONSTEXPR uint32_t InvalidStyleIdx = nbl::hlsl::numeric_limits<uint32_t>::max;
 NBL_CONSTEXPR uint32_t InvalidMainObjectIdx = MaxIndexableMainObjects;
-NBL_CONSTEXPR uint64_t InvalidClipProjectionAddress = nbl::hlsl::numeric_limits<uint64_t>::max;
-NBL_CONSTEXPR uint32_t InvalidTextureIdx = nbl::hlsl::numeric_limits<uint32_t>::max;
+NBL_CONSTEXPR uint64_t InvalidClipProjectionAddress = numeric_limits<uint64_t>::max;
+NBL_CONSTEXPR uint32_t InvalidTextureIdx = numeric_limits<uint32_t>::max;
 NBL_CONSTEXPR MajorAxis SelectedMajorAxis = MajorAxis::MAJOR_Y;
 // TODO: get automatic version working on HLSL
 NBL_CONSTEXPR MajorAxis SelectedMinorAxis = MajorAxis::MAJOR_X; //(MajorAxis) (1 - (uint32_t) SelectedMajorAxis);
@@ -263,26 +260,26 @@ NBL_CONSTEXPR float HatchFillMSDFSceenSpaceSize = 8.0;
 
 #ifdef __HLSL_VERSION
 
-// TODO: Use these in C++ as well once nbl::hlsl::numeric_limits<uint32_t> compiles on C++
+// TODO: Use these in C++ as well once numeric_limits<uint32_t> compiles on C++
 float32_t2 unpackCurveBoxUnorm(uint32_t2 value)
 {
-    return float32_t2(value) / float32_t(nbl::hlsl::numeric_limits<uint32_t>::max);
+    return float32_t2(value) / float32_t(numeric_limits<uint32_t>::max);
 }
 
 float32_t2 unpackCurveBoxSnorm(int32_t2 value)
 {
-    return float32_t2(value) / float32_t(nbl::hlsl::numeric_limits<int32_t>::max);
+    return float32_t2(value) / float32_t(numeric_limits<int32_t>::max);
 }
 
 
 uint32_t2 packCurveBoxUnorm(float32_t2 value)
 {
-    return value * float32_t(nbl::hlsl::numeric_limits<uint32_t>::max);
+    return value * float32_t(numeric_limits<uint32_t>::max);
 }
 
 int32_t2 packCurveBoxSnorm(float32_t2 value)
 {
-    return value * float32_t(nbl::hlsl::numeric_limits<int32_t>::max);
+    return value * float32_t(numeric_limits<int32_t>::max);
 }
 
 // TODO: Remove these two when we include our builtin shaders
@@ -317,7 +314,7 @@ struct PrecomputedRootFinder
         return result;
     }
 
-    static PrecomputedRootFinder construct(nbl::hlsl::math::equations::Quadratic<float_t> quadratic)
+    static PrecomputedRootFinder construct(math::equations::Quadratic<float_t> quadratic)
     {
         PrecomputedRootFinder result;
         result.C2 = quadratic.c * 2.0;
@@ -369,25 +366,25 @@ struct PSInput
     void setLineEnd(float2 lineEnd) { data2.zw = lineEnd; }
 
     /* QUAD_BEZIER */
-    nbl::hlsl::shapes::Quadratic<float> getQuadratic()
+    shapes::Quadratic<float> getQuadratic()
     {
-        return nbl::hlsl::shapes::Quadratic<float>::construct(data2.xy, data2.zw, data3.xy);
+        return shapes::Quadratic<float>::construct(data2.xy, data2.zw, data3.xy);
     }
-    void setQuadratic(nbl::hlsl::shapes::Quadratic<float> quadratic)
+    void setQuadratic(shapes::Quadratic<float> quadratic)
     {
         data2.xy = quadratic.A;
         data2.zw = quadratic.B;
         data3.xy = quadratic.C;
     }
 
-    void setQuadraticPrecomputedArcLenData(nbl::hlsl::shapes::Quadratic<float>::ArcLengthCalculator preCompData) 
+    void setQuadraticPrecomputedArcLenData(shapes::Quadratic<float>::ArcLengthCalculator preCompData) 
     {
         data3.zw = float2(preCompData.lenA2, preCompData.AdotB);
         data4 = float4(preCompData.a, preCompData.b, preCompData.c, preCompData.b_over_4a);
     }
-    nbl::hlsl::shapes::Quadratic<float>::ArcLengthCalculator getQuadraticArcLengthCalculator()
+    shapes::Quadratic<float>::ArcLengthCalculator getQuadraticArcLengthCalculator()
     {
-        return nbl::hlsl::shapes::Quadratic<float>::ArcLengthCalculator::construct(data3.z, data3.w, data4.x, data4.y, data4.z, data4.w);
+        return shapes::Quadratic<float>::ArcLengthCalculator::construct(data3.z, data3.w, data4.x, data4.y, data4.z, data4.w);
     }
 
     /* CURVE_BOX */
@@ -397,38 +394,38 @@ struct PSInput
     // TODO: possible optimization: passing precomputed values for solving the quadratic equation instead
 
     // data2, data3, data4
-    nbl::hlsl::math::equations::Quadratic<float> getCurveMinMinor() {
-        return nbl::hlsl::math::equations::Quadratic<float>::construct(data2.x, data2.y, data2.z);
+    math::equations::Quadratic<float> getCurveMinMinor() {
+        return math::equations::Quadratic<float>::construct(data2.x, data2.y, data2.z);
     }
-    nbl::hlsl::math::equations::Quadratic<float> getCurveMaxMinor() {
-        return nbl::hlsl::math::equations::Quadratic<float>::construct(data2.w, data3.x, data3.y);
+    math::equations::Quadratic<float> getCurveMaxMinor() {
+        return math::equations::Quadratic<float>::construct(data2.w, data3.x, data3.y);
     }
 
-    void setCurveMinMinor(nbl::hlsl::math::equations::Quadratic<float> bezier) {
+    void setCurveMinMinor(math::equations::Quadratic<float> bezier) {
         data2.x = bezier.a;
         data2.y = bezier.b;
         data2.z = bezier.c;
     }
-    void setCurveMaxMinor(nbl::hlsl::math::equations::Quadratic<float> bezier) {
+    void setCurveMaxMinor(math::equations::Quadratic<float> bezier) {
         data2.w = bezier.a;
         data3.x = bezier.b;
         data3.y = bezier.c;
     }
 
     // data4
-    nbl::hlsl::math::equations::Quadratic<float> getCurveMinMajor() {
-        return nbl::hlsl::math::equations::Quadratic<float>::construct(data4.x, data4.y, data3.z);
+    math::equations::Quadratic<float> getCurveMinMajor() {
+        return math::equations::Quadratic<float>::construct(data4.x, data4.y, data3.z);
     }
-    nbl::hlsl::math::equations::Quadratic<float> getCurveMaxMajor() {
-        return nbl::hlsl::math::equations::Quadratic<float>::construct(data4.z, data4.w, data3.w);
+    math::equations::Quadratic<float> getCurveMaxMajor() {
+        return math::equations::Quadratic<float>::construct(data4.z, data4.w, data3.w);
     }
 
-    void setCurveMinMajor(nbl::hlsl::math::equations::Quadratic<float> bezier) {
+    void setCurveMinMajor(math::equations::Quadratic<float> bezier) {
         data4.x = bezier.a;
         data4.y = bezier.b;
         data3.z = bezier.c;
     }
-    void setCurveMaxMajor(nbl::hlsl::math::equations::Quadratic<float> bezier) {
+    void setCurveMaxMajor(math::equations::Quadratic<float> bezier) {
         data4.z = bezier.a;
         data4.w = bezier.b;
         data3.w = bezier.c;