Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Updated spirv-cross.

Browse Source
This commit is contained in:
Бранимир Караџић
2019-02-15 19:52:34 -08:00
parent 90af4a2b9c
commit 1fd80956a5
29 changed files with 2313 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
3rdparty/spirv-cross/reference/opt/shaders-msl/asm/tesc/tess-fixed-input-array-builtin-array.invalid.asm.tesc vendored Normal file
View File

@@ -0,0 +1,71 @@
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct VertexOutput
{
float4 pos;
float2 uv;
};
struct VertexOutput_1
{
float2 uv;
};
struct HSOut
{
float2 uv;
};
struct main0_out
{
HSOut _entryPointOutput;
float4 gl_Position;
};
struct main0_in
{
float2 VertexOutput_uv [[attribute(0)]];
float4 gl_Position [[attribute(1)]];
};
// Implementation of an array copy function to cover GLSL's ability to copy an array via assignment.
template<typename T, uint N>
void spvArrayCopyFromStack1(thread T (&dst)[N], thread const T (&src)[N])
{
for (uint i = 0; i < N; dst[i] = src[i], i++);
}
template<typename T, uint N>
void spvArrayCopyFromConstant1(thread T (&dst)[N], constant T (&src)[N])
{
for (uint i = 0; i < N; dst[i] = src[i], i++);
}
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
VertexOutput _223[3] = { VertexOutput{ gl_in[0].gl_Position, gl_in[0].VertexOutput_uv }, VertexOutput{ gl_in[1].gl_Position, gl_in[1].VertexOutput_uv }, VertexOutput{ gl_in[2].gl_Position, gl_in[2].VertexOutput_uv } };
VertexOutput param[3];
spvArrayCopyFromStack1(param, _223);
gl_out[gl_InvocationID].gl_Position = param[gl_InvocationID].pos;
gl_out[gl_InvocationID]._entryPointOutput.uv = param[gl_InvocationID].uv;
threadgroup_barrier(mem_flags::mem_device);
if (int(gl_InvocationID) == 0)
{
float2 _174 = float2(1.0) + gl_in[0].VertexOutput_uv;
float _175 = _174.x;
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_175);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_175);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_175);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_175);
}
}

42
3rdparty/spirv-cross/reference/opt/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,42 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_out
{
float3 vVertex;
};
struct main0_patchOut
{
float3 vPatch[2];
};
struct main0_in
{
float3 vInput [[attribute(0)]];
};
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4];
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
gl_out[gl_InvocationID].vVertex = gl_in[gl_InvocationID].vInput + gl_in[gl_InvocationID ^ 1].vInput;
threadgroup_barrier(mem_flags::mem_device);
if (gl_InvocationID == 0)
{
patchOut.vPatch[0] = float3(10.0);
patchOut.vPatch[1] = float3(20.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0);
}
}

37
3rdparty/spirv-cross/reference/opt/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,37 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_out
{
float4 gl_Position;
};
struct main0_patchOut
{
float3 vFoo;
};
struct main0_in
{
float4 gl_Position [[attribute(0)]];
};
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 1];
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625);
patchOut.vFoo = float3(1.0);
gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position;
}

40
3rdparty/spirv-cross/reference/opt/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,40 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Boo
{
float3 a;
float3 b;
};
struct main0_out
{
Boo vVertex;
};
struct main0_in
{
float3 Boo_a [[attribute(0)]];
float3 Boo_b [[attribute(1)]];
};
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
Boo vInput_24;
vInput_24.a = gl_in[gl_InvocationID].Boo_a;
vInput_24.b = gl_in[gl_InvocationID].Boo_b;
gl_out[gl_InvocationID].vVertex = vInput_24;
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0);
}

22
3rdparty/spirv-cross/reference/opt/shaders-msl/tesc/basic.tesc vendored Normal file
View File

@@ -0,0 +1,22 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_patchOut
{
float3 vFoo;
};
kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]])
{
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625);
patchOut.vFoo = float3(1.0);
}

91
3rdparty/spirv-cross/reference/opt/shaders-msl/tesc/water_tess.tesc vendored Normal file
View File

