encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test/benchmark: Add more shaders to the corpus 

Kindly donated by Brandon Jones and Austin Eng.
Tint has been used to convert all the deprecated attributes to the new style. In doing so, comments have been stripped. These are not massively important for the benchmarking.

Bindings have also been adjusted to be sequential and unique so that the MSL backend doesn't have to deal with binding remapping.

Existing benchmark files that used an underscore '_' have been renamed to use a dash '-' instead, to match the new files.

Change-Id: If5fb507b981f107ed570f6eedb55b232448f67aa
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/77443
Reviewed-by: Brandon Jones <bajones@google.com>
Reviewed-by: Austin Eng <enga@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
This commit is contained in:
Ben Clayton 2022-01-21 22:38:16 +00:00 committed by Tint LUCI CQ
parent a2f4134c56
commit 73ced33dfb
63 changed files with 9341 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/benchmark/benchmark.h
View File

@ -57,12 +57,19 @@ std::variant<ProgramAndFile, Error> LoadProgram(std::string name);
/// Declares a set of benchmarks for the given function using a list of WGSL
/// files in `<tint>/test/benchmark`.
#define TINT_BENCHMARK_WGSL_PROGRAMS(FUNC) \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "empty.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "particles.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple_fragment.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple_vertex.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple_compute.wgsl");
#define TINT_BENCHMARK_WGSL_PROGRAMS(FUNC) \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "animometer.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "bloom-vertical-blur.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "cluster-lights.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "empty.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "metaball-isosurface.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "particles.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "shadow-fragment.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple-compute.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple-fragment.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "simple-vertex.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "skinned-shadowed-pbr-fragment.wgsl"); \
TINT_BENCHMARK_WGSL_PROGRAM(FUNC, "skinned-shadowed-pbr-vertex.wgsl");
} // namespace tint::benchmark

48
test/benchmark/animometer.wgsl Normal file
View File

@ -0,0 +1,48 @@
struct Time {
value : f32;
}
struct Uniforms {
scale : f32;
offsetX : f32;
offsetY : f32;
scalar : f32;
scalarOffset : f32;
}
@binding(0) @group(0) var<uniform> time : Time;
@binding(1) @group(0) var<uniform> uniforms : Uniforms;
struct VertexOutput {
@builtin(position)
Position : vec4<f32>;
@location(0)
v_color : vec4<f32>;
}
@stage(vertex)
fn vert_main(@location(0) position : vec4<f32>, @location(1) color : vec4<f32>) -> VertexOutput {
var fade : f32 = ((uniforms.scalarOffset + ((time.value * uniforms.scalar) / 10.0)) % 1.0);
if ((fade < 0.5)) {
fade = (fade * 2.0);
} else {
fade = ((1.0 - fade) * 2.0);
}
var xpos : f32 = (position.x * uniforms.scale);
var ypos : f32 = (position.y * uniforms.scale);
var angle : f32 = ((3.141590118 * 2.0) * fade);
var xrot : f32 = ((xpos * cos(angle)) - (ypos * sin(angle)));
var yrot : f32 = ((xpos * sin(angle)) + (ypos * cos(angle)));
xpos = (xrot + uniforms.offsetX);
ypos = (yrot + uniforms.offsetY);
var output : VertexOutput;
output.v_color = (vec4<f32>(fade, (1.0 - fade), 0.0, 1.0) + color);
output.Position = vec4<f32>(xpos, ypos, 0.0, 1.0);
return output;
}
@stage(fragment)
fn frag_main(@location(0) v_color : vec4<f32>) -> @location(0) vec4<f32> {
return v_color;
}

149
test/benchmark/animometer.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,149 @@
SKIP: FAILED
#version 310 es
precision mediump float;
struct Time {
float value;
};
struct Uniforms {
float scale;
float offsetX;
float offsetY;
float scalar;
float scalarOffset;
};
layout (binding = 0) uniform Time_1 {
float value;
} time;
layout (binding = 1) uniform Uniforms_1 {
float scale;
float offsetX;
float offsetY;
float scalar;
float scalarOffset;
} uniforms;
struct VertexOutput {
vec4 Position;
vec4 v_color;
};
struct tint_symbol_2 {
vec4 position;
vec4 color;
};
struct tint_symbol_3 {
vec4 v_color;
vec4 Position;
};
VertexOutput vert_main_inner(vec4 position, vec4 color) {
float fade = ((uniforms.scalarOffset + ((time.value * uniforms.scalar) / 10.0f)) % 1.0f);
if ((fade < 0.5f)) {
fade = (fade * 2.0f);
} else {
fade = ((1.0f - fade) * 2.0f);
}
float xpos = (position.x * uniforms.scale);
float ypos = (position.y * uniforms.scale);
float angle = ((3.141590118f * 2.0f) * fade);
float xrot = ((xpos * cos(angle)) - (ypos * sin(angle)));
float yrot = ((xpos * sin(angle)) + (ypos * cos(angle)));
xpos = (xrot + uniforms.offsetX);
ypos = (yrot + uniforms.offsetY);
VertexOutput tint_symbol = VertexOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
tint_symbol.v_color = (vec4(fade, (1.0f - fade), 0.0f, 1.0f) + color);
tint_symbol.Position = vec4(xpos, ypos, 0.0f, 1.0f);
return tint_symbol;
}
struct tint_symbol_5 {
vec4 v_color;
};
struct tint_symbol_6 {
vec4 value;
};
tint_symbol_3 vert_main(tint_symbol_2 tint_symbol_1) {
VertexOutput inner_result = vert_main_inner(tint_symbol_1.position, tint_symbol_1.color);
tint_symbol_3 wrapper_result = tint_symbol_3(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.Position = inner_result.Position;
wrapper_result.v_color = inner_result.v_color;
return wrapper_result;
}
in vec4 position;
in vec4 color;
out vec4 v_color;
void main() {
tint_symbol_2 inputs;
inputs.position = position;
inputs.color = color;
tint_symbol_3 outputs;
outputs = vert_main(inputs);
v_color = outputs.v_color;
gl_Position = outputs.Position;
gl_Position.y = -gl_Position.y;
}
Error parsing GLSL shader:
ERROR: 0:40: '%' : wrong operand types: no operation '%' exists that takes a left-hand operand of type ' temp mediump float' and a right operand of type ' const float' (or there is no acceptable conversion)
ERROR: 0:40: '' : compilation terminated
ERROR: 2 compilation errors. No code generated.
#version 310 es
precision mediump float;
struct Time {
float value;
};
struct Uniforms {
float scale;
float offsetX;
float offsetY;
float scalar;
float scalarOffset;
};
struct VertexOutput {
vec4 Position;
vec4 v_color;
};
struct tint_symbol_2 {
vec4 position;
vec4 color;
};
struct tint_symbol_3 {
vec4 v_color;
vec4 Position;
};
struct tint_symbol_5 {
vec4 v_color;
};
struct tint_symbol_6 {
vec4 value;
};
vec4 frag_main_inner(vec4 v_color) {
return v_color;
}
tint_symbol_6 frag_main(tint_symbol_5 tint_symbol_4) {
vec4 inner_result_1 = frag_main_inner(tint_symbol_4.v_color);
tint_symbol_6 wrapper_result_1 = tint_symbol_6(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}
in vec4 v_color;
out vec4 value;
void main() {
tint_symbol_5 inputs;
inputs.v_color = v_color;
tint_symbol_6 outputs;
outputs = frag_main(inputs);
value = outputs.value;
}

65
test/benchmark/animometer.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,65 @@
cbuffer cbuffer_time : register(b0, space0) {
uint4 time[1];
};
cbuffer cbuffer_uniforms : register(b1, space0) {
uint4 uniforms[2];
};
struct VertexOutput {
float4 Position;
float4 v_color;
};
struct tint_symbol_1 {
float4 position : TEXCOORD0;
float4 color : TEXCOORD1;
};
struct tint_symbol_2 {
float4 v_color : TEXCOORD0;
float4 Position : SV_Position;
};
VertexOutput vert_main_inner(float4 position, float4 color) {
float fade = ((asfloat(uniforms[1].x) + ((asfloat(time[0].x) * asfloat(uniforms[0].w)) / 10.0f)) % 1.0f);
if ((fade < 0.5f)) {
fade = (fade * 2.0f);
} else {
fade = ((1.0f - fade) * 2.0f);
}
float xpos = (position.x * asfloat(uniforms[0].x));
float ypos = (position.y * asfloat(uniforms[0].x));
float angle = ((3.141590118f * 2.0f) * fade);
float xrot = ((xpos * cos(angle)) - (ypos * sin(angle)));
float yrot = ((xpos * sin(angle)) + (ypos * cos(angle)));
xpos = (xrot + asfloat(uniforms[0].y));
ypos = (yrot + asfloat(uniforms[0].z));
VertexOutput output = (VertexOutput)0;
output.v_color = (float4(fade, (1.0f - fade), 0.0f, 1.0f) + color);
output.Position = float4(xpos, ypos, 0.0f, 1.0f);
return output;
}
tint_symbol_2 vert_main(tint_symbol_1 tint_symbol) {
const VertexOutput inner_result = vert_main_inner(tint_symbol.position, tint_symbol.color);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.Position = inner_result.Position;
wrapper_result.v_color = inner_result.v_color;
return wrapper_result;
}
struct tint_symbol_4 {
float4 v_color : TEXCOORD0;
};
struct tint_symbol_5 {
float4 value : SV_Target0;
};
float4 frag_main_inner(float4 v_color) {
return v_color;
}
tint_symbol_5 frag_main(tint_symbol_4 tint_symbol_3) {
const float4 inner_result_1 = frag_main_inner(tint_symbol_3.v_color);
tint_symbol_5 wrapper_result_1 = (tint_symbol_5)0;
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}

71
test/benchmark/animometer.wgsl.expected.msl Normal file
View File

@ -0,0 +1,71 @@
#include <metal_stdlib>
using namespace metal;
struct Time {
/* 0x0000 */ float value;
};
struct Uniforms {
/* 0x0000 */ float scale;
/* 0x0004 */ float offsetX;
/* 0x0008 */ float offsetY;
/* 0x000c */ float scalar;
/* 0x0010 */ float scalarOffset;
};
struct VertexOutput {
float4 Position;
float4 v_color;
};
struct tint_symbol_1 {
float4 position [[attribute(0)]];
float4 color [[attribute(1)]];
};
struct tint_symbol_2 {
float4 v_color [[user(locn0)]];
float4 Position [[position]];
};
struct tint_symbol_4 {
float4 v_color [[user(locn0)]];
};
struct tint_symbol_5 {
float4 value [[color(0)]];
};
VertexOutput vert_main_inner(float4 position, float4 color, const constant Uniforms* const tint_symbol_6, const constant Time* const tint_symbol_7) {
float fade = fmod(((*(tint_symbol_6)).scalarOffset + (((*(tint_symbol_7)).value * (*(tint_symbol_6)).scalar) / 10.0f)), 1.0f);
if ((fade < 0.5f)) {
fade = (fade * 2.0f);
} else {
fade = ((1.0f - fade) * 2.0f);
}
float xpos = (position[0] * (*(tint_symbol_6)).scale);
float ypos = (position[1] * (*(tint_symbol_6)).scale);
float angle = ((3.141590118f * 2.0f) * fade);
float xrot = ((xpos * cos(angle)) - (ypos * sin(angle)));
float yrot = ((xpos * sin(angle)) + (ypos * cos(angle)));
xpos = (xrot + (*(tint_symbol_6)).offsetX);
ypos = (yrot + (*(tint_symbol_6)).offsetY);
VertexOutput output = {};
output.v_color = (float4(fade, (1.0f - fade), 0.0f, 1.0f) + color);
output.Position = float4(xpos, ypos, 0.0f, 1.0f);
return output;
}
vertex tint_symbol_2 vert_main(const constant Uniforms* tint_symbol_8 [[buffer(0)]], const constant Time* tint_symbol_9 [[buffer(1)]], tint_symbol_1 tint_symbol [[stage_in]]) {
VertexOutput const inner_result = vert_main_inner(tint_symbol.position, tint_symbol.color, tint_symbol_8, tint_symbol_9);
tint_symbol_2 wrapper_result = {};
wrapper_result.Position = inner_result.Position;
wrapper_result.v_color = inner_result.v_color;
return wrapper_result;
}
float4 frag_main_inner(float4 v_color) {
return v_color;
}
fragment tint_symbol_5 frag_main(tint_symbol_4 tint_symbol_3 [[stage_in]]) {
float4 const inner_result_1 = frag_main_inner(tint_symbol_3.v_color);
tint_symbol_5 wrapper_result_1 = {};
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}

232
test/benchmark/animometer.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,232 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 138
; Schema: 0
OpCapability Shader
%76 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vert_main "vert_main" %position_1 %color_1 %Position_1 %v_color_1 %vertex_point_size
OpEntryPoint Fragment %frag_main "frag_main" %v_color_2 %value_1
OpExecutionMode %frag_main OriginUpperLeft
OpName %position_1 "position_1"
OpName %color_1 "color_1"
OpName %Position_1 "Position_1"
OpName %v_color_1 "v_color_1"
OpName %vertex_point_size "vertex_point_size"
OpName %v_color_2 "v_color_2"
OpName %value_1 "value_1"
OpName %Time "Time"
OpMemberName %Time 0 "value"
OpName %time "time"
OpName %Uniforms "Uniforms"
OpMemberName %Uniforms 0 "scale"
OpMemberName %Uniforms 1 "offsetX"
OpMemberName %Uniforms 2 "offsetY"
OpMemberName %Uniforms 3 "scalar"
OpMemberName %Uniforms 4 "scalarOffset"
OpName %uniforms "uniforms"
OpName %VertexOutput "VertexOutput"
OpMemberName %VertexOutput 0 "Position"
OpMemberName %VertexOutput 1 "v_color"
OpName %vert_main_inner "vert_main_inner"
OpName %position "position"
OpName %color "color"
OpName %fade "fade"
OpName %xpos "xpos"
OpName %ypos "ypos"
OpName %angle "angle"
OpName %xrot "xrot"
OpName %yrot "yrot"
OpName %output "output"
OpName %vert_main "vert_main"
OpName %frag_main_inner "frag_main_inner"
OpName %v_color "v_color"
OpName %frag_main "frag_main"
OpDecorate %position_1 Location 0
OpDecorate %color_1 Location 1
OpDecorate %Position_1 BuiltIn Position
OpDecorate %v_color_1 Location 0
OpDecorate %vertex_point_size BuiltIn PointSize
OpDecorate %v_color_2 Location 0
OpDecorate %value_1 Location 0
OpDecorate %Time Block
OpMemberDecorate %Time 0 Offset 0
OpDecorate %time NonWritable
OpDecorate %time Binding 0
OpDecorate %time DescriptorSet 0
OpDecorate %Uniforms Block
OpMemberDecorate %Uniforms 0 Offset 0
OpMemberDecorate %Uniforms 1 Offset 4
OpMemberDecorate %Uniforms 2 Offset 8
OpMemberDecorate %Uniforms 3 Offset 12
OpMemberDecorate %Uniforms 4 Offset 16
OpDecorate %uniforms NonWritable
OpDecorate %uniforms Binding 1
OpDecorate %uniforms DescriptorSet 0
OpMemberDecorate %VertexOutput 0 Offset 0
OpMemberDecorate %VertexOutput 1 Offset 16
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Input_v4float = OpTypePointer Input %v4float
%position_1 = OpVariable %_ptr_Input_v4float Input
%color_1 = OpVariable %_ptr_Input_v4float Input
%_ptr_Output_v4float = OpTypePointer Output %v4float
%8 = OpConstantNull %v4float
%Position_1 = OpVariable %_ptr_Output_v4float Output %8
%v_color_1 = OpVariable %_ptr_Output_v4float Output %8
%_ptr_Output_float = OpTypePointer Output %float
%12 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %12
%v_color_2 = OpVariable %_ptr_Input_v4float Input
%value_1 = OpVariable %_ptr_Output_v4float Output %8
%Time = OpTypeStruct %float
%_ptr_Uniform_Time = OpTypePointer Uniform %Time
%time = OpVariable %_ptr_Uniform_Time Uniform
%Uniforms = OpTypeStruct %float %float %float %float %float
%_ptr_Uniform_Uniforms = OpTypePointer Uniform %Uniforms
%uniforms = OpVariable %_ptr_Uniform_Uniforms Uniform
%VertexOutput = OpTypeStruct %v4float %v4float
%21 = OpTypeFunction %VertexOutput %v4float %v4float
%uint = OpTypeInt 32 0
%uint_4 = OpConstant %uint 4
%_ptr_Uniform_float = OpTypePointer Uniform %float
%uint_0 = OpConstant %uint 0
%uint_3 = OpConstant %uint 3
%float_10 = OpConstant %float 10
%float_1 = OpConstant %float 1
%_ptr_Function_float = OpTypePointer Function %float
%float_0_5 = OpConstant %float 0.5
%bool = OpTypeBool
%float_2 = OpConstant %float 2
%float_3_14159012 = OpConstant %float 3.14159012
%uint_1 = OpConstant %uint 1
%uint_2 = OpConstant %uint 2
%_ptr_Function_VertexOutput = OpTypePointer Function %VertexOutput
%107 = OpConstantNull %VertexOutput
%_ptr_Function_v4float = OpTypePointer Function %v4float
%float_0 = OpConstant %float 0
%void = OpTypeVoid
%121 = OpTypeFunction %void
%130 = OpTypeFunction %v4float %v4float
%vert_main_inner = OpFunction %VertexOutput None %21
%position = OpFunctionParameter %v4float
%color = OpFunctionParameter %v4float
%26 = OpLabel
%fade = OpVariable %_ptr_Function_float Function %12
%xpos = OpVariable %_ptr_Function_float Function %12
%ypos = OpVariable %_ptr_Function_float Function %12
%angle = OpVariable %_ptr_Function_float Function %12
%xrot = OpVariable %_ptr_Function_float Function %12
%yrot = OpVariable %_ptr_Function_float Function %12
%output = OpVariable %_ptr_Function_VertexOutput Function %107
%30 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4
%31 = OpLoad %float %30
%33 = OpAccessChain %_ptr_Uniform_float %time %uint_0
%34 = OpLoad %float %33
%36 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_3
%37 = OpLoad %float %36
%38 = OpFMul %float %34 %37
%40 = OpFDiv %float %38 %float_10
%41 = OpFAdd %float %31 %40
%43 = OpFRem %float %41 %float_1
OpStore %fade %43
%46 = OpLoad %float %fade
%48 = OpFOrdLessThan %bool %46 %float_0_5
OpSelectionMerge %50 None
OpBranchConditional %48 %51 %52
%51 = OpLabel
%53 = OpLoad %float %fade
%55 = OpFMul %float %53 %float_2
OpStore %fade %55
OpBranch %50
%52 = OpLabel
%56 = OpLoad %float %fade
%57 = OpFSub %float %float_1 %56
%58 = OpFMul %float %57 %float_2
OpStore %fade %58
OpBranch %50
%50 = OpLabel
%59 = OpCompositeExtract %float %position 0
%60 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_0
%61 = OpLoad %float %60
%62 = OpFMul %float %59 %61
OpStore %xpos %62
%64 = OpCompositeExtract %float %position 1
%65 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_0
%66 = OpLoad %float %65
%67 = OpFMul %float %64 %66
OpStore %ypos %67
%70 = OpFMul %float %float_3_14159012 %float_2
%71 = OpLoad %float %fade
%72 = OpFMul %float %70 %71
OpStore %angle %72
%74 = OpLoad %float %xpos
%77 = OpLoad %float %angle
%75 = OpExtInst %float %76 Cos %77
%78 = OpFMul %float %74 %75
%79 = OpLoad %float %ypos
%81 = OpLoad %float %angle
%80 = OpExtInst %float %76 Sin %81
%82 = OpFMul %float %79 %80
%83 = OpFSub %float %78 %82
OpStore %xrot %83
%85 = OpLoad %float %xpos
%87 = OpLoad %float %angle
%86 = OpExtInst %float %76 Sin %87
%88 = OpFMul %float %85 %86
%89 = OpLoad %float %ypos
%91 = OpLoad %float %angle
%90 = OpExtInst %float %76 Cos %91
%92 = OpFMul %float %89 %90
%93 = OpFAdd %float %88 %92
OpStore %yrot %93
%95 = OpLoad %float %xrot
%97 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_1
%98 = OpLoad %float %97
%99 = OpFAdd %float %95 %98
OpStore %xpos %99
%100 = OpLoad %float %yrot
%102 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_2
%103 = OpLoad %float %102
%104 = OpFAdd %float %100 %103
OpStore %ypos %104
%109 = OpAccessChain %_ptr_Function_v4float %output %uint_1
%110 = OpLoad %float %fade
%111 = OpLoad %float %fade
%112 = OpFSub %float %float_1 %111
%114 = OpCompositeConstruct %v4float %110 %112 %float_0 %float_1
%115 = OpFAdd %v4float %114 %color
OpStore %109 %115
%116 = OpAccessChain %_ptr_Function_v4float %output %uint_0
%117 = OpLoad %float %xpos
%118 = OpLoad %float %ypos
%119 = OpCompositeConstruct %v4float %117 %118 %float_0 %float_1
OpStore %116 %119
%120 = OpLoad %VertexOutput %output
OpReturnValue %120
OpFunctionEnd
%vert_main = OpFunction %void None %121
%124 = OpLabel
%126 = OpLoad %v4float %position_1
%127 = OpLoad %v4float %color_1
%125 = OpFunctionCall %VertexOutput %vert_main_inner %126 %127
%128 = OpCompositeExtract %v4float %125 0
OpStore %Position_1 %128
%129 = OpCompositeExtract %v4float %125 1
OpStore %v_color_1 %129
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%frag_main_inner = OpFunction %v4float None %130
%v_color = OpFunctionParameter %v4float
%133 = OpLabel
OpReturnValue %v_color
OpFunctionEnd
%frag_main = OpFunction %void None %121
%135 = OpLabel
%137 = OpLoad %v4float %v_color_2
%136 = OpFunctionCall %v4float %frag_main_inner %137
OpStore %value_1 %136
OpReturn
OpFunctionEnd

48
test/benchmark/animometer.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,48 @@
struct Time {
value : f32;
}
struct Uniforms {
scale : f32;
offsetX : f32;
offsetY : f32;
scalar : f32;
scalarOffset : f32;
}
@binding(0) @group(0) var<uniform> time : Time;
@binding(1) @group(0) var<uniform> uniforms : Uniforms;
struct VertexOutput {
@builtin(position)
Position : vec4<f32>;
@location(0)
v_color : vec4<f32>;
}
@stage(vertex)
fn vert_main(@location(0) position : vec4<f32>, @location(1) color : vec4<f32>) -> VertexOutput {
var fade : f32 = ((uniforms.scalarOffset + ((time.value * uniforms.scalar) / 10.0)) % 1.0);
if ((fade < 0.5)) {
fade = (fade * 2.0);
} else {
fade = ((1.0 - fade) * 2.0);
}
var xpos : f32 = (position.x * uniforms.scale);
var ypos : f32 = (position.y * uniforms.scale);
var angle : f32 = ((3.141590118 * 2.0) * fade);
var xrot : f32 = ((xpos * cos(angle)) - (ypos * sin(angle)));
var yrot : f32 = ((xpos * sin(angle)) + (ypos * cos(angle)));
xpos = (xrot + uniforms.offsetX);
ypos = (yrot + uniforms.offsetY);
var output : VertexOutput;
output.v_color = (vec4<f32>(fade, (1.0 - fade), 0.0, 1.0) + color);
output.Position = vec4<f32>(xpos, ypos, 0.0, 1.0);
return output;
}
@stage(fragment)
fn frag_main(@location(0) v_color : vec4<f32>) -> @location(0) vec4<f32> {
return v_color;
}

42
test/benchmark/bloom-vertical-blur.wgsl Normal file
View File

@ -0,0 +1,42 @@
let bloomDir = vec2(0.0, 1.0);
var<private> offsets : array<f32, 3> = array<f32, 3>(0.0, 1.384615421, 3.230769157);
var<private> weights : array<f32, 3> = array<f32, 3>(0.227027029, 0.31621623, 0.07027027);
struct BloomUniforms {
radius : f32;
dim : f32;
}
@group(0) @binding(0) var<uniform> bloom : BloomUniforms;
@group(0) @binding(1) var bloomTexture : texture_2d<f32>;
@group(0) @binding(2) var bloomSampler : sampler;
struct FragmentInput {
@location(0)
texCoord : vec2<f32>;
}
fn getGaussianBlur(texCoord : vec2<f32>) -> vec4<f32> {
let texelRadius = (vec2(bloom.radius) / vec2<f32>(textureDimensions(bloomTexture)));
let step = (bloomDir * texelRadius);
var sum = vec4(0.0);
sum = (sum + (textureSample(bloomTexture, bloomSampler, texCoord) * weights[0]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord + (step * 1.0))) * weights[1]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord - (step * 1.0))) * weights[1]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord + (step * 2.0))) * weights[2]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord - (step * 2.0))) * weights[2]));
return vec4(sum.rgb, 1.0);
}
@group(0) @binding(3) var prevTexture : texture_2d<f32>;
@stage(fragment)
fn fragmentMain(input : FragmentInput) -> @location(0) vec4<f32> {
let blurColor = getGaussianBlur(input.texCoord);
let dimColor = (textureSample(prevTexture, bloomSampler, input.texCoord) * bloom.dim);
return (blurColor + dimColor);
}

67
test/benchmark/bloom-vertical-blur.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,67 @@
#version 310 es
precision mediump float;
const vec2 bloomDir = vec2(0.0f, 1.0f);
float weights[3] = float[3](0.227027029f, 0.31621623f, 0.07027027f);
struct BloomUniforms {
float radius;
float dim;
};
layout (binding = 0) uniform BloomUniforms_1 {
float radius;
float dim;
} bloom;
uniform highp sampler2D bloomTexture;
struct FragmentInput {
vec2 texCoord;
};
vec4 getGaussianBlur(vec2 texCoord) {
vec2 texelRadius = (vec2(bloom.radius) / vec2(textureSize(bloomTexture, 0)));
vec2 tint_symbol = (bloomDir * texelRadius);
vec4 sum = vec4(0.0f);
sum = (sum + (texture(bloomTexture, texCoord) * weights[0]));
sum = (sum + (texture(bloomTexture, (texCoord + (tint_symbol * 1.0f))) * weights[1]));
sum = (sum + (texture(bloomTexture, (texCoord - (tint_symbol * 1.0f))) * weights[1]));
sum = (sum + (texture(bloomTexture, (texCoord + (tint_symbol * 2.0f))) * weights[2]));
sum = (sum + (texture(bloomTexture, (texCoord - (tint_symbol * 2.0f))) * weights[2]));
return vec4(sum.rgb, 1.0f);
}
uniform highp sampler2D prevTexture;
struct tint_symbol_3 {
vec2 texCoord;
};
struct tint_symbol_4 {
vec4 value;
};
vec4 fragmentMain_inner(FragmentInput tint_symbol_1) {
vec4 blurColor = getGaussianBlur(tint_symbol_1.texCoord);
vec4 dimColor = (texture(prevTexture, tint_symbol_1.texCoord) * bloom.dim);
return (blurColor + dimColor);
}
tint_symbol_4 fragmentMain(tint_symbol_3 tint_symbol_2) {
FragmentInput tint_symbol_5 = FragmentInput(tint_symbol_2.texCoord);
vec4 inner_result = fragmentMain_inner(tint_symbol_5);
tint_symbol_4 wrapper_result = tint_symbol_4(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.value = inner_result;
return wrapper_result;
}
in vec2 texCoord;
out vec4 value;
void main() {
tint_symbol_3 inputs;
inputs.texCoord = texCoord;
tint_symbol_4 outputs;
outputs = fragmentMain(inputs);
value = outputs.value;
}

50
test/benchmark/bloom-vertical-blur.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,50 @@
static const float2 bloomDir = float2(0.0f, 1.0f);
static float offsets[3] = {0.0f, 1.384615421f, 3.230769157f};
static float weights[3] = {0.227027029f, 0.31621623f, 0.07027027f};
cbuffer cbuffer_bloom : register(b0, space0) {
uint4 bloom[1];
};
Texture2D<float4> bloomTexture : register(t1, space0);
SamplerState bloomSampler : register(s2, space0);
struct FragmentInput {
float2 texCoord;
};
float4 getGaussianBlur(float2 texCoord) {
int2 tint_tmp;
bloomTexture.GetDimensions(tint_tmp.x, tint_tmp.y);
const float2 texelRadius = (float2((asfloat(bloom[0].x)).xx) / float2(tint_tmp));
const float2 step = (bloomDir * texelRadius);
float4 sum = float4((0.0f).xxxx);
sum = (sum + (bloomTexture.Sample(bloomSampler, texCoord) * weights[0]));
sum = (sum + (bloomTexture.Sample(bloomSampler, (texCoord + (step * 1.0f))) * weights[1]));
sum = (sum + (bloomTexture.Sample(bloomSampler, (texCoord - (step * 1.0f))) * weights[1]));
sum = (sum + (bloomTexture.Sample(bloomSampler, (texCoord + (step * 2.0f))) * weights[2]));
sum = (sum + (bloomTexture.Sample(bloomSampler, (texCoord - (step * 2.0f))) * weights[2]));
return float4(sum.rgb, 1.0f);
}
Texture2D<float4> prevTexture : register(t3, space0);
struct tint_symbol_1 {
float2 texCoord : TEXCOORD0;
};
struct tint_symbol_2 {
float4 value : SV_Target0;
};
float4 fragmentMain_inner(FragmentInput input) {
const float4 blurColor = getGaussianBlur(input.texCoord);
const float4 dimColor = (prevTexture.Sample(bloomSampler, input.texCoord) * asfloat(bloom[0].y));
return (blurColor + dimColor);
}
tint_symbol_2 fragmentMain(tint_symbol_1 tint_symbol) {
const FragmentInput tint_symbol_4 = {tint_symbol.texCoord};
const float4 inner_result = fragmentMain_inner(tint_symbol_4);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.value = inner_result;
return wrapper_result;
}

48
test/benchmark/bloom-vertical-blur.wgsl.expected.msl Normal file
View File

@ -0,0 +1,48 @@
#include <metal_stdlib>
using namespace metal;
struct tint_array_wrapper {
float arr[3];
};
struct BloomUniforms {
/* 0x0000 */ float radius;
/* 0x0004 */ float dim;
};
struct FragmentInput {
float2 texCoord;
};
struct tint_symbol_1 {
float2 texCoord [[user(locn0)]];
};
struct tint_symbol_2 {
float4 value [[color(0)]];
};
constant float2 bloomDir = float2(0.0f, 1.0f);
float4 getGaussianBlur(float2 texCoord, const constant BloomUniforms* const tint_symbol_4, texture2d<float, access::sample> tint_symbol_5, sampler tint_symbol_6, thread tint_array_wrapper* const tint_symbol_7) {
float2 const texelRadius = (float2((*(tint_symbol_4)).radius) / float2(int2(tint_symbol_5.get_width(), tint_symbol_5.get_height())));
float2 const step = (bloomDir * texelRadius);
float4 sum = float4(0.0f);
sum = (sum + (tint_symbol_5.sample(tint_symbol_6, texCoord) * (*(tint_symbol_7)).arr[0]));
sum = (sum + (tint_symbol_5.sample(tint_symbol_6, (texCoord + (step * 1.0f))) * (*(tint_symbol_7)).arr[1]));
sum = (sum + (tint_symbol_5.sample(tint_symbol_6, (texCoord - (step * 1.0f))) * (*(tint_symbol_7)).arr[1]));
sum = (sum + (tint_symbol_5.sample(tint_symbol_6, (texCoord + (step * 2.0f))) * (*(tint_symbol_7)).arr[2]));
sum = (sum + (tint_symbol_5.sample(tint_symbol_6, (texCoord - (step * 2.0f))) * (*(tint_symbol_7)).arr[2]));
return float4(float4(sum).rgb, 1.0f);
}
float4 fragmentMain_inner(FragmentInput input, const constant BloomUniforms* const tint_symbol_8, texture2d<float, access::sample> tint_symbol_9, sampler tint_symbol_10, thread tint_array_wrapper* const tint_symbol_11, texture2d<float, access::sample> tint_symbol_12) {
float4 const blurColor = getGaussianBlur(input.texCoord, tint_symbol_8, tint_symbol_9, tint_symbol_10, tint_symbol_11);
float4 const dimColor = (tint_symbol_12.sample(tint_symbol_10, input.texCoord) * (*(tint_symbol_8)).dim);
return (blurColor + dimColor);
}
fragment tint_symbol_2 fragmentMain(const constant BloomUniforms* tint_symbol_13 [[buffer(0)]], texture2d<float, access::sample> tint_symbol_14 [[texture(0)]], sampler tint_symbol_15 [[sampler(0)]], texture2d<float, access::sample> tint_symbol_17 [[texture(1)]], tint_symbol_1 tint_symbol [[stage_in]]) {
thread tint_array_wrapper tint_symbol_16 = {.arr={0.227027029f, 0.31621623f, 0.07027027f}};
FragmentInput const tint_symbol_3 = {.texCoord=tint_symbol.texCoord};
float4 const inner_result = fragmentMain_inner(tint_symbol_3, tint_symbol_13, tint_symbol_14, tint_symbol_15, &(tint_symbol_16), tint_symbol_17);
tint_symbol_2 wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}

202
test/benchmark/bloom-vertical-blur.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,202 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 144
; Schema: 0
OpCapability Shader
OpCapability ImageQuery
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %fragmentMain "fragmentMain" %texCoord_1 %value
OpExecutionMode %fragmentMain OriginUpperLeft
OpName %texCoord_1 "texCoord_1"
OpName %value "value"
OpName %bloomDir "bloomDir"
OpName %offsets "offsets"
OpName %weights "weights"
OpName %BloomUniforms "BloomUniforms"
OpMemberName %BloomUniforms 0 "radius"
OpMemberName %BloomUniforms 1 "dim"
OpName %bloom "bloom"
OpName %bloomTexture "bloomTexture"
OpName %bloomSampler "bloomSampler"
OpName %prevTexture "prevTexture"
OpName %getGaussianBlur "getGaussianBlur"
OpName %texCoord "texCoord"
OpName %sum "sum"
OpName %FragmentInput "FragmentInput"
OpMemberName %FragmentInput 0 "texCoord"
OpName %fragmentMain_inner "fragmentMain_inner"
OpName %input "input"
OpName %fragmentMain "fragmentMain"
OpDecorate %texCoord_1 Location 0
OpDecorate %value Location 0
OpDecorate %_arr_float_uint_3 ArrayStride 4
OpDecorate %BloomUniforms Block
OpMemberDecorate %BloomUniforms 0 Offset 0
OpMemberDecorate %BloomUniforms 1 Offset 4
OpDecorate %bloom NonWritable
OpDecorate %bloom DescriptorSet 0
OpDecorate %bloom Binding 0
OpDecorate %bloomTexture DescriptorSet 0
OpDecorate %bloomTexture Binding 1
OpDecorate %bloomSampler DescriptorSet 0
OpDecorate %bloomSampler Binding 2
OpDecorate %prevTexture DescriptorSet 0
OpDecorate %prevTexture Binding 3
OpMemberDecorate %FragmentInput 0 Offset 0
%float = OpTypeFloat 32
%v2float = OpTypeVector %float 2
%_ptr_Input_v2float = OpTypePointer Input %v2float
%texCoord_1 = OpVariable %_ptr_Input_v2float Input
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%8 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %8
%float_0 = OpConstant %float 0
%float_1 = OpConstant %float 1
%bloomDir = OpConstantComposite %v2float %float_0 %float_1
%uint = OpTypeInt 32 0
%uint_3 = OpConstant %uint 3
%_arr_float_uint_3 = OpTypeArray %float %uint_3
%float_1_38461542 = OpConstant %float 1.38461542
%float_3_23076916 = OpConstant %float 3.23076916
%17 = OpConstantComposite %_arr_float_uint_3 %float_0 %float_1_38461542 %float_3_23076916
%_ptr_Private__arr_float_uint_3 = OpTypePointer Private %_arr_float_uint_3
%offsets = OpVariable %_ptr_Private__arr_float_uint_3 Private %17
%float_0_227027029 = OpConstant %float 0.227027029
%float_0_31621623 = OpConstant %float 0.31621623
%float_0_0702702701 = OpConstant %float 0.0702702701
%23 = OpConstantComposite %_arr_float_uint_3 %float_0_227027029 %float_0_31621623 %float_0_0702702701
%weights = OpVariable %_ptr_Private__arr_float_uint_3 Private %23
%BloomUniforms = OpTypeStruct %float %float
%_ptr_Uniform_BloomUniforms = OpTypePointer Uniform %BloomUniforms
%bloom = OpVariable %_ptr_Uniform_BloomUniforms Uniform
%30 = OpTypeImage %float 2D 0 0 0 1 Unknown
%_ptr_UniformConstant_30 = OpTypePointer UniformConstant %30
%bloomTexture = OpVariable %_ptr_UniformConstant_30 UniformConstant
%33 = OpTypeSampler
%_ptr_UniformConstant_33 = OpTypePointer UniformConstant %33
%bloomSampler = OpVariable %_ptr_UniformConstant_33 UniformConstant
%prevTexture = OpVariable %_ptr_UniformConstant_30 UniformConstant
%35 = OpTypeFunction %v4float %v2float
%uint_0 = OpConstant %uint 0
%_ptr_Uniform_float = OpTypePointer Uniform %float
%int = OpTypeInt 32 1
%v2int = OpTypeVector %int 2
%int_0 = OpConstant %int 0
%52 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
%_ptr_Function_v4float = OpTypePointer Function %v4float
%59 = OpTypeSampledImage %30
%_ptr_Private_float = OpTypePointer Private %float
%int_1 = OpConstant %int 1
%float_2 = OpConstant %float 2
%int_2 = OpConstant %int 2
%v3float = OpTypeVector %float 3
%FragmentInput = OpTypeStruct %v2float
%120 = OpTypeFunction %v4float %FragmentInput
%uint_1 = OpConstant %uint 1
%void = OpTypeVoid
%137 = OpTypeFunction %void
%getGaussianBlur = OpFunction %v4float None %35
%texCoord = OpFunctionParameter %v2float
%38 = OpLabel
%sum = OpVariable %_ptr_Function_v4float Function %8
%41 = OpAccessChain %_ptr_Uniform_float %bloom %uint_0
%42 = OpLoad %float %41
%43 = OpCompositeConstruct %v2float %42 %42
%48 = OpLoad %30 %bloomTexture
%45 = OpImageQuerySizeLod %v2int %48 %int_0
%44 = OpConvertSToF %v2float %45
%50 = OpFDiv %v2float %43 %44
%51 = OpFMul %v2float %bloomDir %50
OpStore %sum %52
%55 = OpLoad %v4float %sum
%57 = OpLoad %33 %bloomSampler
%58 = OpLoad %30 %bloomTexture
%60 = OpSampledImage %59 %58 %57
%56 = OpImageSampleImplicitLod %v4float %60 %texCoord
%62 = OpAccessChain %_ptr_Private_float %weights %int_0
%63 = OpLoad %float %62
%64 = OpVectorTimesScalar %v4float %56 %63
%65 = OpFAdd %v4float %55 %64
OpStore %sum %65
%66 = OpLoad %v4float %sum
%68 = OpLoad %33 %bloomSampler
%69 = OpLoad %30 %bloomTexture
%70 = OpSampledImage %59 %69 %68
%71 = OpVectorTimesScalar %v2float %51 %float_1
%72 = OpFAdd %v2float %texCoord %71
%67 = OpImageSampleImplicitLod %v4float %70 %72
%74 = OpAccessChain %_ptr_Private_float %weights %int_1
%75 = OpLoad %float %74
%76 = OpVectorTimesScalar %v4float %67 %75
%77 = OpFAdd %v4float %66 %76
OpStore %sum %77
%78 = OpLoad %v4float %sum
%80 = OpLoad %33 %bloomSampler
%81 = OpLoad %30 %bloomTexture
%82 = OpSampledImage %59 %81 %80
%83 = OpVectorTimesScalar %v2float %51 %float_1
%84 = OpFSub %v2float %texCoord %83
%79 = OpImageSampleImplicitLod %v4float %82 %84
%85 = OpAccessChain %_ptr_Private_float %weights %int_1
%86 = OpLoad %float %85
%87 = OpVectorTimesScalar %v4float %79 %86
%88 = OpFAdd %v4float %78 %87
OpStore %sum %88
%89 = OpLoad %v4float %sum
%91 = OpLoad %33 %bloomSampler
%92 = OpLoad %30 %bloomTexture
%93 = OpSampledImage %59 %92 %91
%95 = OpVectorTimesScalar %v2float %51 %float_2
%96 = OpFAdd %v2float %texCoord %95
%90 = OpImageSampleImplicitLod %v4float %93 %96
%98 = OpAccessChain %_ptr_Private_float %weights %int_2
%99 = OpLoad %float %98
%100 = OpVectorTimesScalar %v4float %90 %99
%101 = OpFAdd %v4float %89 %100
OpStore %sum %101
%102 = OpLoad %v4float %sum
%104 = OpLoad %33 %bloomSampler
%105 = OpLoad %30 %bloomTexture
%106 = OpSampledImage %59 %105 %104
%107 = OpVectorTimesScalar %v2float %51 %float_2
%108 = OpFSub %v2float %texCoord %107
%103 = OpImageSampleImplicitLod %v4float %106 %108
%109 = OpAccessChain %_ptr_Private_float %weights %int_2
%110 = OpLoad %float %109
%111 = OpVectorTimesScalar %v4float %103 %110
%112 = OpFAdd %v4float %102 %111
OpStore %sum %112
%114 = OpLoad %v4float %sum
%115 = OpVectorShuffle %v3float %114 %114 0 1 2
%116 = OpCompositeExtract %float %115 0
%117 = OpCompositeExtract %float %115 1
%118 = OpCompositeExtract %float %115 2
%119 = OpCompositeConstruct %v4float %116 %117 %118 %float_1
OpReturnValue %119
OpFunctionEnd
%fragmentMain_inner = OpFunction %v4float None %120
%input = OpFunctionParameter %FragmentInput
%124 = OpLabel
%126 = OpCompositeExtract %v2float %input 0
%125 = OpFunctionCall %v4float %getGaussianBlur %126
%128 = OpLoad %33 %bloomSampler
%129 = OpLoad %30 %prevTexture
%130 = OpSampledImage %59 %129 %128
%131 = OpCompositeExtract %v2float %input 0
%127 = OpImageSampleImplicitLod %v4float %130 %131
%133 = OpAccessChain %_ptr_Uniform_float %bloom %uint_1
%134 = OpLoad %float %133
%135 = OpVectorTimesScalar %v4float %127 %134
%136 = OpFAdd %v4float %125 %135
OpReturnValue %136
OpFunctionEnd
%fragmentMain = OpFunction %void None %137
%140 = OpLabel
%142 = OpLoad %v2float %texCoord_1
%143 = OpCompositeConstruct %FragmentInput %142
%141 = OpFunctionCall %v4float %fragmentMain_inner %143
OpStore %value %141
OpReturn
OpFunctionEnd

42
test/benchmark/bloom-vertical-blur.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,42 @@
let bloomDir = vec2(0.0, 1.0);
var<private> offsets : array<f32, 3> = array<f32, 3>(0.0, 1.384615421, 3.230769157);
var<private> weights : array<f32, 3> = array<f32, 3>(0.227027029, 0.31621623, 0.07027027);
struct BloomUniforms {
radius : f32;
dim : f32;
}
@group(0) @binding(0) var<uniform> bloom : BloomUniforms;
@group(0) @binding(1) var bloomTexture : texture_2d<f32>;
@group(0) @binding(2) var bloomSampler : sampler;
struct FragmentInput {
@location(0)
texCoord : vec2<f32>;
}
fn getGaussianBlur(texCoord : vec2<f32>) -> vec4<f32> {
let texelRadius = (vec2(bloom.radius) / vec2<f32>(textureDimensions(bloomTexture)));
let step = (bloomDir * texelRadius);
var sum = vec4(0.0);
sum = (sum + (textureSample(bloomTexture, bloomSampler, texCoord) * weights[0]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord + (step * 1.0))) * weights[1]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord - (step * 1.0))) * weights[1]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord + (step * 2.0))) * weights[2]));
sum = (sum + (textureSample(bloomTexture, bloomSampler, (texCoord - (step * 2.0))) * weights[2]));
return vec4(sum.rgb, 1.0);
}
@group(0) @binding(3) var prevTexture : texture_2d<f32>;
@stage(fragment)
fn fragmentMain(input : FragmentInput) -> @location(0) vec4<f32> {
let blurColor = getGaussianBlur(input.texCoord);
let dimColor = (textureSample(prevTexture, bloomSampler, input.texCoord) * bloom.dim);
return (blurColor + dimColor);
}

119
test/benchmark/cluster-lights.wgsl Normal file
View File

@ -0,0 +1,119 @@
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@group(0) @binding(0) var<uniform> camera : Camera;
struct ClusterBounds {
minAABB : vec3<f32>;
maxAABB : vec3<f32>;
}
struct Clusters {
bounds : array<ClusterBounds, 27648>;
}
@group(0) @binding(1) var<storage, read> clusters : Clusters;
struct ClusterLights {
offset : u32;
count : u32;
}
struct ClusterLightGroup {
offset : atomic<u32>;
lights : array<ClusterLights, 27648>;
indices : array<u32, 1769472>;
}
@group(0) @binding(2) var<storage, read_write> clusterLights : ClusterLightGroup;
struct Light {
position : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
struct GlobalLights {
ambient : vec3<f32>;
dirColor : vec3<f32>;
dirIntensity : f32;
dirDirection : vec3<f32>;
lightCount : u32;
lights : array<Light>;
}
@group(0) @binding(3) var<storage, read> globalLights : GlobalLights;
let tileCount = vec3(32u, 18u, 48u);
fn linearDepth(depthSample : f32) -> f32 {
return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}
fn getTile(fragCoord : vec4<f32>) -> vec3<u32> {
let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear)));
let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0));
return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile);
}
fn getClusterIndex(fragCoord : vec4<f32>) -> u32 {
let tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
fn sqDistPointAABB(point : vec3<f32>, minAABB : vec3<f32>, maxAABB : vec3<f32>) -> f32 {
var sqDist = 0.0;
for(var i : i32 = 0; (i < 3); i = (i + 1)) {
let v = point[i];
if ((v < minAABB[i])) {
sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
}
if ((v > maxAABB[i])) {
sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
}
}
return sqDist;
}
@stage(compute) @workgroup_size(4, 2, 4)
fn computeMain(@builtin(global_invocation_id) global_id : vec3<u32>) {
let tileIndex = ((global_id.x + (global_id.y * tileCount.x)) + ((global_id.z * tileCount.x) * tileCount.y));
var clusterLightCount = 0u;
var cluserLightIndices : array<u32, 256>;
for(var i = 0u; (i < globalLights.lightCount); i = (i + 1u)) {
let range = globalLights.lights[i].range;
var lightInCluster : bool = (range <= 0.0);
if (!(lightInCluster)) {
let lightViewPos = (camera.view * vec4(globalLights.lights[i].position, 1.0));
let sqDist = sqDistPointAABB(lightViewPos.xyz, clusters.bounds[tileIndex].minAABB, clusters.bounds[tileIndex].maxAABB);
lightInCluster = (sqDist <= (range * range));
}
if (lightInCluster) {
cluserLightIndices[clusterLightCount] = i;
clusterLightCount = (clusterLightCount + 1u);
}
if ((clusterLightCount == 256u)) {
break;
}
}
let lightCount = clusterLightCount;
var offset = atomicAdd(&(clusterLights.offset), lightCount);
if ((offset >= 1769472u)) {
return;
}
for(var i = 0u; (i < clusterLightCount); i = (i + 1u)) {
clusterLights.indices[(offset + i)] = cluserLightIndices[i];
}
clusterLights.lights[tileIndex].offset = offset;
clusterLights.lights[tileIndex].count = clusterLightCount;
}

137
test/benchmark/cluster-lights.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,137 @@
#version 310 es
precision mediump float;
struct Camera {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
};
layout (binding = 0) uniform Camera_1 {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
} camera;
struct ClusterBounds {
vec3 minAABB;
vec3 maxAABB;
};
struct Clusters {
ClusterBounds bounds[27648];
};
layout (binding = 1) buffer Clusters_1 {
ClusterBounds bounds[27648];
} clusters;
struct ClusterLights {
uint offset;
uint count;
};
struct ClusterLightGroup {
uint offset;
ClusterLights lights[27648];
uint indices[1769472];
};
layout (binding = 2) buffer ClusterLightGroup_1 {
uint offset;
ClusterLights lights[27648];
uint indices[1769472];
} clusterLights;
struct Light {
vec3 position;
float range;
vec3 color;
float intensity;
};
layout (binding = 3) buffer GlobalLights_1 {
vec3 ambient;
vec3 dirColor;
float dirIntensity;
vec3 dirDirection;
uint lightCount;
Light lights[];
} globalLights;
const uvec3 tileCount = uvec3(32u, 18u, 48u);
float sqDistPointAABB(vec3 point, vec3 minAABB, vec3 maxAABB) {
float sqDist = 0.0f;
{
for(int i = 0; (i < 3); i = (i + 1)) {
float v = point[i];
if ((v < minAABB[i])) {
sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
}
if ((v > maxAABB[i])) {
sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
}
}
}
return sqDist;
}
struct tint_symbol_1 {
uvec3 global_id;
};
void computeMain_inner(uvec3 global_id) {
uint tileIndex = ((global_id.x + (global_id.y * tileCount.x)) + ((global_id.z * tileCount.x) * tileCount.y));
uint clusterLightCount = 0u;
uint cluserLightIndices[256] = uint[256](0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u);
{
for(uint i = 0u; (i < globalLights.lightCount); i = (i + 1u)) {
float range = globalLights.lights[i].range;
bool lightInCluster = (range <= 0.0f);
if (!(lightInCluster)) {
vec4 lightViewPos = (camera.view * vec4(globalLights.lights[i].position, 1.0f));
float sqDist = sqDistPointAABB(lightViewPos.xyz, clusters.bounds[tileIndex].minAABB, clusters.bounds[tileIndex].maxAABB);
lightInCluster = (sqDist <= (range * range));
}
if (lightInCluster) {
cluserLightIndices[clusterLightCount] = i;
clusterLightCount = (clusterLightCount + 1u);
}
if ((clusterLightCount == 256u)) {
break;
}
}
}
uint offset = atomicAdd(clusterLights.offset, clusterLightCount);
if ((offset >= 1769472u)) {
return;
}
{
for(uint i = 0u; (i < clusterLightCount); i = (i + 1u)) {
clusterLights.indices[(offset + i)] = cluserLightIndices[i];
}
}
clusterLights.lights[tileIndex].offset = offset;
clusterLights.lights[tileIndex].count = clusterLightCount;
}
layout(local_size_x = 4, local_size_y = 2, local_size_z = 4) in;
void computeMain(tint_symbol_1 tint_symbol) {
computeMain_inner(tint_symbol.global_id);
return;
}
void main() {
tint_symbol_1 inputs;
inputs.global_id = gl_GlobalInvocationID;
computeMain(inputs);
}

101
test/benchmark/cluster-lights.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,101 @@
uint atomicAdd_1(RWByteAddressBuffer buffer, uint offset, uint value) {
uint original_value = 0;
buffer.InterlockedAdd(offset, value, original_value);
return original_value;
}
cbuffer cbuffer_camera : register(b0, space0) {
uint4 camera[14];
};
ByteAddressBuffer clusters : register(t1, space0);
RWByteAddressBuffer clusterLights : register(u2, space0);
ByteAddressBuffer globalLights : register(t3, space0);
static const uint3 tileCount = uint3(32u, 18u, 48u);
float linearDepth(float depthSample) {
return ((asfloat(camera[13].w) * asfloat(camera[13].z)) / mad(depthSample, (asfloat(camera[13].z) - asfloat(camera[13].w)), asfloat(camera[13].w)));
}
uint3 getTile(float4 fragCoord) {
const float sliceScale = (float(tileCount.z) / log2((asfloat(camera[13].w) / asfloat(camera[13].z))));
const float sliceBias = -(((float(tileCount.z) * log2(asfloat(camera[13].z))) / log2((asfloat(camera[13].w) / asfloat(camera[13].z)))));
const uint zTile = uint(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0f));
return uint3(uint((fragCoord.x / (asfloat(camera[13].x) / float(tileCount.x)))), uint((fragCoord.y / (asfloat(camera[13].y) / float(tileCount.y)))), zTile);
}
uint getClusterIndex(float4 fragCoord) {
const uint3 tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
float sqDistPointAABB(float3 tint_symbol, float3 minAABB, float3 maxAABB) {
float sqDist = 0.0f;
{
[loop] for(int i = 0; (i < 3); i = (i + 1)) {
const float v = tint_symbol[i];
if ((v < minAABB[i])) {
sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
}
if ((v > maxAABB[i])) {
sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
}
}
}
return sqDist;
}
struct tint_symbol_2 {
uint3 global_id : SV_DispatchThreadID;
};
float4x4 tint_symbol_6(uint4 buffer[14], uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4;
const uint scalar_offset_2 = ((offset + 32u)) / 4;
const uint scalar_offset_3 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset / 4]), asfloat(buffer[scalar_offset_1 / 4]), asfloat(buffer[scalar_offset_2 / 4]), asfloat(buffer[scalar_offset_3 / 4]));
}
void computeMain_inner(uint3 global_id) {
const uint tileIndex = ((global_id.x + (global_id.y * tileCount.x)) + ((global_id.z * tileCount.x) * tileCount.y));
uint clusterLightCount = 0u;
uint cluserLightIndices[256] = (uint[256])0;
{
[loop] for(uint i = 0u; (i < globalLights.Load(44u)); i = (i + 1u)) {
const float range = asfloat(globalLights.Load(((48u + (32u * i)) + 12u)));
bool lightInCluster = (range <= 0.0f);
if (!(lightInCluster)) {
const float4 lightViewPos = mul(float4(asfloat(globalLights.Load3((48u + (32u * i)))), 1.0f), tint_symbol_6(camera, 128u));
const float sqDist = sqDistPointAABB(lightViewPos.xyz, asfloat(clusters.Load3((32u * tileIndex))), asfloat(clusters.Load3(((32u * tileIndex) + 16u))));
lightInCluster = (sqDist <= (range * range));
}
if (lightInCluster) {
cluserLightIndices[clusterLightCount] = i;
clusterLightCount = (clusterLightCount + 1u);
}
if ((clusterLightCount == 256u)) {
break;
}
}
}
uint offset = atomicAdd_1(clusterLights, 0u, clusterLightCount);
if ((offset >= 1769472u)) {
return;
}
{
[loop] for(uint i = 0u; (i < clusterLightCount); i = (i + 1u)) {
clusterLights.Store((221188u + (4u * (offset + i))), asuint(cluserLightIndices[i]));
}
}
clusterLights.Store((4u + (8u * tileIndex)), asuint(offset));
clusterLights.Store(((4u + (8u * tileIndex)) + 4u), asuint(clusterLightCount));
}
[numthreads(4, 2, 4)]
void computeMain(tint_symbol_2 tint_symbol_1) {
computeMain_inner(tint_symbol_1.global_id);
return;
}

138
test/benchmark/cluster-lights.wgsl.expected.msl Normal file
View File

@ -0,0 +1,138 @@
#include <metal_stdlib>
using namespace metal;
template<typename T, int N, int M>
inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
return lhs * vec<T, N>(rhs);
}
template<typename T, int N, int M>
inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
return vec<T, M>(lhs) * rhs;
}
struct Camera {
/* 0x0000 */ float4x4 projection;
/* 0x0040 */ float4x4 inverseProjection;
/* 0x0080 */ float4x4 view;
/* 0x00c0 */ packed_float3 position;
/* 0x00cc */ float time;
/* 0x00d0 */ float2 outputSize;
/* 0x00d8 */ float zNear;
/* 0x00dc */ float zFar;
};
struct ClusterBounds {
/* 0x0000 */ packed_float3 minAABB;
/* 0x000c */ int8_t tint_pad[4];
/* 0x0010 */ packed_float3 maxAABB;
/* 0x001c */ int8_t tint_pad_1[4];
};
struct tint_array_wrapper {
/* 0x0000 */ ClusterBounds arr[27648];
};
struct Clusters {
/* 0x0000 */ tint_array_wrapper bounds;
};
struct ClusterLights {
/* 0x0000 */ uint offset;
/* 0x0004 */ uint count;
};
struct tint_array_wrapper_1 {
/* 0x0000 */ ClusterLights arr[27648];
};
struct tint_array_wrapper_2 {
/* 0x0000 */ uint arr[1769472];
};
struct ClusterLightGroup {
/* 0x0000 */ atomic_uint offset;
/* 0x0004 */ tint_array_wrapper_1 lights;
/* 0x36004 */ tint_array_wrapper_2 indices;
};
struct Light {
/* 0x0000 */ packed_float3 position;
/* 0x000c */ float range;
/* 0x0010 */ packed_float3 color;
/* 0x001c */ float intensity;
};
struct GlobalLights {
/* 0x0000 */ packed_float3 ambient;
/* 0x000c */ int8_t tint_pad_2[4];
/* 0x0010 */ packed_float3 dirColor;
/* 0x001c */ float dirIntensity;
/* 0x0020 */ packed_float3 dirDirection;
/* 0x002c */ uint lightCount;
/* 0x0030 */ Light lights[1];
};
struct tint_array_wrapper_3 {
uint arr[256];
};
constant uint3 tileCount = uint3(32u, 18u, 48u);
float linearDepth(float depthSample, const constant Camera* const tint_symbol) {
return (((*(tint_symbol)).zFar * (*(tint_symbol)).zNear) / fma(depthSample, ((*(tint_symbol)).zNear - (*(tint_symbol)).zFar), (*(tint_symbol)).zFar));
}
uint3 getTile(float4 fragCoord, const constant Camera* const tint_symbol_1) {
float const sliceScale = (float(tileCount[2]) / log2(((*(tint_symbol_1)).zFar / (*(tint_symbol_1)).zNear)));
float const sliceBias = -(((float(tileCount[2]) * log2((*(tint_symbol_1)).zNear)) / log2(((*(tint_symbol_1)).zFar / (*(tint_symbol_1)).zNear))));
uint const zTile = uint(fmax(((log2(linearDepth(fragCoord[2], tint_symbol_1)) * sliceScale) + sliceBias), 0.0f));
return uint3(uint((fragCoord[0] / ((*(tint_symbol_1)).outputSize[0] / float(tileCount[0])))), uint((fragCoord[1] / ((*(tint_symbol_1)).outputSize[1] / float(tileCount[1])))), zTile);
}
uint getClusterIndex(float4 fragCoord, const constant Camera* const tint_symbol_2) {
uint3 const tile = getTile(fragCoord, tint_symbol_2);
return ((tile[0] + (tile[1] * tileCount[0])) + ((tile[2] * tileCount[0]) * tileCount[1]));
}
float sqDistPointAABB(float3 point, float3 minAABB, float3 maxAABB) {
float sqDist = 0.0f;
for(int i = 0; (i < 3); i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)))) {
float const v = point[i];
if ((v < minAABB[i])) {
sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
}
if ((v > maxAABB[i])) {
sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
}
}
return sqDist;
}
void computeMain_inner(uint3 global_id, const device GlobalLights* const tint_symbol_3, const constant Camera* const tint_symbol_4, const device Clusters* const tint_symbol_5, device ClusterLightGroup* const tint_symbol_6) {
uint const tileIndex = ((global_id[0] + (global_id[1] * tileCount[0])) + ((global_id[2] * tileCount[0]) * tileCount[1]));
uint clusterLightCount = 0u;
tint_array_wrapper_3 cluserLightIndices = {};
for(uint i = 0u; (i < (*(tint_symbol_3)).lightCount); i = (i + 1u)) {
float const range = (*(tint_symbol_3)).lights[i].range;
bool lightInCluster = (range <= 0.0f);
if (!(lightInCluster)) {
float4 const lightViewPos = ((*(tint_symbol_4)).view * float4((*(tint_symbol_3)).lights[i].position, 1.0f));
float const sqDist = sqDistPointAABB(float4(lightViewPos).xyz, (*(tint_symbol_5)).bounds.arr[tileIndex].minAABB, (*(tint_symbol_5)).bounds.arr[tileIndex].maxAABB);
lightInCluster = (sqDist <= (range * range));
}
if (lightInCluster) {
cluserLightIndices.arr[clusterLightCount] = i;
clusterLightCount = (clusterLightCount + 1u);
}
if ((clusterLightCount == 256u)) {
break;
}
}
uint const lightCount = clusterLightCount;
uint offset = atomic_fetch_add_explicit(&((*(tint_symbol_6)).offset), lightCount, memory_order_relaxed);
if ((offset >= 1769472u)) {
return;
}
for(uint i = 0u; (i < clusterLightCount); i = (i + 1u)) {
(*(tint_symbol_6)).indices.arr[(offset + i)] = cluserLightIndices.arr[i];
}
(*(tint_symbol_6)).lights.arr[tileIndex].offset = offset;
(*(tint_symbol_6)).lights.arr[tileIndex].count = clusterLightCount;
}
kernel void computeMain(const device GlobalLights* tint_symbol_7 [[buffer(2)]], const constant Camera* tint_symbol_8 [[buffer(0)]], const device Clusters* tint_symbol_9 [[buffer(3)]], device ClusterLightGroup* tint_symbol_10 [[buffer(1)]], uint3 global_id [[thread_position_in_grid]]) {
computeMain_inner(global_id, tint_symbol_7, tint_symbol_8, tint_symbol_9, tint_symbol_10);
return;
}

504
test/benchmark/cluster-lights.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,504 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 312
; Schema: 0
OpCapability Shader
%48 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %computeMain "computeMain" %global_id_1
OpExecutionMode %computeMain LocalSize 4 2 4
OpName %global_id_1 "global_id_1"
OpName %Camera "Camera"
OpMemberName %Camera 0 "projection"
OpMemberName %Camera 1 "inverseProjection"
OpMemberName %Camera 2 "view"
OpMemberName %Camera 3 "position"
OpMemberName %Camera 4 "time"
OpMemberName %Camera 5 "outputSize"
OpMemberName %Camera 6 "zNear"
OpMemberName %Camera 7 "zFar"
OpName %camera "camera"
OpName %Clusters "Clusters"
OpMemberName %Clusters 0 "bounds"
OpName %ClusterBounds "ClusterBounds"
OpMemberName %ClusterBounds 0 "minAABB"
OpMemberName %ClusterBounds 1 "maxAABB"
OpName %clusters "clusters"
OpName %ClusterLightGroup "ClusterLightGroup"
OpMemberName %ClusterLightGroup 0 "offset"
OpMemberName %ClusterLightGroup 1 "lights"
OpName %ClusterLights "ClusterLights"
OpMemberName %ClusterLights 0 "offset"
OpMemberName %ClusterLights 1 "count"
OpMemberName %ClusterLightGroup 2 "indices"
OpName %clusterLights "clusterLights"
OpName %GlobalLights "GlobalLights"
OpMemberName %GlobalLights 0 "ambient"
OpMemberName %GlobalLights 1 "dirColor"
OpMemberName %GlobalLights 2 "dirIntensity"
OpMemberName %GlobalLights 3 "dirDirection"
OpMemberName %GlobalLights 4 "lightCount"
OpMemberName %GlobalLights 5 "lights"
OpName %Light "Light"
OpMemberName %Light 0 "position"
OpMemberName %Light 1 "range"
OpMemberName %Light 2 "color"
OpMemberName %Light 3 "intensity"
OpName %globalLights "globalLights"
OpName %tileCount "tileCount"
OpName %linearDepth "linearDepth"
OpName %depthSample "depthSample"
OpName %getTile "getTile"
OpName %fragCoord "fragCoord"
OpName %getClusterIndex "getClusterIndex"
OpName %fragCoord_0 "fragCoord"
OpName %sqDistPointAABB "sqDistPointAABB"
OpName %point "point"
OpName %minAABB "minAABB"
OpName %maxAABB "maxAABB"
OpName %sqDist "sqDist"
OpName %i "i"
OpName %computeMain_inner "computeMain_inner"
OpName %global_id "global_id"
OpName %clusterLightCount "clusterLightCount"
OpName %cluserLightIndices "cluserLightIndices"
OpName %i_0 "i"
OpName %lightInCluster "lightInCluster"
OpName %offset "offset"
OpName %i_1 "i"
OpName %computeMain "computeMain"
OpDecorate %global_id_1 BuiltIn GlobalInvocationId
OpDecorate %Camera Block
OpMemberDecorate %Camera 0 Offset 0
OpMemberDecorate %Camera 0 ColMajor
OpMemberDecorate %Camera 0 MatrixStride 16
OpMemberDecorate %Camera 1 Offset 64
OpMemberDecorate %Camera 1 ColMajor
OpMemberDecorate %Camera 1 MatrixStride 16
OpMemberDecorate %Camera 2 Offset 128
OpMemberDecorate %Camera 2 ColMajor
OpMemberDecorate %Camera 2 MatrixStride 16
OpMemberDecorate %Camera 3 Offset 192
OpMemberDecorate %Camera 4 Offset 204
OpMemberDecorate %Camera 5 Offset 208
OpMemberDecorate %Camera 6 Offset 216
OpMemberDecorate %Camera 7 Offset 220
OpDecorate %camera NonWritable
OpDecorate %camera DescriptorSet 0
OpDecorate %camera Binding 0
OpDecorate %Clusters Block
OpMemberDecorate %Clusters 0 Offset 0
OpMemberDecorate %ClusterBounds 0 Offset 0
OpMemberDecorate %ClusterBounds 1 Offset 16
OpDecorate %_arr_ClusterBounds_uint_27648 ArrayStride 32
OpDecorate %clusters NonWritable
OpDecorate %clusters DescriptorSet 0
OpDecorate %clusters Binding 1
OpDecorate %ClusterLightGroup Block
OpMemberDecorate %ClusterLightGroup 0 Offset 0
OpMemberDecorate %ClusterLightGroup 1 Offset 4
OpMemberDecorate %ClusterLights 0 Offset 0
OpMemberDecorate %ClusterLights 1 Offset 4
OpDecorate %_arr_ClusterLights_uint_27648 ArrayStride 8
OpMemberDecorate %ClusterLightGroup 2 Offset 221188
OpDecorate %_arr_uint_uint_1769472 ArrayStride 4
OpDecorate %clusterLights DescriptorSet 0
OpDecorate %clusterLights Binding 2
OpDecorate %GlobalLights Block
OpMemberDecorate %GlobalLights 0 Offset 0
OpMemberDecorate %GlobalLights 1 Offset 16
OpMemberDecorate %GlobalLights 2 Offset 28
OpMemberDecorate %GlobalLights 3 Offset 32
OpMemberDecorate %GlobalLights 4 Offset 44
OpMemberDecorate %GlobalLights 5 Offset 48
OpMemberDecorate %Light 0 Offset 0
OpMemberDecorate %Light 1 Offset 12
OpMemberDecorate %Light 2 Offset 16
OpMemberDecorate %Light 3 Offset 28
OpDecorate %_runtimearr_Light ArrayStride 32
OpDecorate %globalLights NonWritable
OpDecorate %globalLights DescriptorSet 0
OpDecorate %globalLights Binding 3
OpDecorate %_arr_uint_uint_256 ArrayStride 4
%uint = OpTypeInt 32 0
%v3uint = OpTypeVector %uint 3
%_ptr_Input_v3uint = OpTypePointer Input %v3uint
%global_id_1 = OpVariable %_ptr_Input_v3uint Input
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%mat4v4float = OpTypeMatrix %v4float 4
%v3float = OpTypeVector %float 3
%v2float = OpTypeVector %float 2
%Camera = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %v3float %float %v2float %float %float
%_ptr_Uniform_Camera = OpTypePointer Uniform %Camera
%camera = OpVariable %_ptr_Uniform_Camera Uniform
%ClusterBounds = OpTypeStruct %v3float %v3float
%uint_27648 = OpConstant %uint 27648
%_arr_ClusterBounds_uint_27648 = OpTypeArray %ClusterBounds %uint_27648
%Clusters = OpTypeStruct %_arr_ClusterBounds_uint_27648
%_ptr_StorageBuffer_Clusters = OpTypePointer StorageBuffer %Clusters
%clusters = OpVariable %_ptr_StorageBuffer_Clusters StorageBuffer
%ClusterLights = OpTypeStruct %uint %uint
%_arr_ClusterLights_uint_27648 = OpTypeArray %ClusterLights %uint_27648
%uint_1769472 = OpConstant %uint 1769472
%_arr_uint_uint_1769472 = OpTypeArray %uint %uint_1769472
%ClusterLightGroup = OpTypeStruct %uint %_arr_ClusterLights_uint_27648 %_arr_uint_uint_1769472
%_ptr_StorageBuffer_ClusterLightGroup = OpTypePointer StorageBuffer %ClusterLightGroup
%clusterLights = OpVariable %_ptr_StorageBuffer_ClusterLightGroup StorageBuffer
%Light = OpTypeStruct %v3float %float %v3float %float
%_runtimearr_Light = OpTypeRuntimeArray %Light
%GlobalLights = OpTypeStruct %v3float %v3float %float %v3float %uint %_runtimearr_Light
%_ptr_StorageBuffer_GlobalLights = OpTypePointer StorageBuffer %GlobalLights
%globalLights = OpVariable %_ptr_StorageBuffer_GlobalLights StorageBuffer
%uint_32 = OpConstant %uint 32
%uint_18 = OpConstant %uint 18
%uint_48 = OpConstant %uint 48
%tileCount = OpConstantComposite %v3uint %uint_32 %uint_18 %uint_48
%35 = OpTypeFunction %float %float
%uint_7 = OpConstant %uint 7
%_ptr_Uniform_float = OpTypePointer Uniform %float
%uint_6 = OpConstant %uint 6
%57 = OpTypeFunction %v3uint %v4float
%float_0 = OpConstant %float 0
%uint_5 = OpConstant %uint 5
%uint_0 = OpConstant %uint 0
%uint_1 = OpConstant %uint 1
%112 = OpTypeFunction %uint %v4float
%128 = OpTypeFunction %float %v3float %v3float %v3float
%_ptr_Function_float = OpTypePointer Function %float
%136 = OpConstantNull %float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_ptr_Function_int = OpTypePointer Function %int
%141 = OpConstantNull %int
%int_3 = OpConstant %int 3
%bool = OpTypeBool
%int_1 = OpConstant %int 1
%void = OpTypeVoid
%187 = OpTypeFunction %void %v3uint
%_ptr_Function_uint = OpTypePointer Function %uint
%205 = OpConstantNull %uint
%uint_256 = OpConstant %uint 256
%_arr_uint_uint_256 = OpTypeArray %uint %uint_256
%_ptr_Function__arr_uint_uint_256 = OpTypePointer Function %_arr_uint_uint_256
%210 = OpConstantNull %_arr_uint_uint_256
%uint_4 = OpConstant %uint 4
%_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint
%_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float
%_ptr_Function_bool = OpTypePointer Function %bool
%232 = OpConstantNull %bool
%uint_2 = OpConstant %uint 2
%_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float
%_ptr_StorageBuffer_v3float = OpTypePointer StorageBuffer %v3float
%float_1 = OpConstant %float 1
%_ptr_StorageBuffer_uint_0 = OpTypePointer StorageBuffer %uint
%307 = OpTypeFunction %void
%linearDepth = OpFunction %float None %35
%depthSample = OpFunctionParameter %float
%38 = OpLabel
%41 = OpAccessChain %_ptr_Uniform_float %camera %uint_7
%42 = OpLoad %float %41
%44 = OpAccessChain %_ptr_Uniform_float %camera %uint_6
%45 = OpLoad %float %44
%46 = OpFMul %float %42 %45
%49 = OpAccessChain %_ptr_Uniform_float %camera %uint_6
%50 = OpLoad %float %49
%51 = OpAccessChain %_ptr_Uniform_float %camera %uint_7
%52 = OpLoad %float %51
%53 = OpFSub %float %50 %52
%54 = OpAccessChain %_ptr_Uniform_float %camera %uint_7
%55 = OpLoad %float %54
%47 = OpExtInst %float %48 Fma %depthSample %53 %55
%56 = OpFDiv %float %46 %47
OpReturnValue %56
OpFunctionEnd
%getTile = OpFunction %v3uint None %57
%fragCoord = OpFunctionParameter %v4float
%60 = OpLabel
%62 = OpCompositeExtract %uint %tileCount 2
%61 = OpConvertUToF %float %62
%64 = OpAccessChain %_ptr_Uniform_float %camera %uint_7
%65 = OpLoad %float %64
%66 = OpAccessChain %_ptr_Uniform_float %camera %uint_6
%67 = OpLoad %float %66
%68 = OpFDiv %float %65 %67
%63 = OpExtInst %float %48 Log2 %68
%69 = OpFDiv %float %61 %63
%72 = OpCompositeExtract %uint %tileCount 2
%71 = OpConvertUToF %float %72
%74 = OpAccessChain %_ptr_Uniform_float %camera %uint_6
%75 = OpLoad %float %74
%73 = OpExtInst %float %48 Log2 %75
%76 = OpFMul %float %71 %73
%78 = OpAccessChain %_ptr_Uniform_float %camera %uint_7
%79 = OpLoad %float %78
%80 = OpAccessChain %_ptr_Uniform_float %camera %uint_6
%81 = OpLoad %float %80
%82 = OpFDiv %float %79 %81
%77 = OpExtInst %float %48 Log2 %82
%83 = OpFDiv %float %76 %77
%70 = OpFNegate %float %83
%88 = OpCompositeExtract %float %fragCoord 2
%87 = OpFunctionCall %float %linearDepth %88
%86 = OpExtInst %float %48 Log2 %87
%89 = OpFMul %float %86 %69
%90 = OpFAdd %float %89 %70
%85 = OpExtInst %float %48 NMax %90 %float_0
%84 = OpConvertFToU %uint %85
%93 = OpCompositeExtract %float %fragCoord 0
%96 = OpAccessChain %_ptr_Uniform_float %camera %uint_5 %uint_0
%97 = OpLoad %float %96
%99 = OpCompositeExtract %uint %tileCount 0
%98 = OpConvertUToF %float %99
%100 = OpFDiv %float %97 %98
%101 = OpFDiv %float %93 %100
%92 = OpConvertFToU %uint %101
%103 = OpCompositeExtract %float %fragCoord 1
%105 = OpAccessChain %_ptr_Uniform_float %camera %uint_5 %uint_1
%106 = OpLoad %float %105
%108 = OpCompositeExtract %uint %tileCount 1
%107 = OpConvertUToF %float %108
%109 = OpFDiv %float %106 %107
%110 = OpFDiv %float %103 %109
%102 = OpConvertFToU %uint %110
%111 = OpCompositeConstruct %v3uint %92 %102 %84
OpReturnValue %111
OpFunctionEnd
%getClusterIndex = OpFunction %uint None %112
%fragCoord_0 = OpFunctionParameter %v4float
%115 = OpLabel
%116 = OpFunctionCall %v3uint %getTile %fragCoord_0
%117 = OpCompositeExtract %uint %116 0
%118 = OpCompositeExtract %uint %116 1
%119 = OpCompositeExtract %uint %tileCount 0
%120 = OpIMul %uint %118 %119
%121 = OpIAdd %uint %117 %120
%122 = OpCompositeExtract %uint %116 2
%123 = OpCompositeExtract %uint %tileCount 0
%124 = OpIMul %uint %122 %123
%125 = OpCompositeExtract %uint %tileCount 1
%126 = OpIMul %uint %124 %125
%127 = OpIAdd %uint %121 %126
OpReturnValue %127
OpFunctionEnd
%sqDistPointAABB = OpFunction %float None %128
%point = OpFunctionParameter %v3float
%minAABB = OpFunctionParameter %v3float
%maxAABB = OpFunctionParameter %v3float
%133 = OpLabel
%sqDist = OpVariable %_ptr_Function_float Function %136
%i = OpVariable %_ptr_Function_int Function %141
OpStore %sqDist %float_0
OpStore %i %int_0
OpBranch %142
%142 = OpLabel
OpLoopMerge %143 %144 None
OpBranch %145
%145 = OpLabel
%147 = OpLoad %int %i
%149 = OpSLessThan %bool %147 %int_3
%146 = OpLogicalNot %bool %149
OpSelectionMerge %151 None
OpBranchConditional %146 %152 %151
%152 = OpLabel
OpBranch %143
%151 = OpLabel
%153 = OpLoad %int %i
%154 = OpVectorExtractDynamic %float %point %153
%155 = OpLoad %int %i
%156 = OpVectorExtractDynamic %float %minAABB %155
%157 = OpFOrdLessThan %bool %154 %156
OpSelectionMerge %158 None
OpBranchConditional %157 %159 %158
%159 = OpLabel
%160 = OpLoad %float %sqDist
%161 = OpLoad %int %i
%162 = OpVectorExtractDynamic %float %minAABB %161
%163 = OpFSub %float %162 %154
%164 = OpLoad %int %i
%165 = OpVectorExtractDynamic %float %minAABB %164
%166 = OpFSub %float %165 %154
%167 = OpFMul %float %163 %166
%168 = OpFAdd %float %160 %167
OpStore %sqDist %168
OpBranch %158
%158 = OpLabel
%169 = OpLoad %int %i
%170 = OpVectorExtractDynamic %float %maxAABB %169
%171 = OpFOrdGreaterThan %bool %154 %170
OpSelectionMerge %172 None
OpBranchConditional %171 %173 %172
%173 = OpLabel
%174 = OpLoad %float %sqDist
%175 = OpLoad %int %i
%176 = OpVectorExtractDynamic %float %maxAABB %175
%177 = OpFSub %float %154 %176
%178 = OpLoad %int %i
%179 = OpVectorExtractDynamic %float %maxAABB %178
%180 = OpFSub %float %154 %179
%181 = OpFMul %float %177 %180
%182 = OpFAdd %float %174 %181
OpStore %sqDist %182
OpBranch %172
%172 = OpLabel
OpBranch %144
%144 = OpLabel
%183 = OpLoad %int %i
%185 = OpIAdd %int %183 %int_1
OpStore %i %185
OpBranch %142
%143 = OpLabel
%186 = OpLoad %float %sqDist
OpReturnValue %186
OpFunctionEnd
%computeMain_inner = OpFunction %void None %187
%global_id = OpFunctionParameter %v3uint
%191 = OpLabel
%clusterLightCount = OpVariable %_ptr_Function_uint Function %205
%cluserLightIndices = OpVariable %_ptr_Function__arr_uint_uint_256 Function %210
%i_0 = OpVariable %_ptr_Function_uint Function %205
%lightInCluster = OpVariable %_ptr_Function_bool Function %232
%offset = OpVariable %_ptr_Function_uint Function %205
%i_1 = OpVariable %_ptr_Function_uint Function %205
%192 = OpCompositeExtract %uint %global_id 0
%193 = OpCompositeExtract %uint %global_id 1
%194 = OpCompositeExtract %uint %tileCount 0
%195 = OpIMul %uint %193 %194
%196 = OpIAdd %uint %192 %195
%197 = OpCompositeExtract %uint %global_id 2
%198 = OpCompositeExtract %uint %tileCount 0
%199 = OpIMul %uint %197 %198
%200 = OpCompositeExtract %uint %tileCount 1
%201 = OpIMul %uint %199 %200
%202 = OpIAdd %uint %196 %201
OpStore %clusterLightCount %uint_0
OpStore %i_0 %uint_0
OpBranch %212
%212 = OpLabel
OpLoopMerge %213 %214 None
OpBranch %215
%215 = OpLabel
%217 = OpLoad %uint %i_0
%220 = OpAccessChain %_ptr_StorageBuffer_uint %globalLights %uint_4
%221 = OpLoad %uint %220
%222 = OpULessThan %bool %217 %221
%216 = OpLogicalNot %bool %222
OpSelectionMerge %223 None
OpBranchConditional %216 %224 %223
%224 = OpLabel
OpBranch %213
%223 = OpLabel
%225 = OpLoad %uint %i_0
%227 = OpAccessChain %_ptr_StorageBuffer_float %globalLights %uint_5 %225 %uint_1
%228 = OpLoad %float %227
%229 = OpFOrdLessThanEqual %bool %228 %float_0
OpStore %lightInCluster %229
%234 = OpLoad %bool %lightInCluster
%233 = OpLogicalNot %bool %234
OpSelectionMerge %235 None
OpBranchConditional %233 %236 %235
%236 = OpLabel
%239 = OpAccessChain %_ptr_Uniform_mat4v4float %camera %uint_2
%240 = OpLoad %mat4v4float %239
%241 = OpLoad %uint %i_0
%243 = OpAccessChain %_ptr_StorageBuffer_v3float %globalLights %uint_5 %241 %uint_0
%244 = OpLoad %v3float %243
%245 = OpCompositeExtract %float %244 0
%246 = OpCompositeExtract %float %244 1
%247 = OpCompositeExtract %float %244 2
%249 = OpCompositeConstruct %v4float %245 %246 %247 %float_1
%250 = OpMatrixTimesVector %v4float %240 %249
%252 = OpVectorShuffle %v3float %250 %250 0 1 2
%253 = OpAccessChain %_ptr_StorageBuffer_v3float %clusters %uint_0 %202 %uint_0
%254 = OpLoad %v3float %253
%255 = OpAccessChain %_ptr_StorageBuffer_v3float %clusters %uint_0 %202 %uint_1
%256 = OpLoad %v3float %255
%251 = OpFunctionCall %float %sqDistPointAABB %252 %254 %256
%257 = OpFMul %float %228 %228
%258 = OpFOrdLessThanEqual %bool %251 %257
OpStore %lightInCluster %258
OpBranch %235
%235 = OpLabel
%259 = OpLoad %bool %lightInCluster
OpSelectionMerge %260 None
OpBranchConditional %259 %261 %260
%261 = OpLabel
%262 = OpLoad %uint %clusterLightCount
%263 = OpAccessChain %_ptr_Function_uint %cluserLightIndices %262
%264 = OpLoad %uint %i_0
OpStore %263 %264
%265 = OpLoad %uint %clusterLightCount
%266 = OpIAdd %uint %265 %uint_1
OpStore %clusterLightCount %266
OpBranch %260
%260 = OpLabel
%267 = OpLoad %uint %clusterLightCount
%268 = OpIEqual %bool %267 %uint_256
OpSelectionMerge %269 None
OpBranchConditional %268 %270 %269
%270 = OpLabel
OpBranch %213
%269 = OpLabel
OpBranch %214
%214 = OpLabel
%271 = OpLoad %uint %i_0
%272 = OpIAdd %uint %271 %uint_1
OpStore %i_0 %272
OpBranch %212
%213 = OpLabel
%273 = OpLoad %uint %clusterLightCount
%277 = OpAccessChain %_ptr_StorageBuffer_uint_0 %clusterLights %uint_0
%274 = OpAtomicIAdd %uint %277 %uint_1 %uint_0 %273
OpStore %offset %274
%279 = OpLoad %uint %offset
%280 = OpUGreaterThanEqual %bool %279 %uint_1769472
OpSelectionMerge %281 None
OpBranchConditional %280 %282 %281
%282 = OpLabel
OpReturn
%281 = OpLabel
OpStore %i_1 %uint_0
OpBranch %284
%284 = OpLabel
OpLoopMerge %285 %286 None
OpBranch %287
%287 = OpLabel
%289 = OpLoad %uint %i_1
%290 = OpLoad %uint %clusterLightCount
%291 = OpULessThan %bool %289 %290
%288 = OpLogicalNot %bool %291
OpSelectionMerge %292 None
OpBranchConditional %288 %293 %292
%293 = OpLabel
OpBranch %285
%292 = OpLabel
%294 = OpLoad %uint %offset
%295 = OpLoad %uint %i_1
%296 = OpIAdd %uint %294 %295
%297 = OpAccessChain %_ptr_StorageBuffer_uint %clusterLights %uint_2 %296
%298 = OpLoad %uint %i_1
%299 = OpAccessChain %_ptr_Function_uint %cluserLightIndices %298
%300 = OpLoad %uint %299
OpStore %297 %300
OpBranch %286
%286 = OpLabel
%301 = OpLoad %uint %i_1
%302 = OpIAdd %uint %301 %uint_1
OpStore %i_1 %302
OpBranch %284
%285 = OpLabel
%303 = OpAccessChain %_ptr_StorageBuffer_uint %clusterLights %uint_1 %202 %uint_0
%304 = OpLoad %uint %offset
OpStore %303 %304
%305 = OpAccessChain %_ptr_StorageBuffer_uint %clusterLights %uint_1 %202 %uint_1
%306 = OpLoad %uint %clusterLightCount
OpStore %305 %306
OpReturn
OpFunctionEnd
%computeMain = OpFunction %void None %307
%309 = OpLabel
%311 = OpLoad %v3uint %global_id_1
%310 = OpFunctionCall %void %computeMain_inner %311
OpReturn
OpFunctionEnd

119
test/benchmark/cluster-lights.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,119 @@
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@group(0) @binding(0) var<uniform> camera : Camera;
struct ClusterBounds {
minAABB : vec3<f32>;
maxAABB : vec3<f32>;
}
struct Clusters {
bounds : array<ClusterBounds, 27648>;
}
@group(0) @binding(1) var<storage, read> clusters : Clusters;
struct ClusterLights {
offset : u32;
count : u32;
}
struct ClusterLightGroup {
offset : atomic<u32>;
lights : array<ClusterLights, 27648>;
indices : array<u32, 1769472>;
}
@group(0) @binding(2) var<storage, read_write> clusterLights : ClusterLightGroup;
struct Light {
position : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
struct GlobalLights {
ambient : vec3<f32>;
dirColor : vec3<f32>;
dirIntensity : f32;
dirDirection : vec3<f32>;
lightCount : u32;
lights : array<Light>;
}
@group(0) @binding(3) var<storage, read> globalLights : GlobalLights;
let tileCount = vec3(32u, 18u, 48u);
fn linearDepth(depthSample : f32) -> f32 {
return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}
fn getTile(fragCoord : vec4<f32>) -> vec3<u32> {
let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear)));
let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0));
return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile);
}
fn getClusterIndex(fragCoord : vec4<f32>) -> u32 {
let tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
fn sqDistPointAABB(point : vec3<f32>, minAABB : vec3<f32>, maxAABB : vec3<f32>) -> f32 {
var sqDist = 0.0;
for(var i : i32 = 0; (i < 3); i = (i + 1)) {
let v = point[i];
if ((v < minAABB[i])) {
sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
}
if ((v > maxAABB[i])) {
sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
}
}
return sqDist;
}
@stage(compute) @workgroup_size(4, 2, 4)
fn computeMain(@builtin(global_invocation_id) global_id : vec3<u32>) {
let tileIndex = ((global_id.x + (global_id.y * tileCount.x)) + ((global_id.z * tileCount.x) * tileCount.y));
var clusterLightCount = 0u;
var cluserLightIndices : array<u32, 256>;
for(var i = 0u; (i < globalLights.lightCount); i = (i + 1u)) {
let range = globalLights.lights[i].range;
var lightInCluster : bool = (range <= 0.0);
if (!(lightInCluster)) {
let lightViewPos = (camera.view * vec4(globalLights.lights[i].position, 1.0));
let sqDist = sqDistPointAABB(lightViewPos.xyz, clusters.bounds[tileIndex].minAABB, clusters.bounds[tileIndex].maxAABB);
lightInCluster = (sqDist <= (range * range));
}
if (lightInCluster) {
cluserLightIndices[clusterLightCount] = i;
clusterLightCount = (clusterLightCount + 1u);
}
if ((clusterLightCount == 256u)) {
break;
}
}
let lightCount = clusterLightCount;
var offset = atomicAdd(&(clusterLights.offset), lightCount);
if ((offset >= 1769472u)) {
return;
}
for(var i = 0u; (i < clusterLightCount); i = (i + 1u)) {
clusterLights.indices[(offset + i)] = cluserLightIndices[i];
}
clusterLights.lights[tileIndex].offset = offset;
clusterLights.lights[tileIndex].count = clusterLightCount;
}

12
test/benchmark/empty.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,12 @@
#version 310 es
precision mediump float;
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void unused_entry_point() {
return;
}
void main() {
unused_entry_point();
}

205
test/benchmark/metaball-isosurface.wgsl Normal file
View File

@ -0,0 +1,205 @@
struct Tables {
edges : array<u32, 256>;
tris : array<i32, 4096>;
}
@group(0) @binding(0) var<storage> tables : Tables;
struct IsosurfaceVolume {
min : vec3<f32>;
max : vec3<f32>;
step : vec3<f32>;
size : vec3<u32>;
threshold : f32;
values : array<f32>;
}
@group(0) @binding(1) var<storage, write> volume : IsosurfaceVolume;
struct PositionBuffer {
values : array<f32>;
}
@group(0) @binding(2) var<storage, write> positionsOut : PositionBuffer;
struct NormalBuffer {
values : array<f32>;
}
@group(0) @binding(3) var<storage, write> normalsOut : NormalBuffer;
struct IndexBuffer {
tris : array<u32>;
}
@group(0) @binding(4) var<storage, write> indicesOut : IndexBuffer;
struct DrawIndirectArgs {
vc : u32;
vertexCount : atomic<u32>;
firstVertex : u32;
firstInstance : u32;
indexCount : atomic<u32>;
indexedInstanceCount : u32;
indexedFirstIndex : u32;
indexedBaseVertex : u32;
indexedFirstInstance : u32;
}
@group(0) @binding(5) var<storage, read_write> drawOut : DrawIndirectArgs;
fn valueAt(index : vec3<u32>) -> f32 {
if (any((index >= volume.size))) {
return 0.0;
}
let valueIndex = ((index.x + (index.y * volume.size.x)) + ((index.z * volume.size.x) * volume.size.y));
return volume.values[valueIndex];
}
fn positionAt(index : vec3<u32>) -> vec3<f32> {
return (volume.min + (volume.step * vec3<f32>(index.xyz)));
}
fn normalAt(index : vec3<u32>) -> vec3<f32> {
return vec3<f32>((valueAt((index - vec3<u32>(1u, 0u, 0u))) - valueAt((index + vec3<u32>(1u, 0u, 0u)))), (valueAt((index - vec3<u32>(0u, 1u, 0u))) - valueAt((index + vec3<u32>(0u, 1u, 0u)))), (valueAt((index - vec3<u32>(0u, 0u, 1u))) - valueAt((index + vec3<u32>(0u, 0u, 1u)))));
}
var<private> positions : array<vec3<f32>, 12>;
var<private> normals : array<vec3<f32>, 12>;
var<private> indices : array<u32, 12>;
var<private> cubeVerts : u32 = 0u;
fn interpX(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>((volume.step.x * mu), 0.0, 0.0));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(1u, 0u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
fn interpY(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>(0.0, (volume.step.y * mu), 0.0));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(0u, 1u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
fn interpZ(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>(0.0, 0.0, (volume.step.z * mu)));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(0u, 0u, 1u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
@stage(compute) @workgroup_size(4, 4, 4)
fn computeMain(@builtin(global_invocation_id) global_id : vec3<u32>) {
let i0 = global_id;
let i1 = (global_id + vec3<u32>(1u, 0u, 0u));
let i2 = (global_id + vec3<u32>(1u, 1u, 0u));
let i3 = (global_id + vec3<u32>(0u, 1u, 0u));
let i4 = (global_id + vec3<u32>(0u, 0u, 1u));
let i5 = (global_id + vec3<u32>(1u, 0u, 1u));
let i6 = (global_id + vec3<u32>(1u, 1u, 1u));
let i7 = (global_id + vec3<u32>(0u, 1u, 1u));
let v0 = valueAt(i0);
let v1 = valueAt(i1);
let v2 = valueAt(i2);
let v3 = valueAt(i3);
let v4 = valueAt(i4);
let v5 = valueAt(i5);
let v6 = valueAt(i6);
let v7 = valueAt(i7);
var cubeIndex = 0u;
if ((v0 < volume.threshold)) {
cubeIndex = (cubeIndex | 1u);
}
if ((v1 < volume.threshold)) {
cubeIndex = (cubeIndex | 2u);
}
if ((v2 < volume.threshold)) {
cubeIndex = (cubeIndex | 4u);
}
if ((v3 < volume.threshold)) {
cubeIndex = (cubeIndex | 8u);
}
if ((v4 < volume.threshold)) {
cubeIndex = (cubeIndex | 16u);
}
if ((v5 < volume.threshold)) {
cubeIndex = (cubeIndex | 32u);
}
if ((v6 < volume.threshold)) {
cubeIndex = (cubeIndex | 64u);
}
if ((v7 < volume.threshold)) {
cubeIndex = (cubeIndex | 128u);
}
let edges = tables.edges[cubeIndex];
if (((edges & 1u) != 0u)) {
interpX(0u, i0, v0, v1);
}
if (((edges & 2u) != 0u)) {
interpY(1u, i1, v1, v2);
}
if (((edges & 4u) != 0u)) {
interpX(2u, i3, v3, v2);
}
if (((edges & 8u) != 0u)) {
interpY(3u, i0, v0, v3);
}
if (((edges & 16u) != 0u)) {
interpX(4u, i4, v4, v5);
}
if (((edges & 32u) != 0u)) {
interpY(5u, i5, v5, v6);
}
if (((edges & 64u) != 0u)) {
interpX(6u, i7, v7, v6);
}
if (((edges & 128u) != 0u)) {
interpY(7u, i4, v4, v7);
}
if (((edges & 256u) != 0u)) {
interpZ(8u, i0, v0, v4);
}
if (((edges & 512u) != 0u)) {
interpZ(9u, i1, v1, v5);
}
if (((edges & 1024u) != 0u)) {
interpZ(10u, i2, v2, v6);
}
if (((edges & 2048u) != 0u)) {
interpZ(11u, i3, v3, v7);
}
let triTableOffset = ((cubeIndex << 4u) + 1u);
let indexCount = u32(tables.tris[(triTableOffset - 1u)]);
var firstVertex = atomicAdd(&(drawOut.vertexCount), cubeVerts);
let bufferOffset = ((global_id.x + (global_id.y * volume.size.x)) + ((global_id.z * volume.size.x) * volume.size.y));
let firstIndex = (bufferOffset * 15u);
for(var i = 0u; (i < cubeVerts); i = (i + 1u)) {
positionsOut.values[((firstVertex * 3u) + (i * 3u))] = positions[i].x;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = positions[i].y;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = positions[i].z;
normalsOut.values[((firstVertex * 3u) + (i * 3u))] = normals[i].x;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = normals[i].y;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = normals[i].z;
}
for(var i = 0u; (i < indexCount); i = (i + 1u)) {
let index = tables.tris[(triTableOffset + i)];
indicesOut.tris[(firstIndex + i)] = (firstVertex + indices[index]);
}
for(var i = indexCount; (i < 15u); i = (i + 1u)) {
indicesOut.tris[(firstIndex + i)] = firstVertex;
}
}

232
test/benchmark/metaball-isosurface.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,232 @@
#version 310 es
precision mediump float;
struct Tables {
uint edges[256];
int tris[4096];
};
layout (binding = 0) buffer Tables_1 {
uint edges[256];
int tris[4096];
} tables;
layout (binding = 1) buffer IsosurfaceVolume_1 {
vec3 tint_symbol;
vec3 tint_symbol_1;
vec3 tint_symbol_2;
uvec3 size;
float threshold;
float values[];
} volume;
layout (binding = 2) buffer PositionBuffer_1 {
float values[];
} positionsOut;
layout (binding = 3) buffer NormalBuffer_1 {
float values[];
} normalsOut;
layout (binding = 4) buffer IndexBuffer_1 {
uint tris[];
} indicesOut;
struct DrawIndirectArgs {
uint vc;
uint vertexCount;
uint firstVertex;
uint firstInstance;
uint indexCount;
uint indexedInstanceCount;
uint indexedFirstIndex;
uint indexedBaseVertex;
uint indexedFirstInstance;
};
layout (binding = 5) buffer DrawIndirectArgs_1 {
uint vc;
uint vertexCount;
uint firstVertex;
uint firstInstance;
uint indexCount;
uint indexedInstanceCount;
uint indexedFirstIndex;
uint indexedBaseVertex;
uint indexedFirstInstance;
} drawOut;
float valueAt(uvec3 index) {
if (any(greaterThanEqual(index, volume.size))) {
return 0.0f;
}
uint valueIndex = ((index.x + (index.y * volume.size.x)) + ((index.z * volume.size.x) * volume.size.y));
return volume.values[valueIndex];
}
vec3 positionAt(uvec3 index) {
return (volume.tint_symbol + (volume.tint_symbol_2 * vec3(index.xyz)));
}
vec3 normalAt(uvec3 index) {
return vec3((valueAt((index - uvec3(1u, 0u, 0u))) - valueAt((index + uvec3(1u, 0u, 0u)))), (valueAt((index - uvec3(0u, 1u, 0u))) - valueAt((index + uvec3(0u, 1u, 0u)))), (valueAt((index - uvec3(0u, 0u, 1u))) - valueAt((index + uvec3(0u, 0u, 1u)))));
}
vec3 positions[12] = vec3[12](vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
vec3 normals[12] = vec3[12](vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
uint indices[12] = uint[12](0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u);
uint cubeVerts = 0u;
void interpX(uint index, uvec3 i, float va, float vb) {
float mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3((volume.tint_symbol_2.x * mu), 0.0f, 0.0f));
vec3 na = normalAt(i);
vec3 nb = normalAt((i + uvec3(1u, 0u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
void interpY(uint index, uvec3 i, float va, float vb) {
float mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3(0.0f, (volume.tint_symbol_2.y * mu), 0.0f));
vec3 na = normalAt(i);
vec3 nb = normalAt((i + uvec3(0u, 1u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
void interpZ(uint index, uvec3 i, float va, float vb) {
float mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3(0.0f, 0.0f, (volume.tint_symbol_2.z * mu)));
vec3 na = normalAt(i);
vec3 nb = normalAt((i + uvec3(0u, 0u, 1u)));
normals[cubeVerts] = mix(na, nb, vec3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
struct tint_symbol_4 {
uvec3 global_id;
};
void computeMain_inner(uvec3 global_id) {
uvec3 i0 = global_id;
uvec3 i1 = (global_id + uvec3(1u, 0u, 0u));
uvec3 i2 = (global_id + uvec3(1u, 1u, 0u));
uvec3 i3 = (global_id + uvec3(0u, 1u, 0u));
uvec3 i4 = (global_id + uvec3(0u, 0u, 1u));
uvec3 i5 = (global_id + uvec3(1u, 0u, 1u));
uvec3 i6 = (global_id + uvec3(1u, 1u, 1u));
uvec3 i7 = (global_id + uvec3(0u, 1u, 1u));
float v0 = valueAt(i0);
float v1 = valueAt(i1);
float v2 = valueAt(i2);
float v3 = valueAt(i3);
float v4 = valueAt(i4);
float v5 = valueAt(i5);
float v6 = valueAt(i6);
float v7 = valueAt(i7);
uint cubeIndex = 0u;
if ((v0 < volume.threshold)) {
cubeIndex = (cubeIndex | 1u);
}
if ((v1 < volume.threshold)) {
cubeIndex = (cubeIndex | 2u);
}
if ((v2 < volume.threshold)) {
cubeIndex = (cubeIndex | 4u);
}
if ((v3 < volume.threshold)) {
cubeIndex = (cubeIndex | 8u);
}
if ((v4 < volume.threshold)) {
cubeIndex = (cubeIndex | 16u);
}
if ((v5 < volume.threshold)) {
cubeIndex = (cubeIndex | 32u);
}
if ((v6 < volume.threshold)) {
cubeIndex = (cubeIndex | 64u);
}
if ((v7 < volume.threshold)) {
cubeIndex = (cubeIndex | 128u);
}
uint edges = tables.edges[cubeIndex];
if (((edges & 1u) != 0u)) {
interpX(0u, i0, v0, v1);
}
if (((edges & 2u) != 0u)) {
interpY(1u, i1, v1, v2);
}
if (((edges & 4u) != 0u)) {
interpX(2u, i3, v3, v2);
}
if (((edges & 8u) != 0u)) {
interpY(3u, i0, v0, v3);
}
if (((edges & 16u) != 0u)) {
interpX(4u, i4, v4, v5);
}
if (((edges & 32u) != 0u)) {
interpY(5u, i5, v5, v6);
}
if (((edges & 64u) != 0u)) {
interpX(6u, i7, v7, v6);
}
if (((edges & 128u) != 0u)) {
interpY(7u, i4, v4, v7);
}
if (((edges & 256u) != 0u)) {
interpZ(8u, i0, v0, v4);
}
if (((edges & 512u) != 0u)) {
interpZ(9u, i1, v1, v5);
}
if (((edges & 1024u) != 0u)) {
interpZ(10u, i2, v2, v6);
}
if (((edges & 2048u) != 0u)) {
interpZ(11u, i3, v3, v7);
}
uint triTableOffset = ((cubeIndex << 4u) + 1u);
uint indexCount = uint(tables.tris[(triTableOffset - 1u)]);
uint firstVertex = atomicAdd(drawOut.vertexCount, cubeVerts);
uint bufferOffset = ((global_id.x + (global_id.y * volume.size.x)) + ((global_id.z * volume.size.x) * volume.size.y));
uint firstIndex = (bufferOffset * 15u);
{
for(uint i = 0u; (i < cubeVerts); i = (i + 1u)) {
positionsOut.values[((firstVertex * 3u) + (i * 3u))] = positions[i].x;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = positions[i].y;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = positions[i].z;
normalsOut.values[((firstVertex * 3u) + (i * 3u))] = normals[i].x;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = normals[i].y;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = normals[i].z;
}
}
{
for(uint i = 0u; (i < indexCount); i = (i + 1u)) {
int index = tables.tris[(triTableOffset + i)];
indicesOut.tris[(firstIndex + i)] = (firstVertex + indices[index]);
}
}
{
for(uint i = indexCount; (i < 15u); i = (i + 1u)) {
indicesOut.tris[(firstIndex + i)] = firstVertex;
}
}
}
layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;
void computeMain(tint_symbol_4 tint_symbol_3) {
computeMain_inner(tint_symbol_3.global_id);
return;
}
void main() {
tint_symbol_4 inputs;
inputs.global_id = gl_GlobalInvocationID;
computeMain(inputs);
}

185
test/benchmark/metaball-isosurface.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,185 @@
uint atomicAdd_1(RWByteAddressBuffer buffer, uint offset, uint value) {
uint original_value = 0;
buffer.InterlockedAdd(offset, value, original_value);
return original_value;
}
ByteAddressBuffer tables : register(t0, space0);
RWByteAddressBuffer volume : register(u1, space0);
RWByteAddressBuffer positionsOut : register(u2, space0);
RWByteAddressBuffer normalsOut : register(u3, space0);
RWByteAddressBuffer indicesOut : register(u4, space0);
RWByteAddressBuffer drawOut : register(u5, space0);
float valueAt(uint3 index) {
if (any((index >= volume.Load3(48u)))) {
return 0.0f;
}
const uint valueIndex = ((index.x + (index.y * volume.Load(48u))) + ((index.z * volume.Load(48u)) * volume.Load(52u)));
return asfloat(volume.Load((64u + (4u * valueIndex))));
}
float3 positionAt(uint3 index) {
return (asfloat(volume.Load3(0u)) + (asfloat(volume.Load3(32u)) * float3(index.xyz)));
}
float3 normalAt(uint3 index) {
return float3((valueAt((index - uint3(1u, 0u, 0u))) - valueAt((index + uint3(1u, 0u, 0u)))), (valueAt((index - uint3(0u, 1u, 0u))) - valueAt((index + uint3(0u, 1u, 0u)))), (valueAt((index - uint3(0u, 0u, 1u))) - valueAt((index + uint3(0u, 0u, 1u)))));
}
static float3 positions[12] = (float3[12])0;
static float3 normals[12] = (float3[12])0;
static uint indices[12] = (uint[12])0;
static uint cubeVerts = 0u;
void interpX(uint index, uint3 i, float va, float vb) {
const float mu = ((asfloat(volume.Load(60u)) - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + float3((asfloat(volume.Load(32u)) * mu), 0.0f, 0.0f));
const float3 na = normalAt(i);
const float3 nb = normalAt((i + uint3(1u, 0u, 0u)));
normals[cubeVerts] = lerp(na, nb, float3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
void interpY(uint index, uint3 i, float va, float vb) {
const float mu = ((asfloat(volume.Load(60u)) - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + float3(0.0f, (asfloat(volume.Load(36u)) * mu), 0.0f));
const float3 na = normalAt(i);
const float3 nb = normalAt((i + uint3(0u, 1u, 0u)));
normals[cubeVerts] = lerp(na, nb, float3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
void interpZ(uint index, uint3 i, float va, float vb) {
const float mu = ((asfloat(volume.Load(60u)) - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + float3(0.0f, 0.0f, (asfloat(volume.Load(40u)) * mu)));
const float3 na = normalAt(i);
const float3 nb = normalAt((i + uint3(0u, 0u, 1u)));
normals[cubeVerts] = lerp(na, nb, float3(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
struct tint_symbol_1 {
uint3 global_id : SV_DispatchThreadID;
};
void computeMain_inner(uint3 global_id) {
const uint3 i0 = global_id;
const uint3 i1 = (global_id + uint3(1u, 0u, 0u));
const uint3 i2 = (global_id + uint3(1u, 1u, 0u));
const uint3 i3 = (global_id + uint3(0u, 1u, 0u));
const uint3 i4 = (global_id + uint3(0u, 0u, 1u));
const uint3 i5 = (global_id + uint3(1u, 0u, 1u));
const uint3 i6 = (global_id + uint3(1u, 1u, 1u));
const uint3 i7 = (global_id + uint3(0u, 1u, 1u));
const float v0 = valueAt(i0);
const float v1 = valueAt(i1);
const float v2 = valueAt(i2);
const float v3 = valueAt(i3);
const float v4 = valueAt(i4);
const float v5 = valueAt(i5);
const float v6 = valueAt(i6);
const float v7 = valueAt(i7);
uint cubeIndex = 0u;
if ((v0 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 1u);
}
if ((v1 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 2u);
}
if ((v2 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 4u);
}
if ((v3 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 8u);
}
if ((v4 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 16u);
}
if ((v5 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 32u);
}
if ((v6 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 64u);
}
if ((v7 < asfloat(volume.Load(60u)))) {
cubeIndex = (cubeIndex | 128u);
}
const uint edges = tables.Load((4u * cubeIndex));
if (((edges & 1u) != 0u)) {
interpX(0u, i0, v0, v1);
}
if (((edges & 2u) != 0u)) {
interpY(1u, i1, v1, v2);
}
if (((edges & 4u) != 0u)) {
interpX(2u, i3, v3, v2);
}
if (((edges & 8u) != 0u)) {
interpY(3u, i0, v0, v3);
}
if (((edges & 16u) != 0u)) {
interpX(4u, i4, v4, v5);
}
if (((edges & 32u) != 0u)) {
interpY(5u, i5, v5, v6);
}
if (((edges & 64u) != 0u)) {
interpX(6u, i7, v7, v6);
}
if (((edges & 128u) != 0u)) {
interpY(7u, i4, v4, v7);
}
if (((edges & 256u) != 0u)) {
interpZ(8u, i0, v0, v4);
}
if (((edges & 512u) != 0u)) {
interpZ(9u, i1, v1, v5);
}
if (((edges & 1024u) != 0u)) {
interpZ(10u, i2, v2, v6);
}
if (((edges & 2048u) != 0u)) {
interpZ(11u, i3, v3, v7);
}
const uint triTableOffset = ((cubeIndex << 4u) + 1u);
const uint indexCount = uint(asint(tables.Load((1024u + (4u * (triTableOffset - 1u))))));
uint firstVertex = atomicAdd_1(drawOut, 4u, cubeVerts);
const uint bufferOffset = ((global_id.x + (global_id.y * volume.Load(48u))) + ((global_id.z * volume.Load(48u)) * volume.Load(52u)));
const uint firstIndex = (bufferOffset * 15u);
{
[loop] for(uint i = 0u; (i < cubeVerts); i = (i + 1u)) {
positionsOut.Store((4u * ((firstVertex * 3u) + (i * 3u))), asuint(positions[i].x));
positionsOut.Store((4u * (((firstVertex * 3u) + (i * 3u)) + 1u)), asuint(positions[i].y));
positionsOut.Store((4u * (((firstVertex * 3u) + (i * 3u)) + 2u)), asuint(positions[i].z));
normalsOut.Store((4u * ((firstVertex * 3u) + (i * 3u))), asuint(normals[i].x));
normalsOut.Store((4u * (((firstVertex * 3u) + (i * 3u)) + 1u)), asuint(normals[i].y));
normalsOut.Store((4u * (((firstVertex * 3u) + (i * 3u)) + 2u)), asuint(normals[i].z));
}
}
{
[loop] for(uint i = 0u; (i < indexCount); i = (i + 1u)) {
const int index = asint(tables.Load((1024u + (4u * (triTableOffset + i)))));
indicesOut.Store((4u * (firstIndex + i)), asuint((firstVertex + indices[index])));
}
}
{
[loop] for(uint i = indexCount; (i < 15u); i = (i + 1u)) {
indicesOut.Store((4u * (firstIndex + i)), asuint(firstVertex));
}
}
}
[numthreads(4, 4, 4)]
void computeMain(tint_symbol_1 tint_symbol) {
computeMain_inner(tint_symbol.global_id);
return;
}

219
test/benchmark/metaball-isosurface.wgsl.expected.msl Normal file
View File

@ -0,0 +1,219 @@
#include <metal_stdlib>
using namespace metal;
template<typename T, int N, int M>
inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
return lhs * vec<T, N>(rhs);
}
template<typename T, int N, int M>
inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
return vec<T, M>(lhs) * rhs;
}
struct tint_array_wrapper {
/* 0x0000 */ uint arr[256];
};
struct tint_array_wrapper_1 {
/* 0x0000 */ int arr[4096];
};
struct Tables {
/* 0x0000 */ tint_array_wrapper edges;
/* 0x0400 */ tint_array_wrapper_1 tris;
};
struct IsosurfaceVolume {
/* 0x0000 */ packed_float3 min;
/* 0x000c */ int8_t tint_pad[4];
/* 0x0010 */ packed_float3 max;
/* 0x001c */ int8_t tint_pad_1[4];
/* 0x0020 */ packed_float3 step;
/* 0x002c */ int8_t tint_pad_2[4];
/* 0x0030 */ packed_uint3 size;
/* 0x003c */ float threshold;
/* 0x0040 */ float values[1];
/* 0x0044 */ int8_t tint_pad_3[12];
};
struct PositionBuffer {
/* 0x0000 */ float values[1];
};
struct NormalBuffer {
/* 0x0000 */ float values[1];
};
struct IndexBuffer {
/* 0x0000 */ uint tris[1];
};
struct DrawIndirectArgs {
/* 0x0000 */ uint vc;
/* 0x0004 */ atomic_uint vertexCount;
/* 0x0008 */ uint firstVertex;
/* 0x000c */ uint firstInstance;
/* 0x0010 */ atomic_uint indexCount;
/* 0x0014 */ uint indexedInstanceCount;
/* 0x0018 */ uint indexedFirstIndex;
/* 0x001c */ uint indexedBaseVertex;
/* 0x0020 */ uint indexedFirstInstance;
};
struct tint_array_wrapper_2 {
float3 arr[12];
};
struct tint_array_wrapper_3 {
uint arr[12];
};
float valueAt(uint3 index, device IsosurfaceVolume* const tint_symbol) {
if (any((index >= (*(tint_symbol)).size))) {
return 0.0f;
}
uint const valueIndex = ((index[0] + (index[1] * (*(tint_symbol)).size[0])) + ((index[2] * (*(tint_symbol)).size[0]) * (*(tint_symbol)).size[1]));
return (*(tint_symbol)).values[valueIndex];
}
float3 positionAt(uint3 index, device IsosurfaceVolume* const tint_symbol_1) {
return ((*(tint_symbol_1)).min + ((*(tint_symbol_1)).step * float3(uint3(index).xyz)));
}
float3 normalAt(uint3 index, device IsosurfaceVolume* const tint_symbol_2) {
return float3((valueAt((index - uint3(1u, 0u, 0u)), tint_symbol_2) - valueAt((index + uint3(1u, 0u, 0u)), tint_symbol_2)), (valueAt((index - uint3(0u, 1u, 0u)), tint_symbol_2) - valueAt((index + uint3(0u, 1u, 0u)), tint_symbol_2)), (valueAt((index - uint3(0u, 0u, 1u)), tint_symbol_2) - valueAt((index + uint3(0u, 0u, 1u)), tint_symbol_2)));
}
void interpX(uint index, uint3 i, float va, float vb, device IsosurfaceVolume* const tint_symbol_3, thread tint_array_wrapper_2* const tint_symbol_4, thread uint* const tint_symbol_5, thread tint_array_wrapper_2* const tint_symbol_6, thread tint_array_wrapper_3* const tint_symbol_7) {
float const mu = (((*(tint_symbol_3)).threshold - va) / (vb - va));
(*(tint_symbol_4)).arr[*(tint_symbol_5)] = (positionAt(i, tint_symbol_3) + float3(((*(tint_symbol_3)).step[0] * mu), 0.0f, 0.0f));
float3 const na = normalAt(i, tint_symbol_3);
float3 const nb = normalAt((i + uint3(1u, 0u, 0u)), tint_symbol_3);
(*(tint_symbol_6)).arr[*(tint_symbol_5)] = mix(na, nb, float3(mu, mu, mu));
(*(tint_symbol_7)).arr[index] = *(tint_symbol_5);
*(tint_symbol_5) = (*(tint_symbol_5) + 1u);
}
void interpY(uint index, uint3 i, float va, float vb, device IsosurfaceVolume* const tint_symbol_8, thread tint_array_wrapper_2* const tint_symbol_9, thread uint* const tint_symbol_10, thread tint_array_wrapper_2* const tint_symbol_11, thread tint_array_wrapper_3* const tint_symbol_12) {
float const mu = (((*(tint_symbol_8)).threshold - va) / (vb - va));
(*(tint_symbol_9)).arr[*(tint_symbol_10)] = (positionAt(i, tint_symbol_8) + float3(0.0f, ((*(tint_symbol_8)).step[1] * mu), 0.0f));
float3 const na = normalAt(i, tint_symbol_8);
float3 const nb = normalAt((i + uint3(0u, 1u, 0u)), tint_symbol_8);
(*(tint_symbol_11)).arr[*(tint_symbol_10)] = mix(na, nb, float3(mu, mu, mu));
(*(tint_symbol_12)).arr[index] = *(tint_symbol_10);
*(tint_symbol_10) = (*(tint_symbol_10) + 1u);
}
void interpZ(uint index, uint3 i, float va, float vb, device IsosurfaceVolume* const tint_symbol_13, thread tint_array_wrapper_2* const tint_symbol_14, thread uint* const tint_symbol_15, thread tint_array_wrapper_2* const tint_symbol_16, thread tint_array_wrapper_3* const tint_symbol_17) {
float const mu = (((*(tint_symbol_13)).threshold - va) / (vb - va));
(*(tint_symbol_14)).arr[*(tint_symbol_15)] = (positionAt(i, tint_symbol_13) + float3(0.0f, 0.0f, ((*(tint_symbol_13)).step[2] * mu)));
float3 const na = normalAt(i, tint_symbol_13);
float3 const nb = normalAt((i + uint3(0u, 0u, 1u)), tint_symbol_13);
(*(tint_symbol_16)).arr[*(tint_symbol_15)] = mix(na, nb, float3(mu, mu, mu));
(*(tint_symbol_17)).arr[index] = *(tint_symbol_15);
*(tint_symbol_15) = (*(tint_symbol_15) + 1u);
}
void computeMain_inner(uint3 global_id, device IsosurfaceVolume* const tint_symbol_18, const device Tables* const tint_symbol_19, thread tint_array_wrapper_2* const tint_symbol_20, thread uint* const tint_symbol_21, thread tint_array_wrapper_2* const tint_symbol_22, thread tint_array_wrapper_3* const tint_symbol_23, device DrawIndirectArgs* const tint_symbol_24, device PositionBuffer* const tint_symbol_25, device NormalBuffer* const tint_symbol_26, device IndexBuffer* const tint_symbol_27) {
uint3 const i0 = global_id;
uint3 const i1 = (global_id + uint3(1u, 0u, 0u));
uint3 const i2 = (global_id + uint3(1u, 1u, 0u));
uint3 const i3 = (global_id + uint3(0u, 1u, 0u));
uint3 const i4 = (global_id + uint3(0u, 0u, 1u));
uint3 const i5 = (global_id + uint3(1u, 0u, 1u));
uint3 const i6 = (global_id + uint3(1u, 1u, 1u));
uint3 const i7 = (global_id + uint3(0u, 1u, 1u));
float const v0 = valueAt(i0, tint_symbol_18);
float const v1 = valueAt(i1, tint_symbol_18);
float const v2 = valueAt(i2, tint_symbol_18);
float const v3 = valueAt(i3, tint_symbol_18);
float const v4 = valueAt(i4, tint_symbol_18);
float const v5 = valueAt(i5, tint_symbol_18);
float const v6 = valueAt(i6, tint_symbol_18);
float const v7 = valueAt(i7, tint_symbol_18);
uint cubeIndex = 0u;
if ((v0 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 1u);
}
if ((v1 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 2u);
}
if ((v2 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 4u);
}
if ((v3 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 8u);
}
if ((v4 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 16u);
}
if ((v5 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 32u);
}
if ((v6 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 64u);
}
if ((v7 < (*(tint_symbol_18)).threshold)) {
cubeIndex = (cubeIndex | 128u);
}
uint const edges = (*(tint_symbol_19)).edges.arr[cubeIndex];
if (((edges & 1u) != 0u)) {
interpX(0u, i0, v0, v1, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 2u) != 0u)) {
interpY(1u, i1, v1, v2, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 4u) != 0u)) {
interpX(2u, i3, v3, v2, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 8u) != 0u)) {
interpY(3u, i0, v0, v3, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 16u) != 0u)) {
interpX(4u, i4, v4, v5, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 32u) != 0u)) {
interpY(5u, i5, v5, v6, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 64u) != 0u)) {
interpX(6u, i7, v7, v6, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 128u) != 0u)) {
interpY(7u, i4, v4, v7, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 256u) != 0u)) {
interpZ(8u, i0, v0, v4, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 512u) != 0u)) {
interpZ(9u, i1, v1, v5, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 1024u) != 0u)) {
interpZ(10u, i2, v2, v6, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
if (((edges & 2048u) != 0u)) {
interpZ(11u, i3, v3, v7, tint_symbol_18, tint_symbol_20, tint_symbol_21, tint_symbol_22, tint_symbol_23);
}
uint const triTableOffset = ((cubeIndex << 4u) + 1u);
uint const indexCount = uint((*(tint_symbol_19)).tris.arr[(triTableOffset - 1u)]);
uint firstVertex = atomic_fetch_add_explicit(&((*(tint_symbol_24)).vertexCount), *(tint_symbol_21), memory_order_relaxed);
uint const bufferOffset = ((global_id[0] + (global_id[1] * (*(tint_symbol_18)).size[0])) + ((global_id[2] * (*(tint_symbol_18)).size[0]) * (*(tint_symbol_18)).size[1]));
uint const firstIndex = (bufferOffset * 15u);
for(uint i = 0u; (i < *(tint_symbol_21)); i = (i + 1u)) {
(*(tint_symbol_25)).values[((firstVertex * 3u) + (i * 3u))] = (*(tint_symbol_20)).arr[i][0];
(*(tint_symbol_25)).values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = (*(tint_symbol_20)).arr[i][1];
(*(tint_symbol_25)).values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = (*(tint_symbol_20)).arr[i][2];
(*(tint_symbol_26)).values[((firstVertex * 3u) + (i * 3u))] = (*(tint_symbol_22)).arr[i][0];
(*(tint_symbol_26)).values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = (*(tint_symbol_22)).arr[i][1];
(*(tint_symbol_26)).values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = (*(tint_symbol_22)).arr[i][2];
}
for(uint i = 0u; (i < indexCount); i = (i + 1u)) {
int const index = (*(tint_symbol_19)).tris.arr[(triTableOffset + i)];
(*(tint_symbol_27)).tris[(firstIndex + i)] = (firstVertex + (*(tint_symbol_23)).arr[index]);
}
for(uint i = indexCount; (i < 15u); i = (i + 1u)) {
(*(tint_symbol_27)).tris[(firstIndex + i)] = firstVertex;
}
}
kernel void computeMain(device IsosurfaceVolume* tint_symbol_28 [[buffer(0)]], const device Tables* tint_symbol_29 [[buffer(5)]], device DrawIndirectArgs* tint_symbol_34 [[buffer(1)]], device PositionBuffer* tint_symbol_35 [[buffer(2)]], device NormalBuffer* tint_symbol_36 [[buffer(3)]], device IndexBuffer* tint_symbol_37 [[buffer(4)]], uint3 global_id [[thread_position_in_grid]]) {
thread tint_array_wrapper_2 tint_symbol_30 = {};
thread uint tint_symbol_31 = 0u;
thread tint_array_wrapper_2 tint_symbol_32 = {};
thread tint_array_wrapper_3 tint_symbol_33 = {};
computeMain_inner(global_id, tint_symbol_28, tint_symbol_29, &(tint_symbol_30), &(tint_symbol_31), &(tint_symbol_32), &(tint_symbol_33), tint_symbol_34, tint_symbol_35, tint_symbol_36, tint_symbol_37);
return;
}

777
test/benchmark/metaball-isosurface.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,777 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 515
; Schema: 0
OpCapability Shader
%145 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %computeMain "computeMain" %global_id_1
OpExecutionMode %computeMain LocalSize 4 4 4
OpName %global_id_1 "global_id_1"
OpName %Tables "Tables"
OpMemberName %Tables 0 "edges"
OpMemberName %Tables 1 "tris"
OpName %tables "tables"
OpName %IsosurfaceVolume "IsosurfaceVolume"
OpMemberName %IsosurfaceVolume 0 "min"
OpMemberName %IsosurfaceVolume 1 "max"
OpMemberName %IsosurfaceVolume 2 "step"
OpMemberName %IsosurfaceVolume 3 "size"
OpMemberName %IsosurfaceVolume 4 "threshold"
OpMemberName %IsosurfaceVolume 5 "values"
OpName %volume "volume"
OpName %PositionBuffer "PositionBuffer"
OpMemberName %PositionBuffer 0 "values"
OpName %positionsOut "positionsOut"
OpName %NormalBuffer "NormalBuffer"
OpMemberName %NormalBuffer 0 "values"
OpName %normalsOut "normalsOut"
OpName %IndexBuffer "IndexBuffer"
OpMemberName %IndexBuffer 0 "tris"
OpName %indicesOut "indicesOut"
OpName %DrawIndirectArgs "DrawIndirectArgs"
OpMemberName %DrawIndirectArgs 0 "vc"
OpMemberName %DrawIndirectArgs 1 "vertexCount"
OpMemberName %DrawIndirectArgs 2 "firstVertex"
OpMemberName %DrawIndirectArgs 3 "firstInstance"
OpMemberName %DrawIndirectArgs 4 "indexCount"
OpMemberName %DrawIndirectArgs 5 "indexedInstanceCount"
OpMemberName %DrawIndirectArgs 6 "indexedFirstIndex"
OpMemberName %DrawIndirectArgs 7 "indexedBaseVertex"
OpMemberName %DrawIndirectArgs 8 "indexedFirstInstance"
OpName %drawOut "drawOut"
OpName %positions "positions"
OpName %normals "normals"
OpName %indices "indices"
OpName %cubeVerts "cubeVerts"
OpName %valueAt "valueAt"
OpName %index "index"
OpName %positionAt "positionAt"
OpName %index_0 "index"
OpName %normalAt "normalAt"
OpName %index_1 "index"
OpName %interpX "interpX"
OpName %index_2 "index"
OpName %i "i"
OpName %va "va"
OpName %vb "vb"
OpName %interpY "interpY"
OpName %index_3 "index"
OpName %i_0 "i"
OpName %va_0 "va"
OpName %vb_0 "vb"
OpName %interpZ "interpZ"
OpName %index_4 "index"
OpName %i_1 "i"
OpName %va_1 "va"
OpName %vb_1 "vb"
OpName %computeMain_inner "computeMain_inner"
OpName %global_id "global_id"
OpName %cubeIndex "cubeIndex"
OpName %firstVertex "firstVertex"
OpName %i_2 "i"
OpName %i_3 "i"
OpName %i_4 "i"
OpName %computeMain "computeMain"
OpDecorate %global_id_1 BuiltIn GlobalInvocationId
OpDecorate %Tables Block
OpMemberDecorate %Tables 0 Offset 0
OpDecorate %_arr_uint_uint_256 ArrayStride 4
OpMemberDecorate %Tables 1 Offset 1024
OpDecorate %_arr_int_uint_4096 ArrayStride 4
OpDecorate %tables NonWritable
OpDecorate %tables DescriptorSet 0
OpDecorate %tables Binding 0
OpDecorate %IsosurfaceVolume Block
OpMemberDecorate %IsosurfaceVolume 0 Offset 0
OpMemberDecorate %IsosurfaceVolume 1 Offset 16
OpMemberDecorate %IsosurfaceVolume 2 Offset 32
OpMemberDecorate %IsosurfaceVolume 3 Offset 48
OpMemberDecorate %IsosurfaceVolume 4 Offset 60
OpMemberDecorate %IsosurfaceVolume 5 Offset 64
OpDecorate %_runtimearr_float ArrayStride 4
OpDecorate %volume NonReadable
OpDecorate %volume DescriptorSet 0
OpDecorate %volume Binding 1
OpDecorate %PositionBuffer Block
OpMemberDecorate %PositionBuffer 0 Offset 0
OpDecorate %positionsOut NonReadable
OpDecorate %positionsOut DescriptorSet 0
OpDecorate %positionsOut Binding 2
OpDecorate %NormalBuffer Block
OpMemberDecorate %NormalBuffer 0 Offset 0
OpDecorate %normalsOut NonReadable
OpDecorate %normalsOut DescriptorSet 0
OpDecorate %normalsOut Binding 3
OpDecorate %IndexBuffer Block
OpMemberDecorate %IndexBuffer 0 Offset 0
OpDecorate %_runtimearr_uint ArrayStride 4
OpDecorate %indicesOut NonReadable
OpDecorate %indicesOut DescriptorSet 0
OpDecorate %indicesOut Binding 4
OpDecorate %DrawIndirectArgs Block
OpMemberDecorate %DrawIndirectArgs 0 Offset 0
OpMemberDecorate %DrawIndirectArgs 1 Offset 4
OpMemberDecorate %DrawIndirectArgs 2 Offset 8
OpMemberDecorate %DrawIndirectArgs 3 Offset 12
OpMemberDecorate %DrawIndirectArgs 4 Offset 16
OpMemberDecorate %DrawIndirectArgs 5 Offset 20
OpMemberDecorate %DrawIndirectArgs 6 Offset 24
OpMemberDecorate %DrawIndirectArgs 7 Offset 28
OpMemberDecorate %DrawIndirectArgs 8 Offset 32
OpDecorate %drawOut DescriptorSet 0
OpDecorate %drawOut Binding 5
OpDecorate %_arr_v3float_uint_12 ArrayStride 16
OpDecorate %_arr_uint_uint_12 ArrayStride 4
%uint = OpTypeInt 32 0
%v3uint = OpTypeVector %uint 3
%_ptr_Input_v3uint = OpTypePointer Input %v3uint
%global_id_1 = OpVariable %_ptr_Input_v3uint Input
%uint_256 = OpConstant %uint 256
%_arr_uint_uint_256 = OpTypeArray %uint %uint_256
%int = OpTypeInt 32 1
%uint_4096 = OpConstant %uint 4096
%_arr_int_uint_4096 = OpTypeArray %int %uint_4096
%Tables = OpTypeStruct %_arr_uint_uint_256 %_arr_int_uint_4096
%_ptr_StorageBuffer_Tables = OpTypePointer StorageBuffer %Tables
%tables = OpVariable %_ptr_StorageBuffer_Tables StorageBuffer
%float = OpTypeFloat 32
%v3float = OpTypeVector %float 3
%_runtimearr_float = OpTypeRuntimeArray %float
%IsosurfaceVolume = OpTypeStruct %v3float %v3float %v3float %v3uint %float %_runtimearr_float
%_ptr_StorageBuffer_IsosurfaceVolume = OpTypePointer StorageBuffer %IsosurfaceVolume
%volume = OpVariable %_ptr_StorageBuffer_IsosurfaceVolume StorageBuffer
%PositionBuffer = OpTypeStruct %_runtimearr_float
%_ptr_StorageBuffer_PositionBuffer = OpTypePointer StorageBuffer %PositionBuffer
%positionsOut = OpVariable %_ptr_StorageBuffer_PositionBuffer StorageBuffer
%NormalBuffer = OpTypeStruct %_runtimearr_float
%_ptr_StorageBuffer_NormalBuffer = OpTypePointer StorageBuffer %NormalBuffer
%normalsOut = OpVariable %_ptr_StorageBuffer_NormalBuffer StorageBuffer
%_runtimearr_uint = OpTypeRuntimeArray %uint
%IndexBuffer = OpTypeStruct %_runtimearr_uint
%_ptr_StorageBuffer_IndexBuffer = OpTypePointer StorageBuffer %IndexBuffer
%indicesOut = OpVariable %_ptr_StorageBuffer_IndexBuffer StorageBuffer
%DrawIndirectArgs = OpTypeStruct %uint %uint %uint %uint %uint %uint %uint %uint %uint
%_ptr_StorageBuffer_DrawIndirectArgs = OpTypePointer StorageBuffer %DrawIndirectArgs
%drawOut = OpVariable %_ptr_StorageBuffer_DrawIndirectArgs StorageBuffer
%uint_12 = OpConstant %uint 12
%_arr_v3float_uint_12 = OpTypeArray %v3float %uint_12
%_ptr_Private__arr_v3float_uint_12 = OpTypePointer Private %_arr_v3float_uint_12
%36 = OpConstantNull %_arr_v3float_uint_12
%positions = OpVariable %_ptr_Private__arr_v3float_uint_12 Private %36
%normals = OpVariable %_ptr_Private__arr_v3float_uint_12 Private %36
%_arr_uint_uint_12 = OpTypeArray %uint %uint_12
%_ptr_Private__arr_uint_uint_12 = OpTypePointer Private %_arr_uint_uint_12
%41 = OpConstantNull %_arr_uint_uint_12
%indices = OpVariable %_ptr_Private__arr_uint_uint_12 Private %41
%uint_0 = OpConstant %uint 0
%_ptr_Private_uint = OpTypePointer Private %uint
%cubeVerts = OpVariable %_ptr_Private_uint Private %uint_0
%45 = OpTypeFunction %float %v3uint
%bool = OpTypeBool
%uint_3 = OpConstant %uint 3
%_ptr_StorageBuffer_v3uint = OpTypePointer StorageBuffer %v3uint
%v3bool = OpTypeVector %bool 3
%float_0 = OpConstant %float 0
%_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint
%uint_1 = OpConstant %uint 1
%uint_5 = OpConstant %uint 5
%_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float
%80 = OpTypeFunction %v3float %v3uint
%_ptr_StorageBuffer_v3float = OpTypePointer StorageBuffer %v3float
%uint_2 = OpConstant %uint 2
%98 = OpConstantComposite %v3uint %uint_1 %uint_0 %uint_0
%104 = OpConstantComposite %v3uint %uint_0 %uint_1 %uint_0
%110 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_1
%void = OpTypeVoid
%116 = OpTypeFunction %void %uint %v3uint %float %float
%uint_4 = OpConstant %uint 4
%_ptr_Private_v3float = OpTypePointer Private %v3float
%211 = OpTypeFunction %void %v3uint
%216 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_0
%220 = OpConstantComposite %v3uint %uint_1 %uint_0 %uint_1
%222 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1
%224 = OpConstantComposite %v3uint %uint_0 %uint_1 %uint_1
%_ptr_Function_uint = OpTypePointer Function %uint
%236 = OpConstantNull %uint
%uint_8 = OpConstant %uint 8
%uint_16 = OpConstant %uint 16
%uint_32 = OpConstant %uint 32
%uint_64 = OpConstant %uint 64
%uint_128 = OpConstant %uint 128
%uint_6 = OpConstant %uint 6
%uint_7 = OpConstant %uint 7
%uint_512 = OpConstant %uint 512
%uint_9 = OpConstant %uint 9
%uint_1024 = OpConstant %uint 1024
%uint_10 = OpConstant %uint 10
%uint_2048 = OpConstant %uint 2048
%uint_11 = OpConstant %uint 11
%_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int
%_ptr_StorageBuffer_uint_0 = OpTypePointer StorageBuffer %uint
%uint_15 = OpConstant %uint 15
%_ptr_Private_float = OpTypePointer Private %float
%510 = OpTypeFunction %void
%valueAt = OpFunction %float None %45
%index = OpFunctionParameter %v3uint
%48 = OpLabel
%53 = OpAccessChain %_ptr_StorageBuffer_v3uint %volume %uint_3
%54 = OpLoad %v3uint %53
%55 = OpUGreaterThanEqual %v3bool %index %54
%49 = OpAny %bool %55
OpSelectionMerge %57 None
OpBranchConditional %49 %58 %57
%58 = OpLabel
OpReturnValue %float_0
%57 = OpLabel
%60 = OpCompositeExtract %uint %index 0
%61 = OpCompositeExtract %uint %index 1
%63 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_0
%64 = OpLoad %uint %63
%65 = OpIMul %uint %61 %64
%66 = OpIAdd %uint %60 %65
%67 = OpCompositeExtract %uint %index 2
%68 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_0
%69 = OpLoad %uint %68
%70 = OpIMul %uint %67 %69
%72 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_1
%73 = OpLoad %uint %72
%74 = OpIMul %uint %70 %73
%75 = OpIAdd %uint %66 %74
%78 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_5 %75
%79 = OpLoad %float %78
OpReturnValue %79
OpFunctionEnd
%positionAt = OpFunction %v3float None %80
%index_0 = OpFunctionParameter %v3uint
%83 = OpLabel
%85 = OpAccessChain %_ptr_StorageBuffer_v3float %volume %uint_0
%86 = OpLoad %v3float %85
%88 = OpAccessChain %_ptr_StorageBuffer_v3float %volume %uint_2
%89 = OpLoad %v3float %88
%91 = OpVectorShuffle %v3uint %index_0 %index_0 0 1 2
%90 = OpConvertUToF %v3float %91
%92 = OpFMul %v3float %89 %90
%93 = OpFAdd %v3float %86 %92
OpReturnValue %93
OpFunctionEnd
%normalAt = OpFunction %v3float None %80
%index_1 = OpFunctionParameter %v3uint
%96 = OpLabel
%99 = OpISub %v3uint %index_1 %98
%97 = OpFunctionCall %float %valueAt %99
%101 = OpIAdd %v3uint %index_1 %98
%100 = OpFunctionCall %float %valueAt %101
%102 = OpFSub %float %97 %100
%105 = OpISub %v3uint %index_1 %104
%103 = OpFunctionCall %float %valueAt %105
%107 = OpIAdd %v3uint %index_1 %104
%106 = OpFunctionCall %float %valueAt %107
%108 = OpFSub %float %103 %106
%111 = OpISub %v3uint %index_1 %110
%109 = OpFunctionCall %float %valueAt %111
%113 = OpIAdd %v3uint %index_1 %110
%112 = OpFunctionCall %float %valueAt %113
%114 = OpFSub %float %109 %112
%115 = OpCompositeConstruct %v3float %102 %108 %114
OpReturnValue %115
OpFunctionEnd
%interpX = OpFunction %void None %116
%index_2 = OpFunctionParameter %uint
%i = OpFunctionParameter %v3uint
%va = OpFunctionParameter %float
%vb = OpFunctionParameter %float
%123 = OpLabel
%125 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%126 = OpLoad %float %125
%127 = OpFSub %float %126 %va
%128 = OpFSub %float %vb %va
%129 = OpFDiv %float %127 %128
%130 = OpLoad %uint %cubeVerts
%132 = OpAccessChain %_ptr_Private_v3float %positions %130
%133 = OpFunctionCall %v3float %positionAt %i
%134 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_2 %uint_0
%135 = OpLoad %float %134
%136 = OpFMul %float %135 %129
%137 = OpCompositeConstruct %v3float %136 %float_0 %float_0
%138 = OpFAdd %v3float %133 %137
OpStore %132 %138
%139 = OpFunctionCall %v3float %normalAt %i
%141 = OpIAdd %v3uint %i %98
%140 = OpFunctionCall %v3float %normalAt %141
%142 = OpLoad %uint %cubeVerts
%143 = OpAccessChain %_ptr_Private_v3float %normals %142
%146 = OpCompositeConstruct %v3float %129 %129 %129
%144 = OpExtInst %v3float %145 FMix %139 %140 %146
OpStore %143 %144
%147 = OpAccessChain %_ptr_Private_uint %indices %index_2
%148 = OpLoad %uint %cubeVerts
OpStore %147 %148
%149 = OpLoad %uint %cubeVerts
%150 = OpIAdd %uint %149 %uint_1
OpStore %cubeVerts %150
OpReturn
OpFunctionEnd
%interpY = OpFunction %void None %116
%index_3 = OpFunctionParameter %uint
%i_0 = OpFunctionParameter %v3uint
%va_0 = OpFunctionParameter %float
%vb_0 = OpFunctionParameter %float
%156 = OpLabel
%157 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%158 = OpLoad %float %157
%159 = OpFSub %float %158 %va_0
%160 = OpFSub %float %vb_0 %va_0
%161 = OpFDiv %float %159 %160
%162 = OpLoad %uint %cubeVerts
%163 = OpAccessChain %_ptr_Private_v3float %positions %162
%164 = OpFunctionCall %v3float %positionAt %i_0
%165 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_2 %uint_1
%166 = OpLoad %float %165
%167 = OpFMul %float %166 %161
%168 = OpCompositeConstruct %v3float %float_0 %167 %float_0
%169 = OpFAdd %v3float %164 %168
OpStore %163 %169
%170 = OpFunctionCall %v3float %normalAt %i_0
%172 = OpIAdd %v3uint %i_0 %104
%171 = OpFunctionCall %v3float %normalAt %172
%173 = OpLoad %uint %cubeVerts
%174 = OpAccessChain %_ptr_Private_v3float %normals %173
%176 = OpCompositeConstruct %v3float %161 %161 %161
%175 = OpExtInst %v3float %145 FMix %170 %171 %176
OpStore %174 %175
%177 = OpAccessChain %_ptr_Private_uint %indices %index_3
%178 = OpLoad %uint %cubeVerts
OpStore %177 %178
%179 = OpLoad %uint %cubeVerts
%180 = OpIAdd %uint %179 %uint_1
OpStore %cubeVerts %180
OpReturn
OpFunctionEnd
%interpZ = OpFunction %void None %116
%index_4 = OpFunctionParameter %uint
%i_1 = OpFunctionParameter %v3uint
%va_1 = OpFunctionParameter %float
%vb_1 = OpFunctionParameter %float
%186 = OpLabel
%187 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%188 = OpLoad %float %187
%189 = OpFSub %float %188 %va_1
%190 = OpFSub %float %vb_1 %va_1
%191 = OpFDiv %float %189 %190
%192 = OpLoad %uint %cubeVerts
%193 = OpAccessChain %_ptr_Private_v3float %positions %192
%194 = OpFunctionCall %v3float %positionAt %i_1
%195 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_2 %uint_2
%196 = OpLoad %float %195
%197 = OpFMul %float %196 %191
%198 = OpCompositeConstruct %v3float %float_0 %float_0 %197
%199 = OpFAdd %v3float %194 %198
OpStore %193 %199
%200 = OpFunctionCall %v3float %normalAt %i_1
%202 = OpIAdd %v3uint %i_1 %110
%201 = OpFunctionCall %v3float %normalAt %202
%203 = OpLoad %uint %cubeVerts
%204 = OpAccessChain %_ptr_Private_v3float %normals %203
%206 = OpCompositeConstruct %v3float %191 %191 %191
%205 = OpExtInst %v3float %145 FMix %200 %201 %206
OpStore %204 %205
%207 = OpAccessChain %_ptr_Private_uint %indices %index_4
%208 = OpLoad %uint %cubeVerts
OpStore %207 %208
%209 = OpLoad %uint %cubeVerts
%210 = OpIAdd %uint %209 %uint_1
OpStore %cubeVerts %210
OpReturn
OpFunctionEnd
%computeMain_inner = OpFunction %void None %211
%global_id = OpFunctionParameter %v3uint
%214 = OpLabel
%cubeIndex = OpVariable %_ptr_Function_uint Function %236
%firstVertex = OpVariable %_ptr_Function_uint Function %236
%i_2 = OpVariable %_ptr_Function_uint Function %236
%i_3 = OpVariable %_ptr_Function_uint Function %236
%i_4 = OpVariable %_ptr_Function_uint Function %236
%215 = OpIAdd %v3uint %global_id %98
%217 = OpIAdd %v3uint %global_id %216
%218 = OpIAdd %v3uint %global_id %104
%219 = OpIAdd %v3uint %global_id %110
%221 = OpIAdd %v3uint %global_id %220
%223 = OpIAdd %v3uint %global_id %222
%225 = OpIAdd %v3uint %global_id %224
%226 = OpFunctionCall %float %valueAt %global_id
%227 = OpFunctionCall %float %valueAt %215
%228 = OpFunctionCall %float %valueAt %217
%229 = OpFunctionCall %float %valueAt %218
%230 = OpFunctionCall %float %valueAt %219
%231 = OpFunctionCall %float %valueAt %221
%232 = OpFunctionCall %float %valueAt %223
%233 = OpFunctionCall %float %valueAt %225
OpStore %cubeIndex %uint_0
%237 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%238 = OpLoad %float %237
%239 = OpFOrdLessThan %bool %226 %238
OpSelectionMerge %240 None
OpBranchConditional %239 %241 %240
%241 = OpLabel
%242 = OpLoad %uint %cubeIndex
%243 = OpBitwiseOr %uint %242 %uint_1
OpStore %cubeIndex %243
OpBranch %240
%240 = OpLabel
%244 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%245 = OpLoad %float %244
%246 = OpFOrdLessThan %bool %227 %245
OpSelectionMerge %247 None
OpBranchConditional %246 %248 %247
%248 = OpLabel
%249 = OpLoad %uint %cubeIndex
%250 = OpBitwiseOr %uint %249 %uint_2
OpStore %cubeIndex %250
OpBranch %247
%247 = OpLabel
%251 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%252 = OpLoad %float %251
%253 = OpFOrdLessThan %bool %228 %252
OpSelectionMerge %254 None
OpBranchConditional %253 %255 %254
%255 = OpLabel
%256 = OpLoad %uint %cubeIndex
%257 = OpBitwiseOr %uint %256 %uint_4
OpStore %cubeIndex %257
OpBranch %254
%254 = OpLabel
%258 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%259 = OpLoad %float %258
%260 = OpFOrdLessThan %bool %229 %259
OpSelectionMerge %261 None
OpBranchConditional %260 %262 %261
%262 = OpLabel
%263 = OpLoad %uint %cubeIndex
%265 = OpBitwiseOr %uint %263 %uint_8
OpStore %cubeIndex %265
OpBranch %261
%261 = OpLabel
%266 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%267 = OpLoad %float %266
%268 = OpFOrdLessThan %bool %230 %267
OpSelectionMerge %269 None
OpBranchConditional %268 %270 %269
%270 = OpLabel
%271 = OpLoad %uint %cubeIndex
%273 = OpBitwiseOr %uint %271 %uint_16
OpStore %cubeIndex %273
OpBranch %269
%269 = OpLabel
%274 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%275 = OpLoad %float %274
%276 = OpFOrdLessThan %bool %231 %275
OpSelectionMerge %277 None
OpBranchConditional %276 %278 %277
%278 = OpLabel
%279 = OpLoad %uint %cubeIndex
%281 = OpBitwiseOr %uint %279 %uint_32
OpStore %cubeIndex %281
OpBranch %277
%277 = OpLabel
%282 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%283 = OpLoad %float %282
%284 = OpFOrdLessThan %bool %232 %283
OpSelectionMerge %285 None
OpBranchConditional %284 %286 %285
%286 = OpLabel
%287 = OpLoad %uint %cubeIndex
%289 = OpBitwiseOr %uint %287 %uint_64
OpStore %cubeIndex %289
OpBranch %285
%285 = OpLabel
%290 = OpAccessChain %_ptr_StorageBuffer_float %volume %uint_4
%291 = OpLoad %float %290
%292 = OpFOrdLessThan %bool %233 %291
OpSelectionMerge %293 None
OpBranchConditional %292 %294 %293
%294 = OpLabel
%295 = OpLoad %uint %cubeIndex
%297 = OpBitwiseOr %uint %295 %uint_128
OpStore %cubeIndex %297
OpBranch %293
%293 = OpLabel
%298 = OpLoad %uint %cubeIndex
%299 = OpAccessChain %_ptr_StorageBuffer_uint %tables %uint_0 %298
%300 = OpLoad %uint %299
%301 = OpBitwiseAnd %uint %300 %uint_1
%302 = OpINotEqual %bool %301 %uint_0
OpSelectionMerge %303 None
OpBranchConditional %302 %304 %303
%304 = OpLabel
%305 = OpFunctionCall %void %interpX %uint_0 %global_id %226 %227
OpBranch %303
%303 = OpLabel
%306 = OpBitwiseAnd %uint %300 %uint_2
%307 = OpINotEqual %bool %306 %uint_0
OpSelectionMerge %308 None
OpBranchConditional %307 %309 %308
%309 = OpLabel
%310 = OpFunctionCall %void %interpY %uint_1 %215 %227 %228
OpBranch %308
%308 = OpLabel
%311 = OpBitwiseAnd %uint %300 %uint_4
%312 = OpINotEqual %bool %311 %uint_0
OpSelectionMerge %313 None
OpBranchConditional %312 %314 %313
%314 = OpLabel
%315 = OpFunctionCall %void %interpX %uint_2 %218 %229 %228
OpBranch %313
%313 = OpLabel
%316 = OpBitwiseAnd %uint %300 %uint_8
%317 = OpINotEqual %bool %316 %uint_0
OpSelectionMerge %318 None
OpBranchConditional %317 %319 %318
%319 = OpLabel
%320 = OpFunctionCall %void %interpY %uint_3 %global_id %226 %229
OpBranch %318
%318 = OpLabel
%321 = OpBitwiseAnd %uint %300 %uint_16
%322 = OpINotEqual %bool %321 %uint_0
OpSelectionMerge %323 None
OpBranchConditional %322 %324 %323
%324 = OpLabel
%325 = OpFunctionCall %void %interpX %uint_4 %219 %230 %231
OpBranch %323
%323 = OpLabel
%326 = OpBitwiseAnd %uint %300 %uint_32
%327 = OpINotEqual %bool %326 %uint_0
OpSelectionMerge %328 None
OpBranchConditional %327 %329 %328
%329 = OpLabel
%330 = OpFunctionCall %void %interpY %uint_5 %221 %231 %232
OpBranch %328
%328 = OpLabel
%331 = OpBitwiseAnd %uint %300 %uint_64
%332 = OpINotEqual %bool %331 %uint_0
OpSelectionMerge %333 None
OpBranchConditional %332 %334 %333
%334 = OpLabel
%335 = OpFunctionCall %void %interpX %uint_6 %225 %233 %232
OpBranch %333
%333 = OpLabel
%337 = OpBitwiseAnd %uint %300 %uint_128
%338 = OpINotEqual %bool %337 %uint_0
OpSelectionMerge %339 None
OpBranchConditional %338 %340 %339
%340 = OpLabel
%341 = OpFunctionCall %void %interpY %uint_7 %219 %230 %233
OpBranch %339
%339 = OpLabel
%343 = OpBitwiseAnd %uint %300 %uint_256
%344 = OpINotEqual %bool %343 %uint_0
OpSelectionMerge %345 None
OpBranchConditional %344 %346 %345
%346 = OpLabel
%347 = OpFunctionCall %void %interpZ %uint_8 %global_id %226 %230
OpBranch %345
%345 = OpLabel
%349 = OpBitwiseAnd %uint %300 %uint_512
%350 = OpINotEqual %bool %349 %uint_0
OpSelectionMerge %351 None
OpBranchConditional %350 %352 %351
%352 = OpLabel
%353 = OpFunctionCall %void %interpZ %uint_9 %215 %227 %231
OpBranch %351
%351 = OpLabel
%356 = OpBitwiseAnd %uint %300 %uint_1024
%357 = OpINotEqual %bool %356 %uint_0
OpSelectionMerge %358 None
OpBranchConditional %357 %359 %358
%359 = OpLabel
%360 = OpFunctionCall %void %interpZ %uint_10 %217 %228 %232
OpBranch %358
%358 = OpLabel
%363 = OpBitwiseAnd %uint %300 %uint_2048
%364 = OpINotEqual %bool %363 %uint_0
OpSelectionMerge %365 None
OpBranchConditional %364 %366 %365
%366 = OpLabel
%367 = OpFunctionCall %void %interpZ %uint_11 %218 %229 %233
OpBranch %365
%365 = OpLabel
%369 = OpLoad %uint %cubeIndex
%370 = OpShiftLeftLogical %uint %369 %uint_4
%371 = OpIAdd %uint %370 %uint_1
%373 = OpISub %uint %371 %uint_1
%375 = OpAccessChain %_ptr_StorageBuffer_int %tables %uint_1 %373
%376 = OpLoad %int %375
%372 = OpBitcast %uint %376
%380 = OpAccessChain %_ptr_StorageBuffer_uint_0 %drawOut %uint_1
%381 = OpLoad %uint %cubeVerts
%377 = OpAtomicIAdd %uint %380 %uint_1 %uint_0 %381
OpStore %firstVertex %377
%383 = OpCompositeExtract %uint %global_id 0
%384 = OpCompositeExtract %uint %global_id 1
%385 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_0
%386 = OpLoad %uint %385
%387 = OpIMul %uint %384 %386
%388 = OpIAdd %uint %383 %387
%389 = OpCompositeExtract %uint %global_id 2
%390 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_0
%391 = OpLoad %uint %390
%392 = OpIMul %uint %389 %391
%393 = OpAccessChain %_ptr_StorageBuffer_uint %volume %uint_3 %uint_1
%394 = OpLoad %uint %393
%395 = OpIMul %uint %392 %394
%396 = OpIAdd %uint %388 %395
%398 = OpIMul %uint %396 %uint_15
OpStore %i_2 %uint_0
OpBranch %400
%400 = OpLabel
OpLoopMerge %401 %402 None
OpBranch %403
%403 = OpLabel
%405 = OpLoad %uint %i_2
%406 = OpLoad %uint %cubeVerts
%407 = OpULessThan %bool %405 %406
%404 = OpLogicalNot %bool %407
OpSelectionMerge %408 None
OpBranchConditional %404 %409 %408
%409 = OpLabel
OpBranch %401
%408 = OpLabel
%410 = OpLoad %uint %firstVertex
%411 = OpIMul %uint %410 %uint_3
%412 = OpLoad %uint %i_2
%413 = OpIMul %uint %412 %uint_3
%414 = OpIAdd %uint %411 %413
%415 = OpAccessChain %_ptr_StorageBuffer_float %positionsOut %uint_0 %414
%416 = OpLoad %uint %i_2
%418 = OpAccessChain %_ptr_Private_float %positions %416 %uint_0
%419 = OpLoad %float %418
OpStore %415 %419
%420 = OpLoad %uint %firstVertex
%421 = OpIMul %uint %420 %uint_3
%422 = OpLoad %uint %i_2
%423 = OpIMul %uint %422 %uint_3
%424 = OpIAdd %uint %421 %423
%425 = OpIAdd %uint %424 %uint_1
%426 = OpAccessChain %_ptr_StorageBuffer_float %positionsOut %uint_0 %425
%427 = OpLoad %uint %i_2
%428 = OpAccessChain %_ptr_Private_float %positions %427 %uint_1
%429 = OpLoad %float %428
OpStore %426 %429
%430 = OpLoad %uint %firstVertex
%431 = OpIMul %uint %430 %uint_3
%432 = OpLoad %uint %i_2
%433 = OpIMul %uint %432 %uint_3
%434 = OpIAdd %uint %431 %433
%435 = OpIAdd %uint %434 %uint_2
%436 = OpAccessChain %_ptr_StorageBuffer_float %positionsOut %uint_0 %435
%437 = OpLoad %uint %i_2
%438 = OpAccessChain %_ptr_Private_float %positions %437 %uint_2
%439 = OpLoad %float %438
OpStore %436 %439
%440 = OpLoad %uint %firstVertex
%441 = OpIMul %uint %440 %uint_3
%442 = OpLoad %uint %i_2
%443 = OpIMul %uint %442 %uint_3
%444 = OpIAdd %uint %441 %443
%445 = OpAccessChain %_ptr_StorageBuffer_float %normalsOut %uint_0 %444
%446 = OpLoad %uint %i_2
%447 = OpAccessChain %_ptr_Private_float %normals %446 %uint_0
%448 = OpLoad %float %447
OpStore %445 %448
%449 = OpLoad %uint %firstVertex
%450 = OpIMul %uint %449 %uint_3
%451 = OpLoad %uint %i_2
%452 = OpIMul %uint %451 %uint_3
%453 = OpIAdd %uint %450 %452
%454 = OpIAdd %uint %453 %uint_1
%455 = OpAccessChain %_ptr_StorageBuffer_float %normalsOut %uint_0 %454
%456 = OpLoad %uint %i_2
%457 = OpAccessChain %_ptr_Private_float %normals %456 %uint_1
%458 = OpLoad %float %457
OpStore %455 %458
%459 = OpLoad %uint %firstVertex
%460 = OpIMul %uint %459 %uint_3
%461 = OpLoad %uint %i_2
%462 = OpIMul %uint %461 %uint_3
%463 = OpIAdd %uint %460 %462
%464 = OpIAdd %uint %463 %uint_2
%465 = OpAccessChain %_ptr_StorageBuffer_float %normalsOut %uint_0 %464
%466 = OpLoad %uint %i_2
%467 = OpAccessChain %_ptr_Private_float %normals %466 %uint_2
%468 = OpLoad %float %467
OpStore %465 %468
OpBranch %402
%402 = OpLabel
%469 = OpLoad %uint %i_2
%470 = OpIAdd %uint %469 %uint_1
OpStore %i_2 %470
OpBranch %400
%401 = OpLabel
OpStore %i_3 %uint_0
OpBranch %472
%472 = OpLabel
OpLoopMerge %473 %474 None
OpBranch %475
%475 = OpLabel
%477 = OpLoad %uint %i_3
%478 = OpULessThan %bool %477 %372
%476 = OpLogicalNot %bool %478
OpSelectionMerge %479 None
OpBranchConditional %476 %480 %479
%480 = OpLabel
OpBranch %473
%479 = OpLabel
%481 = OpLoad %uint %i_3
%482 = OpIAdd %uint %371 %481
%483 = OpAccessChain %_ptr_StorageBuffer_int %tables %uint_1 %482
%484 = OpLoad %int %483
%485 = OpLoad %uint %i_3
%486 = OpIAdd %uint %398 %485
%487 = OpAccessChain %_ptr_StorageBuffer_uint %indicesOut %uint_0 %486
%488 = OpLoad %uint %firstVertex
%489 = OpAccessChain %_ptr_Private_uint %indices %484
%490 = OpLoad %uint %489
%491 = OpIAdd %uint %488 %490
OpStore %487 %491
OpBranch %474
%474 = OpLabel
%492 = OpLoad %uint %i_3
%493 = OpIAdd %uint %492 %uint_1
OpStore %i_3 %493
OpBranch %472
%473 = OpLabel
OpStore %i_4 %372
OpBranch %495
%495 = OpLabel
OpLoopMerge %496 %497 None
OpBranch %498
%498 = OpLabel
%500 = OpLoad %uint %i_4
%501 = OpULessThan %bool %500 %uint_15
%499 = OpLogicalNot %bool %501
OpSelectionMerge %502 None
OpBranchConditional %499 %503 %502
%503 = OpLabel
OpBranch %496
%502 = OpLabel
%504 = OpLoad %uint %i_4
%505 = OpIAdd %uint %398 %504
%506 = OpAccessChain %_ptr_StorageBuffer_uint %indicesOut %uint_0 %505
%507 = OpLoad %uint %firstVertex
OpStore %506 %507
OpBranch %497
%497 = OpLabel
%508 = OpLoad %uint %i_4
%509 = OpIAdd %uint %508 %uint_1
OpStore %i_4 %509
OpBranch %495
%496 = OpLabel
OpReturn
OpFunctionEnd
%computeMain = OpFunction %void None %510
%512 = OpLabel
%514 = OpLoad %v3uint %global_id_1
%513 = OpFunctionCall %void %computeMain_inner %514
OpReturn
OpFunctionEnd

205
test/benchmark/metaball-isosurface.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,205 @@
struct Tables {
edges : array<u32, 256>;
tris : array<i32, 4096>;
}
@group(0) @binding(0) var<storage> tables : Tables;
struct IsosurfaceVolume {
min : vec3<f32>;
max : vec3<f32>;
step : vec3<f32>;
size : vec3<u32>;
threshold : f32;
values : array<f32>;
}
@group(0) @binding(1) var<storage, write> volume : IsosurfaceVolume;
struct PositionBuffer {
values : array<f32>;
}
@group(0) @binding(2) var<storage, write> positionsOut : PositionBuffer;
struct NormalBuffer {
values : array<f32>;
}
@group(0) @binding(3) var<storage, write> normalsOut : NormalBuffer;
struct IndexBuffer {
tris : array<u32>;
}
@group(0) @binding(4) var<storage, write> indicesOut : IndexBuffer;
struct DrawIndirectArgs {
vc : u32;
vertexCount : atomic<u32>;
firstVertex : u32;
firstInstance : u32;
indexCount : atomic<u32>;
indexedInstanceCount : u32;
indexedFirstIndex : u32;
indexedBaseVertex : u32;
indexedFirstInstance : u32;
}
@group(0) @binding(5) var<storage, read_write> drawOut : DrawIndirectArgs;
fn valueAt(index : vec3<u32>) -> f32 {
if (any((index >= volume.size))) {
return 0.0;
}
let valueIndex = ((index.x + (index.y * volume.size.x)) + ((index.z * volume.size.x) * volume.size.y));
return volume.values[valueIndex];
}
fn positionAt(index : vec3<u32>) -> vec3<f32> {
return (volume.min + (volume.step * vec3<f32>(index.xyz)));
}
fn normalAt(index : vec3<u32>) -> vec3<f32> {
return vec3<f32>((valueAt((index - vec3<u32>(1u, 0u, 0u))) - valueAt((index + vec3<u32>(1u, 0u, 0u)))), (valueAt((index - vec3<u32>(0u, 1u, 0u))) - valueAt((index + vec3<u32>(0u, 1u, 0u)))), (valueAt((index - vec3<u32>(0u, 0u, 1u))) - valueAt((index + vec3<u32>(0u, 0u, 1u)))));
}
var<private> positions : array<vec3<f32>, 12>;
var<private> normals : array<vec3<f32>, 12>;
var<private> indices : array<u32, 12>;
var<private> cubeVerts : u32 = 0u;
fn interpX(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>((volume.step.x * mu), 0.0, 0.0));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(1u, 0u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
fn interpY(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>(0.0, (volume.step.y * mu), 0.0));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(0u, 1u, 0u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
fn interpZ(index : u32, i : vec3<u32>, va : f32, vb : f32) {
let mu = ((volume.threshold - va) / (vb - va));
positions[cubeVerts] = (positionAt(i) + vec3<f32>(0.0, 0.0, (volume.step.z * mu)));
let na = normalAt(i);
let nb = normalAt((i + vec3<u32>(0u, 0u, 1u)));
normals[cubeVerts] = mix(na, nb, vec3<f32>(mu, mu, mu));
indices[index] = cubeVerts;
cubeVerts = (cubeVerts + 1u);
}
@stage(compute) @workgroup_size(4, 4, 4)
fn computeMain(@builtin(global_invocation_id) global_id : vec3<u32>) {
let i0 = global_id;
let i1 = (global_id + vec3<u32>(1u, 0u, 0u));
let i2 = (global_id + vec3<u32>(1u, 1u, 0u));
let i3 = (global_id + vec3<u32>(0u, 1u, 0u));
let i4 = (global_id + vec3<u32>(0u, 0u, 1u));
let i5 = (global_id + vec3<u32>(1u, 0u, 1u));
let i6 = (global_id + vec3<u32>(1u, 1u, 1u));
let i7 = (global_id + vec3<u32>(0u, 1u, 1u));
let v0 = valueAt(i0);
let v1 = valueAt(i1);
let v2 = valueAt(i2);
let v3 = valueAt(i3);
let v4 = valueAt(i4);
let v5 = valueAt(i5);
let v6 = valueAt(i6);
let v7 = valueAt(i7);
var cubeIndex = 0u;
if ((v0 < volume.threshold)) {
cubeIndex = (cubeIndex | 1u);
}
if ((v1 < volume.threshold)) {
cubeIndex = (cubeIndex | 2u);
}
if ((v2 < volume.threshold)) {
cubeIndex = (cubeIndex | 4u);
}
if ((v3 < volume.threshold)) {
cubeIndex = (cubeIndex | 8u);
}
if ((v4 < volume.threshold)) {
cubeIndex = (cubeIndex | 16u);
}
if ((v5 < volume.threshold)) {
cubeIndex = (cubeIndex | 32u);
}
if ((v6 < volume.threshold)) {
cubeIndex = (cubeIndex | 64u);
}
if ((v7 < volume.threshold)) {
cubeIndex = (cubeIndex | 128u);
}
let edges = tables.edges[cubeIndex];
if (((edges & 1u) != 0u)) {
interpX(0u, i0, v0, v1);
}
if (((edges & 2u) != 0u)) {
interpY(1u, i1, v1, v2);
}
if (((edges & 4u) != 0u)) {
interpX(2u, i3, v3, v2);
}
if (((edges & 8u) != 0u)) {
interpY(3u, i0, v0, v3);
}
if (((edges & 16u) != 0u)) {
interpX(4u, i4, v4, v5);
}
if (((edges & 32u) != 0u)) {
interpY(5u, i5, v5, v6);
}
if (((edges & 64u) != 0u)) {
interpX(6u, i7, v7, v6);
}
if (((edges & 128u) != 0u)) {
interpY(7u, i4, v4, v7);
}
if (((edges & 256u) != 0u)) {
interpZ(8u, i0, v0, v4);
}
if (((edges & 512u) != 0u)) {
interpZ(9u, i1, v1, v5);
}
if (((edges & 1024u) != 0u)) {
interpZ(10u, i2, v2, v6);
}
if (((edges & 2048u) != 0u)) {
interpZ(11u, i3, v3, v7);
}
let triTableOffset = ((cubeIndex << 4u) + 1u);
let indexCount = u32(tables.tris[(triTableOffset - 1u)]);
var firstVertex = atomicAdd(&(drawOut.vertexCount), cubeVerts);
let bufferOffset = ((global_id.x + (global_id.y * volume.size.x)) + ((global_id.z * volume.size.x) * volume.size.y));
let firstIndex = (bufferOffset * 15u);
for(var i = 0u; (i < cubeVerts); i = (i + 1u)) {
positionsOut.values[((firstVertex * 3u) + (i * 3u))] = positions[i].x;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = positions[i].y;
positionsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = positions[i].z;
normalsOut.values[((firstVertex * 3u) + (i * 3u))] = normals[i].x;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 1u)] = normals[i].y;
normalsOut.values[(((firstVertex * 3u) + (i * 3u)) + 2u)] = normals[i].z;
}
for(var i = 0u; (i < indexCount); i = (i + 1u)) {
let index = tables.tris[(triTableOffset + i)];
indicesOut.tris[(firstIndex + i)] = (firstVertex + indices[index]);
}
for(var i = indexCount; (i < 15u); i = (i + 1u)) {
indicesOut.tris[(firstIndex + i)] = firstVertex;
}
}

515
test/benchmark/particles.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,515 @@
SKIP: FAILED
#version 310 es
precision mediump float;
struct RenderParams {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
};
layout (binding = 0) uniform RenderParams_1 {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
} render_params;
struct VertexInput {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct VertexOutput {
vec4 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_4 {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_5 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
VertexOutput vs_main_inner(VertexInput tint_symbol) {
vec3 quad_pos = (mat2x3(render_params.right, render_params.up) * tint_symbol.quad_pos);
vec3 position = (tint_symbol.position + (quad_pos * 0.01f));
VertexOutput tint_symbol_1 = VertexOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f), vec2(0.0f, 0.0f));
tint_symbol_1.position = (render_params.modelViewProjectionMatrix * vec4(position, 1.0f));
tint_symbol_1.color = tint_symbol.color;
tint_symbol_1.quad_pos = tint_symbol.quad_pos;
return tint_symbol_1;
}
struct tint_symbol_7 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_8 {
vec4 value;
};
struct SimulationParams {
float deltaTime;
vec4 seed;
};
struct Particle {
vec3 position;
float lifetime;
vec4 color;
vec3 velocity;
};
struct tint_symbol_10 {
uvec3 GlobalInvocationID;
};
struct UBO {
uint width;
};
struct tint_symbol_12 {
uvec3 coord;
};
struct tint_symbol_14 {
uvec3 coord;
};
tint_symbol_5 vs_main(tint_symbol_4 tint_symbol_3) {
VertexInput tint_symbol_15 = VertexInput(tint_symbol_3.position, tint_symbol_3.color, tint_symbol_3.quad_pos);
VertexOutput inner_result = vs_main_inner(tint_symbol_15);
tint_symbol_5 wrapper_result = tint_symbol_5(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec2(0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.position = inner_result.position;
wrapper_result.color = inner_result.color;
wrapper_result.quad_pos = inner_result.quad_pos;
return wrapper_result;
}
in vec3 position;
in vec4 color;
in vec2 quad_pos;
out vec4 color;
out vec2 quad_pos;
void main() {
tint_symbol_4 inputs;
inputs.position = position;
inputs.color = color;
inputs.quad_pos = quad_pos;
tint_symbol_5 outputs;
outputs = vs_main(inputs);
color = outputs.color;
quad_pos = outputs.quad_pos;
gl_Position = outputs.position;
gl_Position.y = -gl_Position.y;
}
Error parsing GLSL shader:
ERROR: 0:90: 'color' : redefinition
ERROR: 1 compilation errors. No code generated.
#version 310 es
precision mediump float;
struct RenderParams {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
};
struct VertexInput {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct VertexOutput {
vec4 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_4 {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_5 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_7 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_8 {
vec4 value;
};
vec4 fs_main_inner(VertexOutput tint_symbol) {
vec4 color = tint_symbol.color;
color.a = (color.a * max((1.0f - length(tint_symbol.quad_pos)), 0.0f));
return color;
}
struct SimulationParams {
float deltaTime;
vec4 seed;
};
struct Particle {
vec3 position;
float lifetime;
vec4 color;
vec3 velocity;
};
struct tint_symbol_10 {
uvec3 GlobalInvocationID;
};
struct UBO {
uint width;
};
struct tint_symbol_12 {
uvec3 coord;
};
struct tint_symbol_14 {
uvec3 coord;
};
tint_symbol_8 fs_main(tint_symbol_7 tint_symbol_6) {
VertexOutput tint_symbol_15 = VertexOutput(tint_symbol_6.position, tint_symbol_6.color, tint_symbol_6.quad_pos);
vec4 inner_result_1 = fs_main_inner(tint_symbol_15);
tint_symbol_8 wrapper_result_1 = tint_symbol_8(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}
in vec4 color;
in vec2 quad_pos;
out vec4 value;
void main() {
tint_symbol_7 inputs;
inputs.color = color;
inputs.quad_pos = quad_pos;
inputs.position = gl_FragCoord;
tint_symbol_8 outputs;
outputs = fs_main(inputs);
value = outputs.value;
}
#version 310 es
precision mediump float;
vec2 rand_seed = vec2(0.0f, 0.0f);
float rand() {
rand_seed.x = frac((cos(dot(rand_seed, vec2(23.140779495f, 232.616897583f))) * 136.816802979f));
rand_seed.y = frac((cos(dot(rand_seed, vec2(54.478565216f, 345.841522217f))) * 534.764526367f));
return rand_seed.y;
}
struct RenderParams {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
};
struct VertexInput {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct VertexOutput {
vec4 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_4 {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_5 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_7 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_8 {
vec4 value;
};
struct SimulationParams {
float deltaTime;
vec4 seed;
};
struct Particle {
vec3 position;
float lifetime;
vec4 color;
vec3 velocity;
};
layout (binding = 0) uniform SimulationParams_1 {
float deltaTime;
vec4 seed;
} sim_params;
layout (binding = 1) buffer Particles_1 {
Particle particles[];
} data;
uniform highp sampler2D tint_symbol_2;
struct tint_symbol_10 {
uvec3 GlobalInvocationID;
};
void simulate_inner(uvec3 GlobalInvocationID) {
rand_seed = ((sim_params.seed.xy + vec2(GlobalInvocationID.xy)) * sim_params.seed.zw);
uint idx = GlobalInvocationID.x;
Particle particle = data.particles[idx];
particle.velocity.z = (particle.velocity.z - (sim_params.deltaTime * 0.5f));
particle.position = (particle.position + (sim_params.deltaTime * particle.velocity));
particle.lifetime = (particle.lifetime - sim_params.deltaTime);
particle.color.a = smoothstep(0.0f, 0.5f, particle.lifetime);
if ((particle.lifetime < 0.0f)) {
ivec2 coord = ivec2(0, 0);
{
for(int level = (textureQueryLevels(tint_symbol_2); - 1); (level > 0); level = (level - 1)) {
vec4 probabilites = texelFetch(tint_symbol_2, coord, level);
vec4 value = vec4(rand());
bvec4 mask = (greaterThanEqual(value, vec4(0.0f, probabilites.xyz)) & lessThan(value, probabilites));
coord = (coord * 2);
coord.x = (coord.x + (any(mask.yw) ? 1 : 0));
coord.y = (coord.y + (any(mask.zw) ? 1 : 0));
}
}
vec2 uv = (vec2(coord) / vec2(textureSize(tint_symbol_2, 0)));
particle.position = vec3((((uv - 0.5f) * 3.0f) * vec2(1.0f, -1.0f)), 0.0f);
particle.color = texelFetch(tint_symbol_2, coord, 0);
particle.velocity.x = ((rand() - 0.5f) * 0.100000001f);
particle.velocity.y = ((rand() - 0.5f) * 0.100000001f);
particle.velocity.z = (rand() * 0.300000012f);
particle.lifetime = (0.5f + (rand() * 2.0f));
}
data.particles[idx] = particle;
}
struct UBO {
uint width;
};
struct tint_symbol_12 {
uvec3 coord;
};
struct tint_symbol_14 {
uvec3 coord;
};
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
void simulate(tint_symbol_10 tint_symbol_9) {
simulate_inner(tint_symbol_9.GlobalInvocationID);
return;
}
void main() {
tint_symbol_10 inputs;
inputs.GlobalInvocationID = gl_GlobalInvocationID;
simulate(inputs);
}
Error parsing GLSL shader:
ERROR: 0:7: 'frac' : no matching overloaded function found
ERROR: 0:7: '' : compilation terminated
ERROR: 2 compilation errors. No code generated.
#version 310 es
precision mediump float;
struct RenderParams {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
};
struct VertexInput {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct VertexOutput {
vec4 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_4 {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_5 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_7 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_8 {
vec4 value;
};
struct SimulationParams {
float deltaTime;
vec4 seed;
};
struct Particle {
vec3 position;
float lifetime;
vec4 color;
vec3 velocity;
};
struct tint_symbol_10 {
uvec3 GlobalInvocationID;
};
struct UBO {
uint width;
};
layout (binding = 3) uniform UBO_1 {
uint width;
} ubo;
layout (binding = 4) buffer Buffer_1 {
float weights[];
} buf_in;
layout (binding = 5) buffer Buffer_2 {
float weights[];
} buf_out;
uniform highp sampler2D tex_in;
struct tint_symbol_12 {
uvec3 coord;
};
void import_level_inner(uvec3 coord) {
uint offset = (coord.x + (coord.y * ubo.width));
buf_out.weights[offset] = texelFetch(tex_in, ivec2(coord.xy), 0).w;
}
struct tint_symbol_14 {
uvec3 coord;
};
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
void import_level(tint_symbol_12 tint_symbol_11) {
import_level_inner(tint_symbol_11.coord);
return;
}
void main() {
tint_symbol_12 inputs;
inputs.coord = gl_GlobalInvocationID;
import_level(inputs);
}
#version 310 es
precision mediump float;
struct RenderParams {
mat4 modelViewProjectionMatrix;
vec3 right;
vec3 up;
};
struct VertexInput {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct VertexOutput {
vec4 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_4 {
vec3 position;
vec4 color;
vec2 quad_pos;
};
struct tint_symbol_5 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_7 {
vec4 color;
vec2 quad_pos;
vec4 position;
};
struct tint_symbol_8 {
vec4 value;
};
struct SimulationParams {
float deltaTime;
vec4 seed;
};
struct Particle {
vec3 position;
float lifetime;
vec4 color;
vec3 velocity;
};
struct tint_symbol_10 {
uvec3 GlobalInvocationID;
};
struct UBO {
uint width;
};
layout (binding = 3) uniform UBO_1 {
uint width;
} ubo;
layout (binding = 4) buffer Buffer_1 {
float weights[];
} buf_in;
layout (binding = 5) buffer Buffer_2 {
float weights[];
} buf_out;
uniform highp writeonly image2D tex_out;
struct tint_symbol_12 {
uvec3 coord;
};
struct tint_symbol_14 {
uvec3 coord;
};
void export_level_inner(uvec3 coord) {
if (all(lessThan(coord.xy, uvec2(imageSize(tex_out))))) {
uint dst_offset = (coord.x + (coord.y * ubo.width));
uint src_offset = ((coord.x * 2u) + ((coord.y * 2u) * ubo.width));
float a_1 = buf_in.weights[(src_offset + 0u)];
float b = buf_in.weights[(src_offset + 1u)];
float c = buf_in.weights[((src_offset + 0u) + ubo.width)];
float d = buf_in.weights[((src_offset + 1u) + ubo.width)];
float sum = dot(vec4(a_1, b, c, d), vec4(1.0f));
buf_out.weights[dst_offset] = (sum / 4.0f);
vec4 probabilities = (vec4(a_1, (a_1 + b), ((a_1 + b) + c), sum) / max(sum, 0.0001f));
imageStore(tex_out, ivec2(coord.xy), probabilities);
}
}
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
void export_level(tint_symbol_14 tint_symbol_13) {
export_level_inner(tint_symbol_13.coord);
return;
}
void main() {
tint_symbol_14 inputs;
inputs.coord = gl_GlobalInvocationID;
export_level(inputs);
}

42
test/benchmark/shadow-fragment.wgsl Normal file
View File

@ -0,0 +1,42 @@
let shadowDepthTextureSize : f32 = 1024.0;
struct Scene {
lightViewProjMatrix : mat4x4<f32>;
cameraViewProjMatrix : mat4x4<f32>;
lightPos : vec3<f32>;
}
@group(0) @binding(0) var<uniform> scene : Scene;
@group(0) @binding(1) var shadowMap : texture_depth_2d;
@group(0) @binding(2) var shadowSampler : sampler_comparison;
struct FragmentInput {
@location(0)
shadowPos : vec3<f32>;
@location(1)
fragPos : vec3<f32>;
@location(2)
fragNorm : vec3<f32>;
}
let albedo : vec3<f32> = vec3<f32>(0.899999976, 0.899999976, 0.899999976);
let ambientFactor : f32 = 0.200000003;
@stage(fragment)
fn main(input : FragmentInput) -> @location(0) vec4<f32> {
var visibility : f32 = 0.0;
let oneOverShadowDepthTextureSize = (1.0 / shadowDepthTextureSize);
for(var y : i32 = -1; (y <= 1); y = (y + 1)) {
for(var x : i32 = -1; (x <= 1); x = (x + 1)) {
let offset : vec2<f32> = vec2<f32>((f32(x) * oneOverShadowDepthTextureSize), (f32(y) * oneOverShadowDepthTextureSize));
visibility = (visibility + textureSampleCompare(shadowMap, shadowSampler, (input.shadowPos.xy + offset), (input.shadowPos.z - 0.007)));
}
}
visibility = (visibility / 9.0);
let lambertFactor : f32 = max(dot(normalize((scene.lightPos - input.fragPos)), input.fragNorm), 0.0);
let lightingFactor : f32 = min((ambientFactor + (visibility * lambertFactor)), 1.0);
return vec4<f32>((lightingFactor * albedo), 1.0);
}

87
test/benchmark/shadow-fragment.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,87 @@
SKIP: FAILED
#version 310 es
precision mediump float;
const float shadowDepthTextureSize = 1024.0f;
struct Scene {
mat4 lightViewProjMatrix;
mat4 cameraViewProjMatrix;
vec3 lightPos;
};
layout (binding = 0) uniform Scene_1 {
mat4 lightViewProjMatrix;
mat4 cameraViewProjMatrix;
vec3 lightPos;
} scene;
uniform highp sampler2D shadowMap;
struct FragmentInput {
vec3 shadowPos;
vec3 fragPos;
vec3 fragNorm;
};
const vec3 albedo = vec3(0.899999976f, 0.899999976f, 0.899999976f);
const float ambientFactor = 0.200000003f;
struct tint_symbol_3 {
vec3 shadowPos;
vec3 fragPos;
vec3 fragNorm;
};
struct tint_symbol_4 {
vec4 value;
};
vec4 tint_symbol_inner(FragmentInput tint_symbol_1) {
float visibility = 0.0f;
float oneOverShadowDepthTextureSize = (1.0f / shadowDepthTextureSize);
{
for(int y = -1; (y <= 1); y = (y + 1)) {
{
for(int x = -1; (x <= 1); x = (x + 1)) {
vec2 offset = vec2((float(x) * oneOverShadowDepthTextureSize), (float(y) * oneOverShadowDepthTextureSize));
visibility = (visibility + texture(shadowMap, (tint_symbol_1.shadowPos.xy + offset), (tint_symbol_1.shadowPos.z - 0.007f)));
}
}
}
}
visibility = (visibility / 9.0f);
float lambertFactor = max(dot(normalize((scene.lightPos - tint_symbol_1.fragPos)), tint_symbol_1.fragNorm), 0.0f);
float lightingFactor = min((ambientFactor + (visibility * lambertFactor)), 1.0f);
return vec4((lightingFactor * albedo), 1.0f);
}
tint_symbol_4 tint_symbol(tint_symbol_3 tint_symbol_2) {
FragmentInput tint_symbol_5 = FragmentInput(tint_symbol_2.shadowPos, tint_symbol_2.fragPos, tint_symbol_2.fragNorm);
vec4 inner_result = tint_symbol_inner(tint_symbol_5);
tint_symbol_4 wrapper_result = tint_symbol_4(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.value = inner_result;
return wrapper_result;
}
in vec3 shadowPos;
in vec3 fragPos;
in vec3 fragNorm;
out vec4 value;
void main() {
tint_symbol_3 inputs;
inputs.shadowPos = shadowPos;
inputs.fragPos = fragPos;
inputs.fragNorm = fragNorm;
tint_symbol_4 outputs;
outputs = tint_symbol(inputs);
value = outputs.value;
}
Error parsing GLSL shader:
ERROR: 0:46: 'assign' : cannot convert from ' temp highp 4-component vector of float' to ' temp mediump float'
ERROR: 0:46: '' : compilation terminated
ERROR: 2 compilation errors. No code generated.

52
test/benchmark/shadow-fragment.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,52 @@
static const float shadowDepthTextureSize = 1024.0f;
cbuffer cbuffer_scene : register(b0, space0) {
uint4 scene[9];
};
Texture2D shadowMap : register(t1, space0);
SamplerComparisonState shadowSampler : register(s2, space0);
struct FragmentInput {
float3 shadowPos;
float3 fragPos;
float3 fragNorm;
};
static const float3 albedo = float3(0.899999976f, 0.899999976f, 0.899999976f);
static const float ambientFactor = 0.200000003f;
struct tint_symbol_1 {
float3 shadowPos : TEXCOORD0;
float3 fragPos : TEXCOORD1;
float3 fragNorm : TEXCOORD2;
};
struct tint_symbol_2 {
float4 value : SV_Target0;
};
float4 main_inner(FragmentInput input) {
float visibility = 0.0f;
const float oneOverShadowDepthTextureSize = (1.0f / shadowDepthTextureSize);
{
[loop] for(int y = -1; (y <= 1); y = (y + 1)) {
{
[loop] for(int x = -1; (x <= 1); x = (x + 1)) {
const float2 offset = float2((float(x) * oneOverShadowDepthTextureSize), (float(y) * oneOverShadowDepthTextureSize));
visibility = (visibility + shadowMap.SampleCmp(shadowSampler, (input.shadowPos.xy + offset), (input.shadowPos.z - 0.007f)));
}
}
}
}
visibility = (visibility / 9.0f);
const float lambertFactor = max(dot(normalize((asfloat(scene[8].xyz) - input.fragPos)), input.fragNorm), 0.0f);
const float lightingFactor = min((ambientFactor + (visibility * lambertFactor)), 1.0f);
return float4((lightingFactor * albedo), 1.0f);
}
tint_symbol_2 main(tint_symbol_1 tint_symbol) {
const FragmentInput tint_symbol_4 = {tint_symbol.shadowPos, tint_symbol.fragPos, tint_symbol.fragNorm};
const float4 inner_result = main_inner(tint_symbol_4);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.value = inner_result;
return wrapper_result;
}

60
test/benchmark/shadow-fragment.wgsl.expected.msl Normal file
View File

@ -0,0 +1,60 @@
#include <metal_stdlib>
using namespace metal;
template<typename T, int N, int M>
inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
return lhs * vec<T, N>(rhs);
}
template<typename T, int N, int M>
inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
return vec<T, M>(lhs) * rhs;
}
struct Scene {
/* 0x0000 */ float4x4 lightViewProjMatrix;
/* 0x0040 */ float4x4 cameraViewProjMatrix;
/* 0x0080 */ packed_float3 lightPos;
/* 0x008c */ int8_t tint_pad[4];
};
struct FragmentInput {
float3 shadowPos;
float3 fragPos;
float3 fragNorm;
};
struct tint_symbol_2 {
float3 shadowPos [[user(locn0)]];
float3 fragPos [[user(locn1)]];
float3 fragNorm [[user(locn2)]];
};
struct tint_symbol_3 {
float4 value [[color(0)]];
};
constant float shadowDepthTextureSize = 1024.0f;
constant float3 albedo = float3(0.899999976f, 0.899999976f, 0.899999976f);
constant float ambientFactor = 0.200000003f;
float4 tint_symbol_inner(FragmentInput input, depth2d<float, access::sample> tint_symbol_5, sampler tint_symbol_6, const constant Scene* const tint_symbol_7) {
float visibility = 0.0f;
float const oneOverShadowDepthTextureSize = (1.0f / shadowDepthTextureSize);
for(int y = -1; (y <= 1); y = as_type<int>((as_type<uint>(y) + as_type<uint>(1)))) {
for(int x = -1; (x <= 1); x = as_type<int>((as_type<uint>(x) + as_type<uint>(1)))) {
float2 const offset = float2((float(x) * oneOverShadowDepthTextureSize), (float(y) * oneOverShadowDepthTextureSize));
visibility = (visibility + tint_symbol_5.sample_compare(tint_symbol_6, (float3(input.shadowPos).xy + offset), (input.shadowPos[2] - 0.007f)));
}
}
visibility = (visibility / 9.0f);
float const lambertFactor = fmax(dot(normalize(((*(tint_symbol_7)).lightPos - input.fragPos)), input.fragNorm), 0.0f);
float const lightingFactor = fmin((ambientFactor + (visibility * lambertFactor)), 1.0f);
return float4((lightingFactor * albedo), 1.0f);
}
fragment tint_symbol_3 tint_symbol(depth2d<float, access::sample> tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(0)]], const constant Scene* tint_symbol_10 [[buffer(0)]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
FragmentInput const tint_symbol_4 = {.shadowPos=tint_symbol_1.shadowPos, .fragPos=tint_symbol_1.fragPos, .fragNorm=tint_symbol_1.fragNorm};
float4 const inner_result = tint_symbol_inner(tint_symbol_4, tint_symbol_8, tint_symbol_9, tint_symbol_10);
tint_symbol_3 wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}

203
test/benchmark/shadow-fragment.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,203 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 121
; Schema: 0
OpCapability Shader
%92 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %shadowPos_1 %fragPos_1 %fragNorm_1 %value
OpExecutionMode %main OriginUpperLeft
OpName %shadowPos_1 "shadowPos_1"
OpName %fragPos_1 "fragPos_1"
OpName %fragNorm_1 "fragNorm_1"
OpName %value "value"
OpName %shadowDepthTextureSize "shadowDepthTextureSize"
OpName %Scene "Scene"
OpMemberName %Scene 0 "lightViewProjMatrix"
OpMemberName %Scene 1 "cameraViewProjMatrix"
OpMemberName %Scene 2 "lightPos"
OpName %scene "scene"
OpName %shadowMap "shadowMap"
OpName %shadowSampler "shadowSampler"
OpName %albedo "albedo"
OpName %ambientFactor "ambientFactor"
OpName %FragmentInput "FragmentInput"
OpMemberName %FragmentInput 0 "shadowPos"
OpMemberName %FragmentInput 1 "fragPos"
OpMemberName %FragmentInput 2 "fragNorm"
OpName %main_inner "main_inner"
OpName %input "input"
OpName %visibility "visibility"
OpName %y "y"
OpName %x "x"
OpName %main "main"
OpDecorate %shadowPos_1 Location 0
OpDecorate %fragPos_1 Location 1
OpDecorate %fragNorm_1 Location 2
OpDecorate %value Location 0
OpDecorate %Scene Block
OpMemberDecorate %Scene 0 Offset 0
OpMemberDecorate %Scene 0 ColMajor
OpMemberDecorate %Scene 0 MatrixStride 16
OpMemberDecorate %Scene 1 Offset 64
OpMemberDecorate %Scene 1 ColMajor
OpMemberDecorate %Scene 1 MatrixStride 16
OpMemberDecorate %Scene 2 Offset 128
OpDecorate %scene NonWritable
OpDecorate %scene DescriptorSet 0
OpDecorate %scene Binding 0
OpDecorate %shadowMap DescriptorSet 0
OpDecorate %shadowMap Binding 1
OpDecorate %shadowSampler DescriptorSet 0
OpDecorate %shadowSampler Binding 2
OpMemberDecorate %FragmentInput 0 Offset 0
OpMemberDecorate %FragmentInput 1 Offset 16
OpMemberDecorate %FragmentInput 2 Offset 32
%float = OpTypeFloat 32
%v3float = OpTypeVector %float 3
%_ptr_Input_v3float = OpTypePointer Input %v3float
%shadowPos_1 = OpVariable %_ptr_Input_v3float Input
%fragPos_1 = OpVariable %_ptr_Input_v3float Input
%fragNorm_1 = OpVariable %_ptr_Input_v3float Input
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%10 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %10
%shadowDepthTextureSize = OpConstant %float 1024
%mat4v4float = OpTypeMatrix %v4float 4
%Scene = OpTypeStruct %mat4v4float %mat4v4float %v3float
%_ptr_Uniform_Scene = OpTypePointer Uniform %Scene
%scene = OpVariable %_ptr_Uniform_Scene Uniform
%18 = OpTypeImage %float 2D 1 0 0 1 Unknown
%_ptr_UniformConstant_18 = OpTypePointer UniformConstant %18
%shadowMap = OpVariable %_ptr_UniformConstant_18 UniformConstant
%21 = OpTypeSampler
%_ptr_UniformConstant_21 = OpTypePointer UniformConstant %21
%shadowSampler = OpVariable %_ptr_UniformConstant_21 UniformConstant
%float_0_899999976 = OpConstant %float 0.899999976
%albedo = OpConstantComposite %v3float %float_0_899999976 %float_0_899999976 %float_0_899999976
%ambientFactor = OpConstant %float 0.200000003
%FragmentInput = OpTypeStruct %v3float %v3float %v3float
%25 = OpTypeFunction %v4float %FragmentInput
%float_0 = OpConstant %float 0
%_ptr_Function_float = OpTypePointer Function %float
%33 = OpConstantNull %float
%float_1 = OpConstant %float 1
%int = OpTypeInt 32 1
%int_n1 = OpConstant %int -1
%_ptr_Function_int = OpTypePointer Function %int
%40 = OpConstantNull %int
%int_1 = OpConstant %int 1
%bool = OpTypeBool
%v2float = OpTypeVector %float 2
%74 = OpTypeSampledImage %18
%float_0_00700000022 = OpConstant %float 0.00700000022
%float_9 = OpConstant %float 9
%uint = OpTypeInt 32 0
%uint_2 = OpConstant %uint 2
%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
%void = OpTypeVoid
%112 = OpTypeFunction %void
%main_inner = OpFunction %v4float None %25
%input = OpFunctionParameter %FragmentInput
%29 = OpLabel
%visibility = OpVariable %_ptr_Function_float Function %33
%y = OpVariable %_ptr_Function_int Function %40
%x = OpVariable %_ptr_Function_int Function %40
OpStore %visibility %float_0
%35 = OpFDiv %float %float_1 %shadowDepthTextureSize
OpStore %y %int_n1
OpBranch %41
%41 = OpLabel
OpLoopMerge %42 %43 None
OpBranch %44
%44 = OpLabel
%46 = OpLoad %int %y
%48 = OpSLessThanEqual %bool %46 %int_1
%45 = OpLogicalNot %bool %48
OpSelectionMerge %50 None
OpBranchConditional %45 %51 %50
%51 = OpLabel
OpBranch %42
%50 = OpLabel
OpStore %x %int_n1
OpBranch %53
%53 = OpLabel
OpLoopMerge %54 %55 None
OpBranch %56
%56 = OpLabel
%58 = OpLoad %int %x
%59 = OpSLessThanEqual %bool %58 %int_1
%57 = OpLogicalNot %bool %59
OpSelectionMerge %60 None
OpBranchConditional %57 %61 %60
%61 = OpLabel
OpBranch %54
%60 = OpLabel
%64 = OpLoad %int %x
%63 = OpConvertSToF %float %64
%65 = OpFMul %float %63 %35
%67 = OpLoad %int %y
%66 = OpConvertSToF %float %67
%68 = OpFMul %float %66 %35
%69 = OpCompositeConstruct %v2float %65 %68
%70 = OpLoad %float %visibility
%72 = OpLoad %21 %shadowSampler
%73 = OpLoad %18 %shadowMap
%75 = OpSampledImage %74 %73 %72
%76 = OpCompositeExtract %v3float %input 0
%77 = OpVectorShuffle %v2float %76 %76 0 1
%78 = OpFAdd %v2float %77 %69
%79 = OpCompositeExtract %v3float %input 0
%80 = OpCompositeExtract %float %79 2
%82 = OpFSub %float %80 %float_0_00700000022
%71 = OpImageSampleDrefImplicitLod %float %75 %78 %82
%83 = OpFAdd %float %70 %71
OpStore %visibility %83
OpBranch %55
%55 = OpLabel
%84 = OpLoad %int %x
%85 = OpIAdd %int %84 %int_1
OpStore %x %85
OpBranch %53
%54 = OpLabel
OpBranch %43
%43 = OpLabel
%86 = OpLoad %int %y
%87 = OpIAdd %int %86 %int_1
OpStore %y %87
OpBranch %41
%42 = OpLabel
%88 = OpLoad %float %visibility
%90 = OpFDiv %float %88 %float_9
OpStore %visibility %90
%98 = OpAccessChain %_ptr_Uniform_v3float %scene %uint_2
%99 = OpLoad %v3float %98
%100 = OpCompositeExtract %v3float %input 1
%101 = OpFSub %v3float %99 %100
%94 = OpExtInst %v3float %92 Normalize %101
%102 = OpCompositeExtract %v3float %input 2
%93 = OpDot %float %94 %102
%91 = OpExtInst %float %92 NMax %93 %float_0
%104 = OpLoad %float %visibility
%105 = OpFMul %float %104 %91
%106 = OpFAdd %float %ambientFactor %105
%103 = OpExtInst %float %92 NMin %106 %float_1
%107 = OpVectorTimesScalar %v3float %albedo %103
%108 = OpCompositeExtract %float %107 0
%109 = OpCompositeExtract %float %107 1
%110 = OpCompositeExtract %float %107 2
%111 = OpCompositeConstruct %v4float %108 %109 %110 %float_1
OpReturnValue %111
OpFunctionEnd
%main = OpFunction %void None %112
%115 = OpLabel
%117 = OpLoad %v3float %shadowPos_1
%118 = OpLoad %v3float %fragPos_1
%119 = OpLoad %v3float %fragNorm_1
%120 = OpCompositeConstruct %FragmentInput %117 %118 %119
%116 = OpFunctionCall %v4float %main_inner %120
OpStore %value %116
OpReturn
OpFunctionEnd

42
test/benchmark/shadow-fragment.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,42 @@
let shadowDepthTextureSize : f32 = 1024.0;
struct Scene {
lightViewProjMatrix : mat4x4<f32>;
cameraViewProjMatrix : mat4x4<f32>;
lightPos : vec3<f32>;
}
@group(0) @binding(0) var<uniform> scene : Scene;
@group(0) @binding(1) var shadowMap : texture_depth_2d;
@group(0) @binding(2) var shadowSampler : sampler_comparison;
struct FragmentInput {
@location(0)
shadowPos : vec3<f32>;
@location(1)
fragPos : vec3<f32>;
@location(2)
fragNorm : vec3<f32>;
}
let albedo : vec3<f32> = vec3<f32>(0.899999976, 0.899999976, 0.899999976);
let ambientFactor : f32 = 0.200000003;
@stage(fragment)
fn main(input : FragmentInput) -> @location(0) vec4<f32> {
var visibility : f32 = 0.0;
let oneOverShadowDepthTextureSize = (1.0 / shadowDepthTextureSize);
for(var y : i32 = -1; (y <= 1); y = (y + 1)) {
for(var x : i32 = -1; (x <= 1); x = (x + 1)) {
let offset : vec2<f32> = vec2<f32>((f32(x) * oneOverShadowDepthTextureSize), (f32(y) * oneOverShadowDepthTextureSize));
visibility = (visibility + textureSampleCompare(shadowMap, shadowSampler, (input.shadowPos.xy + offset), (input.shadowPos.z - 0.007)));
}
}
visibility = (visibility / 9.0);
let lambertFactor : f32 = max(dot(normalize((scene.lightPos - input.fragPos)), input.fragNorm), 0.0);
let lightingFactor : f32 = min((ambientFactor + (visibility * lambertFactor)), 1.0);
return vec4<f32>((lightingFactor * albedo), 1.0);
}

0
test/benchmark/simple_compute.wgsl → test/benchmark/simple-compute.wgsl
View File

28
test/benchmark/simple-compute.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,28 @@
#version 310 es
precision mediump float;
layout (binding = 0) buffer SB_1 {
int data[];
} tint_symbol;
struct tint_symbol_3 {
uvec3 id;
};
void tint_symbol_1_inner(uvec3 id) {
tint_symbol.data[id.x] = (tint_symbol.data[id.x] + 1);
}
layout(local_size_x = 1, local_size_y = 2, local_size_z = 3) in;
void tint_symbol_1(tint_symbol_3 tint_symbol_2) {
tint_symbol_1_inner(tint_symbol_2.id);
return;
}
void main() {
tint_symbol_3 inputs;
inputs.id = gl_GlobalInvocationID;
tint_symbol_1(inputs);
}

0
test/benchmark/simple_compute.wgsl.expected.hlsl → test/benchmark/simple-compute.wgsl.expected.hlsl
View File

0
test/benchmark/simple_compute.wgsl.expected.msl → test/benchmark/simple-compute.wgsl.expected.msl
View File

0
test/benchmark/simple_compute.wgsl.expected.spvasm → test/benchmark/simple-compute.wgsl.expected.spvasm
View File

0
test/benchmark/simple_compute.wgsl.expected.wgsl → test/benchmark/simple-compute.wgsl.expected.wgsl
View File

0
test/benchmark/simple_fragment.wgsl → test/benchmark/simple-fragment.wgsl
View File

47
test/benchmark/simple-fragment.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,47 @@
SKIP: FAILED
#version 310 es
precision mediump float;
struct Input {
vec4 color;
};
struct Output {
vec4 color;
};
struct tint_symbol_3 {
vec4 color;
};
struct tint_symbol_4 {
vec4 color;
};
Output tint_symbol_inner(Input tint_symbol_1) {
Output tint_symbol_5 = Output(tint_symbol_1.color);
return tint_symbol_5;
}
tint_symbol_4 tint_symbol(tint_symbol_3 tint_symbol_2) {
Input tint_symbol_6 = Input(tint_symbol_2.color);
Output inner_result = tint_symbol_inner(tint_symbol_6);
tint_symbol_4 wrapper_result = tint_symbol_4(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.color = inner_result.color;
return wrapper_result;
}
in vec4 color;
out vec4 color;
void main() {
tint_symbol_3 inputs;
inputs.color = color;
tint_symbol_4 outputs;
outputs = tint_symbol(inputs);
color = outputs.color;
}
Error parsing GLSL shader:
ERROR: 0:30: 'color' : redefinition
ERROR: 1 compilation errors. No code generated.

0
test/benchmark/simple_fragment.wgsl.expected.hlsl → test/benchmark/simple-fragment.wgsl.expected.hlsl
View File

0
test/benchmark/simple_fragment.wgsl.expected.msl → test/benchmark/simple-fragment.wgsl.expected.msl
View File

0
test/benchmark/simple_fragment.wgsl.expected.spvasm → test/benchmark/simple-fragment.wgsl.expected.spvasm
View File

0
test/benchmark/simple_fragment.wgsl.expected.wgsl → test/benchmark/simple-fragment.wgsl.expected.wgsl
View File

0
test/benchmark/simple_vertex.wgsl → test/benchmark/simple-vertex.wgsl
View File

39
test/benchmark/simple-vertex.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,39 @@
#version 310 es
precision mediump float;
struct Input {
vec4 position;
};
struct Output {
vec4 position;
};
struct tint_symbol_3 {
vec4 position;
};
struct tint_symbol_4 {
vec4 position;
};
Output tint_symbol_inner(Input tint_symbol_1) {
Output tint_symbol_5 = Output(tint_symbol_1.position);
return tint_symbol_5;
}
tint_symbol_4 tint_symbol(tint_symbol_3 tint_symbol_2) {
Input tint_symbol_6 = Input(tint_symbol_2.position);
Output inner_result = tint_symbol_inner(tint_symbol_6);
tint_symbol_4 wrapper_result = tint_symbol_4(vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.position = inner_result.position;
return wrapper_result;
}
in vec4 position;
void main() {
tint_symbol_3 inputs;
inputs.position = position;
tint_symbol_4 outputs;
outputs = tint_symbol(inputs);
gl_Position = outputs.position;
gl_Position.y = -gl_Position.y;
}

0
test/benchmark/simple_vertex.wgsl.expected.hlsl → test/benchmark/simple-vertex.wgsl.expected.hlsl
View File

0
test/benchmark/simple_vertex.wgsl.expected.msl → test/benchmark/simple-vertex.wgsl.expected.msl
View File

0
test/benchmark/simple_vertex.wgsl.expected.spvasm → test/benchmark/simple-vertex.wgsl.expected.spvasm
View File

0
test/benchmark/simple_vertex.wgsl.expected.wgsl → test/benchmark/simple-vertex.wgsl.expected.wgsl
View File

368
test/benchmark/skinned-shadowed-pbr-fragment.wgsl Normal file
View File

@ -0,0 +1,368 @@
let GAMMA = 2.200000048;
fn linearTosRGB(linear : vec3<f32>) -> vec3<f32> {
let INV_GAMMA = (1.0 / GAMMA);
return pow(linear, vec3(INV_GAMMA));
}
fn sRGBToLinear(srgb : vec3<f32>) -> vec3<f32> {
return pow(srgb, vec3(GAMMA));
}
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@binding(0) @group(0) var<uniform> camera : Camera;
struct ClusterLights {
offset : u32;
count : u32;
}
struct ClusterLightGroup {
offset : u32;
lights : array<ClusterLights, 27648>;
indices : array<u32, 1769472>;
}
@binding(1) @group(0) var<storage, read> clusterLights : ClusterLightGroup;
struct Light {
position : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
struct GlobalLights {
ambient : vec3<f32>;
dirColor : vec3<f32>;
dirIntensity : f32;
dirDirection : vec3<f32>;
lightCount : u32;
lights : @stride(32) array<Light>;
}
@binding(2) @group(0) var<storage, read> globalLights : GlobalLights;
let tileCount = vec3(32u, 18u, 48u);
fn linearDepth(depthSample : f32) -> f32 {
return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}
fn getTile(fragCoord : vec4<f32>) -> vec3<u32> {
let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear)));
let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0));
return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile);
}
fn getClusterIndex(fragCoord : vec4<f32>) -> u32 {
let tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
@binding(3) @group(0) var defaultSampler : sampler;
@binding(4) @group(0) var shadowTexture : texture_depth_2d;
@binding(5) @group(0) var shadowSampler : sampler_comparison;
struct LightShadowTable {
light : array<i32>;
}
@binding(6) @group(0) var<storage, read> lightShadowTable : LightShadowTable;
var<private> shadowSampleOffsets : array<vec2<f32>, 16> = array<vec2<f32>, 16>(vec2(-1.5, -1.5), vec2(-1.5, -0.5), vec2(-1.5, 0.5), vec2(-1.5, 1.5), vec2(-0.5, -1.5), vec2(-0.5, -0.5), vec2(-0.5, 0.5), vec2(-0.5, 1.5), vec2(0.5, -1.5), vec2(0.5, -0.5), vec2(0.5, 0.5), vec2(0.5, 1.5), vec2(1.5, -1.5), vec2(1.5, -0.5), vec2(1.5, 0.5), vec2(1.5, 1.5));
let shadowSampleCount = 16u;
struct ShadowProperties {
viewport : vec4<f32>;
viewProj : mat4x4<f32>;
}
struct LightShadows {
properties : array<ShadowProperties>;
}
@binding(7) @group(0) var<storage, read> shadow : LightShadows;
fn dirLightVisibility(worldPos : vec3<f32>) -> f32 {
let shadowIndex = lightShadowTable.light[0u];
if ((shadowIndex == -1)) {
return 1.0;
}
let viewport = shadow.properties[shadowIndex].viewport;
let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0));
let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w));
let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0)));
let clampRect = vec4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize));
var visibility = 0.0;
for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003)));
}
return (visibility / f32(shadowSampleCount));
}
fn getCubeFace(v : vec3<f32>) -> i32 {
let vAbs = abs(v);
if (((vAbs.z >= vAbs.x) && (vAbs.z >= vAbs.y))) {
if ((v.z < 0.0)) {
return 5;
}
return 4;
}
if ((vAbs.y >= vAbs.x)) {
if ((v.y < 0.0)) {
return 3;
}
return 2;
}
if ((v.x < 0.0)) {
return 1;
}
return 0;
}
fn pointLightVisibility(lightIndex : u32, worldPos : vec3<f32>, pointToLight : vec3<f32>) -> f32 {
var shadowIndex = lightShadowTable.light[(lightIndex + 1u)];
if ((shadowIndex == -1)) {
return 1.0;
}
shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0)));
let viewport = shadow.properties[shadowIndex].viewport;
let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0));
let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w));
let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0)));
let clampRect = vec4(viewport.xy, (viewport.xy + viewport.zw));
var visibility = 0.0;
for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01)));
}
return (visibility / f32(shadowSampleCount));
}
struct VertexOutput {
@builtin(position)
position : vec4<f32>;
@location(0)
worldPos : vec3<f32>;
@location(1)
view : vec3<f32>;
@location(2)
texcoord : vec2<f32>;
@location(3)
texcoord2 : vec2<f32>;
@location(4)
color : vec4<f32>;
@location(5)
instanceColor : vec4<f32>;
@location(6)
normal : vec3<f32>;
@location(7)
tangent : vec3<f32>;
@location(8)
bitangent : vec3<f32>;
}
struct Material {
baseColorFactor : vec4<f32>;
emissiveFactor : vec3<f32>;
occlusionStrength : f32;
metallicRoughnessFactor : vec2<f32>;
alphaCutoff : f32;
}
@binding(8) @group(0) var<uniform> material : Material;
@binding(9) @group(0) var baseColorTexture : texture_2d<f32>;
@binding(10) @group(0) var baseColorSampler : sampler;
@binding(11) @group(0) var normalTexture : texture_2d<f32>;
@binding(12) @group(0) var normalSampler : sampler;
@binding(13) @group(0) var metallicRoughnessTexture : texture_2d<f32>;
@binding(14) @group(0) var metallicRoughnessSampler : sampler;
@binding(15) @group(0) var occlusionTexture : texture_2d<f32>;
@binding(16) @group(0) var occlusionSampler : sampler;
@binding(17) @group(0) var emissiveTexture : texture_2d<f32>;
@binding(18) @group(0) var emissiveSampler : sampler;
struct SurfaceInfo {
baseColor : vec4<f32>;
albedo : vec3<f32>;
metallic : f32;
roughness : f32;
normal : vec3<f32>;
f0 : vec3<f32>;
ao : f32;
emissive : vec3<f32>;
v : vec3<f32>;
}
fn GetSurfaceInfo(input : VertexOutput) -> SurfaceInfo {
var surface : SurfaceInfo;
surface.v = normalize(input.view);
let tbn = mat3x3(input.tangent, input.bitangent, input.normal);
let normalMap = textureSample(normalTexture, normalSampler, input.texcoord).rgb;
surface.normal = normalize((tbn * ((2.0 * normalMap) - vec3(1.0))));
let baseColorMap = textureSample(baseColorTexture, baseColorSampler, input.texcoord);
surface.baseColor = ((input.color * material.baseColorFactor) * baseColorMap);
if ((surface.baseColor.a < material.alphaCutoff)) {
discard;
}
surface.albedo = surface.baseColor.rgb;
let metallicRoughnessMap = textureSample(metallicRoughnessTexture, metallicRoughnessSampler, input.texcoord);
surface.metallic = (material.metallicRoughnessFactor.x * metallicRoughnessMap.b);
surface.roughness = (material.metallicRoughnessFactor.y * metallicRoughnessMap.g);
let dielectricSpec = vec3(0.039999999);
surface.f0 = mix(dielectricSpec, surface.albedo, vec3(surface.metallic));
let occlusionMap = textureSample(occlusionTexture, occlusionSampler, input.texcoord);
surface.ao = (material.occlusionStrength * occlusionMap.r);
let emissiveMap = textureSample(emissiveTexture, emissiveSampler, input.texcoord);
surface.emissive = (material.emissiveFactor * emissiveMap.rgb);
if ((input.instanceColor.a == 0.0)) {
surface.albedo = (surface.albedo + input.instanceColor.rgb);
} else {
surface.albedo = (surface.albedo * input.instanceColor.rgb);
}
return surface;
}
let PI = 3.141592741;
let LightType_Point = 0u;
let LightType_Spot = 1u;
let LightType_Directional = 2u;
struct PuctualLight {
lightType : u32;
pointToLight : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
fn FresnelSchlick(cosTheta : f32, F0 : vec3<f32>) -> vec3<f32> {
return (F0 + ((vec3(1.0) - F0) * pow((1.0 - cosTheta), 5.0)));
}
fn DistributionGGX(N : vec3<f32>, H : vec3<f32>, roughness : f32) -> f32 {
let a = (roughness * roughness);
let a2 = (a * a);
let NdotH = max(dot(N, H), 0.0);
let NdotH2 = (NdotH * NdotH);
let num = a2;
let denom = ((NdotH2 * (a2 - 1.0)) + 1.0);
return (num / ((PI * denom) * denom));
}
fn GeometrySchlickGGX(NdotV : f32, roughness : f32) -> f32 {
let r = (roughness + 1.0);
let k = ((r * r) / 8.0);
let num = NdotV;
let denom = ((NdotV * (1.0 - k)) + k);
return (num / denom);
}
fn GeometrySmith(N : vec3<f32>, V : vec3<f32>, L : vec3<f32>, roughness : f32) -> f32 {
let NdotV = max(dot(N, V), 0.0);
let NdotL = max(dot(N, L), 0.0);
let ggx2 = GeometrySchlickGGX(NdotV, roughness);
let ggx1 = GeometrySchlickGGX(NdotL, roughness);
return (ggx1 * ggx2);
}
fn lightAttenuation(light : PuctualLight) -> f32 {
if ((light.lightType == LightType_Directional)) {
return 1.0;
}
let distance = length(light.pointToLight);
if ((light.range <= 0.0)) {
return (1.0 / pow(distance, 2.0));
}
return (clamp((1.0 - pow((distance / light.range), 4.0)), 0.0, 1.0) / pow(distance, 2.0));
}
fn lightRadiance(light : PuctualLight, surface : SurfaceInfo) -> vec3<f32> {
let L = normalize(light.pointToLight);
let H = normalize((surface.v + L));
let NDF = DistributionGGX(surface.normal, H, surface.roughness);
let G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
let F = FresnelSchlick(max(dot(H, surface.v), 0.0), surface.f0);
let kD = ((vec3(1.0) - F) * (1.0 - surface.metallic));
let NdotL = max(dot(surface.normal, L), 0.0);
let numerator = ((NDF * G) * F);
let denominator = max(((4.0 * max(dot(surface.normal, surface.v), 0.0)) * NdotL), 0.001);
let specular = (numerator / vec3(denominator));
let radiance = ((light.color * light.intensity) * lightAttenuation(light));
return (((((kD * surface.albedo) / vec3(PI)) + specular) * radiance) * NdotL);
}
@binding(19) @group(0) var ssaoTexture : texture_2d<f32>;
struct FragmentOutput {
@location(0)
color : vec4<f32>;
@location(1)
emissive : vec4<f32>;
}
@stage(fragment)
fn fragmentMain(input : VertexOutput) -> FragmentOutput {
let surface = GetSurfaceInfo(input);
var Lo = vec3(0.0, 0.0, 0.0);
if ((globalLights.dirIntensity > 0.0)) {
var light : PuctualLight;
light.lightType = LightType_Directional;
light.pointToLight = globalLights.dirDirection;
light.color = globalLights.dirColor;
light.intensity = globalLights.dirIntensity;
let lightVis = dirLightVisibility(input.worldPos);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
let clusterIndex = getClusterIndex(input.position);
let lightOffset = clusterLights.lights[clusterIndex].offset;
let lightCount = clusterLights.lights[clusterIndex].count;
for(var lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
let i = clusterLights.indices[(lightOffset + lightIndex)];
var light : PuctualLight;
light.lightType = LightType_Point;
light.pointToLight = (globalLights.lights[i].position.xyz - input.worldPos);
light.range = globalLights.lights[i].range;
light.color = globalLights.lights[i].color;
light.intensity = globalLights.lights[i].intensity;
let lightVis = pointLightVisibility(i, input.worldPos, light.pointToLight);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
let ssaoCoord = (input.position.xy / vec2<f32>(textureDimensions(ssaoTexture).xy));
let ssaoFactor = textureSample(ssaoTexture, defaultSampler, ssaoCoord).r;
let ambient = (((globalLights.ambient * surface.albedo) * surface.ao) * ssaoFactor);
let color = linearTosRGB(((Lo + ambient) + surface.emissive));
var out : FragmentOutput;
out.color = vec4(color, surface.baseColor.a);
out.emissive = vec4(surface.emissive, surface.baseColor.a);
return out;
}

424
test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,424 @@
SKIP: FAILED
benchmark/skinned-shadowed-pbr-fragment.wgsl:51:13 warning: use of deprecated language feature: the @stride attribute is deprecated; use a larger type if necessary
lights : @stride(32) array<Light>;
^^^^^^
#version 310 es
precision mediump float;
const float GAMMA = 2.200000048f;
vec3 linearTosRGB(vec3 linear) {
float INV_GAMMA = (1.0f / GAMMA);
return pow(linear, vec3(INV_GAMMA));
}
struct Camera {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
};
layout (binding = 0) uniform Camera_1 {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
} camera;
struct ClusterLights {
uint offset;
uint count;
};
struct ClusterLightGroup {
uint offset;
ClusterLights lights[27648];
uint indices[1769472];
};
layout (binding = 1) buffer ClusterLightGroup_1 {
uint offset;
ClusterLights lights[27648];
uint indices[1769472];
} clusterLights;
struct Light {
vec3 position;
float range;
vec3 color;
float intensity;
};
layout (binding = 2) buffer GlobalLights_1 {
vec3 ambient;
vec3 dirColor;
float dirIntensity;
vec3 dirDirection;
uint lightCount;
Light lights[];
} globalLights;
const uvec3 tileCount = uvec3(32u, 18u, 48u);
float linearDepth(float depthSample) {
return ((camera.zFar * camera.zNear) / mad(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}
uvec3 getTile(vec4 fragCoord) {
float sliceScale = (float(tileCount.z) / log2((camera.zFar / camera.zNear)));
float sliceBias = -(((float(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
uint zTile = uint(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0f));
return uvec3(uint((fragCoord.x / (camera.outputSize.x / float(tileCount.x)))), uint((fragCoord.y / (camera.outputSize.y / float(tileCount.y)))), zTile);
}
uint getClusterIndex(vec4 fragCoord) {
uvec3 tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
uniform highp sampler2D shadowTexture;
layout (binding = 6) buffer LightShadowTable_1 {
int light[];
} lightShadowTable;
vec2 shadowSampleOffsets[16] = vec2[16](vec2(-1.5f, -1.5f), vec2(-1.5f, -0.5f), vec2(-1.5f, 0.5f), vec2(-1.5f, 1.5f), vec2(-0.5f, -1.5f), vec2(-0.5f, -0.5f), vec2(-0.5f, 0.5f), vec2(-0.5f, 1.5f), vec2(0.5f, -1.5f), vec2(0.5f, -0.5f), vec2(0.5f, 0.5f), vec2(0.5f, 1.5f), vec2(1.5f, -1.5f), vec2(1.5f, -0.5f), vec2(1.5f, 0.5f), vec2(1.5f, 1.5f));
const uint shadowSampleCount = 16u;
struct ShadowProperties {
vec4 viewport;
mat4 viewProj;
};
layout (binding = 7) buffer LightShadows_1 {
ShadowProperties properties[];
} shadow;
float dirLightVisibility(vec3 worldPos) {
int shadowIndex = lightShadowTable.light[0u];
if ((shadowIndex == -1)) {
return 1.0f;
}
vec4 viewport = shadow.properties[shadowIndex].viewport;
vec4 lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0f));
vec3 shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5f, -0.5f)) + vec2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
vec2 viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
vec2 texelSize = (1.0f / vec2(textureSize(shadowTexture, 0)));
vec4 clampRect = vec4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize));
float visibility = 0.0f;
{
for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + texture(shadowTexture, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003f)));
}
}
return (visibility / float(shadowSampleCount));
}
int getCubeFace(vec3 v) {
vec3 vAbs = abs(v);
bool tint_tmp = (vAbs.z >= vAbs.x);
if (tint_tmp) {
tint_tmp = (vAbs.z >= vAbs.y);
}
if ((tint_tmp)) {
if ((v.z < 0.0f)) {
return 5;
}
return 4;
}
if ((vAbs.y >= vAbs.x)) {
if ((v.y < 0.0f)) {
return 3;
}
return 2;
}
if ((v.x < 0.0f)) {
return 1;
}
return 0;
}
float pointLightVisibility(uint lightIndex, vec3 worldPos, vec3 pointToLight) {
int shadowIndex = lightShadowTable.light[(lightIndex + 1u)];
if ((shadowIndex == -1)) {
return 1.0f;
}
shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0f)));
vec4 viewport = shadow.properties[shadowIndex].viewport;
vec4 lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0f));
vec3 shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5f, -0.5f)) + vec2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
vec2 viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
vec2 texelSize = (1.0f / vec2(textureSize(shadowTexture, 0)));
vec4 clampRect = vec4(viewport.xy, (viewport.xy + viewport.zw));
float visibility = 0.0f;
{
for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + texture(shadowTexture, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01f)));
}
}
return (visibility / float(shadowSampleCount));
}
struct VertexOutput {
vec4 position;
vec3 worldPos;
vec3 view;
vec2 texcoord;
vec2 texcoord2;
vec4 color;
vec4 instanceColor;
vec3 normal;
vec3 tangent;
vec3 bitangent;
};
struct Material {
vec4 baseColorFactor;
vec3 emissiveFactor;
float occlusionStrength;
vec2 metallicRoughnessFactor;
float alphaCutoff;
};
layout (binding = 8) uniform Material_1 {
vec4 baseColorFactor;
vec3 emissiveFactor;
float occlusionStrength;
vec2 metallicRoughnessFactor;
float alphaCutoff;
} material;
uniform highp sampler2D baseColorTexture;
uniform highp sampler2D normalTexture;
uniform highp sampler2D metallicRoughnessTexture;
uniform highp sampler2D occlusionTexture;
uniform highp sampler2D emissiveTexture;
struct SurfaceInfo {
vec4 baseColor;
vec3 albedo;
float metallic;
float roughness;
vec3 normal;
vec3 f0;
float ao;
vec3 emissive;
vec3 v;
};
SurfaceInfo GetSurfaceInfo(VertexOutput tint_symbol) {
SurfaceInfo surface = SurfaceInfo(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), 0.0f, 0.0f, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
surface.v = normalize(tint_symbol.view);
mat3 tbn = mat3(tint_symbol.tangent, tint_symbol.bitangent, tint_symbol.normal);
vec3 normalMap = texture(normalTexture, tint_symbol.texcoord).rgb;
surface.normal = normalize((tbn * ((2.0f * normalMap) - vec3(1.0f))));
vec4 baseColorMap = texture(baseColorTexture, tint_symbol.texcoord);
surface.baseColor = ((tint_symbol.color * material.baseColorFactor) * baseColorMap);
if ((surface.baseColor.a < material.alphaCutoff)) {
discard;
}
surface.albedo = surface.baseColor.rgb;
vec4 metallicRoughnessMap = texture(metallicRoughnessTexture, tint_symbol.texcoord);
surface.metallic = (material.metallicRoughnessFactor.x * metallicRoughnessMap.b);
surface.roughness = (material.metallicRoughnessFactor.y * metallicRoughnessMap.g);
vec3 dielectricSpec = vec3(0.039999999f);
surface.f0 = mix(dielectricSpec, surface.albedo, vec3(surface.metallic));
vec4 occlusionMap = texture(occlusionTexture, tint_symbol.texcoord);
surface.ao = (material.occlusionStrength * occlusionMap.r);
vec4 emissiveMap = texture(emissiveTexture, tint_symbol.texcoord);
surface.emissive = (material.emissiveFactor * emissiveMap.rgb);
if ((tint_symbol.instanceColor.a == 0.0f)) {
surface.albedo = (surface.albedo + tint_symbol.instanceColor.rgb);
} else {
surface.albedo = (surface.albedo * tint_symbol.instanceColor.rgb);
}
return surface;
}
const float PI = 3.141592741f;
const uint LightType_Point = 0u;
const uint LightType_Directional = 2u;
struct PuctualLight {
uint lightType;
vec3 pointToLight;
float range;
vec3 color;
float intensity;
};
vec3 FresnelSchlick(float cosTheta, vec3 F0) {
return (F0 + ((vec3(1.0f) - F0) * pow((1.0f - cosTheta), 5.0f)));
}
float DistributionGGX(vec3 N, vec3 H, float roughness) {
float a_1 = (roughness * roughness);
float a2 = (a_1 * a_1);
float NdotH = max(dot(N, H), 0.0f);
float NdotH2 = (NdotH * NdotH);
float num = a2;
float denom = ((NdotH2 * (a2 - 1.0f)) + 1.0f);
return (num / ((PI * denom) * denom));
}
float GeometrySchlickGGX(float NdotV, float roughness) {
float r_1 = (roughness + 1.0f);
float k = ((r_1 * r_1) / 8.0f);
float num = NdotV;
float denom = ((NdotV * (1.0f - k)) + k);
return (num / denom);
}
float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
float NdotV = max(dot(N, V), 0.0f);
float NdotL = max(dot(N, L), 0.0f);
float ggx2 = GeometrySchlickGGX(NdotV, roughness);
float ggx1 = GeometrySchlickGGX(NdotL, roughness);
return (ggx1 * ggx2);
}
float lightAttenuation(PuctualLight light) {
if ((light.lightType == LightType_Directional)) {
return 1.0f;
}
float tint_symbol_1 = length(light.pointToLight);
if ((light.range <= 0.0f)) {
return (1.0f / pow(tint_symbol_1, 2.0f));
}
return (clamp((1.0f - pow((tint_symbol_1 / light.range), 4.0f)), 0.0f, 1.0f) / pow(tint_symbol_1, 2.0f));
}
vec3 lightRadiance(PuctualLight light, SurfaceInfo surface) {
vec3 L = normalize(light.pointToLight);
vec3 H = normalize((surface.v + L));
float NDF = DistributionGGX(surface.normal, H, surface.roughness);
float G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
vec3 F = FresnelSchlick(max(dot(H, surface.v), 0.0f), surface.f0);
vec3 kD = ((vec3(1.0f) - F) * (1.0f - surface.metallic));
float NdotL = max(dot(surface.normal, L), 0.0f);
vec3 numerator = ((NDF * G) * F);
float denominator = max(((4.0f * max(dot(surface.normal, surface.v), 0.0f)) * NdotL), 0.001f);
vec3 specular = (numerator / vec3(denominator));
vec3 radiance = ((light.color * light.intensity) * lightAttenuation(light));
return (((((kD * surface.albedo) / vec3(PI)) + specular) * radiance) * NdotL);
}
uniform highp sampler2D ssaoTexture;
struct FragmentOutput {
vec4 color;
vec4 emissive;
};
struct tint_symbol_4 {
vec3 worldPos;
vec3 view;
vec2 texcoord;
vec2 texcoord2;
vec4 color;
vec4 instanceColor;
vec3 normal;
vec3 tangent;
vec3 bitangent;
vec4 position;
};
struct tint_symbol_5 {
vec4 color;
vec4 emissive;
};
FragmentOutput fragmentMain_inner(VertexOutput tint_symbol) {
SurfaceInfo surface = GetSurfaceInfo(tint_symbol);
vec3 Lo = vec3(0.0f, 0.0f, 0.0f);
if ((globalLights.dirIntensity > 0.0f)) {
PuctualLight light = PuctualLight(0u, vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), 0.0f);
light.lightType = LightType_Directional;
light.pointToLight = globalLights.dirDirection;
light.color = globalLights.dirColor;
light.intensity = globalLights.dirIntensity;
float lightVis = dirLightVisibility(tint_symbol.worldPos);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
uint clusterIndex = getClusterIndex(tint_symbol.position);
uint lightOffset = clusterLights.lights[clusterIndex].offset;
uint lightCount = clusterLights.lights[clusterIndex].count;
{
for(uint lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
uint i = clusterLights.indices[(lightOffset + lightIndex)];
PuctualLight light = PuctualLight(0u, vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), 0.0f);
light.lightType = LightType_Point;
light.pointToLight = (globalLights.lights[i].position.xyz - tint_symbol.worldPos);
light.range = globalLights.lights[i].range;
light.color = globalLights.lights[i].color;
light.intensity = globalLights.lights[i].intensity;
float lightVis = pointLightVisibility(i, tint_symbol.worldPos, light.pointToLight);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
}
vec2 ssaoCoord = (tint_symbol.position.xy / vec2(textureSize(ssaoTexture, 0).xy));
float ssaoFactor = texture(ssaoTexture, ssaoCoord).r;
vec3 ambient = (((globalLights.ambient * surface.albedo) * surface.ao) * ssaoFactor);
vec3 color = linearTosRGB(((Lo + ambient) + surface.emissive));
FragmentOutput tint_symbol_2 = FragmentOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
tint_symbol_2.color = vec4(color, surface.baseColor.a);
tint_symbol_2.emissive = vec4(surface.emissive, surface.baseColor.a);
return tint_symbol_2;
}
tint_symbol_5 fragmentMain(tint_symbol_4 tint_symbol_3) {
VertexOutput tint_symbol_6 = VertexOutput(tint_symbol_3.position, tint_symbol_3.worldPos, tint_symbol_3.view, tint_symbol_3.texcoord, tint_symbol_3.texcoord2, tint_symbol_3.color, tint_symbol_3.instanceColor, tint_symbol_3.normal, tint_symbol_3.tangent, tint_symbol_3.bitangent);
FragmentOutput inner_result = fragmentMain_inner(tint_symbol_6);
tint_symbol_5 wrapper_result = tint_symbol_5(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.color = inner_result.color;
wrapper_result.emissive = inner_result.emissive;
return wrapper_result;
}
in vec3 worldPos;
in vec3 view;
in vec2 texcoord;
in vec2 texcoord2;
in vec4 color;
in vec4 instanceColor;
in vec3 normal;
in vec3 tangent;
in vec3 bitangent;
out vec4 color;
out vec4 emissive;
void main() {
tint_symbol_4 inputs;
inputs.worldPos = worldPos;
inputs.view = view;
inputs.texcoord = texcoord;
inputs.texcoord2 = texcoord2;
inputs.color = color;
inputs.instanceColor = instanceColor;
inputs.normal = normal;
inputs.tangent = tangent;
inputs.bitangent = bitangent;
inputs.position = gl_FragCoord;
tint_symbol_5 outputs;
outputs = fragmentMain(inputs);
color = outputs.color;
emissive = outputs.emissive;
}
Error parsing GLSL shader:
ERROR: 0:67: 'mad' : no matching overloaded function found
ERROR: 0:67: '' : compilation terminated
ERROR: 2 compilation errors. No code generated.

335
test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,335 @@
benchmark/skinned-shadowed-pbr-fragment.wgsl:51:13 warning: use of deprecated language feature: the @stride attribute is deprecated; use a larger type if necessary
lights : @stride(32) array<Light>;
^^^^^^
static const float GAMMA = 2.200000048f;
float3 linearTosRGB(float3 tint_symbol) {
const float INV_GAMMA = (1.0f / GAMMA);
return pow(tint_symbol, float3((INV_GAMMA).xxx));
}
float3 sRGBToLinear(float3 srgb) {
return pow(srgb, float3((GAMMA).xxx));
}
cbuffer cbuffer_camera : register(b0, space0) {
uint4 camera[14];
};
ByteAddressBuffer clusterLights : register(t1, space0);
ByteAddressBuffer globalLights : register(t2, space0);
static const uint3 tileCount = uint3(32u, 18u, 48u);
float linearDepth(float depthSample) {
return ((asfloat(camera[13].w) * asfloat(camera[13].z)) / mad(depthSample, (asfloat(camera[13].z) - asfloat(camera[13].w)), asfloat(camera[13].w)));
}
uint3 getTile(float4 fragCoord) {
const float sliceScale = (float(tileCount.z) / log2((asfloat(camera[13].w) / asfloat(camera[13].z))));
const float sliceBias = -(((float(tileCount.z) * log2(asfloat(camera[13].z))) / log2((asfloat(camera[13].w) / asfloat(camera[13].z)))));
const uint zTile = uint(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0f));
return uint3(uint((fragCoord.x / (asfloat(camera[13].x) / float(tileCount.x)))), uint((fragCoord.y / (asfloat(camera[13].y) / float(tileCount.y)))), zTile);
}
uint getClusterIndex(float4 fragCoord) {
const uint3 tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
SamplerState defaultSampler : register(s3, space0);
Texture2D shadowTexture : register(t4, space0);
SamplerComparisonState shadowSampler : register(s5, space0);
ByteAddressBuffer lightShadowTable : register(t6, space0);
static float2 shadowSampleOffsets[16] = {float2(-1.5f, -1.5f), float2(-1.5f, -0.5f), float2(-1.5f, 0.5f), float2(-1.5f, 1.5f), float2(-0.5f, -1.5f), float2(-0.5f, -0.5f), float2(-0.5f, 0.5f), float2(-0.5f, 1.5f), float2(0.5f, -1.5f), float2(0.5f, -0.5f), float2(0.5f, 0.5f), float2(0.5f, 1.5f), float2(1.5f, -1.5f), float2(1.5f, -0.5f), float2(1.5f, 0.5f), float2(1.5f, 1.5f)};
static const uint shadowSampleCount = 16u;
ByteAddressBuffer shadow : register(t7, space0);
float4x4 tint_symbol_8(ByteAddressBuffer buffer, uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
}
float dirLightVisibility(float3 worldPos) {
const int shadowIndex = asint(lightShadowTable.Load(0u));
if ((shadowIndex == -1)) {
return 1.0f;
}
const float4 viewport = asfloat(shadow.Load4((80u * uint(shadowIndex))));
const float4 lightPos = mul(float4(worldPos, 1.0f), tint_symbol_8(shadow, ((80u * uint(shadowIndex)) + 16u)));
const float3 shadowPos = float3((((lightPos.xy / lightPos.w) * float2(0.5f, -0.5f)) + float2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
const float2 viewportPos = float2((viewport.xy + (shadowPos.xy * viewport.zw)));
int3 tint_tmp;
shadowTexture.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z);
const float2 texelSize = (1.0f / float2(tint_tmp.xy));
const float4 clampRect = float4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize));
float visibility = 0.0f;
{
[loop] for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + shadowTexture.SampleCmpLevelZero(shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003f)));
}
}
return (visibility / float(shadowSampleCount));
}
int getCubeFace(float3 v) {
const float3 vAbs = abs(v);
bool tint_tmp_1 = (vAbs.z >= vAbs.x);
if (tint_tmp_1) {
tint_tmp_1 = (vAbs.z >= vAbs.y);
}
if ((tint_tmp_1)) {
if ((v.z < 0.0f)) {
return 5;
}
return 4;
}
if ((vAbs.y >= vAbs.x)) {
if ((v.y < 0.0f)) {
return 3;
}
return 2;
}
if ((v.x < 0.0f)) {
return 1;
}
return 0;
}
float pointLightVisibility(uint lightIndex, float3 worldPos, float3 pointToLight) {
int shadowIndex = asint(lightShadowTable.Load((4u * (lightIndex + 1u))));
if ((shadowIndex == -1)) {
return 1.0f;
}
shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0f)));
const float4 viewport = asfloat(shadow.Load4((80u * uint(shadowIndex))));
const float4 lightPos = mul(float4(worldPos, 1.0f), tint_symbol_8(shadow, ((80u * uint(shadowIndex)) + 16u)));
const float3 shadowPos = float3((((lightPos.xy / lightPos.w) * float2(0.5f, -0.5f)) + float2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
const float2 viewportPos = float2((viewport.xy + (shadowPos.xy * viewport.zw)));
int3 tint_tmp_2;
shadowTexture.GetDimensions(0, tint_tmp_2.x, tint_tmp_2.y, tint_tmp_2.z);
const float2 texelSize = (1.0f / float2(tint_tmp_2.xy));
const float4 clampRect = float4(viewport.xy, (viewport.xy + viewport.zw));
float visibility = 0.0f;
{
[loop] for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + shadowTexture.SampleCmpLevelZero(shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01f)));
}
}
return (visibility / float(shadowSampleCount));
}
struct VertexOutput {
float4 position;
float3 worldPos;
float3 view;
float2 texcoord;
float2 texcoord2;
float4 color;
float4 instanceColor;
float3 normal;
float3 tangent;
float3 bitangent;
};
cbuffer cbuffer_material : register(b8, space0) {
uint4 material[3];
};
Texture2D<float4> baseColorTexture : register(t9, space0);
SamplerState baseColorSampler : register(s10, space0);
Texture2D<float4> normalTexture : register(t11, space0);
SamplerState normalSampler : register(s12, space0);
Texture2D<float4> metallicRoughnessTexture : register(t13, space0);
SamplerState metallicRoughnessSampler : register(s14, space0);
Texture2D<float4> occlusionTexture : register(t15, space0);
SamplerState occlusionSampler : register(s16, space0);
Texture2D<float4> emissiveTexture : register(t17, space0);
SamplerState emissiveSampler : register(s18, space0);
struct SurfaceInfo {
float4 baseColor;
float3 albedo;
float metallic;
float roughness;
float3 normal;
float3 f0;
float ao;
float3 emissive;
float3 v;
};
SurfaceInfo GetSurfaceInfo(VertexOutput input) {
if (true) {
SurfaceInfo surface = (SurfaceInfo)0;
surface.v = normalize(input.view);
const float3x3 tbn = float3x3(input.tangent, input.bitangent, input.normal);
const float3 normalMap = normalTexture.Sample(normalSampler, input.texcoord).rgb;
surface.normal = normalize(mul(((2.0f * normalMap) - float3((1.0f).xxx)), tbn));
const float4 baseColorMap = baseColorTexture.Sample(baseColorSampler, input.texcoord);
surface.baseColor = ((input.color * asfloat(material[0])) * baseColorMap);
if ((surface.baseColor.a < asfloat(material[2].z))) {
discard;
}
surface.albedo = surface.baseColor.rgb;
const float4 metallicRoughnessMap = metallicRoughnessTexture.Sample(metallicRoughnessSampler, input.texcoord);
surface.metallic = (asfloat(material[2].x) * metallicRoughnessMap.b);
surface.roughness = (asfloat(material[2].y) * metallicRoughnessMap.g);
const float3 dielectricSpec = float3((0.039999999f).xxx);
surface.f0 = lerp(dielectricSpec, surface.albedo, float3((surface.metallic).xxx));
const float4 occlusionMap = occlusionTexture.Sample(occlusionSampler, input.texcoord);
surface.ao = (asfloat(material[1].w) * occlusionMap.r);
const float4 emissiveMap = emissiveTexture.Sample(emissiveSampler, input.texcoord);
surface.emissive = (asfloat(material[1].xyz) * emissiveMap.rgb);
if ((input.instanceColor.a == 0.0f)) {
surface.albedo = (surface.albedo + input.instanceColor.rgb);
} else {
surface.albedo = (surface.albedo * input.instanceColor.rgb);
}
return surface;
}
SurfaceInfo unused;
return unused;
}
static const float PI = 3.141592741f;
static const uint LightType_Point = 0u;
static const uint LightType_Spot = 1u;
static const uint LightType_Directional = 2u;
struct PuctualLight {
uint lightType;
float3 pointToLight;
float range;
float3 color;
float intensity;
};
float3 FresnelSchlick(float cosTheta, float3 F0) {
return (F0 + ((float3((1.0f).xxx) - F0) * pow((1.0f - cosTheta), 5.0f)));
}
float DistributionGGX(float3 N, float3 H, float roughness) {
const float a_1 = (roughness * roughness);
const float a2 = (a_1 * a_1);
const float NdotH = max(dot(N, H), 0.0f);
const float NdotH2 = (NdotH * NdotH);
const float num = a2;
const float denom = ((NdotH2 * (a2 - 1.0f)) + 1.0f);
return (num / ((PI * denom) * denom));
}
float GeometrySchlickGGX(float NdotV, float roughness) {
const float r_1 = (roughness + 1.0f);
const float k = ((r_1 * r_1) / 8.0f);
const float num = NdotV;
const float denom = ((NdotV * (1.0f - k)) + k);
return (num / denom);
}
float GeometrySmith(float3 N, float3 V, float3 L, float roughness) {
const float NdotV = max(dot(N, V), 0.0f);
const float NdotL = max(dot(N, L), 0.0f);
const float ggx2 = GeometrySchlickGGX(NdotV, roughness);
const float ggx1 = GeometrySchlickGGX(NdotL, roughness);
return (ggx1 * ggx2);
}
float lightAttenuation(PuctualLight light) {
if ((light.lightType == LightType_Directional)) {
return 1.0f;
}
const float distance = length(light.pointToLight);
if ((light.range <= 0.0f)) {
return (1.0f / pow(distance, 2.0f));
}
return (clamp((1.0f - pow((distance / light.range), 4.0f)), 0.0f, 1.0f) / pow(distance, 2.0f));
}
float3 lightRadiance(PuctualLight light, SurfaceInfo surface) {
const float3 L = normalize(light.pointToLight);
const float3 H = normalize((surface.v + L));
const float NDF = DistributionGGX(surface.normal, H, surface.roughness);
const float G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
const float3 F = FresnelSchlick(max(dot(H, surface.v), 0.0f), surface.f0);
const float3 kD = ((float3((1.0f).xxx) - F) * (1.0f - surface.metallic));
const float NdotL = max(dot(surface.normal, L), 0.0f);
const float3 numerator = ((NDF * G) * F);
const float denominator = max(((4.0f * max(dot(surface.normal, surface.v), 0.0f)) * NdotL), 0.001f);
const float3 specular = (numerator / float3((denominator).xxx));
const float3 radiance = ((light.color * light.intensity) * lightAttenuation(light));
return (((((kD * surface.albedo) / float3((PI).xxx)) + specular) * radiance) * NdotL);
}
Texture2D<float4> ssaoTexture : register(t19, space0);
struct FragmentOutput {
float4 color;
float4 emissive;
};
struct tint_symbol_3 {
float3 worldPos : TEXCOORD0;
float3 view : TEXCOORD1;
float2 texcoord : TEXCOORD2;
float2 texcoord2 : TEXCOORD3;
float4 color : TEXCOORD4;
float4 instanceColor : TEXCOORD5;
float3 normal : TEXCOORD6;
float3 tangent : TEXCOORD7;
float3 bitangent : TEXCOORD8;
float4 position : SV_Position;
};
struct tint_symbol_4 {
float4 color : SV_Target0;
float4 emissive : SV_Target1;
};
FragmentOutput fragmentMain_inner(VertexOutput input) {
const SurfaceInfo surface = GetSurfaceInfo(input);
float3 Lo = float3(0.0f, 0.0f, 0.0f);
if ((asfloat(globalLights.Load(28u)) > 0.0f)) {
PuctualLight light = (PuctualLight)0;
light.lightType = LightType_Directional;
light.pointToLight = asfloat(globalLights.Load3(32u));
light.color = asfloat(globalLights.Load3(16u));
light.intensity = asfloat(globalLights.Load(28u));
const float lightVis = dirLightVisibility(input.worldPos);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
const uint clusterIndex = getClusterIndex(input.position);
const uint lightOffset = clusterLights.Load((4u + (8u * clusterIndex)));
const uint lightCount = clusterLights.Load(((4u + (8u * clusterIndex)) + 4u));
{
[loop] for(uint lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
const uint i = clusterLights.Load((221188u + (4u * (lightOffset + lightIndex))));
PuctualLight light = (PuctualLight)0;
light.lightType = LightType_Point;
light.pointToLight = (asfloat(globalLights.Load3((48u + (32u * i)))).xyz - input.worldPos);
light.range = asfloat(globalLights.Load(((48u + (32u * i)) + 12u)));
light.color = asfloat(globalLights.Load3(((48u + (32u * i)) + 16u)));
light.intensity = asfloat(globalLights.Load(((48u + (32u * i)) + 28u)));
const float lightVis = pointLightVisibility(i, input.worldPos, light.pointToLight);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
}
int2 tint_tmp_3;
ssaoTexture.GetDimensions(tint_tmp_3.x, tint_tmp_3.y);
const float2 ssaoCoord = (input.position.xy / float2(tint_tmp_3.xy));
const float ssaoFactor = ssaoTexture.Sample(defaultSampler, ssaoCoord).r;
const float3 ambient = (((asfloat(globalLights.Load3(0u)) * surface.albedo) * surface.ao) * ssaoFactor);
const float3 color = linearTosRGB(((Lo + ambient) + surface.emissive));
FragmentOutput tint_symbol_1 = (FragmentOutput)0;
tint_symbol_1.color = float4(color, surface.baseColor.a);
tint_symbol_1.emissive = float4(surface.emissive, surface.baseColor.a);
return tint_symbol_1;
}
tint_symbol_4 fragmentMain(tint_symbol_3 tint_symbol_2) {
const VertexOutput tint_symbol_15 = {tint_symbol_2.position, tint_symbol_2.worldPos, tint_symbol_2.view, tint_symbol_2.texcoord, tint_symbol_2.texcoord2, tint_symbol_2.color, tint_symbol_2.instanceColor, tint_symbol_2.normal, tint_symbol_2.tangent, tint_symbol_2.bitangent};
const FragmentOutput inner_result = fragmentMain_inner(tint_symbol_15);
tint_symbol_4 wrapper_result = (tint_symbol_4)0;
wrapper_result.color = inner_result.color;
wrapper_result.emissive = inner_result.emissive;
return wrapper_result;
}

349
test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.msl Normal file
View File

@ -0,0 +1,349 @@
benchmark/skinned-shadowed-pbr-fragment.wgsl:51:13 warning: use of deprecated language feature: the @stride attribute is deprecated; use a larger type if necessary
lights : @stride(32) array<Light>;
^^^^^^
#include <metal_stdlib>
using namespace metal;
template<typename T, int N, int M>
inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
return lhs * vec<T, N>(rhs);
}
template<typename T, int N, int M>
inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
return vec<T, M>(lhs) * rhs;
}
struct Camera {
/* 0x0000 */ float4x4 projection;
/* 0x0040 */ float4x4 inverseProjection;
/* 0x0080 */ float4x4 view;
/* 0x00c0 */ packed_float3 position;
/* 0x00cc */ float time;
/* 0x00d0 */ float2 outputSize;
/* 0x00d8 */ float zNear;
/* 0x00dc */ float zFar;
};
struct ClusterLights {
/* 0x0000 */ uint offset;
/* 0x0004 */ uint count;
};
struct tint_array_wrapper {
/* 0x0000 */ ClusterLights arr[27648];
};
struct tint_array_wrapper_1 {
/* 0x0000 */ uint arr[1769472];
};
struct ClusterLightGroup {
/* 0x0000 */ uint offset;
/* 0x0004 */ tint_array_wrapper lights;
/* 0x36004 */ tint_array_wrapper_1 indices;
};
struct Light {
/* 0x0000 */ packed_float3 position;
/* 0x000c */ float range;
/* 0x0010 */ packed_float3 color;
/* 0x001c */ float intensity;
};
struct GlobalLights {
/* 0x0000 */ packed_float3 ambient;
/* 0x000c */ int8_t tint_pad[4];
/* 0x0010 */ packed_float3 dirColor;
/* 0x001c */ float dirIntensity;
/* 0x0020 */ packed_float3 dirDirection;
/* 0x002c */ uint lightCount;
/* 0x0030 */ Light lights[1];
};
struct LightShadowTable {
/* 0x0000 */ int light[1];
};
struct tint_array_wrapper_2 {
float2 arr[16];
};
struct ShadowProperties {
/* 0x0000 */ float4 viewport;
/* 0x0010 */ float4x4 viewProj;
};
struct LightShadows {
/* 0x0000 */ ShadowProperties properties[1];
};
struct VertexOutput {
float4 position;
float3 worldPos;
float3 view;
float2 texcoord;
float2 texcoord2;
float4 color;
float4 instanceColor;
float3 normal;
float3 tangent;
float3 bitangent;
};
struct Material {
/* 0x0000 */ float4 baseColorFactor;
/* 0x0010 */ packed_float3 emissiveFactor;
/* 0x001c */ float occlusionStrength;
/* 0x0020 */ float2 metallicRoughnessFactor;
/* 0x0028 */ float alphaCutoff;
/* 0x002c */ int8_t tint_pad_1[4];
};
struct SurfaceInfo {
float4 baseColor;
float3 albedo;
float metallic;
float roughness;
float3 normal;
float3 f0;
float ao;
float3 emissive;
float3 v;
};
struct PuctualLight {
uint lightType;
float3 pointToLight;
float range;
float3 color;
float intensity;
};
struct FragmentOutput {
float4 color;
float4 emissive;
};
struct tint_symbol_1 {
float3 worldPos [[user(locn0)]];
float3 view [[user(locn1)]];
float2 texcoord [[user(locn2)]];
float2 texcoord2 [[user(locn3)]];
float4 color [[user(locn4)]];
float4 instanceColor [[user(locn5)]];
float3 normal [[user(locn6)]];
float3 tangent [[user(locn7)]];
float3 bitangent [[user(locn8)]];
};
struct tint_symbol_2 {
float4 color [[color(0)]];
float4 emissive [[color(1)]];
};
constant float GAMMA = 2.200000048f;
constant uint3 tileCount = uint3(32u, 18u, 48u);
constant uint shadowSampleCount = 16u;
constant float PI = 3.141592741f;
constant uint LightType_Point = 0u;
constant uint LightType_Spot = 1u;
constant uint LightType_Directional = 2u;
float3 linearTosRGB(float3 linear) {
float const INV_GAMMA = (1.0f / GAMMA);
return pow(linear, float3(INV_GAMMA));
}
float3 sRGBToLinear(float3 srgb) {
return pow(srgb, float3(GAMMA));
}
float linearDepth(float depthSample, const constant Camera* const tint_symbol_4) {
return (((*(tint_symbol_4)).zFar * (*(tint_symbol_4)).zNear) / fma(depthSample, ((*(tint_symbol_4)).zNear - (*(tint_symbol_4)).zFar), (*(tint_symbol_4)).zFar));
}
uint3 getTile(float4 fragCoord, const constant Camera* const tint_symbol_5) {
float const sliceScale = (float(tileCount[2]) / log2(((*(tint_symbol_5)).zFar / (*(tint_symbol_5)).zNear)));
float const sliceBias = -(((float(tileCount[2]) * log2((*(tint_symbol_5)).zNear)) / log2(((*(tint_symbol_5)).zFar / (*(tint_symbol_5)).zNear))));
uint const zTile = uint(fmax(((log2(linearDepth(fragCoord[2], tint_symbol_5)) * sliceScale) + sliceBias), 0.0f));
return uint3(uint((fragCoord[0] / ((*(tint_symbol_5)).outputSize[0] / float(tileCount[0])))), uint((fragCoord[1] / ((*(tint_symbol_5)).outputSize[1] / float(tileCount[1])))), zTile);
}
uint getClusterIndex(float4 fragCoord, const constant Camera* const tint_symbol_6) {
uint3 const tile = getTile(fragCoord, tint_symbol_6);
return ((tile[0] + (tile[1] * tileCount[0])) + ((tile[2] * tileCount[0]) * tileCount[1]));
}
float dirLightVisibility(float3 worldPos, const device LightShadowTable* const tint_symbol_7, const device LightShadows* const tint_symbol_8, depth2d<float, access::sample> tint_symbol_9, sampler tint_symbol_10, thread tint_array_wrapper_2* const tint_symbol_11) {
int const shadowIndex = (*(tint_symbol_7)).light[0u];
if ((shadowIndex == -1)) {
return 1.0f;
}
float4 const viewport = (*(tint_symbol_8)).properties[shadowIndex].viewport;
float4 const lightPos = ((*(tint_symbol_8)).properties[shadowIndex].viewProj * float4(worldPos, 1.0f));
float3 const shadowPos = float3((((float4(lightPos).xy / lightPos[3]) * float2(0.5f, -0.5f)) + float2(0.5f, 0.5f)), (lightPos[2] / lightPos[3]));
float2 const viewportPos = float2((float4(viewport).xy + (float3(shadowPos).xy * float4(viewport).zw)));
float2 const texelSize = (1.0f / float2(int2(tint_symbol_9.get_width(0), tint_symbol_9.get_height(0))));
float4 const clampRect = float4((float4(viewport).xy - texelSize), ((float4(viewport).xy + float4(viewport).zw) + texelSize));
float visibility = 0.0f;
for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + tint_symbol_9.sample_compare(tint_symbol_10, clamp((viewportPos + ((*(tint_symbol_11)).arr[i] * texelSize)), float4(clampRect).xy, float4(clampRect).zw), (shadowPos[2] - 0.003f), level(0)));
}
return (visibility / float(shadowSampleCount));
}
int getCubeFace(float3 v) {
float3 const vAbs = fabs(v);
if (((vAbs[2] >= vAbs[0]) && (vAbs[2] >= vAbs[1]))) {
if ((v[2] < 0.0f)) {
return 5;
}
return 4;
}
if ((vAbs[1] >= vAbs[0])) {
if ((v[1] < 0.0f)) {
return 3;
}
return 2;
}
if ((v[0] < 0.0f)) {
return 1;
}
return 0;
}
float pointLightVisibility(uint lightIndex, float3 worldPos, float3 pointToLight, const device LightShadowTable* const tint_symbol_12, const device LightShadows* const tint_symbol_13, depth2d<float, access::sample> tint_symbol_14, sampler tint_symbol_15, thread tint_array_wrapper_2* const tint_symbol_16) {
int shadowIndex = (*(tint_symbol_12)).light[(lightIndex + 1u)];
if ((shadowIndex == -1)) {
return 1.0f;
}
shadowIndex = as_type<int>((as_type<uint>(shadowIndex) + as_type<uint>(getCubeFace((pointToLight * -1.0f)))));
float4 const viewport = (*(tint_symbol_13)).properties[shadowIndex].viewport;
float4 const lightPos = ((*(tint_symbol_13)).properties[shadowIndex].viewProj * float4(worldPos, 1.0f));
float3 const shadowPos = float3((((float4(lightPos).xy / lightPos[3]) * float2(0.5f, -0.5f)) + float2(0.5f, 0.5f)), (lightPos[2] / lightPos[3]));
float2 const viewportPos = float2((float4(viewport).xy + (float3(shadowPos).xy * float4(viewport).zw)));
float2 const texelSize = (1.0f / float2(int2(tint_symbol_14.get_width(0), tint_symbol_14.get_height(0))));
float4 const clampRect = float4(float4(viewport).xy, (float4(viewport).xy + float4(viewport).zw));
float visibility = 0.0f;
for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + tint_symbol_14.sample_compare(tint_symbol_15, clamp((viewportPos + ((*(tint_symbol_16)).arr[i] * texelSize)), float4(clampRect).xy, float4(clampRect).zw), (shadowPos[2] - 0.01f), level(0)));
}
return (visibility / float(shadowSampleCount));
}
SurfaceInfo GetSurfaceInfo(VertexOutput input, texture2d<float, access::sample> tint_symbol_17, sampler tint_symbol_18, texture2d<float, access::sample> tint_symbol_19, sampler tint_symbol_20, const constant Material* const tint_symbol_21, texture2d<float, access::sample> tint_symbol_22, sampler tint_symbol_23, texture2d<float, access::sample> tint_symbol_24, sampler tint_symbol_25, texture2d<float, access::sample> tint_symbol_26, sampler tint_symbol_27) {
SurfaceInfo surface = {};
surface.v = normalize(input.view);
float3x3 const tbn = float3x3(input.tangent, input.bitangent, input.normal);
float3 const normalMap = float4(tint_symbol_17.sample(tint_symbol_18, input.texcoord)).rgb;
surface.normal = normalize((tbn * ((2.0f * normalMap) - float3(1.0f))));
float4 const baseColorMap = tint_symbol_19.sample(tint_symbol_20, input.texcoord);
surface.baseColor = ((input.color * (*(tint_symbol_21)).baseColorFactor) * baseColorMap);
if ((surface.baseColor[3] < (*(tint_symbol_21)).alphaCutoff)) {
discard_fragment();
}
surface.albedo = float4(surface.baseColor).rgb;
float4 const metallicRoughnessMap = tint_symbol_22.sample(tint_symbol_23, input.texcoord);
surface.metallic = ((*(tint_symbol_21)).metallicRoughnessFactor[0] * metallicRoughnessMap[2]);
surface.roughness = ((*(tint_symbol_21)).metallicRoughnessFactor[1] * metallicRoughnessMap[1]);
float3 const dielectricSpec = float3(0.039999999f);
surface.f0 = mix(dielectricSpec, surface.albedo, float3(surface.metallic));
float4 const occlusionMap = tint_symbol_24.sample(tint_symbol_25, input.texcoord);
surface.ao = ((*(tint_symbol_21)).occlusionStrength * occlusionMap[0]);
float4 const emissiveMap = tint_symbol_26.sample(tint_symbol_27, input.texcoord);
surface.emissive = ((*(tint_symbol_21)).emissiveFactor * float4(emissiveMap).rgb);
if ((input.instanceColor[3] == 0.0f)) {
surface.albedo = (surface.albedo + float4(input.instanceColor).rgb);
} else {
surface.albedo = (surface.albedo * float4(input.instanceColor).rgb);
}
return surface;
}
float3 FresnelSchlick(float cosTheta, float3 F0) {
return (F0 + ((float3(1.0f) - F0) * pow((1.0f - cosTheta), 5.0f)));
}
float DistributionGGX(float3 N, float3 H, float roughness) {
float const a_1 = (roughness * roughness);
float const a2 = (a_1 * a_1);
float const NdotH = fmax(dot(N, H), 0.0f);
float const NdotH2 = (NdotH * NdotH);
float const num = a2;
float const denom = ((NdotH2 * (a2 - 1.0f)) + 1.0f);
return (num / ((PI * denom) * denom));
}
float GeometrySchlickGGX(float NdotV, float roughness) {
float const r_1 = (roughness + 1.0f);
float const k = ((r_1 * r_1) / 8.0f);
float const num = NdotV;
float const denom = ((NdotV * (1.0f - k)) + k);
return (num / denom);
}
float GeometrySmith(float3 N, float3 V, float3 L, float roughness) {
float const NdotV = fmax(dot(N, V), 0.0f);
float const NdotL = fmax(dot(N, L), 0.0f);
float const ggx2 = GeometrySchlickGGX(NdotV, roughness);
float const ggx1 = GeometrySchlickGGX(NdotL, roughness);
return (ggx1 * ggx2);
}
float lightAttenuation(PuctualLight light) {
if ((light.lightType == LightType_Directional)) {
return 1.0f;
}
float const distance = length(light.pointToLight);
if ((light.range <= 0.0f)) {
return (1.0f / pow(distance, 2.0f));
}
return (clamp((1.0f - pow((distance / light.range), 4.0f)), 0.0f, 1.0f) / pow(distance, 2.0f));
}
float3 lightRadiance(PuctualLight light, SurfaceInfo surface) {
float3 const L = normalize(light.pointToLight);
float3 const H = normalize((surface.v + L));
float const NDF = DistributionGGX(surface.normal, H, surface.roughness);
float const G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
float3 const F = FresnelSchlick(fmax(dot(H, surface.v), 0.0f), surface.f0);
float3 const kD = ((float3(1.0f) - F) * (1.0f - surface.metallic));
float const NdotL = fmax(dot(surface.normal, L), 0.0f);
float3 const numerator = ((NDF * G) * F);
float const denominator = fmax(((4.0f * fmax(dot(surface.normal, surface.v), 0.0f)) * NdotL), 0.001f);
float3 const specular = (numerator / float3(denominator));
float3 const radiance = ((light.color * light.intensity) * lightAttenuation(light));
return (((((kD * surface.albedo) / float3(PI)) + specular) * radiance) * NdotL);
}
FragmentOutput fragmentMain_inner(VertexOutput input, texture2d<float, access::sample> tint_symbol_28, sampler tint_symbol_29, texture2d<float, access::sample> tint_symbol_30, sampler tint_symbol_31, const constant Material* const tint_symbol_32, texture2d<float, access::sample> tint_symbol_33, sampler tint_symbol_34, texture2d<float, access::sample> tint_symbol_35, sampler tint_symbol_36, texture2d<float, access::sample> tint_symbol_37, sampler tint_symbol_38, const device GlobalLights* const tint_symbol_39, const device LightShadowTable* const tint_symbol_40, const device LightShadows* const tint_symbol_41, depth2d<float, access::sample> tint_symbol_42, sampler tint_symbol_43, thread tint_array_wrapper_2* const tint_symbol_44, const constant Camera* const tint_symbol_45, const device ClusterLightGroup* const tint_symbol_46, texture2d<float, access::sample> tint_symbol_47, sampler tint_symbol_48) {
SurfaceInfo const surface = GetSurfaceInfo(input, tint_symbol_28, tint_symbol_29, tint_symbol_30, tint_symbol_31, tint_symbol_32, tint_symbol_33, tint_symbol_34, tint_symbol_35, tint_symbol_36, tint_symbol_37, tint_symbol_38);
float3 Lo = float3(0.0f, 0.0f, 0.0f);
if (((*(tint_symbol_39)).dirIntensity > 0.0f)) {
PuctualLight light = {};
light.lightType = LightType_Directional;
light.pointToLight = (*(tint_symbol_39)).dirDirection;
light.color = (*(tint_symbol_39)).dirColor;
light.intensity = (*(tint_symbol_39)).dirIntensity;
float const lightVis = dirLightVisibility(input.worldPos, tint_symbol_40, tint_symbol_41, tint_symbol_42, tint_symbol_43, tint_symbol_44);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
uint const clusterIndex = getClusterIndex(input.position, tint_symbol_45);
uint const lightOffset = (*(tint_symbol_46)).lights.arr[clusterIndex].offset;
uint const lightCount = (*(tint_symbol_46)).lights.arr[clusterIndex].count;
for(uint lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
uint const i = (*(tint_symbol_46)).indices.arr[(lightOffset + lightIndex)];
PuctualLight light = {};
light.lightType = LightType_Point;
light.pointToLight = (float3((*(tint_symbol_39)).lights[i].position).xyz - input.worldPos);
light.range = (*(tint_symbol_39)).lights[i].range;
light.color = (*(tint_symbol_39)).lights[i].color;
light.intensity = (*(tint_symbol_39)).lights[i].intensity;
float const lightVis = pointLightVisibility(i, input.worldPos, light.pointToLight, tint_symbol_40, tint_symbol_41, tint_symbol_42, tint_symbol_43, tint_symbol_44);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
float2 const ssaoCoord = (float4(input.position).xy / float2(int2(int2(tint_symbol_47.get_width(), tint_symbol_47.get_height())).xy));
float const ssaoFactor = tint_symbol_47.sample(tint_symbol_48, ssaoCoord)[0];
float3 const ambient = ((((*(tint_symbol_39)).ambient * surface.albedo) * surface.ao) * ssaoFactor);
float3 const color = linearTosRGB(((Lo + ambient) + surface.emissive));
FragmentOutput out = {};
out.color = float4(color, surface.baseColor[3]);
out.emissive = float4(surface.emissive, surface.baseColor[3]);
return out;
}
fragment tint_symbol_2 fragmentMain(texture2d<float, access::sample> tint_symbol_49 [[texture(0)]], sampler tint_symbol_50 [[sampler(0)]], texture2d<float, access::sample> tint_symbol_51 [[texture(1)]], sampler tint_symbol_52 [[sampler(1)]], const constant Material* tint_symbol_53 [[buffer(0)]], texture2d<float, access::sample> tint_symbol_54 [[texture(2)]], sampler tint_symbol_55 [[sampler(2)]], texture2d<float, access::sample> tint_symbol_56 [[texture(3)]], sampler tint_symbol_57 [[sampler(3)]], texture2d<float, access::sample> tint_symbol_58 [[texture(4)]], sampler tint_symbol_59 [[sampler(4)]], const device GlobalLights* tint_symbol_60 [[buffer(2)]], const device LightShadowTable* tint_symbol_61 [[buffer(3)]], const device LightShadows* tint_symbol_62 [[buffer(4)]], depth2d<float, access::sample> tint_symbol_63 [[texture(6)]], sampler tint_symbol_64 [[sampler(6)]], const constant Camera* tint_symbol_66 [[buffer(1)]], const device ClusterLightGroup* tint_symbol_67 [[buffer(5)]], texture2d<float, access::sample> tint_symbol_68 [[texture(5)]], sampler tint_symbol_69 [[sampler(5)]], float4 position [[position]], tint_symbol_1 tint_symbol [[stage_in]]) {
thread tint_array_wrapper_2 tint_symbol_65 = {.arr={float2(-1.5f, -1.5f), float2(-1.5f, -0.5f), float2(-1.5f, 0.5f), float2(-1.5f, 1.5f), float2(-0.5f, -1.5f), float2(-0.5f, -0.5f), float2(-0.5f, 0.5f), float2(-0.5f, 1.5f), float2(0.5f, -1.5f), float2(0.5f, -0.5f), float2(0.5f, 0.5f), float2(0.5f, 1.5f), float2(1.5f, -1.5f), float2(1.5f, -0.5f), float2(1.5f, 0.5f), float2(1.5f, 1.5f)}};
VertexOutput const tint_symbol_3 = {.position=position, .worldPos=tint_symbol.worldPos, .view=tint_symbol.view, .texcoord=tint_symbol.texcoord, .texcoord2=tint_symbol.texcoord2, .color=tint_symbol.color, .instanceColor=tint_symbol.instanceColor, .normal=tint_symbol.normal, .tangent=tint_symbol.tangent, .bitangent=tint_symbol.bitangent};
FragmentOutput const inner_result = fragmentMain_inner(tint_symbol_3, tint_symbol_49, tint_symbol_50, tint_symbol_51, tint_symbol_52, tint_symbol_53, tint_symbol_54, tint_symbol_55, tint_symbol_56, tint_symbol_57, tint_symbol_58, tint_symbol_59, tint_symbol_60, tint_symbol_61, tint_symbol_62, tint_symbol_63, tint_symbol_64, &(tint_symbol_65), tint_symbol_66, tint_symbol_67, tint_symbol_68, tint_symbol_69);
tint_symbol_2 wrapper_result = {};
wrapper_result.color = inner_result.color;
wrapper_result.emissive = inner_result.emissive;
return wrapper_result;
}

1302
test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.spvasm Normal file
View File

File diff suppressed because it is too large Load Diff

372
test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,372 @@
benchmark/skinned-shadowed-pbr-fragment.wgsl:51:13 warning: use of deprecated language feature: the @stride attribute is deprecated; use a larger type if necessary
lights : @stride(32) array<Light>;
^^^^^^
let GAMMA = 2.200000048;
fn linearTosRGB(linear : vec3<f32>) -> vec3<f32> {
let INV_GAMMA = (1.0 / GAMMA);
return pow(linear, vec3(INV_GAMMA));
}
fn sRGBToLinear(srgb : vec3<f32>) -> vec3<f32> {
return pow(srgb, vec3(GAMMA));
}
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@binding(0) @group(0) var<uniform> camera : Camera;
struct ClusterLights {
offset : u32;
count : u32;
}
struct ClusterLightGroup {
offset : u32;
lights : array<ClusterLights, 27648>;
indices : array<u32, 1769472>;
}
@binding(1) @group(0) var<storage, read> clusterLights : ClusterLightGroup;
struct Light {
position : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
struct GlobalLights {
ambient : vec3<f32>;
dirColor : vec3<f32>;
dirIntensity : f32;
dirDirection : vec3<f32>;
lightCount : u32;
lights : @stride(32) array<Light>;
}
@binding(2) @group(0) var<storage, read> globalLights : GlobalLights;
let tileCount = vec3(32u, 18u, 48u);
fn linearDepth(depthSample : f32) -> f32 {
return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}
fn getTile(fragCoord : vec4<f32>) -> vec3<u32> {
let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear)));
let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0));
return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile);
}
fn getClusterIndex(fragCoord : vec4<f32>) -> u32 {
let tile = getTile(fragCoord);
return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}
@binding(3) @group(0) var defaultSampler : sampler;
@binding(4) @group(0) var shadowTexture : texture_depth_2d;
@binding(5) @group(0) var shadowSampler : sampler_comparison;
struct LightShadowTable {
light : array<i32>;
}
@binding(6) @group(0) var<storage, read> lightShadowTable : LightShadowTable;
var<private> shadowSampleOffsets : array<vec2<f32>, 16> = array<vec2<f32>, 16>(vec2(-1.5, -1.5), vec2(-1.5, -0.5), vec2(-1.5, 0.5), vec2(-1.5, 1.5), vec2(-0.5, -1.5), vec2(-0.5, -0.5), vec2(-0.5, 0.5), vec2(-0.5, 1.5), vec2(0.5, -1.5), vec2(0.5, -0.5), vec2(0.5, 0.5), vec2(0.5, 1.5), vec2(1.5, -1.5), vec2(1.5, -0.5), vec2(1.5, 0.5), vec2(1.5, 1.5));
let shadowSampleCount = 16u;
struct ShadowProperties {
viewport : vec4<f32>;
viewProj : mat4x4<f32>;
}
struct LightShadows {
properties : array<ShadowProperties>;
}
@binding(7) @group(0) var<storage, read> shadow : LightShadows;
fn dirLightVisibility(worldPos : vec3<f32>) -> f32 {
let shadowIndex = lightShadowTable.light[0u];
if ((shadowIndex == -1)) {
return 1.0;
}
let viewport = shadow.properties[shadowIndex].viewport;
let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0));
let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w));
let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0)));
let clampRect = vec4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize));
var visibility = 0.0;
for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003)));
}
return (visibility / f32(shadowSampleCount));
}
fn getCubeFace(v : vec3<f32>) -> i32 {
let vAbs = abs(v);
if (((vAbs.z >= vAbs.x) && (vAbs.z >= vAbs.y))) {
if ((v.z < 0.0)) {
return 5;
}
return 4;
}
if ((vAbs.y >= vAbs.x)) {
if ((v.y < 0.0)) {
return 3;
}
return 2;
}
if ((v.x < 0.0)) {
return 1;
}
return 0;
}
fn pointLightVisibility(lightIndex : u32, worldPos : vec3<f32>, pointToLight : vec3<f32>) -> f32 {
var shadowIndex = lightShadowTable.light[(lightIndex + 1u)];
if ((shadowIndex == -1)) {
return 1.0;
}
shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0)));
let viewport = shadow.properties[shadowIndex].viewport;
let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0));
let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w));
let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0)));
let clampRect = vec4(viewport.xy, (viewport.xy + viewport.zw));
var visibility = 0.0;
for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01)));
}
return (visibility / f32(shadowSampleCount));
}
struct VertexOutput {
@builtin(position)
position : vec4<f32>;
@location(0)
worldPos : vec3<f32>;
@location(1)
view : vec3<f32>;
@location(2)
texcoord : vec2<f32>;
@location(3)
texcoord2 : vec2<f32>;
@location(4)
color : vec4<f32>;
@location(5)
instanceColor : vec4<f32>;
@location(6)
normal : vec3<f32>;
@location(7)
tangent : vec3<f32>;
@location(8)
bitangent : vec3<f32>;
}
struct Material {
baseColorFactor : vec4<f32>;
emissiveFactor : vec3<f32>;
occlusionStrength : f32;
metallicRoughnessFactor : vec2<f32>;
alphaCutoff : f32;
}
@binding(8) @group(0) var<uniform> material : Material;
@binding(9) @group(0) var baseColorTexture : texture_2d<f32>;
@binding(10) @group(0) var baseColorSampler : sampler;
@binding(11) @group(0) var normalTexture : texture_2d<f32>;
@binding(12) @group(0) var normalSampler : sampler;
@binding(13) @group(0) var metallicRoughnessTexture : texture_2d<f32>;
@binding(14) @group(0) var metallicRoughnessSampler : sampler;
@binding(15) @group(0) var occlusionTexture : texture_2d<f32>;
@binding(16) @group(0) var occlusionSampler : sampler;
@binding(17) @group(0) var emissiveTexture : texture_2d<f32>;
@binding(18) @group(0) var emissiveSampler : sampler;
struct SurfaceInfo {
baseColor : vec4<f32>;
albedo : vec3<f32>;
metallic : f32;
roughness : f32;
normal : vec3<f32>;
f0 : vec3<f32>;
ao : f32;
emissive : vec3<f32>;
v : vec3<f32>;
}
fn GetSurfaceInfo(input : VertexOutput) -> SurfaceInfo {
var surface : SurfaceInfo;
surface.v = normalize(input.view);
let tbn = mat3x3(input.tangent, input.bitangent, input.normal);
let normalMap = textureSample(normalTexture, normalSampler, input.texcoord).rgb;
surface.normal = normalize((tbn * ((2.0 * normalMap) - vec3(1.0))));
let baseColorMap = textureSample(baseColorTexture, baseColorSampler, input.texcoord);
surface.baseColor = ((input.color * material.baseColorFactor) * baseColorMap);
if ((surface.baseColor.a < material.alphaCutoff)) {
discard;
}
surface.albedo = surface.baseColor.rgb;
let metallicRoughnessMap = textureSample(metallicRoughnessTexture, metallicRoughnessSampler, input.texcoord);
surface.metallic = (material.metallicRoughnessFactor.x * metallicRoughnessMap.b);
surface.roughness = (material.metallicRoughnessFactor.y * metallicRoughnessMap.g);
let dielectricSpec = vec3(0.039999999);
surface.f0 = mix(dielectricSpec, surface.albedo, vec3(surface.metallic));
let occlusionMap = textureSample(occlusionTexture, occlusionSampler, input.texcoord);
surface.ao = (material.occlusionStrength * occlusionMap.r);
let emissiveMap = textureSample(emissiveTexture, emissiveSampler, input.texcoord);
surface.emissive = (material.emissiveFactor * emissiveMap.rgb);
if ((input.instanceColor.a == 0.0)) {
surface.albedo = (surface.albedo + input.instanceColor.rgb);
} else {
surface.albedo = (surface.albedo * input.instanceColor.rgb);
}
return surface;
}
let PI = 3.141592741;
let LightType_Point = 0u;
let LightType_Spot = 1u;
let LightType_Directional = 2u;
struct PuctualLight {
lightType : u32;
pointToLight : vec3<f32>;
range : f32;
color : vec3<f32>;
intensity : f32;
}
fn FresnelSchlick(cosTheta : f32, F0 : vec3<f32>) -> vec3<f32> {
return (F0 + ((vec3(1.0) - F0) * pow((1.0 - cosTheta), 5.0)));
}
fn DistributionGGX(N : vec3<f32>, H : vec3<f32>, roughness : f32) -> f32 {
let a = (roughness * roughness);
let a2 = (a * a);
let NdotH = max(dot(N, H), 0.0);
let NdotH2 = (NdotH * NdotH);
let num = a2;
let denom = ((NdotH2 * (a2 - 1.0)) + 1.0);
return (num / ((PI * denom) * denom));
}
fn GeometrySchlickGGX(NdotV : f32, roughness : f32) -> f32 {
let r = (roughness + 1.0);
let k = ((r * r) / 8.0);
let num = NdotV;
let denom = ((NdotV * (1.0 - k)) + k);
return (num / denom);
}
fn GeometrySmith(N : vec3<f32>, V : vec3<f32>, L : vec3<f32>, roughness : f32) -> f32 {
let NdotV = max(dot(N, V), 0.0);
let NdotL = max(dot(N, L), 0.0);
let ggx2 = GeometrySchlickGGX(NdotV, roughness);
let ggx1 = GeometrySchlickGGX(NdotL, roughness);
return (ggx1 * ggx2);
}
fn lightAttenuation(light : PuctualLight) -> f32 {
if ((light.lightType == LightType_Directional)) {
return 1.0;
}
let distance = length(light.pointToLight);
if ((light.range <= 0.0)) {
return (1.0 / pow(distance, 2.0));
}
return (clamp((1.0 - pow((distance / light.range), 4.0)), 0.0, 1.0) / pow(distance, 2.0));
}
fn lightRadiance(light : PuctualLight, surface : SurfaceInfo) -> vec3<f32> {
let L = normalize(light.pointToLight);
let H = normalize((surface.v + L));
let NDF = DistributionGGX(surface.normal, H, surface.roughness);
let G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
let F = FresnelSchlick(max(dot(H, surface.v), 0.0), surface.f0);
let kD = ((vec3(1.0) - F) * (1.0 - surface.metallic));
let NdotL = max(dot(surface.normal, L), 0.0);
let numerator = ((NDF * G) * F);
let denominator = max(((4.0 * max(dot(surface.normal, surface.v), 0.0)) * NdotL), 0.001);
let specular = (numerator / vec3(denominator));
let radiance = ((light.color * light.intensity) * lightAttenuation(light));
return (((((kD * surface.albedo) / vec3(PI)) + specular) * radiance) * NdotL);
}
@binding(19) @group(0) var ssaoTexture : texture_2d<f32>;
struct FragmentOutput {
@location(0)
color : vec4<f32>;
@location(1)
emissive : vec4<f32>;
}
@stage(fragment)
fn fragmentMain(input : VertexOutput) -> FragmentOutput {
let surface = GetSurfaceInfo(input);
var Lo = vec3(0.0, 0.0, 0.0);
if ((globalLights.dirIntensity > 0.0)) {
var light : PuctualLight;
light.lightType = LightType_Directional;
light.pointToLight = globalLights.dirDirection;
light.color = globalLights.dirColor;
light.intensity = globalLights.dirIntensity;
let lightVis = dirLightVisibility(input.worldPos);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
let clusterIndex = getClusterIndex(input.position);
let lightOffset = clusterLights.lights[clusterIndex].offset;
let lightCount = clusterLights.lights[clusterIndex].count;
for(var lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
let i = clusterLights.indices[(lightOffset + lightIndex)];
var light : PuctualLight;
light.lightType = LightType_Point;
light.pointToLight = (globalLights.lights[i].position.xyz - input.worldPos);
light.range = globalLights.lights[i].range;
light.color = globalLights.lights[i].color;
light.intensity = globalLights.lights[i].intensity;
let lightVis = pointLightVisibility(i, input.worldPos, light.pointToLight);
Lo = (Lo + (lightRadiance(light, surface) * lightVis));
}
let ssaoCoord = (input.position.xy / vec2<f32>(textureDimensions(ssaoTexture).xy));
let ssaoFactor = textureSample(ssaoTexture, defaultSampler, ssaoCoord).r;
let ambient = (((globalLights.ambient * surface.albedo) * surface.ao) * ssaoFactor);
let color = linearTosRGB(((Lo + ambient) + surface.emissive));
var out : FragmentOutput;
out.color = vec4(color, surface.baseColor.a);
out.emissive = vec4(surface.emissive, surface.baseColor.a);
return out;
}

98
test/benchmark/skinned-shadowed-pbr-vertex.wgsl Normal file
View File

@ -0,0 +1,98 @@
struct VertexInput {
@location(0)
position : vec4<f32>;
@location(1)
normal : vec3<f32>;
@location(2)
tangent : vec4<f32>;
@location(3)
texcoord : vec2<f32>;
@location(6)
joints : vec4<u32>;
@location(7)
weights : vec4<f32>;
@location(8)
instance0 : vec4<f32>;
@location(9)
instance1 : vec4<f32>;
@location(10)
instance2 : vec4<f32>;
@location(11)
instance3 : vec4<f32>;
@location(12)
instanceColor : vec4<f32>;
}
struct VertexOutput {
@builtin(position)
position : vec4<f32>;
@location(0)
worldPos : vec3<f32>;
@location(1)
view : vec3<f32>;
@location(2)
texcoord : vec2<f32>;
@location(3)
texcoord2 : vec2<f32>;
@location(4)
color : vec4<f32>;
@location(5)
instanceColor : vec4<f32>;
@location(6)
normal : vec3<f32>;
@location(7)
tangent : vec3<f32>;
@location(8)
bitangent : vec3<f32>;
}
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@binding(0) @group(0) var<uniform> camera : Camera;
fn getInstanceMatrix(input : VertexInput) -> mat4x4<f32> {
return mat4x4(input.instance0, input.instance1, input.instance2, input.instance3);
}
struct Joints {
matrices : array<mat4x4<f32>>;
}
@binding(1) @group(0) var<storage, read> joint : Joints;
@binding(2) @group(0) var<storage, read> inverseBind : Joints;
fn getSkinMatrix(input : VertexInput) -> mat4x4<f32> {
let joint0 = (joint.matrices[input.joints.x] * inverseBind.matrices[input.joints.x]);
let joint1 = (joint.matrices[input.joints.y] * inverseBind.matrices[input.joints.y]);
let joint2 = (joint.matrices[input.joints.z] * inverseBind.matrices[input.joints.z]);
let joint3 = (joint.matrices[input.joints.w] * inverseBind.matrices[input.joints.w]);
let skinMatrix = ((((joint0 * input.weights.x) + (joint1 * input.weights.y)) + (joint2 * input.weights.z)) + (joint3 * input.weights.w));
return skinMatrix;
}
@stage(vertex)
fn vertexMain(input : VertexInput) -> VertexOutput {
var output : VertexOutput;
let modelMatrix = getSkinMatrix(input);
output.normal = normalize(((modelMatrix * vec4(input.normal, 0.0))).xyz);
output.tangent = normalize(((modelMatrix * vec4(input.tangent.xyz, 0.0))).xyz);
output.bitangent = (cross(output.normal, output.tangent) * input.tangent.w);
output.color = vec4(1.0);
output.texcoord = input.texcoord;
output.instanceColor = input.instanceColor;
let modelPos = (modelMatrix * input.position);
output.worldPos = modelPos.xyz;
output.view = (camera.position - modelPos.xyz);
output.position = ((camera.projection * camera.view) * modelPos);
return output;
}

181
test/benchmark/skinned-shadowed-pbr-vertex.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,181 @@
SKIP: FAILED
#version 310 es
precision mediump float;
struct VertexInput {
vec4 position;
vec3 normal;
vec4 tangent;
vec2 texcoord;
uvec4 joints;
vec4 weights;
vec4 instance0;
vec4 instance1;
vec4 instance2;
vec4 instance3;
vec4 instanceColor;
};
struct VertexOutput {
vec4 position;
vec3 worldPos;
vec3 view;
vec2 texcoord;
vec2 texcoord2;
vec4 color;
vec4 instanceColor;
vec3 normal;
vec3 tangent;
vec3 bitangent;
};
struct Camera {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
};
layout (binding = 0) uniform Camera_1 {
mat4 projection;
mat4 inverseProjection;
mat4 view;
vec3 position;
float time;
vec2 outputSize;
float zNear;
float zFar;
} camera;
layout (binding = 1) buffer Joints_1 {
mat4 matrices[];
} joint;
layout (binding = 2) buffer Joints_2 {
mat4 matrices[];
} inverseBind;
mat4 getSkinMatrix(VertexInput tint_symbol) {
mat4 joint0 = (joint.matrices[tint_symbol.joints.x] * inverseBind.matrices[tint_symbol.joints.x]);
mat4 joint1 = (joint.matrices[tint_symbol.joints.y] * inverseBind.matrices[tint_symbol.joints.y]);
mat4 joint2 = (joint.matrices[tint_symbol.joints.z] * inverseBind.matrices[tint_symbol.joints.z]);
mat4 joint3 = (joint.matrices[tint_symbol.joints.w] * inverseBind.matrices[tint_symbol.joints.w]);
mat4 skinMatrix = ((((joint0 * tint_symbol.weights.x) + (joint1 * tint_symbol.weights.y)) + (joint2 * tint_symbol.weights.z)) + (joint3 * tint_symbol.weights.w));
return skinMatrix;
}
struct tint_symbol_3 {
vec4 position;
vec3 normal;
vec4 tangent;
vec2 texcoord;
uvec4 joints;
vec4 weights;
vec4 instance0;
vec4 instance1;
vec4 instance2;
vec4 instance3;
vec4 instanceColor;
};
struct tint_symbol_4 {
vec3 worldPos;
vec3 view;
vec2 texcoord;
vec2 texcoord2;
vec4 color;
vec4 instanceColor;
vec3 normal;
vec3 tangent;
vec3 bitangent;
vec4 position;
};
VertexOutput vertexMain_inner(VertexInput tint_symbol) {
VertexOutput tint_symbol_1 = VertexOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
mat4 modelMatrix = getSkinMatrix(tint_symbol);
tint_symbol_1.normal = normalize((modelMatrix * vec4(tint_symbol.normal, 0.0f)).xyz);
tint_symbol_1.tangent = normalize((modelMatrix * vec4(tint_symbol.tangent.xyz, 0.0f)).xyz);
tint_symbol_1.bitangent = (cross(tint_symbol_1.normal, tint_symbol_1.tangent) * tint_symbol.tangent.w);
tint_symbol_1.color = vec4(1.0f);
tint_symbol_1.texcoord = tint_symbol.texcoord;
tint_symbol_1.instanceColor = tint_symbol.instanceColor;
vec4 modelPos = (modelMatrix * tint_symbol.position);
tint_symbol_1.worldPos = modelPos.xyz;
tint_symbol_1.view = (camera.position - modelPos.xyz);
tint_symbol_1.position = ((camera.projection * camera.view) * modelPos);
return tint_symbol_1;
}
tint_symbol_4 vertexMain(tint_symbol_3 tint_symbol_2) {
VertexInput tint_symbol_5 = VertexInput(tint_symbol_2.position, tint_symbol_2.normal, tint_symbol_2.tangent, tint_symbol_2.texcoord, tint_symbol_2.joints, tint_symbol_2.weights, tint_symbol_2.instance0, tint_symbol_2.instance1, tint_symbol_2.instance2, tint_symbol_2.instance3, tint_symbol_2.instanceColor);
VertexOutput inner_result = vertexMain_inner(tint_symbol_5);
tint_symbol_4 wrapper_result = tint_symbol_4(vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
wrapper_result.position = inner_result.position;
wrapper_result.worldPos = inner_result.worldPos;
wrapper_result.view = inner_result.view;
wrapper_result.texcoord = inner_result.texcoord;
wrapper_result.texcoord2 = inner_result.texcoord2;
wrapper_result.color = inner_result.color;
wrapper_result.instanceColor = inner_result.instanceColor;
wrapper_result.normal = inner_result.normal;
wrapper_result.tangent = inner_result.tangent;
wrapper_result.bitangent = inner_result.bitangent;
return wrapper_result;
}
in vec4 position;
in vec3 normal;
in vec4 tangent;
in vec2 texcoord;
in uvec4 joints;
in vec4 weights;
in vec4 instance0;
in vec4 instance1;
in vec4 instance2;
in vec4 instance3;
in vec4 instanceColor;
out vec3 worldPos;
out vec3 view;
out vec2 texcoord;
out vec2 texcoord2;
out vec4 color;
out vec4 instanceColor;
out vec3 normal;
out vec3 tangent;
out vec3 bitangent;
void main() {
tint_symbol_3 inputs;
inputs.position = position;
inputs.normal = normal;
inputs.tangent = tangent;
inputs.texcoord = texcoord;
inputs.joints = joints;
inputs.weights = weights;
inputs.instance0 = instance0;
inputs.instance1 = instance1;
inputs.instance2 = instance2;
inputs.instance3 = instance3;
inputs.instanceColor = instanceColor;
tint_symbol_4 outputs;
outputs = vertexMain(inputs);
worldPos = outputs.worldPos;
view = outputs.view;
texcoord = outputs.texcoord;
texcoord2 = outputs.texcoord2;
color = outputs.color;
instanceColor = outputs.instanceColor;
normal = outputs.normal;
tangent = outputs.tangent;
bitangent = outputs.bitangent;
gl_Position = outputs.position;
gl_Position.y = -gl_Position.y;
}
Error parsing GLSL shader:
ERROR: 0:138: 'texcoord' : redefinition
ERROR: 1 compilation errors. No code generated.

116
test/benchmark/skinned-shadowed-pbr-vertex.wgsl.expected.hlsl Normal file
View File

@ -0,0 +1,116 @@
struct VertexInput {
float4 position;
float3 normal;
float4 tangent;
float2 texcoord;
uint4 joints;
float4 weights;
float4 instance0;
float4 instance1;
float4 instance2;
float4 instance3;
float4 instanceColor;
};
struct VertexOutput {
float4 position;
float3 worldPos;
float3 view;
float2 texcoord;
float2 texcoord2;
float4 color;
float4 instanceColor;
float3 normal;
float3 tangent;
float3 bitangent;
};
cbuffer cbuffer_camera : register(b0, space0) {
uint4 camera[14];
};
float4x4 getInstanceMatrix(VertexInput input) {
return float4x4(input.instance0, input.instance1, input.instance2, input.instance3);
}
ByteAddressBuffer joint : register(t1, space0);
ByteAddressBuffer inverseBind : register(t2, space0);
float4x4 tint_symbol_3(ByteAddressBuffer buffer, uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
}
float4x4 getSkinMatrix(VertexInput input) {
const float4x4 joint0 = mul(tint_symbol_3(inverseBind, (64u * input.joints.x)), tint_symbol_3(joint, (64u * input.joints.x)));
const float4x4 joint1 = mul(tint_symbol_3(inverseBind, (64u * input.joints.y)), tint_symbol_3(joint, (64u * input.joints.y)));
const float4x4 joint2 = mul(tint_symbol_3(inverseBind, (64u * input.joints.z)), tint_symbol_3(joint, (64u * input.joints.z)));
const float4x4 joint3 = mul(tint_symbol_3(inverseBind, (64u * input.joints.w)), tint_symbol_3(joint, (64u * input.joints.w)));
const float4x4 skinMatrix = ((((joint0 * input.weights.x) + (joint1 * input.weights.y)) + (joint2 * input.weights.z)) + (joint3 * input.weights.w));
return skinMatrix;
}
struct tint_symbol_1 {
float4 position : TEXCOORD0;
float3 normal : TEXCOORD1;
float4 tangent : TEXCOORD2;
float2 texcoord : TEXCOORD3;
uint4 joints : TEXCOORD6;
float4 weights : TEXCOORD7;
float4 instance0 : TEXCOORD8;
float4 instance1 : TEXCOORD9;
float4 instance2 : TEXCOORD10;
float4 instance3 : TEXCOORD11;
float4 instanceColor : TEXCOORD12;
};
struct tint_symbol_2 {
float3 worldPos : TEXCOORD0;
float3 view : TEXCOORD1;
float2 texcoord : TEXCOORD2;
float2 texcoord2 : TEXCOORD3;
float4 color : TEXCOORD4;
float4 instanceColor : TEXCOORD5;
float3 normal : TEXCOORD6;
float3 tangent : TEXCOORD7;
float3 bitangent : TEXCOORD8;
float4 position : SV_Position;
};
float4x4 tint_symbol_6(uint4 buffer[14], uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4;
const uint scalar_offset_2 = ((offset + 32u)) / 4;
const uint scalar_offset_3 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset / 4]), asfloat(buffer[scalar_offset_1 / 4]), asfloat(buffer[scalar_offset_2 / 4]), asfloat(buffer[scalar_offset_3 / 4]));
}
VertexOutput vertexMain_inner(VertexInput input) {
VertexOutput output = (VertexOutput)0;
const float4x4 modelMatrix = getSkinMatrix(input);
output.normal = normalize(mul(float4(input.normal, 0.0f), modelMatrix).xyz);
output.tangent = normalize(mul(float4(input.tangent.xyz, 0.0f), modelMatrix).xyz);
output.bitangent = (cross(output.normal, output.tangent) * input.tangent.w);
output.color = float4((1.0f).xxxx);
output.texcoord = input.texcoord;
output.instanceColor = input.instanceColor;
const float4 modelPos = mul(input.position, modelMatrix);
output.worldPos = modelPos.xyz;
output.view = (asfloat(camera[12].xyz) - modelPos.xyz);
output.position = mul(modelPos, mul(tint_symbol_6(camera, 128u), tint_symbol_6(camera, 0u)));
return output;
}
tint_symbol_2 vertexMain(tint_symbol_1 tint_symbol) {
const VertexInput tint_symbol_8 = {tint_symbol.position, tint_symbol.normal, tint_symbol.tangent, tint_symbol.texcoord, tint_symbol.joints, tint_symbol.weights, tint_symbol.instance0, tint_symbol.instance1, tint_symbol.instance2, tint_symbol.instance3, tint_symbol.instanceColor};
const VertexOutput inner_result = vertexMain_inner(tint_symbol_8);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.position = inner_result.position;
wrapper_result.worldPos = inner_result.worldPos;
wrapper_result.view = inner_result.view;
wrapper_result.texcoord = inner_result.texcoord;
wrapper_result.texcoord2 = inner_result.texcoord2;
wrapper_result.color = inner_result.color;
wrapper_result.instanceColor = inner_result.instanceColor;
wrapper_result.normal = inner_result.normal;
wrapper_result.tangent = inner_result.tangent;
wrapper_result.bitangent = inner_result.bitangent;
return wrapper_result;
}

124
test/benchmark/skinned-shadowed-pbr-vertex.wgsl.expected.msl Normal file
View File

@ -0,0 +1,124 @@
#include <metal_stdlib>
using namespace metal;
template<typename T, int N, int M>
inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
return lhs * vec<T, N>(rhs);
}
template<typename T, int N, int M>
inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
return vec<T, M>(lhs) * rhs;
}
struct VertexInput {
float4 position;
float3 normal;
float4 tangent;
float2 texcoord;
uint4 joints;
float4 weights;
float4 instance0;
float4 instance1;
float4 instance2;
float4 instance3;
float4 instanceColor;
};
struct VertexOutput {
float4 position;
float3 worldPos;
float3 view;
float2 texcoord;
float2 texcoord2;
float4 color;
float4 instanceColor;
float3 normal;
float3 tangent;
float3 bitangent;
};
struct Camera {
/* 0x0000 */ float4x4 projection;
/* 0x0040 */ float4x4 inverseProjection;
/* 0x0080 */ float4x4 view;
/* 0x00c0 */ packed_float3 position;
/* 0x00cc */ float time;
/* 0x00d0 */ float2 outputSize;
/* 0x00d8 */ float zNear;
/* 0x00dc */ float zFar;
};
struct Joints {
/* 0x0000 */ float4x4 matrices[1];
};
struct tint_symbol_1 {
float4 position [[attribute(0)]];
float3 normal [[attribute(1)]];
float4 tangent [[attribute(2)]];
float2 texcoord [[attribute(3)]];
uint4 joints [[attribute(6)]];
float4 weights [[attribute(7)]];
float4 instance0 [[attribute(8)]];
float4 instance1 [[attribute(9)]];
float4 instance2 [[attribute(10)]];
float4 instance3 [[attribute(11)]];
float4 instanceColor [[attribute(12)]];
};
struct tint_symbol_2 {
float3 worldPos [[user(locn0)]];
float3 view [[user(locn1)]];
float2 texcoord [[user(locn2)]];
float2 texcoord2 [[user(locn3)]];
float4 color [[user(locn4)]];
float4 instanceColor [[user(locn5)]];
float3 normal [[user(locn6)]];
float3 tangent [[user(locn7)]];
float3 bitangent [[user(locn8)]];
float4 position [[position]];
};
float4x4 getInstanceMatrix(VertexInput input) {
return float4x4(input.instance0, input.instance1, input.instance2, input.instance3);
}
float4x4 getSkinMatrix(VertexInput input, const device Joints* const tint_symbol_4, const device Joints* const tint_symbol_5) {
float4x4 const joint0 = ((*(tint_symbol_4)).matrices[input.joints[0]] * (*(tint_symbol_5)).matrices[input.joints[0]]);
float4x4 const joint1 = ((*(tint_symbol_4)).matrices[input.joints[1]] * (*(tint_symbol_5)).matrices[input.joints[1]]);
float4x4 const joint2 = ((*(tint_symbol_4)).matrices[input.joints[2]] * (*(tint_symbol_5)).matrices[input.joints[2]]);
float4x4 const joint3 = ((*(tint_symbol_4)).matrices[input.joints[3]] * (*(tint_symbol_5)).matrices[input.joints[3]]);
float4x4 const skinMatrix = ((((joint0 * input.weights[0]) + (joint1 * input.weights[1])) + (joint2 * input.weights[2])) + (joint3 * input.weights[3]));
return skinMatrix;
}
VertexOutput vertexMain_inner(VertexInput input, const device Joints* const tint_symbol_6, const device Joints* const tint_symbol_7, const constant Camera* const tint_symbol_8) {
VertexOutput output = {};
float4x4 const modelMatrix = getSkinMatrix(input, tint_symbol_6, tint_symbol_7);
output.normal = normalize(float4(((modelMatrix * float4(input.normal, 0.0f)))).xyz);
output.tangent = normalize(float4(((modelMatrix * float4(float4(input.tangent).xyz, 0.0f)))).xyz);
output.bitangent = (cross(output.normal, output.tangent) * input.tangent[3]);
output.color = float4(1.0f);
output.texcoord = input.texcoord;
output.instanceColor = input.instanceColor;
float4 const modelPos = (modelMatrix * input.position);
output.worldPos = float4(modelPos).xyz;
output.view = ((*(tint_symbol_8)).position - float4(modelPos).xyz);
output.position = (((*(tint_symbol_8)).projection * (*(tint_symbol_8)).view) * modelPos);
return output;
}
vertex tint_symbol_2 vertexMain(const device Joints* tint_symbol_9 [[buffer(1)]], const device Joints* tint_symbol_10 [[buffer(2)]], const constant Camera* tint_symbol_11 [[buffer(0)]], tint_symbol_1 tint_symbol [[stage_in]]) {
VertexInput const tint_symbol_3 = {.position=tint_symbol.position, .normal=tint_symbol.normal, .tangent=tint_symbol.tangent, .texcoord=tint_symbol.texcoord, .joints=tint_symbol.joints, .weights=tint_symbol.weights, .instance0=tint_symbol.instance0, .instance1=tint_symbol.instance1, .instance2=tint_symbol.instance2, .instance3=tint_symbol.instance3, .instanceColor=tint_symbol.instanceColor};
VertexOutput const inner_result = vertexMain_inner(tint_symbol_3, tint_symbol_9, tint_symbol_10, tint_symbol_11);
tint_symbol_2 wrapper_result = {};
wrapper_result.position = inner_result.position;
wrapper_result.worldPos = inner_result.worldPos;
wrapper_result.view = inner_result.view;
wrapper_result.texcoord = inner_result.texcoord;
wrapper_result.texcoord2 = inner_result.texcoord2;
wrapper_result.color = inner_result.color;
wrapper_result.instanceColor = inner_result.instanceColor;
wrapper_result.normal = inner_result.normal;
wrapper_result.tangent = inner_result.tangent;
wrapper_result.bitangent = inner_result.bitangent;
return wrapper_result;
}

429
test/benchmark/skinned-shadowed-pbr-vertex.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,429 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 258
; Schema: 0
OpCapability Shader
%168 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertexMain "vertexMain" %position_1 %normal_1 %tangent_1 %texcoord_1 %joints_1 %weights_1 %instance0_1 %instance1_1 %instance2_1 %instance3_1 %instanceColor_1 %position_2 %worldPos_1 %view_1 %texcoord_2 %texcoord2_1 %color_1 %instanceColor_2 %normal_2 %tangent_2 %bitangent_1 %vertex_point_size
OpName %position_1 "position_1"
OpName %normal_1 "normal_1"
OpName %tangent_1 "tangent_1"
OpName %texcoord_1 "texcoord_1"
OpName %joints_1 "joints_1"
OpName %weights_1 "weights_1"
OpName %instance0_1 "instance0_1"
OpName %instance1_1 "instance1_1"
OpName %instance2_1 "instance2_1"
OpName %instance3_1 "instance3_1"
OpName %instanceColor_1 "instanceColor_1"
OpName %position_2 "position_2"
OpName %worldPos_1 "worldPos_1"
OpName %view_1 "view_1"
OpName %texcoord_2 "texcoord_2"
OpName %texcoord2_1 "texcoord2_1"
OpName %color_1 "color_1"
OpName %instanceColor_2 "instanceColor_2"
OpName %normal_2 "normal_2"
OpName %tangent_2 "tangent_2"
OpName %bitangent_1 "bitangent_1"
OpName %vertex_point_size "vertex_point_size"
OpName %Camera "Camera"
OpMemberName %Camera 0 "projection"
OpMemberName %Camera 1 "inverseProjection"
OpMemberName %Camera 2 "view"
OpMemberName %Camera 3 "position"
OpMemberName %Camera 4 "time"
OpMemberName %Camera 5 "outputSize"
OpMemberName %Camera 6 "zNear"
OpMemberName %Camera 7 "zFar"
OpName %camera "camera"
OpName %Joints "Joints"
OpMemberName %Joints 0 "matrices"
OpName %joint "joint"
OpName %inverseBind "inverseBind"
OpName %VertexInput "VertexInput"
OpMemberName %VertexInput 0 "position"
OpMemberName %VertexInput 1 "normal"
OpMemberName %VertexInput 2 "tangent"
OpMemberName %VertexInput 3 "texcoord"
OpMemberName %VertexInput 4 "joints"
OpMemberName %VertexInput 5 "weights"
OpMemberName %VertexInput 6 "instance0"
OpMemberName %VertexInput 7 "instance1"
OpMemberName %VertexInput 8 "instance2"
OpMemberName %VertexInput 9 "instance3"
OpMemberName %VertexInput 10 "instanceColor"
OpName %getInstanceMatrix "getInstanceMatrix"
OpName %input "input"
OpName %getSkinMatrix "getSkinMatrix"
OpName %input_0 "input"
OpName %VertexOutput "VertexOutput"
OpMemberName %VertexOutput 0 "position"
OpMemberName %VertexOutput 1 "worldPos"
OpMemberName %VertexOutput 2 "view"
OpMemberName %VertexOutput 3 "texcoord"
OpMemberName %VertexOutput 4 "texcoord2"
OpMemberName %VertexOutput 5 "color"
OpMemberName %VertexOutput 6 "instanceColor"
OpMemberName %VertexOutput 7 "normal"
OpMemberName %VertexOutput 8 "tangent"
OpMemberName %VertexOutput 9 "bitangent"
OpName %vertexMain_inner "vertexMain_inner"
OpName %input_1 "input"
OpName %output "output"
OpName %vertexMain "vertexMain"
OpDecorate %position_1 Location 0
OpDecorate %normal_1 Location 1
OpDecorate %tangent_1 Location 2
OpDecorate %texcoord_1 Location 3
OpDecorate %joints_1 Location 6
OpDecorate %weights_1 Location 7
OpDecorate %instance0_1 Location 8
OpDecorate %instance1_1 Location 9
OpDecorate %instance2_1 Location 10
OpDecorate %instance3_1 Location 11
OpDecorate %instanceColor_1 Location 12
OpDecorate %position_2 BuiltIn Position
OpDecorate %worldPos_1 Location 0
OpDecorate %view_1 Location 1
OpDecorate %texcoord_2 Location 2
OpDecorate %texcoord2_1 Location 3
OpDecorate %color_1 Location 4
OpDecorate %instanceColor_2 Location 5
OpDecorate %normal_2 Location 6
OpDecorate %tangent_2 Location 7
OpDecorate %bitangent_1 Location 8
OpDecorate %vertex_point_size BuiltIn PointSize
OpDecorate %Camera Block
OpMemberDecorate %Camera 0 Offset 0
OpMemberDecorate %Camera 0 ColMajor
OpMemberDecorate %Camera 0 MatrixStride 16
OpMemberDecorate %Camera 1 Offset 64
OpMemberDecorate %Camera 1 ColMajor
OpMemberDecorate %Camera 1 MatrixStride 16
OpMemberDecorate %Camera 2 Offset 128
OpMemberDecorate %Camera 2 ColMajor
OpMemberDecorate %Camera 2 MatrixStride 16
OpMemberDecorate %Camera 3 Offset 192
OpMemberDecorate %Camera 4 Offset 204
OpMemberDecorate %Camera 5 Offset 208
OpMemberDecorate %Camera 6 Offset 216
OpMemberDecorate %Camera 7 Offset 220
OpDecorate %camera NonWritable
OpDecorate %camera Binding 0
OpDecorate %camera DescriptorSet 0
OpDecorate %Joints Block
OpMemberDecorate %Joints 0 Offset 0
OpMemberDecorate %Joints 0 ColMajor
OpMemberDecorate %Joints 0 MatrixStride 16
OpDecorate %_runtimearr_mat4v4float ArrayStride 64
OpDecorate %joint NonWritable
OpDecorate %joint Binding 1
OpDecorate %joint DescriptorSet 0
OpDecorate %inverseBind NonWritable
OpDecorate %inverseBind Binding 2
OpDecorate %inverseBind DescriptorSet 0
OpMemberDecorate %VertexInput 0 Offset 0
OpMemberDecorate %VertexInput 1 Offset 16
OpMemberDecorate %VertexInput 2 Offset 32
OpMemberDecorate %VertexInput 3 Offset 48
OpMemberDecorate %VertexInput 4 Offset 64
OpMemberDecorate %VertexInput 5 Offset 80
OpMemberDecorate %VertexInput 6 Offset 96
OpMemberDecorate %VertexInput 7 Offset 112
OpMemberDecorate %VertexInput 8 Offset 128
OpMemberDecorate %VertexInput 9 Offset 144
OpMemberDecorate %VertexInput 10 Offset 160
OpMemberDecorate %VertexOutput 0 Offset 0
OpMemberDecorate %VertexOutput 1 Offset 16
OpMemberDecorate %VertexOutput 2 Offset 32
OpMemberDecorate %VertexOutput 3 Offset 48
OpMemberDecorate %VertexOutput 4 Offset 56
OpMemberDecorate %VertexOutput 5 Offset 64
OpMemberDecorate %VertexOutput 6 Offset 80
OpMemberDecorate %VertexOutput 7 Offset 96
OpMemberDecorate %VertexOutput 8 Offset 112
OpMemberDecorate %VertexOutput 9 Offset 128
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Input_v4float = OpTypePointer Input %v4float
%position_1 = OpVariable %_ptr_Input_v4float Input
%v3float = OpTypeVector %float 3
%_ptr_Input_v3float = OpTypePointer Input %v3float
%normal_1 = OpVariable %_ptr_Input_v3float Input
%tangent_1 = OpVariable %_ptr_Input_v4float Input
%v2float = OpTypeVector %float 2
%_ptr_Input_v2float = OpTypePointer Input %v2float
%texcoord_1 = OpVariable %_ptr_Input_v2float Input
%uint = OpTypeInt 32 0
%v4uint = OpTypeVector %uint 4
%_ptr_Input_v4uint = OpTypePointer Input %v4uint
%joints_1 = OpVariable %_ptr_Input_v4uint Input
%weights_1 = OpVariable %_ptr_Input_v4float Input
%instance0_1 = OpVariable %_ptr_Input_v4float Input
%instance1_1 = OpVariable %_ptr_Input_v4float Input
%instance2_1 = OpVariable %_ptr_Input_v4float Input
%instance3_1 = OpVariable %_ptr_Input_v4float Input
%instanceColor_1 = OpVariable %_ptr_Input_v4float Input
%_ptr_Output_v4float = OpTypePointer Output %v4float
%24 = OpConstantNull %v4float
%position_2 = OpVariable %_ptr_Output_v4float Output %24
%_ptr_Output_v3float = OpTypePointer Output %v3float
%27 = OpConstantNull %v3float
%worldPos_1 = OpVariable %_ptr_Output_v3float Output %27
%view_1 = OpVariable %_ptr_Output_v3float Output %27
%_ptr_Output_v2float = OpTypePointer Output %v2float
%31 = OpConstantNull %v2float
%texcoord_2 = OpVariable %_ptr_Output_v2float Output %31
%texcoord2_1 = OpVariable %_ptr_Output_v2float Output %31
%color_1 = OpVariable %_ptr_Output_v4float Output %24
%instanceColor_2 = OpVariable %_ptr_Output_v4float Output %24
%normal_2 = OpVariable %_ptr_Output_v3float Output %27
%tangent_2 = OpVariable %_ptr_Output_v3float Output %27
%bitangent_1 = OpVariable %_ptr_Output_v3float Output %27
%_ptr_Output_float = OpTypePointer Output %float
%40 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %40
%mat4v4float = OpTypeMatrix %v4float 4
%Camera = OpTypeStruct %mat4v4float %mat4v4float %mat4v4float %v3float %float %v2float %float %float
%_ptr_Uniform_Camera = OpTypePointer Uniform %Camera
%camera = OpVariable %_ptr_Uniform_Camera Uniform
%_runtimearr_mat4v4float = OpTypeRuntimeArray %mat4v4float
%Joints = OpTypeStruct %_runtimearr_mat4v4float
%_ptr_StorageBuffer_Joints = OpTypePointer StorageBuffer %Joints
%joint = OpVariable %_ptr_StorageBuffer_Joints StorageBuffer
%inverseBind = OpVariable %_ptr_StorageBuffer_Joints StorageBuffer
%VertexInput = OpTypeStruct %v4float %v3float %v4float %v2float %v4uint %v4float %v4float %v4float %v4float %v4float %v4float
%50 = OpTypeFunction %mat4v4float %VertexInput
%uint_0 = OpConstant %uint 0
%_ptr_StorageBuffer_mat4v4float = OpTypePointer StorageBuffer %mat4v4float
%VertexOutput = OpTypeStruct %v4float %v3float %v3float %v2float %v2float %v4float %v4float %v3float %v3float %v3float
%155 = OpTypeFunction %VertexOutput %VertexInput
%_ptr_Function_VertexOutput = OpTypePointer Function %VertexOutput
%162 = OpConstantNull %VertexOutput
%uint_7 = OpConstant %uint 7
%_ptr_Function_v3float = OpTypePointer Function %v3float
%float_0 = OpConstant %float 0
%uint_8 = OpConstant %uint 8
%uint_9 = OpConstant %uint 9
%uint_5 = OpConstant %uint 5
%_ptr_Function_v4float = OpTypePointer Function %v4float
%float_1 = OpConstant %float 1
%202 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
%uint_3 = OpConstant %uint 3
%_ptr_Function_v2float = OpTypePointer Function %v2float
%uint_6 = OpConstant %uint 6
%uint_1 = OpConstant %uint 1
%uint_2 = OpConstant %uint 2
%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
%_ptr_Uniform_mat4v4float = OpTypePointer Uniform %mat4v4float
%void = OpTypeVoid
%231 = OpTypeFunction %void
%getInstanceMatrix = OpFunction %mat4v4float None %50
%input = OpFunctionParameter %VertexInput
%54 = OpLabel
%55 = OpCompositeExtract %v4float %input 6
%56 = OpCompositeExtract %v4float %input 7
%57 = OpCompositeExtract %v4float %input 8
%58 = OpCompositeExtract %v4float %input 9
%59 = OpCompositeConstruct %mat4v4float %55 %56 %57 %58
OpReturnValue %59
OpFunctionEnd
%getSkinMatrix = OpFunction %mat4v4float None %50
%input_0 = OpFunctionParameter %VertexInput
%62 = OpLabel
%64 = OpCompositeExtract %v4uint %input_0 4
%65 = OpCompositeExtract %uint %64 0
%67 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %joint %uint_0 %65
%68 = OpLoad %mat4v4float %67
%69 = OpCompositeExtract %v4uint %input_0 4
%70 = OpCompositeExtract %uint %69 0
%71 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %inverseBind %uint_0 %70
%72 = OpLoad %mat4v4float %71
%73 = OpMatrixTimesMatrix %mat4v4float %68 %72
%74 = OpCompositeExtract %v4uint %input_0 4
%75 = OpCompositeExtract %uint %74 1
%76 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %joint %uint_0 %75
%77 = OpLoad %mat4v4float %76
%78 = OpCompositeExtract %v4uint %input_0 4
%79 = OpCompositeExtract %uint %78 1
%80 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %inverseBind %uint_0 %79
%81 = OpLoad %mat4v4float %80
%82 = OpMatrixTimesMatrix %mat4v4float %77 %81
%83 = OpCompositeExtract %v4uint %input_0 4
%84 = OpCompositeExtract %uint %83 2
%85 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %joint %uint_0 %84
%86 = OpLoad %mat4v4float %85
%87 = OpCompositeExtract %v4uint %input_0 4
%88 = OpCompositeExtract %uint %87 2
%89 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %inverseBind %uint_0 %88
%90 = OpLoad %mat4v4float %89
%91 = OpMatrixTimesMatrix %mat4v4float %86 %90
%92 = OpCompositeExtract %v4uint %input_0 4
%93 = OpCompositeExtract %uint %92 3
%94 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %joint %uint_0 %93
%95 = OpLoad %mat4v4float %94
%96 = OpCompositeExtract %v4uint %input_0 4
%97 = OpCompositeExtract %uint %96 3
%98 = OpAccessChain %_ptr_StorageBuffer_mat4v4float %inverseBind %uint_0 %97
%99 = OpLoad %mat4v4float %98
%100 = OpMatrixTimesMatrix %mat4v4float %95 %99
%101 = OpCompositeExtract %v4float %input_0 5
%102 = OpCompositeExtract %float %101 0
%103 = OpMatrixTimesScalar %mat4v4float %73 %102
%104 = OpCompositeExtract %v4float %input_0 5
%105 = OpCompositeExtract %float %104 1
%106 = OpMatrixTimesScalar %mat4v4float %82 %105
%108 = OpCompositeExtract %v4float %103 0
%109 = OpCompositeExtract %v4float %106 0
%110 = OpFAdd %v4float %108 %109
%111 = OpCompositeExtract %v4float %103 1
%112 = OpCompositeExtract %v4float %106 1
%113 = OpFAdd %v4float %111 %112
%114 = OpCompositeExtract %v4float %103 2
%115 = OpCompositeExtract %v4float %106 2
%116 = OpFAdd %v4float %114 %115
%117 = OpCompositeExtract %v4float %103 3
%118 = OpCompositeExtract %v4float %106 3
%119 = OpFAdd %v4float %117 %118
%120 = OpCompositeConstruct %mat4v4float %110 %113 %116 %119
%121 = OpCompositeExtract %v4float %input_0 5
%122 = OpCompositeExtract %float %121 2
%123 = OpMatrixTimesScalar %mat4v4float %91 %122
%125 = OpCompositeExtract %v4float %120 0
%126 = OpCompositeExtract %v4float %123 0
%127 = OpFAdd %v4float %125 %126
%128 = OpCompositeExtract %v4float %120 1
%129 = OpCompositeExtract %v4float %123 1
%130 = OpFAdd %v4float %128 %129
%131 = OpCompositeExtract %v4float %120 2
%132 = OpCompositeExtract %v4float %123 2
%133 = OpFAdd %v4float %131 %132
%134 = OpCompositeExtract %v4float %120 3
%135 = OpCompositeExtract %v4float %123 3
%136 = OpFAdd %v4float %134 %135
%137 = OpCompositeConstruct %mat4v4float %127 %130 %133 %136
%138 = OpCompositeExtract %v4float %input_0 5
%139 = OpCompositeExtract %float %138 3
%140 = OpMatrixTimesScalar %mat4v4float %100 %139
%142 = OpCompositeExtract %v4float %137 0
%143 = OpCompositeExtract %v4float %140 0
%144 = OpFAdd %v4float %142 %143
%145 = OpCompositeExtract %v4float %137 1
%146 = OpCompositeExtract %v4float %140 1
%147 = OpFAdd %v4float %145 %146
%148 = OpCompositeExtract %v4float %137 2
%149 = OpCompositeExtract %v4float %140 2
%150 = OpFAdd %v4float %148 %149
%151 = OpCompositeExtract %v4float %137 3
%152 = OpCompositeExtract %v4float %140 3
%153 = OpFAdd %v4float %151 %152
%154 = OpCompositeConstruct %mat4v4float %144 %147 %150 %153
OpReturnValue %154
OpFunctionEnd
%vertexMain_inner = OpFunction %VertexOutput None %155
%input_1 = OpFunctionParameter %VertexInput
%159 = OpLabel
%output = OpVariable %_ptr_Function_VertexOutput Function %162
%163 = OpFunctionCall %mat4v4float %getSkinMatrix %input_1
%166 = OpAccessChain %_ptr_Function_v3float %output %uint_7
%169 = OpCompositeExtract %v3float %input_1 1
%170 = OpCompositeExtract %float %169 0
%171 = OpCompositeExtract %float %169 1
%172 = OpCompositeExtract %float %169 2
%174 = OpCompositeConstruct %v4float %170 %171 %172 %float_0
%175 = OpMatrixTimesVector %v4float %163 %174
%176 = OpVectorShuffle %v3float %175 %175 0 1 2
%167 = OpExtInst %v3float %168 Normalize %176
OpStore %166 %167
%178 = OpAccessChain %_ptr_Function_v3float %output %uint_8
%180 = OpCompositeExtract %v4float %input_1 2
%181 = OpVectorShuffle %v3float %180 %180 0 1 2
%182 = OpCompositeExtract %float %181 0
%183 = OpCompositeExtract %float %181 1
%184 = OpCompositeExtract %float %181 2
%185 = OpCompositeConstruct %v4float %182 %183 %184 %float_0
%186 = OpMatrixTimesVector %v4float %163 %185
%187 = OpVectorShuffle %v3float %186 %186 0 1 2
%179 = OpExtInst %v3float %168 Normalize %187
OpStore %178 %179
%189 = OpAccessChain %_ptr_Function_v3float %output %uint_9
%191 = OpAccessChain %_ptr_Function_v3float %output %uint_7
%192 = OpLoad %v3float %191
%193 = OpAccessChain %_ptr_Function_v3float %output %uint_8
%194 = OpLoad %v3float %193
%190 = OpExtInst %v3float %168 Cross %192 %194
%195 = OpCompositeExtract %v4float %input_1 2
%196 = OpCompositeExtract %float %195 3
%197 = OpVectorTimesScalar %v3float %190 %196
OpStore %189 %197
%200 = OpAccessChain %_ptr_Function_v4float %output %uint_5
OpStore %200 %202
%205 = OpAccessChain %_ptr_Function_v2float %output %uint_3
%206 = OpCompositeExtract %v2float %input_1 3
OpStore %205 %206
%208 = OpAccessChain %_ptr_Function_v4float %output %uint_6
%209 = OpCompositeExtract %v4float %input_1 10
OpStore %208 %209
%210 = OpCompositeExtract %v4float %input_1 0
%211 = OpMatrixTimesVector %v4float %163 %210
%213 = OpAccessChain %_ptr_Function_v3float %output %uint_1
%214 = OpVectorShuffle %v3float %211 %211 0 1 2
OpStore %213 %214
%216 = OpAccessChain %_ptr_Function_v3float %output %uint_2
%218 = OpAccessChain %_ptr_Uniform_v3float %camera %uint_3
%219 = OpLoad %v3float %218
%220 = OpVectorShuffle %v3float %211 %211 0 1 2
%221 = OpFSub %v3float %219 %220
OpStore %216 %221
%222 = OpAccessChain %_ptr_Function_v4float %output %uint_0
%224 = OpAccessChain %_ptr_Uniform_mat4v4float %camera %uint_0
%225 = OpLoad %mat4v4float %224
%226 = OpAccessChain %_ptr_Uniform_mat4v4float %camera %uint_2
%227 = OpLoad %mat4v4float %226
%228 = OpMatrixTimesMatrix %mat4v4float %225 %227
%229 = OpMatrixTimesVector %v4float %228 %211
OpStore %222 %229
%230 = OpLoad %VertexOutput %output
OpReturnValue %230
OpFunctionEnd
%vertexMain = OpFunction %void None %231
%234 = OpLabel
%236 = OpLoad %v4float %position_1
%237 = OpLoad %v3float %normal_1
%238 = OpLoad %v4float %tangent_1
%239 = OpLoad %v2float %texcoord_1
%240 = OpLoad %v4uint %joints_1
%241 = OpLoad %v4float %weights_1
%242 = OpLoad %v4float %instance0_1
%243 = OpLoad %v4float %instance1_1
%244 = OpLoad %v4float %instance2_1
%245 = OpLoad %v4float %instance3_1
%246 = OpLoad %v4float %instanceColor_1
%247 = OpCompositeConstruct %VertexInput %236 %237 %238 %239 %240 %241 %242 %243 %244 %245 %246
%235 = OpFunctionCall %VertexOutput %vertexMain_inner %247
%248 = OpCompositeExtract %v4float %235 0
OpStore %position_2 %248
%249 = OpCompositeExtract %v3float %235 1
OpStore %worldPos_1 %249
%250 = OpCompositeExtract %v3float %235 2
OpStore %view_1 %250
%251 = OpCompositeExtract %v2float %235 3
OpStore %texcoord_2 %251
%252 = OpCompositeExtract %v2float %235 4
OpStore %texcoord2_1 %252
%253 = OpCompositeExtract %v4float %235 5
OpStore %color_1 %253
%254 = OpCompositeExtract %v4float %235 6
OpStore %instanceColor_2 %254
%255 = OpCompositeExtract %v3float %235 7
OpStore %normal_2 %255
%256 = OpCompositeExtract %v3float %235 8
OpStore %tangent_2 %256
%257 = OpCompositeExtract %v3float %235 9
OpStore %bitangent_1 %257
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd

98
test/benchmark/skinned-shadowed-pbr-vertex.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,98 @@
struct VertexInput {
@location(0)
position : vec4<f32>;
@location(1)
normal : vec3<f32>;
@location(2)
tangent : vec4<f32>;
@location(3)
texcoord : vec2<f32>;
@location(6)
joints : vec4<u32>;
@location(7)
weights : vec4<f32>;
@location(8)
instance0 : vec4<f32>;
@location(9)
instance1 : vec4<f32>;
@location(10)
instance2 : vec4<f32>;
@location(11)
instance3 : vec4<f32>;
@location(12)
instanceColor : vec4<f32>;
}
struct VertexOutput {
@builtin(position)
position : vec4<f32>;
@location(0)
worldPos : vec3<f32>;
@location(1)
view : vec3<f32>;
@location(2)
texcoord : vec2<f32>;
@location(3)
texcoord2 : vec2<f32>;
@location(4)
color : vec4<f32>;
@location(5)
instanceColor : vec4<f32>;
@location(6)
normal : vec3<f32>;
@location(7)
tangent : vec3<f32>;
@location(8)
bitangent : vec3<f32>;
}
struct Camera {
projection : mat4x4<f32>;
inverseProjection : mat4x4<f32>;
view : mat4x4<f32>;
position : vec3<f32>;
time : f32;
outputSize : vec2<f32>;
zNear : f32;
zFar : f32;
}
@binding(0) @group(0) var<uniform> camera : Camera;
fn getInstanceMatrix(input : VertexInput) -> mat4x4<f32> {
return mat4x4(input.instance0, input.instance1, input.instance2, input.instance3);
}
struct Joints {
matrices : array<mat4x4<f32>>;
}
@binding(1) @group(0) var<storage, read> joint : Joints;
@binding(2) @group(0) var<storage, read> inverseBind : Joints;
fn getSkinMatrix(input : VertexInput) -> mat4x4<f32> {
let joint0 = (joint.matrices[input.joints.x] * inverseBind.matrices[input.joints.x]);
let joint1 = (joint.matrices[input.joints.y] * inverseBind.matrices[input.joints.y]);
let joint2 = (joint.matrices[input.joints.z] * inverseBind.matrices[input.joints.z]);
let joint3 = (joint.matrices[input.joints.w] * inverseBind.matrices[input.joints.w]);
let skinMatrix = ((((joint0 * input.weights.x) + (joint1 * input.weights.y)) + (joint2 * input.weights.z)) + (joint3 * input.weights.w));
return skinMatrix;
}
@stage(vertex)
fn vertexMain(input : VertexInput) -> VertexOutput {
var output : VertexOutput;
let modelMatrix = getSkinMatrix(input);
output.normal = normalize(((modelMatrix * vec4(input.normal, 0.0))).xyz);
output.tangent = normalize(((modelMatrix * vec4(input.tangent.xyz, 0.0))).xyz);
output.bitangent = (cross(output.normal, output.tangent) * input.tangent.w);
output.color = vec4(1.0);
output.texcoord = input.texcoord;
output.instanceColor = input.instanceColor;
let modelPos = (modelMatrix * input.position);
output.worldPos = modelPos.xyz;
output.view = (camera.position - modelPos.xyz);
output.position = ((camera.projection * camera.view) * modelPos);
return output;
}