@@ -0,0 +1,91 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct UBO
{
float4 uScale;
float3 uCamPos;
float2 uPatchSize;
float2 uMaxTessLevel;
float uDistanceMod;
float4 uFrustum[6];
};
struct main0_patchOut
{
float2 vOutPatchPosBase;
float4 vPatchLods;
};
struct main0_in
{
float2 vPatchPosBase [[attribute(0)]];
};
kernel void main0(main0_in in [[stage_in]], constant UBO& _41 [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
float2 _430 = (gl_in[0].vPatchPosBase - float2(10.0)) * _41.uScale.xy;
float2 _440 = ((gl_in[0].vPatchPosBase + _41.uPatchSize) + float2(10.0)) * _41.uScale.xy;
float3 _445 = float3(_430.x, -10.0, _430.y);
float3 _450 = float3(_440.x, 10.0, _440.y);
float4 _466 = float4((_445 + _450) * 0.5, 1.0);
float3 _513 = float3(length(_450 - _445) * (-0.5));
bool _515 = any(float3(dot(_41.uFrustum[0], _466), dot(_41.uFrustum[1], _466), dot(_41.uFrustum[2], _466)) <= _513);
bool _525;
if (!_515)
{
_525 = any(float3(dot(_41.uFrustum[3], _466), dot(_41.uFrustum[4], _466), dot(_41.uFrustum[5], _466)) <= _513);
}
else
{
_525 = _515;
}
if (!(!_525))
{
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0);
}
else
{
patchOut.vOutPatchPosBase = gl_in[0].vPatchPosBase;
float2 _678 = (gl_in[0].vPatchPosBase + (float2(-0.5) * _41.uPatchSize)) * _41.uScale.xy;
float2 _706 = (gl_in[0].vPatchPosBase + (float2(0.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy;
float _725 = fast::clamp(log2((length(_41.uCamPos - float3(_706.x, 0.0, _706.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x);
float2 _734 = (gl_in[0].vPatchPosBase + (float2(1.5, -0.5) * _41.uPatchSize)) * _41.uScale.xy;
float2 _762 = (gl_in[0].vPatchPosBase + (float2(-0.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy;
float _781 = fast::clamp(log2((length(_41.uCamPos - float3(_762.x, 0.0, _762.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x);
float2 _790 = (gl_in[0].vPatchPosBase + (float2(0.5) * _41.uPatchSize)) * _41.uScale.xy;
float _809 = fast::clamp(log2((length(_41.uCamPos - float3(_790.x, 0.0, _790.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x);
float2 _818 = (gl_in[0].vPatchPosBase + (float2(1.5, 0.5) * _41.uPatchSize)) * _41.uScale.xy;
float _837 = fast::clamp(log2((length(_41.uCamPos - float3(_818.x, 0.0, _818.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x);
float2 _846 = (gl_in[0].vPatchPosBase + (float2(-0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy;
float2 _874 = (gl_in[0].vPatchPosBase + (float2(0.5, 1.5) * _41.uPatchSize)) * _41.uScale.xy;
float _893 = fast::clamp(log2((length(_41.uCamPos - float3(_874.x, 0.0, _874.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x);
float2 _902 = (gl_in[0].vPatchPosBase + (float2(1.5) * _41.uPatchSize)) * _41.uScale.xy;
float _612 = dot(float4(_781, _809, fast::clamp(log2((length(_41.uCamPos - float3(_846.x, 0.0, _846.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _893), float4(0.25));
float _618 = dot(float4(fast::clamp(log2((length(_41.uCamPos - float3(_678.x, 0.0, _678.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _725, _781, _809), float4(0.25));
float _624 = dot(float4(_725, fast::clamp(log2((length(_41.uCamPos - float3(_734.x, 0.0, _734.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x), _809, _837), float4(0.25));
float _630 = dot(float4(_809, _837, _893, fast::clamp(log2((length(_41.uCamPos - float3(_902.x, 0.0, _902.y)) + 9.9999997473787516355514526367188e-05) * _41.uDistanceMod), 0.0, _41.uMaxTessLevel.x)), float4(0.25));
float4 _631 = float4(_612, _618, _624, _630);
patchOut.vPatchLods = _631;
float4 _928 = exp2(-fast::min(_631, _631.yzwx)) * _41.uMaxTessLevel.y;
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_928.x);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_928.y);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_928.z);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(_928.w);
float _935 = _41.uMaxTessLevel.y * exp2(-fast::min(fast::min(fast::min(_612, _618), fast::min(_624, _630)), _809));
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(_935);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(_935);
}
}

35
3rdparty/spirv-cross/reference/opt/shaders/asm/comp/recompile-block-naming.asm.comp vendored Normal file
View File

@@ -0,0 +1,35 @@
#version 450
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
layout(binding = 0, std430) buffer MyFirstBuffer
{
uint _data[];
} MyFirstBuffer_1;
layout(binding = 0, std430) buffer MySecondBuffer
{
uint _data[];
} MySecondBuffer_1;
layout(binding = 0, std430) buffer MyThirdBuffer
{
uint _data[];
} MyThirdBuffer_1;
void main()
{
uint _105 = MyFirstBuffer_1._data[0];
uint _109 = MyFirstBuffer_1._data[1];
uint _113 = MyFirstBuffer_1._data[2];
uint _117 = MyFirstBuffer_1._data[3];
uint _122 = MySecondBuffer_1._data[1];
uint _126 = MySecondBuffer_1._data[2];
uint _130 = MySecondBuffer_1._data[3];
uint _134 = MySecondBuffer_1._data[4];
uvec4 _140 = uvec4(_105, _109, _113, _117) + uvec4(_122, _126, _130, _134);
MyThirdBuffer_1._data[0] = _140.x;
MyThirdBuffer_1._data[1] = _140.y;
MyThirdBuffer_1._data[2] = _140.z;
MyThirdBuffer_1._data[3] = _140.w;
}

111
3rdparty/spirv-cross/reference/shaders-msl/asm/tesc/tess-fixed-input-array-builtin-array.invalid.asm.tesc vendored Normal file
View File

@@ -0,0 +1,111 @@
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct VertexOutput
{
float4 pos;
float2 uv;
};
struct HSOut
{
float4 pos;
float2 uv;
};
struct HSConstantOut
{
float EdgeTess[3];
float InsideTess;
};
struct VertexOutput_1
{
float2 uv;
};
struct HSOut_1
{
float2 uv;
};
struct main0_out
{
HSOut_1 _entryPointOutput;
float4 gl_Position;
};
struct main0_in
{
float2 VertexOutput_uv [[attribute(0)]];
float4 gl_Position [[attribute(1)]];
};
// Implementation of an array copy function to cover GLSL's ability to copy an array via assignment.
template<typename T, uint N>
void spvArrayCopyFromStack1(thread T (&dst)[N], thread const T (&src)[N])
{
for (uint i = 0; i < N; dst[i] = src[i], i++);
}
template<typename T, uint N>
void spvArrayCopyFromConstant1(thread T (&dst)[N], constant T (&src)[N])
{
for (uint i = 0; i < N; dst[i] = src[i], i++);
}
HSOut _hs_main(thread const VertexOutput (&p)[3], thread const uint& i)
{
HSOut _output;
_output.pos = p[i].pos;
_output.uv = p[i].uv;
return _output;
}
HSConstantOut PatchHS(thread const VertexOutput (&_patch)[3])
{
HSConstantOut _output;
_output.EdgeTess[0] = (float2(1.0) + _patch[0].uv).x;
_output.EdgeTess[1] = (float2(1.0) + _patch[0].uv).x;
_output.EdgeTess[2] = (float2(1.0) + _patch[0].uv).x;
_output.InsideTess = (float2(1.0) + _patch[0].uv).x;
return _output;
}
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device MTLTriangleTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 3];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
VertexOutput p[3];
p[0].pos = gl_in[0].gl_Position;
p[0].uv = gl_in[0].VertexOutput_uv;
p[1].pos = gl_in[1].gl_Position;
p[1].uv = gl_in[1].VertexOutput_uv;
p[2].pos = gl_in[2].gl_Position;
p[2].uv = gl_in[2].VertexOutput_uv;
uint i = gl_InvocationID;
VertexOutput param[3];
spvArrayCopyFromStack1(param, p);
uint param_1 = i;
HSOut flattenTemp = _hs_main(param, param_1);
gl_out[gl_InvocationID].gl_Position = flattenTemp.pos;
gl_out[gl_InvocationID]._entryPointOutput.uv = flattenTemp.uv;
threadgroup_barrier(mem_flags::mem_device);
if (int(gl_InvocationID) == 0)
{
VertexOutput param_2[3];
spvArrayCopyFromStack1(param_2, p);
HSConstantOut _patchConstantResult = PatchHS(param_2);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(_patchConstantResult.EdgeTess[0]);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(_patchConstantResult.EdgeTess[1]);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(_patchConstantResult.EdgeTess[2]);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor = half(_patchConstantResult.InsideTess);
}
}

42
3rdparty/spirv-cross/reference/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,42 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_out
{
float3 vVertex;
};
struct main0_patchOut
{
float3 vPatch[2];
};
struct main0_in
{
float3 vInput [[attribute(0)]];
};
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4];
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
gl_out[gl_InvocationID].vVertex = gl_in[gl_InvocationID].vInput + gl_in[gl_InvocationID ^ 1].vInput;
threadgroup_barrier(mem_flags::mem_device);
if (gl_InvocationID == 0)
{
patchOut.vPatch[0] = float3(10.0);
patchOut.vPatch[1] = float3(20.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0);
}
}

44
3rdparty/spirv-cross/reference/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,44 @@
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_out
{
float4 gl_Position;
};
struct main0_patchOut
{
float3 vFoo;
};
struct main0_in
{
float4 gl_Position [[attribute(0)]];
};
void set_position(device main0_out* thread & gl_out, thread uint& gl_InvocationID, threadgroup main0_in* thread & gl_in)
{
gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position;
}
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 1];
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625);
patchOut.vFoo = float3(1.0);
set_position(gl_out, gl_InvocationID, gl_in);
}

40
3rdparty/spirv-cross/reference/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,40 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Boo
{
float3 a;
float3 b;
};
struct main0_out
{
Boo vVertex;
};
struct main0_in
{
float3 Boo_a [[attribute(0)]];
float3 Boo_b [[attribute(1)]];
};
kernel void main0(main0_in in [[stage_in]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device main0_out* spvOut [[buffer(28)]], device uint* spvIndirectParams [[buffer(29)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_out* gl_out = &spvOut[gl_PrimitiveID * 4];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
Boo vInput_24;
vInput_24.a = gl_in[gl_InvocationID].Boo_a;
vInput_24.b = gl_in[gl_InvocationID].Boo_b;
gl_out[gl_InvocationID].vVertex = vInput_24;
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(2.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(2.0);
}

22
3rdparty/spirv-cross/reference/shaders-msl/tesc/basic.tesc vendored Normal file
View File

@@ -0,0 +1,22 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct main0_patchOut
{
float3 vFoo;
};
kernel void main0(uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]])
{
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(8.8999996185302734375);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(6.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(3.900000095367431640625);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(4.900000095367431640625);
patchOut.vFoo = float3(1.0);
}

132
3rdparty/spirv-cross/reference/shaders-msl/tesc/water_tess.tesc vendored Normal file
View File

@@ -0,0 +1,132 @@
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct UBO
{
float4 uScale;
float3 uCamPos;
float2 uPatchSize;
float2 uMaxTessLevel;
float uDistanceMod;
float4 uFrustum[6];
};
struct main0_patchOut
{
float2 vOutPatchPosBase;
float4 vPatchLods;
};
struct main0_in
{
float2 vPatchPosBase [[attribute(0)]];
};
bool frustum_cull(thread const float2& p0, constant UBO& v_41)
{
float2 min_xz = (p0 - float2(10.0)) * v_41.uScale.xy;
float2 max_xz = ((p0 + v_41.uPatchSize) + float2(10.0)) * v_41.uScale.xy;
float3 bb_min = float3(min_xz.x, -10.0, min_xz.y);
float3 bb_max = float3(max_xz.x, 10.0, max_xz.y);
float3 center = (bb_min + bb_max) * 0.5;
float radius = 0.5 * length(bb_max - bb_min);
float3 f0 = float3(dot(v_41.uFrustum[0], float4(center, 1.0)), dot(v_41.uFrustum[1], float4(center, 1.0)), dot(v_41.uFrustum[2], float4(center, 1.0)));
float3 f1 = float3(dot(v_41.uFrustum[3], float4(center, 1.0)), dot(v_41.uFrustum[4], float4(center, 1.0)), dot(v_41.uFrustum[5], float4(center, 1.0)));
float3 _199 = f0;
float _200 = radius;
bool _205 = any(_199 <= float3(-_200));
bool _215;
if (!_205)
{
_215 = any(f1 <= float3(-radius));
}
else
{
_215 = _205;
}
return !_215;
}
float lod_factor(thread const float2& pos_, constant UBO& v_41)
{
float2 pos = pos_ * v_41.uScale.xy;
float3 dist_to_cam = v_41.uCamPos - float3(pos.x, 0.0, pos.y);
float level = log2((length(dist_to_cam) + 9.9999997473787516355514526367188e-05) * v_41.uDistanceMod);
return fast::clamp(level, 0.0, v_41.uMaxTessLevel.x);
}
float4 tess_level(thread const float4& lod, constant UBO& v_41)
{
return exp2(-lod) * v_41.uMaxTessLevel.y;
}
float tess_level(thread const float& lod, constant UBO& v_41)
{
return v_41.uMaxTessLevel.y * exp2(-lod);
}
void compute_tess_levels(thread const float2& p0, constant UBO& v_41, device float2& vOutPatchPosBase, device float4& vPatchLods, device half (&gl_TessLevelOuter)[4], device half (&gl_TessLevelInner)[2])
{
vOutPatchPosBase = p0;
float2 param = p0 + (float2(-0.5) * v_41.uPatchSize);
float l00 = lod_factor(param, v_41);
float2 param_1 = p0 + (float2(0.5, -0.5) * v_41.uPatchSize);
float l10 = lod_factor(param_1, v_41);
float2 param_2 = p0 + (float2(1.5, -0.5) * v_41.uPatchSize);
float l20 = lod_factor(param_2, v_41);
float2 param_3 = p0 + (float2(-0.5, 0.5) * v_41.uPatchSize);
float l01 = lod_factor(param_3, v_41);
float2 param_4 = p0 + (float2(0.5) * v_41.uPatchSize);
float l11 = lod_factor(param_4, v_41);
float2 param_5 = p0 + (float2(1.5, 0.5) * v_41.uPatchSize);
float l21 = lod_factor(param_5, v_41);
float2 param_6 = p0 + (float2(-0.5, 1.5) * v_41.uPatchSize);
float l02 = lod_factor(param_6, v_41);
float2 param_7 = p0 + (float2(0.5, 1.5) * v_41.uPatchSize);
float l12 = lod_factor(param_7, v_41);
float2 param_8 = p0 + (float2(1.5) * v_41.uPatchSize);
float l22 = lod_factor(param_8, v_41);
float4 lods = float4(dot(float4(l01, l11, l02, l12), float4(0.25)), dot(float4(l00, l10, l01, l11), float4(0.25)), dot(float4(l10, l20, l11, l21), float4(0.25)), dot(float4(l11, l21, l12, l22), float4(0.25)));
vPatchLods = lods;
float4 outer_lods = fast::min(lods, lods.yzwx);
float4 param_9 = outer_lods;
float4 levels = tess_level(param_9, v_41);
gl_TessLevelOuter[0] = half(levels.x);
gl_TessLevelOuter[1] = half(levels.y);
gl_TessLevelOuter[2] = half(levels.z);
gl_TessLevelOuter[3] = half(levels.w);
float min_lod = fast::min(fast::min(lods.x, lods.y), fast::min(lods.z, lods.w));
float param_10 = fast::min(min_lod, l11);
float inner = tess_level(param_10, v_41);
gl_TessLevelInner[0] = half(inner);
gl_TessLevelInner[1] = half(inner);
}
kernel void main0(main0_in in [[stage_in]], constant UBO& v_41 [[buffer(0)]], uint gl_InvocationID [[thread_index_in_threadgroup]], uint gl_PrimitiveID [[threadgroup_position_in_grid]], device uint* spvIndirectParams [[buffer(29)]], device main0_patchOut* spvPatchOut [[buffer(27)]], device MTLQuadTessellationFactorsHalf* spvTessLevel [[buffer(26)]], threadgroup main0_in* gl_in [[threadgroup(0)]])
{
device main0_patchOut& patchOut = spvPatchOut[gl_PrimitiveID];
if (gl_InvocationID < spvIndirectParams[0])
gl_in[gl_InvocationID] = in;
threadgroup_barrier(mem_flags::mem_threadgroup);
float2 p0 = gl_in[0].vPatchPosBase;
float2 param = p0;
if (!frustum_cull(param, v_41))
{
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[0] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[1] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[2] = half(-1.0);
spvTessLevel[gl_PrimitiveID].edgeTessellationFactor[3] = half(-1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[0] = half(-1.0);
spvTessLevel[gl_PrimitiveID].insideTessellationFactor[1] = half(-1.0);
}
else
{
float2 param_1 = p0;
compute_tess_levels(param_1, v_41, patchOut.vOutPatchPosBase, patchOut.vPatchLods, spvTessLevel[gl_PrimitiveID].edgeTessellationFactor, spvTessLevel[gl_PrimitiveID].insideTessellationFactor);
}
}

36
3rdparty/spirv-cross/reference/shaders/asm/comp/recompile-block-naming.asm.comp vendored Normal file
View File

@@ -0,0 +1,36 @@
#version 450
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
layout(binding = 0, std430) buffer MyFirstBuffer
{
uint _data[];
} MyFirstBuffer_1;
layout(binding = 0, std430) buffer MySecondBuffer
{
uint _data[];
} MySecondBuffer_1;
layout(binding = 0, std430) buffer MyThirdBuffer
{
uint _data[];
} MyThirdBuffer_1;
void _main()
{
int byteAddrTemp = 0 >> 2;
uvec4 a = uvec4(MyFirstBuffer_1._data[byteAddrTemp], MyFirstBuffer_1._data[byteAddrTemp + 1], MyFirstBuffer_1._data[byteAddrTemp + 2], MyFirstBuffer_1._data[byteAddrTemp + 3]);
int byteAddrTemp_1 = 4 >> 2;
uvec4 b = uvec4(MySecondBuffer_1._data[byteAddrTemp_1], MySecondBuffer_1._data[byteAddrTemp_1 + 1], MySecondBuffer_1._data[byteAddrTemp_1 + 2], MySecondBuffer_1._data[byteAddrTemp_1 + 3]);
int byteAddrTemp_2 = 0 >> 2;
MyThirdBuffer_1._data[byteAddrTemp_2] = (a + b).x;
MyThirdBuffer_1._data[byteAddrTemp_2 + 1] = (a + b).y;
MyThirdBuffer_1._data[byteAddrTemp_2 + 2] = (a + b).z;
MyThirdBuffer_1._data[byteAddrTemp_2 + 3] = (a + b).w;
}
void main()
{
_main();
}

248
3rdparty/spirv-cross/shaders-msl/asm/tesc/tess-fixed-input-array-builtin-array.invalid.asm.tesc vendored Normal file
View File

@@ -0,0 +1,248 @@
; SPIR-V
; Version: 1.0
; Generator: Khronos Glslang Reference Front End; 2
; Bound: 162
; Schema: 0
OpCapability Tessellation
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %hs_main "main" %p_pos %p_1 %i_1 %_entryPointOutput_pos %_entryPointOutput %_patchConstantOutput_EdgeTess %_patchConstantOutput_InsideTess
OpExecutionMode %hs_main OutputVertices 3
OpExecutionMode %hs_main Triangles
OpExecutionMode %hs_main SpacingFractionalOdd
OpExecutionMode %hs_main VertexOrderCw
OpSource HLSL 500
OpName %hs_main "hs_main"
OpName %VertexOutput "VertexOutput"
OpMemberName %VertexOutput 0 "pos"
OpMemberName %VertexOutput 1 "uv"
OpName %HSOut "HSOut"
OpMemberName %HSOut 0 "pos"
OpMemberName %HSOut 1 "uv"
OpName %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ "@hs_main(struct-VertexOutput-vf4-vf21[3];u1;"
OpName %p "p"
OpName %i "i"
OpName %HSConstantOut "HSConstantOut"
OpMemberName %HSConstantOut 0 "EdgeTess"
OpMemberName %HSConstantOut 1 "InsideTess"
OpName %PatchHS_struct_VertexOutput_vf4_vf21_3__ "PatchHS(struct-VertexOutput-vf4-vf21[3];"
OpName %patch "patch"
OpName %output "output"
OpName %p_0 "p"
OpName %p_pos "p.pos"
OpName %VertexOutput_0 "VertexOutput"
OpMemberName %VertexOutput_0 0 "uv"
OpName %p_1 "p"
OpName %i_0 "i"
OpName %i_1 "i"
OpName %flattenTemp "flattenTemp"
OpName %param "param"
OpName %param_0 "param"
OpName %_entryPointOutput_pos "@entryPointOutput.pos"
OpName %HSOut_0 "HSOut"
OpMemberName %HSOut_0 0 "uv"
OpName %_entryPointOutput "@entryPointOutput"
OpName %_patchConstantResult "@patchConstantResult"
OpName %param_1 "param"
OpName %_patchConstantOutput_EdgeTess "@patchConstantOutput.EdgeTess"
OpName %_patchConstantOutput_InsideTess "@patchConstantOutput.InsideTess"
OpName %output_0 "output"
OpDecorate %p_pos BuiltIn Position
OpDecorate %p_1 Location 0
OpDecorate %i_1 BuiltIn InvocationId
OpDecorate %_entryPointOutput_pos BuiltIn Position
OpDecorate %_entryPointOutput Location 0
OpDecorate %_patchConstantOutput_EdgeTess Patch
OpDecorate %_patchConstantOutput_EdgeTess BuiltIn TessLevelOuter
OpDecorate %_patchConstantOutput_InsideTess Patch
OpDecorate %_patchConstantOutput_InsideTess BuiltIn TessLevelInner
%void = OpTypeVoid
%3 = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%v2float = OpTypeVector %float 2
%VertexOutput = OpTypeStruct %v4float %v2float
%uint = OpTypeInt 32 0
%uint_3 = OpConstant %uint 3
%_arr_VertexOutput_uint_3 = OpTypeArray %VertexOutput %uint_3
%_ptr_Function__arr_VertexOutput_uint_3 = OpTypePointer Function %_arr_VertexOutput_uint_3
%_ptr_Function_uint = OpTypePointer Function %uint
%HSOut = OpTypeStruct %v4float %v2float
%16 = OpTypeFunction %HSOut %_ptr_Function__arr_VertexOutput_uint_3 %_ptr_Function_uint
%_arr_float_uint_3 = OpTypeArray %float %uint_3
%HSConstantOut = OpTypeStruct %_arr_float_uint_3 %float
%23 = OpTypeFunction %HSConstantOut %_ptr_Function__arr_VertexOutput_uint_3
%_ptr_Function_HSOut = OpTypePointer Function %HSOut
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_ptr_Function_v4float = OpTypePointer Function %v4float
%int_1 = OpConstant %int 1
%_ptr_Function_v2float = OpTypePointer Function %v2float
%_arr_v4float_uint_3 = OpTypeArray %v4float %uint_3
%_ptr_Input__arr_v4float_uint_3 = OpTypePointer Input %_arr_v4float_uint_3
%p_pos = OpVariable %_ptr_Input__arr_v4float_uint_3 Input
%_ptr_Input_v4float = OpTypePointer Input %v4float
%VertexOutput_0 = OpTypeStruct %v2float
%_arr_VertexOutput_0_uint_3 = OpTypeArray %VertexOutput_0 %uint_3
%_ptr_Input__arr_VertexOutput_0_uint_3 = OpTypePointer Input %_arr_VertexOutput_0_uint_3
%p_1 = OpVariable %_ptr_Input__arr_VertexOutput_0_uint_3 Input
%_ptr_Input_v2float = OpTypePointer Input %v2float
%int_2 = OpConstant %int 2
%_ptr_Input_uint = OpTypePointer Input %uint
%i_1 = OpVariable %_ptr_Input_uint Input
%_ptr_Output__arr_v4float_uint_3 = OpTypePointer Output %_arr_v4float_uint_3
%_entryPointOutput_pos = OpVariable %_ptr_Output__arr_v4float_uint_3 Output
%_ptr_Output_v4float = OpTypePointer Output %v4float
%HSOut_0 = OpTypeStruct %v2float
%_arr_HSOut_0_uint_3 = OpTypeArray %HSOut_0 %uint_3
%_ptr_Output__arr_HSOut_0_uint_3 = OpTypePointer Output %_arr_HSOut_0_uint_3
%_entryPointOutput = OpVariable %_ptr_Output__arr_HSOut_0_uint_3 Output
%_ptr_Output_v2float = OpTypePointer Output %v2float
%uint_2 = OpConstant %uint 2
%uint_1 = OpConstant %uint 1
%uint_0 = OpConstant %uint 0
%bool = OpTypeBool
%_ptr_Function_HSConstantOut = OpTypePointer Function %HSConstantOut
%uint_4 = OpConstant %uint 4
%_arr_float_uint_4 = OpTypeArray %float %uint_4
%_ptr_Output__arr_float_uint_4 = OpTypePointer Output %_arr_float_uint_4
%_patchConstantOutput_EdgeTess = OpVariable %_ptr_Output__arr_float_uint_4 Output
%_ptr_Function_float = OpTypePointer Function %float
%_ptr_Output_float = OpTypePointer Output %float
%_arr_float_uint_2 = OpTypeArray %float %uint_2
%_ptr_Output__arr_float_uint_2 = OpTypePointer Output %_arr_float_uint_2
%_patchConstantOutput_InsideTess = OpVariable %_ptr_Output__arr_float_uint_2 Output
%float_1 = OpConstant %float 1
%hs_main = OpFunction %void None %3
%5 = OpLabel
%p_0 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function
%i_0 = OpVariable %_ptr_Function_uint Function
%flattenTemp = OpVariable %_ptr_Function_HSOut Function
%param = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function
%param_0 = OpVariable %_ptr_Function_uint Function
%_patchConstantResult = OpVariable %_ptr_Function_HSConstantOut Function
%param_1 = OpVariable %_ptr_Function__arr_VertexOutput_uint_3 Function
%50 = OpAccessChain %_ptr_Input_v4float %p_pos %int_0
%51 = OpLoad %v4float %50
%52 = OpAccessChain %_ptr_Function_v4float %p_0 %int_0 %int_0
OpStore %52 %51
%58 = OpAccessChain %_ptr_Input_v2float %p_1 %int_0 %int_0
%59 = OpLoad %v2float %58
%60 = OpAccessChain %_ptr_Function_v2float %p_0 %int_0 %int_1
OpStore %60 %59
%61 = OpAccessChain %_ptr_Input_v4float %p_pos %int_1
%62 = OpLoad %v4float %61
%63 = OpAccessChain %_ptr_Function_v4float %p_0 %int_1 %int_0
OpStore %63 %62
%64 = OpAccessChain %_ptr_Input_v2float %p_1 %int_1 %int_0
%65 = OpLoad %v2float %64
%66 = OpAccessChain %_ptr_Function_v2float %p_0 %int_1 %int_1
OpStore %66 %65
%68 = OpAccessChain %_ptr_Input_v4float %p_pos %int_2
%69 = OpLoad %v4float %68
%70 = OpAccessChain %_ptr_Function_v4float %p_0 %int_2 %int_0
OpStore %70 %69
%71 = OpAccessChain %_ptr_Input_v2float %p_1 %int_2 %int_0
%72 = OpLoad %v2float %71
%73 = OpAccessChain %_ptr_Function_v2float %p_0 %int_2 %int_1
OpStore %73 %72
%77 = OpLoad %uint %i_1
OpStore %i_0 %77
%80 = OpLoad %_arr_VertexOutput_uint_3 %p_0
OpStore %param %80
%82 = OpLoad %uint %i_0
OpStore %param_0 %82
%83 = OpFunctionCall %HSOut %_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ %param %param_0
OpStore %flattenTemp %83
%86 = OpAccessChain %_ptr_Function_v4float %flattenTemp %int_0
%87 = OpLoad %v4float %86
%94 = OpLoad %uint %i_1
%89 = OpAccessChain %_ptr_Output_v4float %_entryPointOutput_pos %94
OpStore %89 %87
%95 = OpAccessChain %_ptr_Function_v2float %flattenTemp %int_1
%96 = OpLoad %v2float %95
%98 = OpAccessChain %_ptr_Output_v2float %_entryPointOutput %94 %int_0
OpStore %98 %96
OpControlBarrier %uint_2 %uint_1 %uint_0
%102 = OpLoad %uint %i_1
%104 = OpIEqual %bool %102 %int_0
OpSelectionMerge %106 None
OpBranchConditional %104 %105 %106
%105 = OpLabel
%110 = OpLoad %_arr_VertexOutput_uint_3 %p_0
OpStore %param_1 %110
%111 = OpFunctionCall %HSConstantOut %PatchHS_struct_VertexOutput_vf4_vf21_3__ %param_1
OpStore %_patchConstantResult %111
%117 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_0
%118 = OpLoad %float %117
%120 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_0
OpStore %120 %118
%121 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_1
%122 = OpLoad %float %121
%123 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_1
OpStore %123 %122
%124 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_0 %int_2
%125 = OpLoad %float %124
%126 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_EdgeTess %int_2
OpStore %126 %125
%130 = OpAccessChain %_ptr_Function_float %_patchConstantResult %int_1
%131 = OpLoad %float %130
%132 = OpAccessChain %_ptr_Output_float %_patchConstantOutput_InsideTess %int_0
OpStore %132 %131
OpBranch %106
%106 = OpLabel
OpReturn
OpFunctionEnd
%_hs_main_struct_VertexOutput_vf4_vf21_3__u1_ = OpFunction %HSOut None %16
%p = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3
%i = OpFunctionParameter %_ptr_Function_uint
%20 = OpLabel
%output = OpVariable %_ptr_Function_HSOut Function
%31 = OpLoad %uint %i
%33 = OpAccessChain %_ptr_Function_v4float %p %31 %int_0
%34 = OpLoad %v4float %33
%35 = OpAccessChain %_ptr_Function_v4float %output %int_0
OpStore %35 %34
%37 = OpLoad %uint %i
%39 = OpAccessChain %_ptr_Function_v2float %p %37 %int_1
%40 = OpLoad %v2float %39
%41 = OpAccessChain %_ptr_Function_v2float %output %int_1
OpStore %41 %40
%42 = OpLoad %HSOut %output
OpReturnValue %42
OpFunctionEnd
%PatchHS_struct_VertexOutput_vf4_vf21_3__ = OpFunction %HSConstantOut None %23
%patch = OpFunctionParameter %_ptr_Function__arr_VertexOutput_uint_3
%26 = OpLabel
%output_0 = OpVariable %_ptr_Function_HSConstantOut Function
%135 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1
%136 = OpLoad %v2float %135
%137 = OpCompositeConstruct %v2float %float_1 %float_1
%138 = OpFAdd %v2float %137 %136
%139 = OpCompositeExtract %float %138 0
%140 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_0
OpStore %140 %139
%141 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1
%142 = OpLoad %v2float %141
%143 = OpCompositeConstruct %v2float %float_1 %float_1
%144 = OpFAdd %v2float %143 %142
%145 = OpCompositeExtract %float %144 0
%146 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_1
OpStore %146 %145
%147 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1
%148 = OpLoad %v2float %147
%149 = OpCompositeConstruct %v2float %float_1 %float_1
%150 = OpFAdd %v2float %149 %148
%151 = OpCompositeExtract %float %150 0
%152 = OpAccessChain %_ptr_Function_float %output_0 %int_0 %int_2
OpStore %152 %151
%153 = OpAccessChain %_ptr_Function_v2float %patch %int_0 %int_1
%154 = OpLoad %v2float %153
%155 = OpCompositeConstruct %v2float %float_1 %float_1
%156 = OpFAdd %v2float %155 %154
%157 = OpCompositeExtract %float %156 0
%158 = OpAccessChain %_ptr_Function_float %output_0 %int_1
OpStore %158 %157
%159 = OpLoad %HSConstantOut %output_0
OpReturnValue %159
OpFunctionEnd

27
3rdparty/spirv-cross/shaders-msl/desktop-only/tesc/arrayed-output.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,27 @@
#version 450
layout(vertices = 4) out;
layout(location = 0) patch out vec3 vPatch[2];
layout(location = 2) out vec3 vVertex[];
layout(location = 0) in vec3 vInput[];
void main()
{
vVertex[gl_InvocationID] =
vInput[gl_InvocationID] +
vInput[gl_InvocationID ^ 1];
barrier();
if (gl_InvocationID == 0)
{
vPatch[0] = vec3(10.0);
vPatch[1] = vec3(20.0);
gl_TessLevelOuter[0] = 1.0;
gl_TessLevelOuter[1] = 2.0;
gl_TessLevelOuter[2] = 3.0;
gl_TessLevelOuter[3] = 4.0;
gl_TessLevelInner[0] = 1.0;
gl_TessLevelInner[1] = 2.0;
}
}

32
3rdparty/spirv-cross/shaders-msl/desktop-only/tesc/basic.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,32 @@
#version 450
layout(vertices = 1) out;
in gl_PerVertex
{
vec4 gl_Position;
} gl_in[gl_MaxPatchVertices];
out gl_PerVertex
{
vec4 gl_Position;
} gl_out[1];
layout(location = 0) patch out vec3 vFoo;
void set_position()
{
gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position;
}
void main()
{
gl_TessLevelInner[0] = 8.9;
gl_TessLevelInner[1] = 6.9;
gl_TessLevelOuter[0] = 8.9;
gl_TessLevelOuter[1] = 6.9;
gl_TessLevelOuter[2] = 3.9;
gl_TessLevelOuter[3] = 4.9;
vFoo = vec3(1.0);
set_position();
}

22
3rdparty/spirv-cross/shaders-msl/desktop-only/tesc/struct-copy.desktop.sso.tesc vendored Normal file
View File

@@ -0,0 +1,22 @@
#version 450
struct Boo
{
vec3 a;
vec3 b;
};
layout(vertices = 4) out;
layout(location = 0) out Boo vVertex[];
layout(location = 0) in Boo vInput[];
void main()
{
vVertex[gl_InvocationID] = vInput[gl_InvocationID];
gl_TessLevelOuter[0] = 1.0;
gl_TessLevelOuter[1] = 2.0;
gl_TessLevelOuter[2] = 3.0;
gl_TessLevelOuter[3] = 4.0;
gl_TessLevelInner[0] = 1.0;
gl_TessLevelInner[1] = 2.0;
}

17
3rdparty/spirv-cross/shaders-msl/tesc/basic.tesc vendored Normal file
View File

@@ -0,0 +1,17 @@
#version 310 es
#extension GL_EXT_tessellation_shader : require
layout(location = 0) patch out vec3 vFoo;
layout(vertices = 1) out;
void main()
{
gl_TessLevelInner[0] = 8.9;
gl_TessLevelInner[1] = 6.9;
gl_TessLevelOuter[0] = 8.9;
gl_TessLevelOuter[1] = 6.9;
gl_TessLevelOuter[2] = 3.9;
gl_TessLevelOuter[3] = 4.9;
vFoo = vec3(1.0);
}

115
3rdparty/spirv-cross/shaders-msl/tesc/water_tess.tesc vendored Normal file
View File

@@ -0,0 +1,115 @@
#version 310 es
#extension GL_EXT_tessellation_shader : require
layout(vertices = 1) out;
layout(location = 0) in vec2 vPatchPosBase[];
layout(std140) uniform UBO
{
vec4 uScale;
highp vec3 uCamPos;
vec2 uPatchSize;
vec2 uMaxTessLevel;
float uDistanceMod;
vec4 uFrustum[6];
};
layout(location = 1) patch out vec2 vOutPatchPosBase;
layout(location = 2) patch out vec4 vPatchLods;
float lod_factor(vec2 pos_)
{
vec2 pos = pos_ * uScale.xy;
vec3 dist_to_cam = uCamPos - vec3(pos.x, 0.0, pos.y);
float level = log2((length(dist_to_cam) + 0.0001) * uDistanceMod);
return clamp(level, 0.0, uMaxTessLevel.x);
}
float tess_level(float lod)
{
return uMaxTessLevel.y * exp2(-lod);
}
vec4 tess_level(vec4 lod)
{
return uMaxTessLevel.y * exp2(-lod);
}
// Guard band for vertex displacement.
#define GUARD_BAND 10.0
bool frustum_cull(vec2 p0)
{
vec2 min_xz = (p0 - GUARD_BAND) * uScale.xy;
vec2 max_xz = (p0 + uPatchSize + GUARD_BAND) * uScale.xy;
vec3 bb_min = vec3(min_xz.x, -GUARD_BAND, min_xz.y);
vec3 bb_max = vec3(max_xz.x, +GUARD_BAND, max_xz.y);
vec3 center = 0.5 * (bb_min + bb_max);
float radius = 0.5 * length(bb_max - bb_min);
vec3 f0 = vec3(
dot(uFrustum[0], vec4(center, 1.0)),
dot(uFrustum[1], vec4(center, 1.0)),
dot(uFrustum[2], vec4(center, 1.0)));
vec3 f1 = vec3(
dot(uFrustum[3], vec4(center, 1.0)),
dot(uFrustum[4], vec4(center, 1.0)),
dot(uFrustum[5], vec4(center, 1.0)));
return !(any(lessThanEqual(f0, vec3(-radius))) || any(lessThanEqual(f1, vec3(-radius))));
}
void compute_tess_levels(vec2 p0)
{
vOutPatchPosBase = p0;
float l00 = lod_factor(p0 + vec2(-0.5, -0.5) * uPatchSize);
float l10 = lod_factor(p0 + vec2(+0.5, -0.5) * uPatchSize);
float l20 = lod_factor(p0 + vec2(+1.5, -0.5) * uPatchSize);
float l01 = lod_factor(p0 + vec2(-0.5, +0.5) * uPatchSize);
float l11 = lod_factor(p0 + vec2(+0.5, +0.5) * uPatchSize);
float l21 = lod_factor(p0 + vec2(+1.5, +0.5) * uPatchSize);
float l02 = lod_factor(p0 + vec2(-0.5, +1.5) * uPatchSize);
float l12 = lod_factor(p0 + vec2(+0.5, +1.5) * uPatchSize);
float l22 = lod_factor(p0 + vec2(+1.5, +1.5) * uPatchSize);
vec4 lods = vec4(
dot(vec4(l01, l11, l02, l12), vec4(0.25)),
dot(vec4(l00, l10, l01, l11), vec4(0.25)),
dot(vec4(l10, l20, l11, l21), vec4(0.25)),
dot(vec4(l11, l21, l12, l22), vec4(0.25)));
vPatchLods = lods;
vec4 outer_lods = min(lods.xyzw, lods.yzwx);
vec4 levels = tess_level(outer_lods);
gl_TessLevelOuter[0] = levels.x;
gl_TessLevelOuter[1] = levels.y;
gl_TessLevelOuter[2] = levels.z;
gl_TessLevelOuter[3] = levels.w;
float min_lod = min(min(lods.x, lods.y), min(lods.z, lods.w));
float inner = tess_level(min(min_lod, l11));
gl_TessLevelInner[0] = inner;
gl_TessLevelInner[1] = inner;
}
void main()
{
vec2 p0 = vPatchPosBase[0];
if (!frustum_cull(p0))
{
gl_TessLevelOuter[0] = -1.0;
gl_TessLevelOuter[1] = -1.0;
gl_TessLevelOuter[2] = -1.0;
gl_TessLevelOuter[3] = -1.0;
gl_TessLevelInner[0] = -1.0;
gl_TessLevelInner[1] = -1.0;
}
else
{
compute_tess_levels(p0);
}
}

140
3rdparty/spirv-cross/shaders/asm/comp/recompile-block-naming.asm.comp vendored Normal file
View File

@@ -0,0 +1,140 @@
; SPIR-V
; Version: 1.0
; Generator: Khronos Glslang Reference Front End; 7
; Bound: 97
; Schema: 0
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
OpExecutionMode %main LocalSize 1 1 1
OpSource HLSL 500
OpName %main "main"
OpName %_main_ "@main("
OpName %a "a"
OpName %byteAddrTemp "byteAddrTemp"
OpName %MyFirstBuffer "MyFirstBuffer"
OpMemberName %MyFirstBuffer 0 "@data"
OpName %MyFirstBuffer_0 "MyFirstBuffer"
OpName %b "b"
OpName %byteAddrTemp_0 "byteAddrTemp"
OpName %MySecondBuffer "MySecondBuffer"
OpName %byteAddrTemp_1 "byteAddrTemp"
OpName %MyThirdBuffer "MyThirdBuffer"
OpDecorate %_runtimearr_uint ArrayStride 4
OpMemberDecorate %MyFirstBuffer 0 Offset 0
OpDecorate %MyFirstBuffer BufferBlock
OpDecorate %MyFirstBuffer_0 DescriptorSet 0
OpDecorate %MyFirstBuffer_0 Binding 0
OpDecorate %MySecondBuffer DescriptorSet 0
OpDecorate %MySecondBuffer Binding 0
OpDecorate %MyThirdBuffer DescriptorSet 0
OpDecorate %MyThirdBuffer Binding 0
%void = OpTypeVoid
%3 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%v4uint = OpTypeVector %uint 4
%_ptr_Function_v4uint = OpTypePointer Function %v4uint
%int = OpTypeInt 32 1
%_ptr_Function_int = OpTypePointer Function %int
%int_0 = OpConstant %int 0
%int_2 = OpConstant %int 2
%_runtimearr_uint = OpTypeRuntimeArray %uint
%MyFirstBuffer = OpTypeStruct %_runtimearr_uint
%_ptr_Uniform_MyFirstBuffer = OpTypePointer Uniform %MyFirstBuffer
%MyFirstBuffer_0 = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform
%_ptr_Uniform_uint = OpTypePointer Uniform %uint
%int_1 = OpConstant %int 1
%int_3 = OpConstant %int 3
%int_4 = OpConstant %int 4
%MySecondBuffer = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform
%MyThirdBuffer = OpVariable %_ptr_Uniform_MyFirstBuffer Uniform
%uint_0 = OpConstant %uint 0
%uint_1 = OpConstant %uint 1
%uint_2 = OpConstant %uint 2
%uint_3 = OpConstant %uint 3
%main = OpFunction %void None %3
%5 = OpLabel
%96 = OpFunctionCall %void %_main_
OpReturn
OpFunctionEnd
%_main_ = OpFunction %void None %3
%7 = OpLabel
%a = OpVariable %_ptr_Function_v4uint Function
%byteAddrTemp = OpVariable %_ptr_Function_int Function
%b = OpVariable %_ptr_Function_v4uint Function
%byteAddrTemp_0 = OpVariable %_ptr_Function_int Function
%byteAddrTemp_1 = OpVariable %_ptr_Function_int Function
%17 = OpShiftRightArithmetic %int %int_0 %int_2
OpStore %byteAddrTemp %17
%22 = OpLoad %int %byteAddrTemp
%24 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %22
%25 = OpLoad %uint %24
%26 = OpLoad %int %byteAddrTemp
%28 = OpIAdd %int %26 %int_1
%29 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %28
%30 = OpLoad %uint %29
%31 = OpLoad %int %byteAddrTemp
%32 = OpIAdd %int %31 %int_2
%33 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %32
%34 = OpLoad %uint %33
%35 = OpLoad %int %byteAddrTemp
%37 = OpIAdd %int %35 %int_3
%38 = OpAccessChain %_ptr_Uniform_uint %MyFirstBuffer_0 %int_0 %37
%39 = OpLoad %uint %38
%40 = OpCompositeConstruct %v4uint %25 %30 %34 %39
OpStore %a %40
%44 = OpShiftRightArithmetic %int %int_4 %int_2
OpStore %byteAddrTemp_0 %44
%46 = OpLoad %int %byteAddrTemp_0
%47 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %46
%48 = OpLoad %uint %47
%49 = OpLoad %int %byteAddrTemp_0
%50 = OpIAdd %int %49 %int_1
%51 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %50
%52 = OpLoad %uint %51
%53 = OpLoad %int %byteAddrTemp_0
%54 = OpIAdd %int %53 %int_2
%55 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %54
%56 = OpLoad %uint %55
%57 = OpLoad %int %byteAddrTemp_0
%58 = OpIAdd %int %57 %int_3
%59 = OpAccessChain %_ptr_Uniform_uint %MySecondBuffer %int_0 %58
%60 = OpLoad %uint %59
%61 = OpCompositeConstruct %v4uint %48 %52 %56 %60
OpStore %b %61
%63 = OpShiftRightArithmetic %int %int_0 %int_2
OpStore %byteAddrTemp_1 %63
%65 = OpLoad %int %byteAddrTemp_1
%66 = OpLoad %v4uint %a
%67 = OpLoad %v4uint %b
%68 = OpIAdd %v4uint %66 %67
%70 = OpCompositeExtract %uint %68 0
%71 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %65
OpStore %71 %70
%72 = OpLoad %int %byteAddrTemp_1
%73 = OpIAdd %int %72 %int_1
%74 = OpLoad %v4uint %a
%75 = OpLoad %v4uint %b
%76 = OpIAdd %v4uint %74 %75
%78 = OpCompositeExtract %uint %76 1
%79 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %73
OpStore %79 %78
%80 = OpLoad %int %byteAddrTemp_1
%81 = OpIAdd %int %80 %int_2
%82 = OpLoad %v4uint %a
%83 = OpLoad %v4uint %b
%84 = OpIAdd %v4uint %82 %83
%86 = OpCompositeExtract %uint %84 2
%87 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %81
OpStore %87 %86
%88 = OpLoad %int %byteAddrTemp_1
%89 = OpIAdd %int %88 %int_3
%90 = OpLoad %v4uint %a
%91 = OpLoad %v4uint %b
%92 = OpIAdd %v4uint %90 %91
%94 = OpCompositeExtract %uint %92 3
%95 = OpAccessChain %_ptr_Uniform_uint %MyThirdBuffer %int_0 %89
OpStore %95 %94
OpReturn
OpFunctionEnd

2
3rdparty/spirv-cross/spirv_common.hpp vendored
View File

@@ -1381,6 +1381,8 @@ struct Meta
{
uint32_t packed_type = 0;
bool packed = false;
uint32_t ib_member_index = -1;
uint32_t ib_orig_id = 0;
} extended;
};

74
3rdparty/spirv-cross/spirv_cross.cpp vendored
View File

@@ -1094,6 +1094,22 @@ const SPIRType &Compiler::get_variable_data_type(const SPIRVariable &var) const
return get<SPIRType>(get_variable_data_type_id(var));
}
SPIRType &Compiler::get_variable_element_type(const SPIRVariable &var)
{
SPIRType *type = &get_variable_data_type(var);
if (is_array(*type))
type = &get<SPIRType>(type->parent_type);
return *type;
}
const SPIRType &Compiler::get_variable_element_type(const SPIRVariable &var) const
{
const SPIRType *type = &get_variable_data_type(var);
if (is_array(*type))
type = &get<SPIRType>(type->parent_type);
return *type;
}
bool Compiler::is_sampled_image_type(const SPIRType &type)
{
return (type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage) && type.image.sampled == 1 &&
@@ -1183,6 +1199,14 @@ void Compiler::set_extended_decoration(uint32_t id, ExtendedDecorations decorati
case SPIRVCrossDecorationPackedType:
dec.extended.packed_type = value;
break;
case SPIRVCrossDecorationInterfaceMemberIndex:
dec.extended.ib_member_index = value;
break;
case SPIRVCrossDecorationInterfaceOrigID:
dec.extended.ib_orig_id = value;
break;
}
}
@@ -1201,6 +1225,14 @@ void Compiler::set_extended_member_decoration(uint32_t type, uint32_t index, Ext
case SPIRVCrossDecorationPackedType:
dec.extended.packed_type = value;
break;
case SPIRVCrossDecorationInterfaceMemberIndex:
dec.extended.ib_member_index = value;
break;
case SPIRVCrossDecorationInterfaceOrigID:
dec.extended.ib_orig_id = value;
break;
}
}
@@ -1218,6 +1250,12 @@ uint32_t Compiler::get_extended_decoration(uint32_t id, ExtendedDecorations deco
case SPIRVCrossDecorationPackedType:
return dec.extended.packed_type;
case SPIRVCrossDecorationInterfaceMemberIndex:
return dec.extended.ib_member_index;
case SPIRVCrossDecorationInterfaceOrigID:
return dec.extended.ib_orig_id;
}
return 0;
@@ -1240,6 +1278,12 @@ uint32_t Compiler::get_extended_member_decoration(uint32_t type, uint32_t index,
case SPIRVCrossDecorationPackedType:
return dec.extended.packed_type;
case SPIRVCrossDecorationInterfaceMemberIndex:
return dec.extended.ib_member_index;
case SPIRVCrossDecorationInterfaceOrigID:
return dec.extended.ib_orig_id;
}
return 0;
@@ -1259,6 +1303,12 @@ bool Compiler::has_extended_decoration(uint32_t id, ExtendedDecorations decorati
case SPIRVCrossDecorationPackedType:
return dec.extended.packed_type != 0;
case SPIRVCrossDecorationInterfaceMemberIndex:
return dec.extended.ib_member_index != uint32_t(-1);
case SPIRVCrossDecorationInterfaceOrigID:
return dec.extended.ib_orig_id != 0;
}
return false;
@@ -1281,6 +1331,12 @@ bool Compiler::has_extended_member_decoration(uint32_t type, uint32_t index, Ext
case SPIRVCrossDecorationPackedType:
return dec.extended.packed_type != 0;
case SPIRVCrossDecorationInterfaceMemberIndex:
return dec.extended.ib_member_index != uint32_t(-1);
case SPIRVCrossDecorationInterfaceOrigID:
return dec.extended.ib_orig_id != 0;
}
return false;
@@ -1298,6 +1354,14 @@ void Compiler::unset_extended_decoration(uint32_t id, ExtendedDecorations decora
case SPIRVCrossDecorationPackedType:
dec.extended.packed_type = 0;
break;
case SPIRVCrossDecorationInterfaceMemberIndex:
dec.extended.ib_member_index = -1;
break;
case SPIRVCrossDecorationInterfaceOrigID:
dec.extended.ib_orig_id = 0;
break;
}
}
@@ -1315,6 +1379,14 @@ void Compiler::unset_extended_member_decoration(uint32_t type, uint32_t index, E
case SPIRVCrossDecorationPackedType:
dec.extended.packed_type = 0;
break;
case SPIRVCrossDecorationInterfaceMemberIndex:
dec.extended.ib_member_index = -1;
break;
case SPIRVCrossDecorationInterfaceOrigID:
dec.extended.ib_orig_id = 0;
break;
}
}
@@ -3527,7 +3599,7 @@ bool Compiler::ActiveBuiltinHandler::handle(spv::Op opcode, const uint32_t *args
auto *type = &compiler.get_variable_data_type(*var);
auto &flags =
type->storage == StorageClassInput ? compiler.active_input_builtins : compiler.active_output_builtins;
var->storage == StorageClassInput ? compiler.active_input_builtins : compiler.active_output_builtins;
uint32_t count = length - 3;
args += 3;

52
3rdparty/spirv-cross/spirv_cross.hpp vendored
View File

@@ -117,7 +117,9 @@ struct EntryPoint
enum ExtendedDecorations
{
SPIRVCrossDecorationPacked,
SPIRVCrossDecorationPackedType
SPIRVCrossDecorationPackedType,
SPIRVCrossDecorationInterfaceMemberIndex,
SPIRVCrossDecorationInterfaceOrigID,
};
class Compiler
@@ -183,27 +185,6 @@ public:
// Gets the SPIR-V type of a variable.
const SPIRType &get_type_from_variable(uint32_t id) const;
// Gets the id of SPIR-V type underlying the given type_id, which might be a pointer.
uint32_t get_pointee_type_id(uint32_t type_id) const;
// Gets the SPIR-V type underlying the given type, which might be a pointer.
const SPIRType &get_pointee_type(const SPIRType &type) const;
// Gets the SPIR-V type underlying the given type_id, which might be a pointer.
const SPIRType &get_pointee_type(uint32_t type_id) const;
// Gets the ID of the SPIR-V type underlying a variable.
uint32_t get_variable_data_type_id(const SPIRVariable &var) const;
// Gets the SPIR-V type underlying a variable.
SPIRType &get_variable_data_type(const SPIRVariable &var);
// Gets the SPIR-V type underlying a variable.
const SPIRType &get_variable_data_type(const SPIRVariable &var) const;
// Returns if the given type refers to a sampled image.
bool is_sampled_image_type(const SPIRType &type);
// Gets the underlying storage class for an OpVariable.
spv::StorageClass get_storage_class(uint32_t id) const;
@@ -603,6 +584,33 @@ protected:
return nullptr;
}
// Gets the id of SPIR-V type underlying the given type_id, which might be a pointer.
uint32_t get_pointee_type_id(uint32_t type_id) const;
// Gets the SPIR-V type underlying the given type, which might be a pointer.
const SPIRType &get_pointee_type(const SPIRType &type) const;
// Gets the SPIR-V type underlying the given type_id, which might be a pointer.
const SPIRType &get_pointee_type(uint32_t type_id) const;
// Gets the ID of the SPIR-V type underlying a variable.
uint32_t get_variable_data_type_id(const SPIRVariable &var) const;
// Gets the SPIR-V type underlying a variable.
SPIRType &get_variable_data_type(const SPIRVariable &var);
// Gets the SPIR-V type underlying a variable.
const SPIRType &get_variable_data_type(const SPIRVariable &var) const;
// Gets the SPIR-V element type underlying an array variable.
SPIRType &get_variable_element_type(const SPIRVariable &var);
// Gets the SPIR-V element type underlying an array variable.
const SPIRType &get_variable_element_type(const SPIRVariable &var) const;
// Returns if the given type refers to a sampled image.
bool is_sampled_image_type(const SPIRType &type);
const SPIREntryPoint &get_entry_point() const;
SPIREntryPoint &get_entry_point();

32
3rdparty/spirv-cross/spirv_glsl.cpp vendored
View File

@@ -262,13 +262,7 @@ void CompilerGLSL::reset()
expression_usage_counts.clear();
forwarded_temporaries.clear();
resource_names.clear();
block_input_names.clear();
block_output_names.clear();
block_ubo_names.clear();
block_ssbo_names.clear();
block_names.clear();
function_overloads.clear();
reset_name_caches();
ir.for_each_typed_id<SPIRFunction>([&](uint32_t, SPIRFunction &func) {
func.active = false;
@@ -1561,6 +1555,10 @@ void CompilerGLSL::emit_buffer_block_native(const SPIRVariable &var)
i++;
}
// var.self can be used as a backup name for the block name,
// so we need to make sure we don't disturb the name here on a recompile.
// It will need to be reset if we have to recompile.
preserve_alias_on_reset(var.self);
add_resource_name(var.self);
end_scope_decl(to_name(var.self) + type_to_array_glsl(type));
statement("");
@@ -10984,3 +10982,23 @@ void CompilerGLSL::bitcast_to_builtin_store(uint32_t target_id, std::string &exp
void CompilerGLSL::emit_block_hints(const SPIRBlock &)
{
}
void CompilerGLSL::preserve_alias_on_reset(uint32_t id)
{
preserved_aliases[id] = get_name(id);
}
void CompilerGLSL::reset_name_caches()
{
for (auto &preserved : preserved_aliases)
set_name(preserved.first, preserved.second);
preserved_aliases.clear();
resource_names.clear();
block_input_names.clear();
block_output_names.clear();
block_ubo_names.clear();
block_ssbo_names.clear();
block_names.clear();
function_overloads.clear();
}

3
3rdparty/spirv-cross/spirv_glsl.hpp vendored
View File

@@ -358,6 +358,9 @@ protected:
std::unordered_set<std::string> block_ssbo_names;
std::unordered_set<std::string> block_names; // A union of all block_*_names.
std::unordered_map<std::string, std::unordered_set<uint64_t>> function_overloads;
std::unordered_map<uint32_t, std::string> preserved_aliases;
void preserve_alias_on_reset(uint32_t id);
void reset_name_caches();
bool processing_entry_point = false;

4
3rdparty/spirv-cross/spirv_hlsl.cpp vendored
View File

@@ -1838,6 +1838,10 @@ void CompilerHLSL::emit_buffer_block(const SPIRVariable &var)
declared_block_names[var.self] = buffer_name;
type.member_name_cache.clear();
// var.self can be used as a backup name for the block name,
// so we need to make sure we don't disturb the name here on a recompile.
// It will need to be reset if we have to recompile.
preserve_alias_on_reset(var.self);
add_resource_name(var.self);
statement("cbuffer ", buffer_name, to_resource_binding(var));
begin_scope();

852
3rdparty/spirv-cross/spirv_msl.cpp vendored
View File

File diff suppressed because it is too large Load Diff

53
3rdparty/spirv-cross/spirv_msl.hpp vendored
View File

@@ -170,6 +170,9 @@ public:
uint32_t aux_buffer_index = 30;
uint32_t indirect_params_buffer_index = 29;
uint32_t shader_output_buffer_index = 28;
uint32_t shader_patch_output_buffer_index = 27;
uint32_t shader_tess_factor_buffer_index = 26;
uint32_t shader_input_wg_index = 0;
bool enable_point_size_builtin = true;
bool disable_rasterization = false;
bool capture_output_to_buffer = false;
@@ -231,7 +234,8 @@ public:
// rasterization if vertex shader requires rasterization to be disabled.
bool get_is_rasterization_disabled() const
{
return is_rasterization_disabled && (get_entry_point().model == spv::ExecutionModelVertex);
return is_rasterization_disabled && (get_entry_point().model == spv::ExecutionModelVertex ||
get_entry_point().model == spv::ExecutionModelTessellationControl);
}
// Provide feedback to calling API to allow it to pass an auxiliary
@@ -248,6 +252,20 @@ public:
return capture_output_to_buffer && stage_out_var_id != 0;
}
// Provide feedback to calling API to allow it to pass a patch output
// buffer if the shader needs it.
bool needs_patch_output_buffer() const
{
return capture_output_to_buffer && patch_stage_out_var_id != 0;
}
// Provide feedback to calling API to allow it to pass an input threadgroup
// buffer if the shader needs it.
bool needs_input_threadgroup_mem() const
{
return capture_output_to_buffer && stage_in_var_id != 0;
}
// An enum of SPIR-V functions that are implemented in additional
// source code that is added to the shader if necessary.
enum SPVFuncImpl
@@ -384,19 +402,24 @@ protected:
void extract_global_variables_from_function(uint32_t func_id, std::set<uint32_t> &added_arg_ids,
std::unordered_set<uint32_t> &global_var_ids,
std::unordered_set<uint32_t> &processed_func_ids);
uint32_t add_interface_block(spv::StorageClass storage);
uint32_t add_interface_block(spv::StorageClass storage, bool patch = false);
uint32_t add_interface_block_pointer(uint32_t ib_var_id, spv::StorageClass storage);
void add_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type,
SPIRVariable &var);
SPIRVariable &var, bool strip_array);
void add_composite_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
SPIRType &ib_type, SPIRVariable &var);
SPIRType &ib_type, SPIRVariable &var, bool strip_array);
void add_plain_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
SPIRType &ib_type, SPIRVariable &var);
SPIRType &ib_type, SPIRVariable &var, bool strip_array);
void add_plain_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
SPIRType &ib_type, SPIRVariable &var, uint32_t index);
SPIRType &ib_type, SPIRVariable &var, uint32_t index,
bool strip_array);
void add_composite_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
SPIRType &ib_type, SPIRVariable &var, uint32_t index);
uint32_t get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx);
SPIRType &ib_type, SPIRVariable &var, uint32_t index,
bool strip_array);
uint32_t get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array);
void fix_up_interface_member_indices(spv::StorageClass storage, uint32_t ib_type_id);
void mark_location_as_used_by_shader(uint32_t location, spv::StorageClass storage);
uint32_t ensure_correct_builtin_type(uint32_t type_id, spv::BuiltIn builtin);
@@ -431,7 +454,10 @@ protected:
MSLStructMemberKey get_struct_member_key(uint32_t type_id, uint32_t index);
std::string get_argument_address_space(const SPIRVariable &argument);
std::string get_type_address_space(const SPIRType &type);
SPIRType &get_stage_in_struct_type();
SPIRType &get_stage_out_struct_type();
SPIRType &get_patch_stage_out_struct_type();
std::string get_tess_factor_struct_name();
void emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1,
uint32_t mem_order_2, bool has_mem_order_2, uint32_t op0, uint32_t op1 = 0,
bool op1_is_pointer = false, bool op1_is_literal = false, uint32_t op2 = 0);
@@ -448,6 +474,8 @@ protected:
uint32_t builtin_base_vertex_id = 0;
uint32_t builtin_instance_idx_id = 0;
uint32_t builtin_base_instance_id = 0;
uint32_t builtin_invocation_id_id = 0;
uint32_t builtin_primitive_id_id = 0;
uint32_t aux_buffer_id = 0;
void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) override;
@@ -456,6 +484,8 @@ protected:
void analyze_sampled_image_usage();
bool emit_tessellation_control_access_chain(const uint32_t *ops, uint32_t length);
Options msl_options;
std::set<SPVFuncImpl> spv_function_implementations;
std::unordered_map<uint32_t, MSLVertexAttr *> vtx_attrs_by_location;
@@ -468,6 +498,9 @@ protected:
MSLResourceBinding next_metal_resource_index;
uint32_t stage_in_var_id = 0;
uint32_t stage_out_var_id = 0;
uint32_t patch_stage_out_var_id = 0;
uint32_t stage_in_ptr_var_id = 0;
uint32_t stage_out_ptr_var_id = 0;
bool has_sampled_images = false;
bool needs_vertex_idx_arg = false;
bool needs_instance_idx_arg = false;
@@ -478,9 +511,13 @@ protected:
std::string qual_pos_var_name;
std::string stage_in_var_name = "in";
std::string stage_out_var_name = "out";
std::string patch_stage_out_var_name = "patchOut";
std::string sampler_name_suffix = "Smplr";
std::string swizzle_name_suffix = "Swzl";
std::string input_wg_var_name = "gl_in";
std::string output_buffer_var_name = "spvOut";
std::string patch_output_buffer_var_name = "spvPatchOut";
std::string tess_factor_buffer_var_name = "spvTessLevel";
spv::Op previous_instruction_opcode = spv::OpNop;
std::unordered_map<uint32_t, MSLConstexprSampler> constexpr_samplers;