engineShaders top-level property
Every shader the engine asks for, in WGSL, beside the
reflection a GPUShaderModule cannot be asked for.
Implementation
final WebGpuSectionStages engineShaders = (
vertex: <String, WebGpuStage>{
'MeshVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e40 = (*t);
let _e44 = (*rowStep);
row = ((f32((_e40 * 3i)) + 0.5f) * _e44);
let _e46 = (*column);
let _e47 = row;
let _e49 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e46, _e47), 0f);
let _e51 = (*weight);
let _e53 = (*position_1);
(*position_1) = (_e53 + (_e49.xyz * _e51));
let _e55 = (*column);
let _e56 = row;
let _e57 = (*rowStep);
let _e60 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e55, (_e56 + _e57)), 0f);
let _e62 = (*weight);
let _e64 = (*normal_1);
(*normal_1) = (_e64 + (_e60.xyz * _e62));
let _e66 = (*column);
let _e67 = row;
let _e68 = (*rowStep);
let _e72 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e66, (_e67 + (_e68 * 2f))), 0f);
let _e74 = (*weight);
let _e76 = (*tangent_1);
let _e78 = (_e76.xyz + (_e72.xyz * _e74));
(*tangent_1)[0u] = _e78.x;
(*tangent_1)[1u] = _e78.y;
(*tangent_1)[2u] = _e78.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e32 = gl_VertexIndex_1;
let _e37 = morph_info.morph_params[1u];
return ((f32(_e32) + 0.5f) * _e37);
}
fn MorphCount_u0028_() -> i32 {
let _e34 = morph_info.morph_params[0u];
return i32((_e34 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e47 = MorphCount_u0028_();
count = _e47;
let _e48 = count;
if (_e48 <= 0i) {
return;
}
let _e50 = MorphColumn_u0028_();
column_1 = _e50;
let _e53 = morph_info.morph_params[2u];
rowStep_1 = _e53;
i = 0i;
loop {
let _e54 = i;
if (_e54 < 8i) {
let _e56 = i;
let _e57 = count;
if (_e56 >= _e57) {
break;
}
let _e59 = i;
let _e61 = i;
let _e72 = morph_info.morph_weights[(_e59 / 4i)][(_e61 - (i32(floor((f32(_e61) / f32(4i)))) * 4i))];
weight_1 = _e72;
let _e73 = weight_1;
if (_e73 == 0f) {
continue;
}
let _e75 = i;
param = _e75;
let _e76 = weight_1;
param_1 = _e76;
let _e77 = column_1;
param_2 = _e77;
let _e78 = rowStep_1;
param_3 = _e78;
let _e79 = (*position_2);
param_4 = _e79;
let _e80 = (*normal_2);
param_5 = _e80;
let _e81 = (*tangent_2);
param_6 = _e81;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e82 = param_4;
(*position_2) = _e82;
let _e83 = param_5;
(*normal_2) = _e83;
let _e84 = param_6;
(*tangent_2) = _e84;
continue;
} else {
break;
}
continuing {
let _e85 = i;
i = (_e85 + 1i);
}
}
return;
}
fn main_1() {
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var world: vec4<f32>;
let _e39 = position_3;
morphed_position = _e39;
let _e40 = normal_3;
morphed_normal = _e40;
let _e41 = tangent_3;
morphed_tangent = _e41;
let _e42 = morphed_position;
param_7 = _e42;
let _e43 = morphed_normal;
param_8 = _e43;
let _e44 = morphed_tangent;
param_9 = _e44;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e45 = param_7;
morphed_position = _e45;
let _e46 = param_8;
morphed_normal = _e46;
let _e47 = param_9;
morphed_tangent = _e47;
let _e49 = frame_info.model;
let _e50 = morphed_position;
world = (_e49 * vec4<f32>(_e50.x, _e50.y, _e50.z, 1f));
let _e56 = world;
v_world_position = _e56.xyz;
let _e59 = frame_info.normal_matrix;
let _e67 = morphed_normal;
v_normal = (mat3x3<f32>(_e59[0].xyz, _e59[1].xyz, _e59[2].xyz) * _e67);
let _e69 = texcoord_1;
v_texcoord = _e69;
let _e71 = frame_info.model;
let _e79 = morphed_tangent;
let _e81 = (mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz) * _e79.xyz);
let _e83 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e81.x, _e81.y, _e81.z, _e83);
let _e88 = color_1;
v_color = _e88;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e90 = frame_info.mvp;
let _e91 = morphed_position;
unnamed.gl_Position = (_e90 * vec4<f32>(_e91.x, _e91.y, _e91.z, 1f));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e21 = v_world_position;
let _e22 = v_normal;
let _e23 = v_texcoord;
let _e24 = v_tangent;
let _e25 = v_color;
let _e26 = v_lightmap_uv;
let _e27 = unnamed.gl_Position;
return VertexOutput(_e21, _e22, _e23, _e24, _e25, _e26, _e27);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DebugLineVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct LineInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_line_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> line_info: LineInfo;
var<private> position_1: vec3<f32>;
fn main_1() {
let _e8 = color_1;
v_line_color = _e8;
let _e10 = line_info.view_projection;
let _e11 = position_1;
unnamed.gl_Position = (_e10 * vec4<f32>(_e11.x, _e11.y, _e11.z, 1f));
return;
}
@vertex
fn main(@location(1) color: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
color_1 = color;
position_1 = position;
main_1();
let _e7 = v_line_color;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'color',
location: 1,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'LineInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'FullscreenVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(5) member: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e8 = texcoord_1;
v_uv = _e8;
let _e9 = position_1;
unnamed.gl_Position = vec4<f32>(_e9.x, _e9.y, 0f, 1f);
return;
}
@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e7 = v_uv;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'texcoord',
location: 1,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'MeshSkinnedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct SkinInfo {
joint_matrices: array<mat4x4<f32>, 64>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(3) member_2: vec4<f32>,
@location(4) member_3: vec2<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(3)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_texture_smp: sampler;
var<private> weights_1: vec4<f32>;
@group(0) @binding(2)
var<uniform> skin_info: SkinInfo;
var<private> joints_1: vec4<f32>;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e46 = (*t);
let _e50 = (*rowStep);
row = ((f32((_e46 * 3i)) + 0.5f) * _e50);
let _e52 = (*column);
let _e53 = row;
let _e55 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e52, _e53), 0f);
let _e57 = (*weight);
let _e59 = (*position_1);
(*position_1) = (_e59 + (_e55.xyz * _e57));
let _e61 = (*column);
let _e62 = row;
let _e63 = (*rowStep);
let _e66 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e61, (_e62 + _e63)), 0f);
let _e68 = (*weight);
let _e70 = (*normal_1);
(*normal_1) = (_e70 + (_e66.xyz * _e68));
let _e72 = (*column);
let _e73 = row;
let _e74 = (*rowStep);
let _e78 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e72, (_e73 + (_e74 * 2f))), 0f);
let _e80 = (*weight);
let _e82 = (*tangent_1);
let _e84 = (_e82.xyz + (_e78.xyz * _e80));
(*tangent_1)[0u] = _e84.x;
(*tangent_1)[1u] = _e84.y;
(*tangent_1)[2u] = _e84.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e38 = gl_VertexIndex_1;
let _e43 = morph_info.morph_params[1u];
return ((f32(_e38) + 0.5f) * _e43);
}
fn MorphCount_u0028_() -> i32 {
let _e40 = morph_info.morph_params[0u];
return i32((_e40 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e53 = MorphCount_u0028_();
count = _e53;
let _e54 = count;
if (_e54 <= 0i) {
return;
}
let _e56 = MorphColumn_u0028_();
column_1 = _e56;
let _e59 = morph_info.morph_params[2u];
rowStep_1 = _e59;
i = 0i;
loop {
let _e60 = i;
if (_e60 < 8i) {
let _e62 = i;
let _e63 = count;
if (_e62 >= _e63) {
break;
}
let _e65 = i;
let _e67 = i;
let _e78 = morph_info.morph_weights[(_e65 / 4i)][(_e67 - (i32(floor((f32(_e67) / f32(4i)))) * 4i))];
weight_1 = _e78;
let _e79 = weight_1;
if (_e79 == 0f) {
continue;
}
let _e81 = i;
param = _e81;
let _e82 = weight_1;
param_1 = _e82;
let _e83 = column_1;
param_2 = _e83;
let _e84 = rowStep_1;
param_3 = _e84;
let _e85 = (*position_2);
param_4 = _e85;
let _e86 = (*normal_2);
param_5 = _e86;
let _e87 = (*tangent_2);
param_6 = _e87;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e88 = param_4;
(*position_2) = _e88;
let _e89 = param_5;
(*normal_2) = _e89;
let _e90 = param_6;
(*tangent_2) = _e90;
continue;
} else {
break;
}
continuing {
let _e91 = i;
i = (_e91 + 1i);
}
}
return;
}
fn SkinMatrix_u0028_() -> mat4x4<f32> {
var total: f32;
var w: vec4<f32>;
var local: vec4<f32>;
let _e42 = weights_1[0u];
let _e44 = weights_1[1u];
let _e47 = weights_1[2u];
let _e50 = weights_1[3u];
total = (((_e42 + _e44) + _e47) + _e50);
let _e52 = total;
if (_e52 > 0.00001f) {
let _e54 = weights_1;
let _e55 = total;
local = (_e54 / vec4(_e55));
} else {
local = vec4<f32>(1f, 0f, 0f, 0f);
}
let _e58 = local;
w = _e58;
let _e60 = w[0u];
let _e62 = joints_1[0u];
let _e66 = skin_info.joint_matrices[i32(_e62)];
let _e67 = (_e66 * _e60);
let _e69 = w[1u];
let _e71 = joints_1[1u];
let _e75 = skin_info.joint_matrices[i32(_e71)];
let _e76 = (_e75 * _e69);
let _e89 = mat4x4<f32>((_e67[0] + _e76[0]), (_e67[1] + _e76[1]), (_e67[2] + _e76[2]), (_e67[3] + _e76[3]));
let _e91 = w[2u];
let _e93 = joints_1[2u];
let _e97 = skin_info.joint_matrices[i32(_e93)];
let _e98 = (_e97 * _e91);
let _e111 = mat4x4<f32>((_e89[0] + _e98[0]), (_e89[1] + _e98[1]), (_e89[2] + _e98[2]), (_e89[3] + _e98[3]));
let _e113 = w[3u];
let _e115 = joints_1[3u];
let _e119 = skin_info.joint_matrices[i32(_e115)];
let _e120 = (_e119 * _e113);
return mat4x4<f32>((_e111[0] + _e120[0]), (_e111[1] + _e120[1]), (_e111[2] + _e120[2]), (_e111[3] + _e120[3]));
}
fn main_1() {
var skin: mat4x4<f32>;
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var skinnedModel: mat4x4<f32>;
var world: vec4<f32>;
var skinRotation: mat3x3<f32>;
let _e48 = SkinMatrix_u0028_();
skin = _e48;
let _e49 = position_3;
morphed_position = _e49;
let _e50 = normal_3;
morphed_normal = _e50;
let _e51 = tangent_3;
morphed_tangent = _e51;
let _e52 = morphed_position;
param_7 = _e52;
let _e53 = morphed_normal;
param_8 = _e53;
let _e54 = morphed_tangent;
param_9 = _e54;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e55 = param_7;
morphed_position = _e55;
let _e56 = param_8;
morphed_normal = _e56;
let _e57 = param_9;
morphed_tangent = _e57;
let _e59 = frame_info.model;
let _e60 = skin;
skinnedModel = (_e59 * _e60);
let _e62 = skinnedModel;
let _e63 = morphed_position;
world = (_e62 * vec4<f32>(_e63.x, _e63.y, _e63.z, 1f));
let _e69 = world;
v_world_position = _e69.xyz;
let _e71 = skin;
skinRotation = mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz);
let _e80 = frame_info.normal_matrix;
let _e88 = skinRotation;
let _e89 = morphed_normal;
v_normal = (mat3x3<f32>(_e80[0].xyz, _e80[1].xyz, _e80[2].xyz) * (_e88 * _e89));
let _e93 = frame_info.model;
let _e101 = skinRotation;
let _e102 = morphed_tangent;
let _e105 = (mat3x3<f32>(_e93[0].xyz, _e93[1].xyz, _e93[2].xyz) * (_e101 * _e102.xyz));
let _e107 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e105.x, _e105.y, _e105.z, _e107);
let _e112 = texcoord_1;
v_texcoord = _e112;
let _e113 = color_1;
v_color = _e113;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e115 = frame_info.mvp;
let _e116 = skin;
let _e117 = morphed_position;
unnamed.gl_Position = (_e115 * (_e116 * vec4<f32>(_e117.x, _e117.y, _e117.z, 1f)));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(6) weights: vec4<f32>, @location(5) joints: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
weights_1 = weights;
joints_1 = joints;
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e25 = v_world_position;
let _e26 = v_normal;
let _e27 = v_tangent;
let _e28 = v_texcoord;
let _e29 = v_color;
let _e30 = v_lightmap_uv;
let _e31 = unnamed.gl_Position;
return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'joints',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'weights',
location: 6,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'SkinInfo',
group: 0,
binding: 2,
sizeInBytes: 4096,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'joint_matrices',
offsetInBytes: 0,
sizeInBytes: 4096,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MeshInstancedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct MorphInstanceInfo {
instance_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(5)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(6)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> morph_instance_info: MorphInstanceInfo;
@group(0) @binding(3)
var morph_instance_weights_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_instance_weights_smp: sampler;
var<private> i_row0_1: vec4<f32>;
var<private> i_row1_1: vec4<f32>;
var<private> i_row2_1: vec4<f32>;
var<private> position_4: vec3<f32>;
var<private> normal_4: vec3<f32>;
var<private> tangent_4: vec4<f32>;
var<private> gl_InstanceIndex_1: i32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e48 = (*t);
let _e52 = (*rowStep);
row = ((f32((_e48 * 3i)) + 0.5f) * _e52);
let _e54 = (*column);
let _e55 = row;
let _e57 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e54, _e55), 0f);
let _e59 = (*weight);
let _e61 = (*position_1);
(*position_1) = (_e61 + (_e57.xyz * _e59));
let _e63 = (*column);
let _e64 = row;
let _e65 = (*rowStep);
let _e68 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e63, (_e64 + _e65)), 0f);
let _e70 = (*weight);
let _e72 = (*normal_1);
(*normal_1) = (_e72 + (_e68.xyz * _e70));
let _e74 = (*column);
let _e75 = row;
let _e76 = (*rowStep);
let _e80 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e74, (_e75 + (_e76 * 2f))), 0f);
let _e82 = (*weight);
let _e84 = (*tangent_1);
let _e86 = (_e84.xyz + (_e80.xyz * _e82));
(*tangent_1)[0u] = _e86.x;
(*tangent_1)[1u] = _e86.y;
(*tangent_1)[2u] = _e86.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e40 = gl_VertexIndex_1;
let _e45 = morph_info.morph_params[1u];
return ((f32(_e40) + 0.5f) * _e45);
}
fn MorphCount_u0028_() -> i32 {
let _e42 = morph_info.morph_params[0u];
return i32((_e42 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e55 = MorphCount_u0028_();
count = _e55;
let _e56 = count;
if (_e56 <= 0i) {
return;
}
let _e58 = MorphColumn_u0028_();
column_1 = _e58;
let _e61 = morph_info.morph_params[2u];
rowStep_1 = _e61;
i = 0i;
loop {
let _e62 = i;
if (_e62 < 8i) {
let _e64 = i;
let _e65 = count;
if (_e64 >= _e65) {
break;
}
let _e67 = i;
let _e69 = i;
let _e80 = morph_info.morph_weights[(_e67 / 4i)][(_e69 - (i32(floor((f32(_e69) / f32(4i)))) * 4i))];
weight_1 = _e80;
let _e81 = weight_1;
if (_e81 == 0f) {
continue;
}
let _e83 = i;
param = _e83;
let _e84 = weight_1;
param_1 = _e84;
let _e85 = column_1;
param_2 = _e85;
let _e86 = rowStep_1;
param_3 = _e86;
let _e87 = (*position_2);
param_4 = _e87;
let _e88 = (*normal_2);
param_5 = _e88;
let _e89 = (*tangent_2);
param_6 = _e89;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e90 = param_4;
(*position_2) = _e90;
let _e91 = param_5;
(*normal_2) = _e91;
let _e92 = param_6;
(*tangent_2) = _e92;
continue;
} else {
break;
}
continuing {
let _e93 = i;
i = (_e93 + 1i);
}
}
return;
}
fn ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(instance: ptr<function, i32>, position_3: ptr<function, vec3<f32>>, normal_3: ptr<function, vec3<f32>>, tangent_3: ptr<function, vec4<f32>>) {
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var count_1: i32;
var deltaColumn: f32;
var deltaRowStep: f32;
var row_1: f32;
var i_1: i32;
var column_2: f32;
var weight_2: f32;
var param_10: i32;
var param_11: f32;
var param_12: f32;
var param_13: f32;
var param_14: vec3<f32>;
var param_15: vec3<f32>;
var param_16: vec4<f32>;
let _e63 = morph_instance_info.instance_params[0u];
if (_e63 < 0.5f) {
let _e65 = (*position_3);
param_7 = _e65;
let _e66 = (*normal_3);
param_8 = _e66;
let _e67 = (*tangent_3);
param_9 = _e67;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e68 = param_7;
(*position_3) = _e68;
let _e69 = param_8;
(*normal_3) = _e69;
let _e70 = param_9;
(*tangent_3) = _e70;
return;
}
let _e71 = MorphCount_u0028_();
count_1 = _e71;
let _e72 = count_1;
if (_e72 <= 0i) {
return;
}
let _e74 = MorphColumn_u0028_();
deltaColumn = _e74;
let _e77 = morph_info.morph_params[2u];
deltaRowStep = _e77;
let _e78 = (*instance);
let _e83 = morph_instance_info.instance_params[2u];
row_1 = ((f32(_e78) + 0.5f) * _e83);
i_1 = 0i;
loop {
let _e85 = i_1;
if (_e85 < 8i) {
let _e87 = i_1;
let _e88 = count_1;
if (_e87 >= _e88) {
break;
}
let _e90 = i_1;
let _e96 = morph_instance_info.instance_params[1u];
column_2 = ((f32((_e90 / 4i)) + 0.5f) * _e96);
let _e98 = column_2;
let _e99 = row_1;
let _e101 = textureSampleLevel(morph_instance_weights_tex, morph_instance_weights_smp, vec2<f32>(_e98, _e99), 0f);
let _e102 = i_1;
let _e109 = (_e102 - (i32(floor((f32(_e102) / f32(4i)))) * 4i));
weight_2 = select(select(select(_e101[0i], _e101[1i], (1i == _e109)), _e101[2i], (2i == _e109)), _e101[3i], (3i == _e109));
let _e124 = weight_2;
if (_e124 == 0f) {
continue;
}
let _e126 = i_1;
param_10 = _e126;
let _e127 = weight_2;
param_11 = _e127;
let _e128 = deltaColumn;
param_12 = _e128;
let _e129 = deltaRowStep;
param_13 = _e129;
let _e130 = (*position_3);
param_14 = _e130;
let _e131 = (*normal_3);
param_15 = _e131;
let _e132 = (*tangent_3);
param_16 = _e132;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13), (¶m_14), (¶m_15), (¶m_16));
let _e133 = param_14;
(*position_3) = _e133;
let _e134 = param_15;
(*normal_3) = _e134;
let _e135 = param_16;
(*tangent_3) = _e135;
continue;
} else {
break;
}
continuing {
let _e136 = i_1;
i_1 = (_e136 + 1i);
}
}
return;
}
fn main_1() {
var instance_1: mat4x4<f32>;
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_17: i32;
var param_18: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec4<f32>;
var local: vec4<f32>;
var world: vec4<f32>;
var rotation: mat3x3<f32>;
let _e52 = i_row0_1[0u];
let _e54 = i_row1_1[0u];
let _e56 = i_row2_1[0u];
let _e57 = vec4<f32>(_e52, _e54, _e56, 0f);
let _e59 = i_row0_1[1u];
let _e61 = i_row1_1[1u];
let _e63 = i_row2_1[1u];
let _e64 = vec4<f32>(_e59, _e61, _e63, 0f);
let _e66 = i_row0_1[2u];
let _e68 = i_row1_1[2u];
let _e70 = i_row2_1[2u];
let _e71 = vec4<f32>(_e66, _e68, _e70, 0f);
let _e73 = i_row0_1[3u];
let _e75 = i_row1_1[3u];
let _e77 = i_row2_1[3u];
let _e78 = vec4<f32>(_e73, _e75, _e77, 1f);
instance_1 = mat4x4<f32>(vec4<f32>(_e57.x, _e57.y, _e57.z, _e57.w), vec4<f32>(_e64.x, _e64.y, _e64.z, _e64.w), vec4<f32>(_e71.x, _e71.y, _e71.z, _e71.w), vec4<f32>(_e78.x, _e78.y, _e78.z, _e78.w));
let _e100 = position_4;
morphed_position = _e100;
let _e101 = normal_4;
morphed_normal = _e101;
let _e102 = tangent_4;
morphed_tangent = _e102;
let _e103 = gl_InstanceIndex_1;
param_17 = _e103;
let _e104 = morphed_position;
param_18 = _e104;
let _e105 = morphed_normal;
param_19 = _e105;
let _e106 = morphed_tangent;
param_20 = _e106;
ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e107 = param_18;
morphed_position = _e107;
let _e108 = param_19;
morphed_normal = _e108;
let _e109 = param_20;
morphed_tangent = _e109;
let _e110 = instance_1;
let _e111 = morphed_position;
local = (_e110 * vec4<f32>(_e111.x, _e111.y, _e111.z, 1f));
let _e118 = frame_info.model;
let _e119 = local;
world = (_e118 * _e119);
let _e121 = world;
v_world_position = _e121.xyz;
let _e123 = instance_1;
rotation = mat3x3<f32>(_e123[0].xyz, _e123[1].xyz, _e123[2].xyz);
let _e132 = frame_info.normal_matrix;
let _e140 = rotation;
let _e141 = morphed_normal;
v_normal = (mat3x3<f32>(_e132[0].xyz, _e132[1].xyz, _e132[2].xyz) * normalize((_e140 * _e141)));
let _e145 = texcoord_1;
v_texcoord = _e145;
let _e147 = frame_info.model;
let _e155 = rotation;
let _e156 = morphed_tangent;
let _e159 = (mat3x3<f32>(_e147[0].xyz, _e147[1].xyz, _e147[2].xyz) * (_e155 * _e156.xyz));
let _e161 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e159.x, _e159.y, _e159.z, _e161);
let _e166 = color_1;
let _e167 = i_color_1;
v_color = (_e166 * _e167);
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e170 = frame_info.mvp;
let _e171 = local;
unnamed.gl_Position = (_e170 * _e171);
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(5) i_row0_: vec4<f32>, @location(6) i_row1_: vec4<f32>, @location(7) i_row2_: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @builtin(instance_index) gl_InstanceIndex: u32, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>, @location(8) i_color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
i_row0_1 = i_row0_;
i_row1_1 = i_row1_;
i_row2_1 = i_row2_;
position_4 = position;
normal_4 = normal;
tangent_4 = tangent;
gl_InstanceIndex_1 = i32(gl_InstanceIndex);
texcoord_1 = texcoord;
color_1 = color;
i_color_1 = i_color;
main_1();
let _e32 = v_world_position;
let _e33 = v_normal;
let _e34 = v_texcoord;
let _e35 = v_tangent;
let _e36 = v_color;
let _e37 = v_lightmap_uv;
let _e38 = unnamed.gl_Position;
return VertexOutput(_e32, _e33, _e34, _e35, _e36, _e37, _e38);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row0',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row1',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row2',
location: 7,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_color',
location: 8,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'MorphInstanceInfo',
group: 0,
binding: 2,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'instance_params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_instance_weights',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MeshLightmappedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> color_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e40 = (*t);
let _e44 = (*rowStep);
row = ((f32((_e40 * 3i)) + 0.5f) * _e44);
let _e46 = (*column);
let _e47 = row;
let _e49 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e46, _e47), 0f);
let _e51 = (*weight);
let _e53 = (*position_1);
(*position_1) = (_e53 + (_e49.xyz * _e51));
let _e55 = (*column);
let _e56 = row;
let _e57 = (*rowStep);
let _e60 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e55, (_e56 + _e57)), 0f);
let _e62 = (*weight);
let _e64 = (*normal_1);
(*normal_1) = (_e64 + (_e60.xyz * _e62));
let _e66 = (*column);
let _e67 = row;
let _e68 = (*rowStep);
let _e72 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e66, (_e67 + (_e68 * 2f))), 0f);
let _e74 = (*weight);
let _e76 = (*tangent_1);
let _e78 = (_e76.xyz + (_e72.xyz * _e74));
(*tangent_1)[0u] = _e78.x;
(*tangent_1)[1u] = _e78.y;
(*tangent_1)[2u] = _e78.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e32 = gl_VertexIndex_1;
let _e37 = morph_info.morph_params[1u];
return ((f32(_e32) + 0.5f) * _e37);
}
fn MorphCount_u0028_() -> i32 {
let _e34 = morph_info.morph_params[0u];
return i32((_e34 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e47 = MorphCount_u0028_();
count = _e47;
let _e48 = count;
if (_e48 <= 0i) {
return;
}
let _e50 = MorphColumn_u0028_();
column_1 = _e50;
let _e53 = morph_info.morph_params[2u];
rowStep_1 = _e53;
i = 0i;
loop {
let _e54 = i;
if (_e54 < 8i) {
let _e56 = i;
let _e57 = count;
if (_e56 >= _e57) {
break;
}
let _e59 = i;
let _e61 = i;
let _e72 = morph_info.morph_weights[(_e59 / 4i)][(_e61 - (i32(floor((f32(_e61) / f32(4i)))) * 4i))];
weight_1 = _e72;
let _e73 = weight_1;
if (_e73 == 0f) {
continue;
}
let _e75 = i;
param = _e75;
let _e76 = weight_1;
param_1 = _e76;
let _e77 = column_1;
param_2 = _e77;
let _e78 = rowStep_1;
param_3 = _e78;
let _e79 = (*position_2);
param_4 = _e79;
let _e80 = (*normal_2);
param_5 = _e80;
let _e81 = (*tangent_2);
param_6 = _e81;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e82 = param_4;
(*position_2) = _e82;
let _e83 = param_5;
(*normal_2) = _e83;
let _e84 = param_6;
(*tangent_2) = _e84;
continue;
} else {
break;
}
continuing {
let _e85 = i;
i = (_e85 + 1i);
}
}
return;
}
fn main_1() {
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var world: vec4<f32>;
let _e39 = position_3;
morphed_position = _e39;
let _e40 = normal_3;
morphed_normal = _e40;
let _e41 = tangent_3;
morphed_tangent = _e41;
let _e42 = morphed_position;
param_7 = _e42;
let _e43 = morphed_normal;
param_8 = _e43;
let _e44 = morphed_tangent;
param_9 = _e44;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e45 = param_7;
morphed_position = _e45;
let _e46 = param_8;
morphed_normal = _e46;
let _e47 = param_9;
morphed_tangent = _e47;
let _e49 = frame_info.model;
let _e50 = morphed_position;
world = (_e49 * vec4<f32>(_e50.x, _e50.y, _e50.z, 1f));
let _e56 = world;
v_world_position = _e56.xyz;
let _e59 = frame_info.normal_matrix;
let _e67 = morphed_normal;
v_normal = (mat3x3<f32>(_e59[0].xyz, _e59[1].xyz, _e59[2].xyz) * _e67);
let _e69 = texcoord_1;
v_texcoord = _e69;
let _e71 = frame_info.model;
let _e79 = morphed_tangent;
let _e81 = (mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz) * _e79.xyz);
let _e83 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e81.x, _e81.y, _e81.z, _e83);
v_color = vec4<f32>(1f, 1f, 1f, 1f);
let _e88 = color_1;
v_lightmap_uv = _e88.xy;
let _e91 = frame_info.mvp;
let _e92 = morphed_position;
unnamed.gl_Position = (_e91 * vec4<f32>(_e92.x, _e92.y, _e92.z, 1f));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e21 = v_world_position;
let _e22 = v_normal;
let _e23 = v_texcoord;
let _e24 = v_tangent;
let _e25 = v_color;
let _e26 = v_lightmap_uv;
let _e27 = unnamed.gl_Position;
return VertexOutput(_e21, _e22, _e23, _e24, _e25, _e26, _e27);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'PolylineVertex': WebGpuStage(
wgsl: r'''
struct MaterialParams {
viewport: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@builtin(position) gl_Position: vec4<f32>,
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
}
@group(0) @binding(1)
var<uniform> params: MaterialParams;
var<private> tangent_1: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> position_1: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
fn ToPixels_u0028_vf4_u003b_vf2_u003b(clip: ptr<function, vec4<f32>>, viewport: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e32 = (*clip);
let _e35 = (*clip)[3u];
let _e38 = (*viewport);
return (((_e32.xy / vec2(_e35)) * _e38) * 0.5f);
}
fn InFront_u0028_vf4_u003b_vf4_u003b(from_: ptr<function, vec4<f32>>, to: ptr<function, vec4<f32>>) -> vec4<f32> {
var t: f32;
let _e34 = (*from_)[3u];
if (_e34 >= 0.0001f) {
let _e36 = (*from_);
return _e36;
}
let _e38 = (*from_)[3u];
let _e41 = (*to)[3u];
let _e43 = (*from_)[3u];
t = ((0.0001f - _e38) / (_e41 - _e43));
let _e46 = (*from_);
let _e47 = (*to);
let _e48 = t;
return mix(_e46, _e47, vec4(clamp(_e48, 0f, 1f)));
}
fn main_1() {
var viewport_1: vec2<f32>;
var halfWidth: f32;
var side: f32;
var here: vec4<f32>;
var before: vec4<f32>;
var after: vec4<f32>;
var local: vec4<f32>;
var param: vec4<f32>;
var param_1: vec4<f32>;
var param_2: vec4<f32>;
var param_3: vec4<f32>;
var param_4: vec4<f32>;
var param_5: vec4<f32>;
var param_6: vec4<f32>;
var param_7: vec4<f32>;
var dir: vec2<f32>;
var param_8: vec4<f32>;
var param_9: vec2<f32>;
var param_10: vec4<f32>;
var param_11: vec2<f32>;
var dirLength: f32;
var segmentNormal: vec2<f32>;
var local_1: vec2<f32>;
var offset: vec2<f32>;
let _e55 = params.viewport;
viewport_1 = _e55.xy;
let _e58 = tangent_1[3u];
halfWidth = abs(_e58);
let _e61 = tangent_1[3u];
side = select(1f, -1f, (_e61 < 0f));
let _e65 = frame_info.mvp;
let _e66 = position_1;
here = (_e65 * vec4<f32>(_e66.x, _e66.y, _e66.z, 1f));
let _e73 = frame_info.mvp;
let _e74 = normal_1;
before = (_e73 * vec4<f32>(_e74.x, _e74.y, _e74.z, 1f));
let _e81 = frame_info.mvp;
let _e82 = tangent_1;
let _e83 = _e82.xyz;
after = (_e81 * vec4<f32>(_e83.x, _e83.y, _e83.z, 1f));
let _e90 = here[3u];
if (_e90 < 0.0001f) {
let _e93 = after[3u];
if (_e93 >= 0.0001f) {
let _e95 = here;
param = _e95;
let _e96 = after;
param_1 = _e96;
let _e97 = InFront_u0028_vf4_u003b_vf4_u003b((¶m), (¶m_1));
local = _e97;
} else {
let _e98 = here;
param_2 = _e98;
let _e99 = before;
param_3 = _e99;
let _e100 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_2), (¶m_3));
local = _e100;
}
let _e101 = local;
here = _e101;
}
let _e102 = before;
param_4 = _e102;
let _e103 = here;
param_5 = _e103;
let _e104 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_4), (¶m_5));
before = _e104;
let _e105 = after;
param_6 = _e105;
let _e106 = here;
param_7 = _e106;
let _e107 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_6), (¶m_7));
after = _e107;
let _e108 = after;
param_8 = _e108;
let _e109 = viewport_1;
param_9 = _e109;
let _e110 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_8), (¶m_9));
let _e111 = before;
param_10 = _e111;
let _e112 = viewport_1;
param_11 = _e112;
let _e113 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_10), (¶m_11));
dir = (_e110 - _e113);
let _e115 = dir;
dirLength = length(_e115);
let _e117 = dirLength;
if (_e117 > 0.000000001f) {
let _e120 = dir[1u];
let _e123 = dir[0u];
let _e125 = dirLength;
local_1 = (vec2<f32>(-(_e120), _e123) / vec2(_e125));
} else {
local_1 = vec2<f32>(1f, 0f);
}
let _e128 = local_1;
segmentNormal = _e128;
let _e129 = segmentNormal;
let _e130 = halfWidth;
let _e132 = side;
offset = ((_e129 * _e130) * _e132);
let _e134 = here;
let _e136 = offset;
let _e137 = viewport_1;
let _e141 = here[3u];
let _e143 = (_e134.xy + ((_e136 / (_e137 * 0.5f)) * _e141));
let _e144 = here;
let _e145 = _e144.zw;
unnamed.gl_Position = vec4<f32>(_e143.x, _e143.y, _e145.x, _e145.y);
let _e153 = frame_info.model;
let _e154 = position_1;
v_world_position = (_e153 * vec4<f32>(_e154.x, _e154.y, _e154.z, 1f)).xyz;
let _e162 = frame_info.normal_matrix;
v_normal = normalize((mat3x3<f32>(_e162[0].xyz, _e162[1].xyz, _e162[2].xyz) * vec3<f32>(0f, 1f, 0f)));
let _e172 = texcoord_1;
v_texcoord = _e172;
v_tangent = vec4<f32>(1f, 0f, 0f, 1f);
let _e173 = color_1;
v_color = _e173;
v_lightmap_uv = vec2<f32>(0f, 0f);
return;
}
@vertex
fn main(@location(3) tangent: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
tangent_1 = tangent;
position_1 = position;
normal_1 = normal;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e18 = unnamed.gl_Position;
let _e19 = v_world_position;
let _e20 = v_normal;
let _e21 = v_texcoord;
let _e22 = v_tangent;
let _e23 = v_color;
let _e24 = v_lightmap_uv;
return VertexOutput(_e18, _e19, _e20, _e21, _e22, _e23, _e24);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MaterialParams',
group: 0,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'viewport',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(5) member_1: vec2<f32>,
@location(6) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_world_position: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_info: ParticleInfo;
fn main_1() {
let _e11 = color_1;
v_color = _e11;
let _e12 = texcoord_1;
v_uv = _e12;
let _e13 = position_1;
v_world_position = _e13;
let _e15 = particle_info.view_projection;
let _e16 = position_1;
unnamed.gl_Position = (_e15 * vec4<f32>(_e16.x, _e16.y, _e16.z, 1f));
return;
}
@vertex
fn main(@location(1) color: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
color_1 = color;
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e11 = v_color;
let _e12 = v_uv;
let _e13 = v_world_position;
let _e14 = unnamed.gl_Position;
return VertexOutput(_e11, _e12, _e13, _e14);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'color',
location: 1,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleMeshVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleMeshInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(6) member_1: vec3<f32>,
@location(2) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> i_position_1: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> i_scale_1: f32;
var<private> v_color: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_mesh_info: ParticleMeshInfo;
fn main_1() {
var world: vec3<f32>;
let _e14 = i_position_1;
let _e15 = position_1;
let _e16 = i_scale_1;
world = (_e14 + (_e15 * _e16));
let _e19 = i_color_1;
v_color = _e19;
let _e20 = world;
v_world_position = _e20;
let _e21 = normal_1;
v_normal = _e21;
let _e23 = particle_mesh_info.view_projection;
let _e24 = world;
unnamed.gl_Position = (_e23 * vec4<f32>(_e24.x, _e24.y, _e24.z, 1f));
return;
}
@vertex
fn main(@location(2) i_position: vec3<f32>, @location(0) position: vec3<f32>, @location(4) i_scale: f32, @location(3) i_color: vec4<f32>, @location(1) normal: vec3<f32>) -> VertexOutput {
i_position_1 = i_position;
position_1 = position;
i_scale_1 = i_scale;
i_color_1 = i_color;
normal_1 = normal;
main_1();
let _e15 = v_color;
let _e16 = v_world_position;
let _e17 = v_normal;
let _e18 = unnamed.gl_Position;
return VertexOutput(_e15, _e16, _e17, _e18);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_position',
location: 2,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_color',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_scale',
location: 4,
format: VertexFormat.float32,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleMeshInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ShadowTileResetVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(5) member: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e7 = texcoord_1;
v_uv = _e7;
let _e8 = position_1;
unnamed.gl_Position = vec4<f32>(_e8.x, _e8.y, 1f, 1f);
return;
}
@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e7 = v_uv;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'texcoord',
location: 1,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(7) member_1: vec4<f32>,
@location(2) member_2: vec4<f32>,
@location(3) member_3: vec4<f32>,
@location(5) member_4: vec4<f32>,
@location(1) member_5: vec4<f32>,
@location(0) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_zenith: vec4<f32>;
var<private> zenith_1: vec4<f32>;
var<private> v_horizon: vec4<f32>;
var<private> horizon_1: vec4<f32>;
var<private> v_nadir: vec4<f32>;
var<private> nadir_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_glow: vec4<f32>;
var<private> glow_1: vec4<f32>;
var<private> v_disc: vec4<f32>;
var<private> disc_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e20 = corner_ray_1;
v_ray = _e20;
let _e21 = zenith_1;
v_zenith = _e21;
let _e22 = horizon_1;
v_horizon = _e22;
let _e23 = nadir_1;
v_nadir = _e23;
let _e24 = sun_1;
v_sun = _e24;
let _e25 = glow_1;
v_glow = _e25;
let _e26 = disc_1;
v_disc = _e26;
let _e27 = position_1;
unnamed.gl_Position = vec4<f32>(_e27.x, _e27.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) zenith: vec4<f32>, @location(3) horizon: vec4<f32>, @location(4) nadir: vec4<f32>, @location(5) sun: vec4<f32>, @location(6) glow: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
zenith_1 = zenith;
horizon_1 = horizon;
nadir_1 = nadir;
sun_1 = sun;
glow_1 = glow;
disc_1 = disc;
position_1 = position;
main_1();
let _e25 = v_ray;
let _e26 = v_zenith;
let _e27 = v_horizon;
let _e28 = v_nadir;
let _e29 = v_sun;
let _e30 = v_glow;
let _e31 = v_disc;
let _e32 = unnamed.gl_Position;
return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31, _e32);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'zenith',
location: 2,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'horizon',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'nadir',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'sun',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'glow',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'disc',
location: 7,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyCubeVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(6) member_1: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_tint: vec4<f32>;
var<private> tint_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e10 = corner_ray_1;
v_ray = _e10;
let _e11 = tint_1;
v_tint = _e11;
let _e12 = position_1;
unnamed.gl_Position = vec4<f32>(_e12.x, _e12.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) tint: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
tint_1 = tint;
position_1 = position;
main_1();
let _e10 = v_ray;
let _e11 = v_tint;
let _e12 = unnamed.gl_Position;
return VertexOutput(_e10, _e11, _e12);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'tint',
location: 2,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'VertexTextureProbeVertex': WebGpuStage(
wgsl: r'''
struct ProbeInfo {
at: vec4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_sampled: vec4<f32>;
@group(0) @binding(1)
var probe_texture_tex: texture_2d<f32>;
@group(0) @binding(2)
var probe_texture_smp: sampler;
@group(0) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;
fn main_1() {
let _e11 = probe_info.at;
let _e13 = textureSampleLevel(probe_texture_tex, probe_texture_smp, _e11.xy, 0f);
v_sampled = _e13;
let _e14 = position_1;
unnamed.gl_Position = vec4<f32>(_e14.x, _e14.y, _e14.z, 1f);
return;
}
@vertex
fn main(@location(0) position: vec3<f32>) -> VertexOutput {
position_1 = position;
main_1();
let _e5 = v_sampled;
let _e6 = unnamed.gl_Position;
return VertexOutput(_e5, _e6);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ProbeInfo',
group: 0,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'at', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'probe_texture',
group: 0,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
},
fragment: <String, WebGpuStage>{
'Unlit': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e59 = (*n)[0u];
let _e62 = (*n)[1u];
let _e66 = (*n)[2u];
let _e69 = (*n);
(*n) = (_e69 / vec3(((abs(_e59) + abs(_e62)) + abs(_e66))));
let _e72 = (*n);
e = _e72.xy;
let _e75 = (*n)[2u];
if (_e75 < 0f) {
let _e77 = (*n);
let _e83 = (*n)[0u];
let _e87 = (*n)[1u];
e = ((vec2(1f) - abs(_e77.yx)) * vec2<f32>(select(-1f, 1f, (_e83 >= 0f)), select(-1f, 1f, (_e87 >= 0f))));
}
let _e92 = e;
return ((_e92 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e56 = v_world_position_1;
let _e58 = fog_info.eye;
let _e62 = fog_info.forward;
return dot((_e56 - _e58.xyz), _e62.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e58 = g_debug_surface_on;
if _e58 {
let _e59 = g_debug_surface;
let _e60 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e59.x, _e59.y, _e59.z, _e60);
return;
}
let _e65 = v_normal_1;
param = normalize(_e65);
let _e67 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e68 = (*roughness);
let _e70 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e67.x, _e67.y, clamp(_e68, 0f, 1f), _e70);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e56 = v_world_position_1;
let _e58 = fog_info.eye;
return distance(_e56, _e58.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e61 = fog_info.fog[3u];
density = _e61;
let _e62 = density;
if (_e62 <= 0f) {
let _e64 = (*color);
return _e64;
}
let _e65 = EyeDistance_u0028_();
d = _e65;
let _e67 = fog_info.fog;
let _e69 = (*color);
let _e70 = density;
let _e72 = d;
return mix(_e67.xyz, _e69, vec3(clamp(exp((-(_e70) * _e72)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e61 = (*linearColor);
param_1 = _e61;
let _e62 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e63 = (*alpha);
frag_color = vec4<f32>(_e62.x, _e62.y, _e62.z, _e63);
let _e68 = (*roughness_1);
param_2 = _e68;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_1: ptr<function, f32>) {
var param_3: vec3<f32>;
var param_4: f32;
var param_5: f32;
let _e61 = (*linearColor_1);
param_3 = _e61;
let _e62 = (*alpha_1);
param_4 = _e62;
param_5 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_3), (¶m_4), (¶m_5));
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e57 = (*srgb);
let _e60 = (*srgb);
let _e65 = (*srgb);
return mix((_e57 / vec3(12.92f)), pow(((_e60 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e65));
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise: f32;
let _e63 = v_texcoord_1;
let _e64 = textureSample(base_color_texture_tex, base_color_texture_smp, _e63);
texel = _e64;
let _e65 = texel;
param_6 = _e65.xyz;
let _e67 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e69 = frag_info.base_color;
param_7 = _e69.xyz;
let _e71 = SrgbToLinear_u0028_vf3_u003b((¶m_7));
let _e73 = v_color_1;
s.albedo = ((_e67 * _e71) * _e73.xyz);
let _e78 = texel[3u];
let _e81 = frag_info.base_color[3u];
let _e84 = v_color_1[3u];
s.alpha = ((_e78 * _e81) * _e84);
let _e89 = frag_info.material2_[0u];
cutoff = _e89;
let _e90 = cutoff;
if (_e90 >= 0f) {
let _e93 = s.alpha;
let _e94 = cutoff;
if (_e93 < _e94) {
discard;
}
} else {
let _e96 = cutoff;
if (_e96 < -1.5f) {
let _e98 = v_world_position_1;
anchored = floor((_e98 * 16f));
let _e101 = anchored;
noise = fract((sin(dot(_e101, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e107 = s.alpha;
let _e108 = noise;
if (_e107 < _e108) {
discard;
}
}
}
let _e110 = v_normal_1;
s.n = normalize(_e110);
let _e114 = frag_info.camera_position;
let _e116 = v_world_position_1;
s.v = normalize((_e114.xyz - _e116));
let _e121 = s.n;
let _e123 = s.v;
s.n_dot_v = max(dot(_e121, _e123), 0.0001f);
let _e129 = frag_info.material[0u];
s.metallic = clamp(_e129, 0f, 1f);
let _e134 = frag_info.material[1u];
s.roughness = clamp(_e134, 0.02f, 1f);
let _e138 = frag_info.ambient_ground;
let _e141 = frag_info.ambient_sky;
let _e145 = s.n[1u];
let _e152 = frag_info.material[2u];
s.ambient = (mix(_e138.xyz, _e141.xyz, vec3(((_e145 * 0.5f) + 0.5f))) * _e152);
let _e157 = frag_info.frame_params[0u];
s.exposure = max(_e157, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e162 = s;
return _e162;
}
fn main_1() {
var s_1: Surface;
var param_8: vec3<f32>;
var param_9: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e59 = ReadSurface_u0028_();
s_1 = _e59;
let _e61 = s_1.albedo;
param_8 = _e61;
let _e63 = s_1.alpha;
param_9 = _e63;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e14 = frag_surface;
let _e15 = frag_color;
return FragmentOutput(_e14, _e15);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Xray': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e54 = v_world_position_1;
let _e56 = fog_info.eye;
return distance(_e54, _e56.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e59 = fog_info.fog[3u];
density = _e59;
let _e60 = density;
if (_e60 <= 0f) {
let _e62 = (*color);
return _e62;
}
let _e63 = EyeDistance_u0028_();
d = _e63;
let _e65 = fog_info.fog;
let _e67 = (*color);
let _e68 = density;
let _e70 = d;
return mix(_e65.xyz, _e67, vec3(clamp(exp((-(_e68) * _e70)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param: vec3<f32>;
var param_1: f32;
let _e59 = (*linearColor);
param = _e59;
let _e60 = ApplyFog_u0028_vf3_u003b((¶m));
let _e61 = (*alpha);
frag_color = vec4<f32>(_e60.x, _e60.y, _e60.z, _e61);
let _e66 = (*roughness_1);
param_1 = _e66;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_1));
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_1: ptr<function, f32>) {
var param_2: vec3<f32>;
var param_3: f32;
var param_4: f32;
let _e59 = (*linearColor_1);
param_2 = _e59;
let _e60 = (*alpha_1);
param_3 = _e60;
param_4 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_2), (¶m_3), (¶m_4));
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e55 = (*srgb);
let _e58 = (*srgb);
let _e63 = (*srgb);
return mix((_e55 / vec3(12.92f)), pow(((_e58 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e63));
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise: f32;
let _e61 = v_texcoord_1;
let _e62 = textureSample(base_color_texture_tex, base_color_texture_smp, _e61);
texel = _e62;
let _e63 = texel;
param_5 = _e63.xyz;
let _e65 = SrgbToLinear_u0028_vf3_u003b((¶m_5));
let _e67 = frag_info.base_color;
param_6 = _e67.xyz;
let _e69 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e71 = v_color_1;
s.albedo = ((_e65 * _e69) * _e71.xyz);
let _e76 = texel[3u];
let _e79 = frag_info.base_color[3u];
let _e82 = v_color_1[3u];
s.alpha = ((_e76 * _e79) * _e82);
let _e87 = frag_info.material2_[0u];
cutoff = _e87;
let _e88 = cutoff;
if (_e88 >= 0f) {
let _e91 = s.alpha;
let _e92 = cutoff;
if (_e91 < _e92) {
discard;
}
} else {
let _e94 = cutoff;
if (_e94 < -1.5f) {
let _e96 = v_world_position_1;
anchored = floor((_e96 * 16f));
let _e99 = anchored;
noise = fract((sin(dot(_e99, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e105 = s.alpha;
let _e106 = noise;
if (_e105 < _e106) {
discard;
}
}
}
let _e108 = v_normal_1;
s.n = normalize(_e108);
let _e112 = frag_info.camera_position;
let _e114 = v_world_position_1;
s.v = normalize((_e112.xyz - _e114));
let _e119 = s.n;
let _e121 = s.v;
s.n_dot_v = max(dot(_e119, _e121), 0.0001f);
let _e127 = frag_info.material[0u];
s.metallic = clamp(_e127, 0f, 1f);
let _e132 = frag_info.material[1u];
s.roughness = clamp(_e132, 0.02f, 1f);
let _e136 = frag_info.ambient_ground;
let _e139 = frag_info.ambient_sky;
let _e143 = s.n[1u];
let _e150 = frag_info.material[2u];
s.ambient = (mix(_e136.xyz, _e139.xyz, vec3(((_e143 * 0.5f) + 0.5f))) * _e150);
let _e155 = frag_info.frame_params[0u];
s.exposure = max(_e155, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e160 = s;
return _e160;
}
fn main_1() {
var s_1: Surface;
var param_7: vec3<f32>;
var param_8: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e57 = ReadSurface_u0028_();
s_1 = _e57;
let _e59 = s_1.albedo;
param_7 = _e59;
let _e61 = s_1.alpha;
param_8 = _e61;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_7), (¶m_8));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Lambert': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e147 = (*n)[0u];
let _e150 = (*n)[1u];
let _e154 = (*n)[2u];
let _e157 = (*n);
(*n) = (_e157 / vec3(((abs(_e147) + abs(_e150)) + abs(_e154))));
let _e160 = (*n);
e = _e160.xy;
let _e163 = (*n)[2u];
if (_e163 < 0f) {
let _e165 = (*n);
let _e171 = (*n)[0u];
let _e175 = (*n)[1u];
e = ((vec2(1f) - abs(_e165.yx)) * vec2<f32>(select(-1f, 1f, (_e171 >= 0f)), select(-1f, 1f, (_e175 >= 0f))));
}
let _e180 = e;
return ((_e180 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e144 = v_world_position_1;
let _e146 = fog_info.eye;
let _e150 = fog_info.forward;
return dot((_e144 - _e146.xyz), _e150.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e146 = g_debug_surface_on;
if _e146 {
let _e147 = g_debug_surface;
let _e148 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e147.x, _e147.y, _e147.z, _e148);
return;
}
let _e153 = v_normal_1;
param = normalize(_e153);
let _e155 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e156 = (*roughness);
let _e158 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e155.x, _e155.y, clamp(_e156, 0f, 1f), _e158);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e144 = v_world_position_1;
let _e146 = fog_info.eye;
return distance(_e144, _e146.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e149 = fog_info.fog[3u];
density = _e149;
let _e150 = density;
if (_e150 <= 0f) {
let _e152 = (*color);
return _e152;
}
let _e153 = EyeDistance_u0028_();
d = _e153;
let _e155 = fog_info.fog;
let _e157 = (*color);
let _e158 = density;
let _e160 = d;
return mix(_e155.xyz, _e157, vec3(clamp(exp((-(_e158) * _e160)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e149 = (*linearColor);
param_1 = _e149;
let _e150 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e151 = (*alpha);
frag_color = vec4<f32>(_e150.x, _e150.y, _e150.z, _e151);
let _e156 = (*roughness_1);
param_2 = _e156;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e147 = (*s).albedo;
return _e147;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e145 = (*i);
if (_e145 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e147 = (*i);
if (_e147 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e149 = (*i);
if (_e149 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e151 = (*i);
if (_e151 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e153 = (*i);
if (_e153 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e155 = (*i);
if (_e155 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e157 = (*i);
if (_e157 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e150 = (*i_1);
param_3 = _e150;
let _e151 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e151;
let _e153 = p[0u];
let _e154 = (*ca);
let _e157 = p[1u];
let _e158 = (*sa);
let _e162 = p[0u];
let _e163 = (*sa);
let _e166 = p[1u];
let _e167 = (*ca);
let _e171 = (*radius);
return (vec2<f32>(((_e153 * _e154) - (_e157 * _e158)), ((_e162 * _e163) + (_e166 * _e167))) * _e171);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e153 = point_shadow.params[0u];
inset = _e153;
let _e154 = (*uv);
let _e155 = (*offset);
let _e157 = inset;
let _e158 = inset;
local = clamp((_e154 + _e155), vec2(_e157), vec2((1f - _e158)));
let _e163 = local;
let _e164 = (*tile);
atlas = ((_e163 + _e164) * vec2<f32>(0.16666667f, 0.16666667f));
let _e169 = point_shadow.params3_[0u];
if (_e169 > 0.5f) {
let _e172 = atlas[1u];
atlas[1u] = (1f - _e172);
}
let _e175 = atlas;
let _e176 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e175, 0f);
let _e178 = atlas;
let _e179 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e178, 0f);
let _e182 = (*range);
return (min(_e176.x, _e179.x) * _e182);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e154 = (*uv_1);
param_4 = _e154;
let _e155 = (*offset_1);
param_5 = _e155;
let _e156 = (*tile_1);
param_6 = _e156;
let _e157 = (*range_1);
param_7 = _e157;
let _e158 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e158;
let _e159 = stored;
let _e160 = (*range_1);
if (_e159 >= (_e160 * 0.999f)) {
return 1f;
}
let _e163 = (*receiver);
let _e164 = stored;
return select(1f, 0f, (_e163 > _e164));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e175 = point_shadow.params2_[1u];
lightRadius = _e175;
let _e178 = point_shadow.params2_[0u];
minRadius = _e178;
let _e181 = point_shadow.params2_[2u];
maxRadius = _e181;
let _e182 = lightRadius;
if (_e182 <= 0f) {
let _e184 = (*uv_2);
param_8 = _e184;
param_9 = vec2<f32>(0f, 0f);
let _e185 = (*tile_2);
param_10 = _e185;
let _e186 = (*range_2);
param_11 = _e186;
let _e187 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e187;
let _e188 = minRadius;
return _e188;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e189 = i_2;
if (_e189 < 8i) {
let _e191 = i_2;
param_12 = _e191;
let _e192 = (*ca_1);
param_13 = _e192;
let _e193 = (*sa_1);
param_14 = _e193;
let _e194 = maxRadius;
param_15 = _e194;
let _e195 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e196 = (*uv_2);
param_16 = _e196;
param_17 = _e195;
let _e197 = (*tile_2);
param_18 = _e197;
let _e198 = (*range_2);
param_19 = _e198;
let _e199 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e199;
let _e200 = stored_1;
let _e201 = (*range_2);
if (_e200 >= (_e201 * 0.999f)) {
continue;
}
let _e204 = stored_1;
let _e205 = (*receiver_1);
if (_e204 >= _e205) {
continue;
}
let _e207 = stored_1;
let _e208 = sum;
sum = (_e208 + _e207);
let _e210 = count;
count = (_e210 + 1f);
continue;
} else {
break;
}
continuing {
let _e212 = i_2;
i_2 = (_e212 + 1i);
}
}
let _e214 = count;
if (_e214 < 0.5f) {
return -1f;
}
let _e216 = sum;
let _e217 = count;
blocker = max((_e216 / _e217), 0.0001f);
let _e220 = blocker;
(*blockerOut) = _e220;
let _e221 = lightRadius;
let _e222 = (*receiver_1);
let _e223 = blocker;
let _e227 = blocker;
world = ((_e221 * max((_e222 - _e223), 0f)) / _e227);
let _e229 = world;
let _e230 = (*receiver_1);
let _e232 = (*tanHalf);
let _e235 = minRadius;
let _e236 = maxRadius;
return clamp((_e229 / ((2f * _e230) * _e232)), _e235, _e236);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1523_: bool;
var phi_1585_: bool;
let _e197 = (*lightIndex);
let _e201 = point_shadow.slots[_e197][0u];
slot = i32((_e201 + 0.5f));
let _e204 = (*lightIndex);
let _e208 = point_shadow.slots[_e204][0u];
if (_e208 < 0f) {
return 1f;
}
let _e212 = point_shadow.params[2u];
strength = _e212;
let _e213 = strength;
if (_e213 <= 0f) {
return 1f;
}
let _e215 = slot;
let _e218 = point_shadow.lights[_e215];
let _e220 = (*world_1);
toLight = (_e218.xyz - _e220);
let _e222 = toLight;
toLightLength = max(length(_e222), 0.000001f);
let _e225 = (*normal);
let _e226 = toLight;
let _e227 = toLightLength;
nDotL = max(dot(_e225, (_e226 / vec3(_e227))), 0.15f);
let _e232 = nDotL;
let _e233 = nDotL;
let _e238 = nDotL;
let _e239 = nDotL;
slope = min((sqrt(max((1f - (_e232 * _e233)), 0f)) / (_e238 * _e239)), 8f);
let _e243 = toLightLength;
let _e245 = (*lightIndex);
let _e249 = point_shadow.slots[_e245][2u];
let _e254 = point_shadow.params3_[1u];
texel = (((2f * _e243) * max(_e249, 0.0001f)) * _e254);
let _e256 = (*world_1);
let _e257 = (*normal);
let _e258 = texel;
let _e262 = point_shadow.params[3u];
let _e264 = slope;
origin = (_e256 + (((_e257 * _e258) * _e262) * (1f + _e264)));
let _e268 = origin;
let _e269 = slot;
let _e272 = point_shadow.lights[_e269];
toFragment = (_e268 - _e272.xyz);
let _e275 = toFragment;
distance_ = length(_e275);
let _e277 = slot;
let _e281 = point_shadow.lights[_e277][3u];
range_3 = max(_e281, 0.0001f);
let _e283 = distance_;
let _e284 = range_3;
if (_e283 >= _e284) {
return 1f;
}
face = 0i;
let _e286 = (*lightIndex);
let _e290 = point_shadow.slots[_e286][1u];
if (_e290 < 0.5f) {
let _e292 = toFragment;
a = abs(_e292);
let _e295 = a[0u];
let _e297 = a[1u];
let _e298 = (_e295 >= _e297);
phi_1523_ = _e298;
if _e298 {
let _e300 = a[0u];
let _e302 = a[2u];
phi_1523_ = (_e300 >= _e302);
}
let _e305 = phi_1523_;
if _e305 {
let _e307 = toFragment[0u];
face = select(1i, 0i, (_e307 > 0f));
} else {
let _e311 = a[1u];
let _e313 = a[2u];
if (_e311 >= _e313) {
let _e316 = toFragment[1u];
face = select(3i, 2i, (_e316 > 0f));
} else {
let _e320 = toFragment[2u];
face = select(5i, 4i, (_e320 > 0f));
}
}
}
let _e323 = slot;
let _e325 = face;
let _e329 = point_shadow.faces[((_e323 * 6i) + _e325)];
let _e330 = origin;
clip = (_e329 * vec4<f32>(_e330.x, _e330.y, _e330.z, 1f));
let _e337 = clip[3u];
if (_e337 <= 0f) {
return 1f;
}
let _e339 = clip;
let _e342 = clip[3u];
ndc = (_e339.xy / vec2(_e342));
let _e346 = ndc[0u];
let _e348 = (abs(_e346) > 1f);
phi_1585_ = _e348;
if !(_e348) {
let _e351 = ndc[1u];
phi_1585_ = (abs(_e351) > 1f);
}
let _e355 = phi_1585_;
if _e355 {
return 1f;
}
let _e357 = ndc[0u];
let _e361 = ndc[1u];
uv_3 = vec2<f32>(((_e357 * 0.5f) + 0.5f), (0.5f - (_e361 * 0.5f)));
let _e365 = face;
let _e367 = slot;
tile_3 = vec2<f32>(f32(_e365), f32(_e367));
let _e370 = distance_;
let _e373 = point_shadow.params[1u];
receiver_2 = (_e370 - _e373);
let _e375 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e375.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e381 = noise;
angle = (_e381 * 6.2831855f);
let _e383 = angle;
ca_2 = cos(_e383);
let _e385 = angle;
sa_2 = sin(_e385);
let _e387 = (*lightIndex);
let _e391 = point_shadow.slots[_e387][2u];
tanHalf_1 = max(_e391, 0.0001f);
blocker_1 = -1f;
let _e393 = uv_3;
param_20 = _e393;
let _e394 = tile_3;
param_21 = _e394;
let _e395 = range_3;
param_22 = _e395;
let _e396 = receiver_2;
param_23 = _e396;
let _e397 = ca_2;
param_24 = _e397;
let _e398 = sa_2;
param_25 = _e398;
let _e399 = tanHalf_1;
param_26 = _e399;
let _e400 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e401 = param_27;
blocker_1 = _e401;
radius_1 = _e400;
let _e404 = point_shadow.params2_[3u];
if (_e404 > 0.5f) {
g_debug_surface_on = true;
let _e406 = radius_1;
if (_e406 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e408 = radius_1;
let _e411 = point_shadow.params2_[2u];
let _e415 = blocker_1;
let _e416 = range_3;
local_1 = vec3<f32>(clamp((_e408 / max(_e411, 0.000001f)), 0f, 1f), clamp((_e415 / _e416), 0f, 1f), 0f);
}
let _e420 = local_1;
g_debug_surface = _e420;
}
let _e421 = radius_1;
if (_e421 < 0f) {
return 1f;
}
let _e423 = uv_3;
param_28 = _e423;
param_29 = vec2<f32>(0f, 0f);
let _e424 = tile_3;
param_30 = _e424;
let _e425 = range_3;
param_31 = _e425;
let _e426 = receiver_2;
param_32 = _e426;
let _e427 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e427;
let _e428 = radius_1;
if (_e428 > 0f) {
i_3 = 0i;
loop {
let _e430 = i_3;
if (_e430 < 8i) {
let _e432 = i_3;
param_33 = _e432;
let _e433 = ca_2;
param_34 = _e433;
let _e434 = sa_2;
param_35 = _e434;
let _e435 = radius_1;
param_36 = _e435;
let _e436 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e437 = uv_3;
param_37 = _e437;
param_38 = _e436;
let _e438 = tile_3;
param_39 = _e438;
let _e439 = range_3;
param_40 = _e439;
let _e440 = receiver_2;
param_41 = _e440;
let _e441 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e442 = lit;
lit = (_e442 + _e441);
continue;
} else {
break;
}
continuing {
let _e444 = i_3;
i_3 = (_e444 + 1i);
}
}
let _e446 = lit;
lit = (_e446 * 0.11111111f);
}
let _e448 = lit;
let _e449 = strength;
return mix(1f, _e448, clamp(_e449, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2009_: bool;
var phi_2020_: bool;
var phi_2110_: bool;
var phi_2117_: bool;
var phi_2124_: bool;
let _e183 = frag_info.shadow_params[3u];
strength_1 = _e183;
let _e184 = strength_1;
if (_e184 <= 0f) {
return 1f;
}
let _e186 = (*lightIndex_1);
let _e189 = frag_info.frame_params[2u];
if (_e186 != i32((_e189 + 0.5f))) {
return 1f;
}
let _e193 = v_world_position_1;
let _e195 = (*s_1).n;
let _e198 = frag_info.shadow_params[2u];
origin_1 = (_e193 + (_e195 * _e198));
let _e203 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e203 + 0.5f));
let _e206 = v_world_position_1;
let _e208 = frag_info.camera_position;
viewDistance = length((_e206 - _e208.xyz));
cascade = 0i;
let _e212 = cascadeCount;
let _e213 = (_e212 > 1i);
phi_2009_ = _e213;
if _e213 {
let _e214 = viewDistance;
let _e217 = frag_info.shadow_cascades[0u];
phi_2009_ = (_e214 > _e217);
}
let _e220 = phi_2009_;
if _e220 {
cascade = 1i;
}
let _e221 = cascadeCount;
let _e222 = (_e221 > 2i);
phi_2020_ = _e222;
if _e222 {
let _e223 = viewDistance;
let _e226 = frag_info.shadow_cascades[1u];
phi_2020_ = (_e223 > _e226);
}
let _e229 = phi_2020_;
if _e229 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e230 = attempt;
if (_e230 < 3i) {
let _e232 = cascade;
let _e233 = attempt;
which = (_e232 + _e233);
let _e235 = which;
let _e236 = cascadeCount;
if (_e235 >= _e236) {
break;
}
let _e238 = which;
if (_e238 == 0i) {
let _e241 = frag_info.shadow_matrix;
local_2 = _e241;
} else {
let _e242 = which;
if (_e242 == 1i) {
let _e245 = frag_info.shadow_matrix_far;
local_3 = _e245;
} else {
let _e247 = frag_info.shadow_matrix_farthest;
local_3 = _e247;
}
let _e248 = local_3;
local_2 = _e248;
}
let _e249 = local_2;
matrix = _e249;
let _e250 = matrix;
let _e251 = origin_1;
lightSpace = (_e250 * vec4<f32>(_e251.x, _e251.y, _e251.z, 1f));
let _e258 = lightSpace[3u];
if (_e258 <= 0f) {
continue;
}
let _e260 = lightSpace;
let _e263 = lightSpace[3u];
candidate = (_e260.xyz / vec3(_e263));
let _e267 = candidate[0u];
let _e271 = candidate[1u];
inTile = vec2<f32>(((_e267 * 0.5f) + 0.5f), (0.5f - (_e271 * 0.5f)));
let _e276 = inTile[0u];
let _e277 = (_e276 < 0f);
phi_2110_ = _e277;
if !(_e277) {
let _e280 = inTile[0u];
phi_2110_ = (_e280 > 1f);
}
let _e283 = phi_2110_;
phi_2117_ = _e283;
if !(_e283) {
let _e286 = inTile[1u];
phi_2117_ = (_e286 < 0f);
}
let _e289 = phi_2117_;
phi_2124_ = _e289;
if !(_e289) {
let _e292 = inTile[1u];
phi_2124_ = (_e292 > 1f);
}
let _e295 = phi_2124_;
if _e295 {
continue;
}
let _e297 = candidate[2u];
if (_e297 > 1f) {
continue;
}
let _e300 = inTile[0u];
let _e301 = which;
let _e304 = cascadeCount;
let _e308 = inTile[1u];
uv_4 = vec2<f32>(((_e300 + f32(_e301)) / f32(_e304)), _e308);
let _e310 = candidate;
projected = _e310;
let _e311 = which;
cascade = _e311;
found = true;
break;
} else {
break;
}
continuing {
let _e312 = attempt;
attempt = (_e312 + 1i);
}
}
let _e314 = found;
if !(_e314) {
return 1f;
}
let _e318 = frag_info.shadow_params[1u];
bias = _e318;
let _e321 = frag_info.shadow_params[0u];
let _e324 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e321, _e324);
let _e328 = frag_info.ambient_ground[3u];
softness = _e328;
lit_1 = 0f;
let _e329 = softness;
if (_e329 <= 0f) {
y = -1i;
loop {
let _e331 = y;
if (_e331 <= 1i) {
x = -1i;
loop {
let _e333 = x;
if (_e333 <= 1i) {
let _e335 = uv_4;
let _e336 = x;
let _e338 = y;
let _e341 = texel_1;
let _e344 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e335 + (vec2<f32>(f32(_e336), f32(_e338)) * _e341)), 0f);
occluder = _e344.x;
let _e347 = projected[2u];
let _e348 = bias;
let _e350 = occluder;
let _e353 = lit_1;
lit_1 = (_e353 + select(1f, 0f, ((_e347 - _e348) > _e350)));
continue;
} else {
break;
}
continuing {
let _e355 = x;
x = (_e355 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e357 = y;
y = (_e357 + 1i);
}
}
let _e359 = lit_1;
lit_1 = (_e359 * 0.11111111f);
} else {
let _e361 = softness;
searchRadius = clamp((_e361 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e364 = i_4;
if (_e364 < 5i) {
let _e366 = uv_4;
let _e367 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e369 = indexable[_e367];
let _e370 = texel_1;
let _e372 = searchRadius;
let _e375 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e366 + ((_e369 * _e370) * _e372)), 0f);
occluder_1 = _e375.x;
let _e378 = projected[2u];
let _e379 = bias;
let _e381 = occluder_1;
if ((_e378 - _e379) > _e381) {
let _e383 = occluder_1;
let _e384 = blockerSum;
blockerSum = (_e384 + _e383);
let _e386 = blockerCount;
blockerCount = (_e386 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e388 = i_4;
i_4 = (_e388 + 1i);
}
}
let _e390 = blockerCount;
if (_e390 <= 0f) {
return 1f;
}
let _e393 = projected[2u];
let _e394 = blockerSum;
let _e395 = blockerCount;
gap = max((_e393 - (_e394 / _e395)), 0f);
let _e399 = gap;
let _e400 = softness;
radius_2 = clamp((_e399 * _e400), 1f, 16f);
i_5 = 0i;
loop {
let _e403 = i_5;
if (_e403 < 5i) {
let _e405 = uv_4;
let _e406 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e408 = indexable_1[_e406];
let _e409 = texel_1;
let _e411 = radius_2;
let _e414 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e405 + ((_e408 * _e409) * _e411)), 0f);
occluder_2 = _e414.x;
let _e417 = projected[2u];
let _e418 = bias;
let _e420 = occluder_2;
let _e423 = lit_1;
lit_1 = (_e423 + select(1f, 0f, ((_e417 - _e418) > _e420)));
continue;
} else {
break;
}
continuing {
let _e425 = i_5;
i_5 = (_e425 + 1i);
}
}
let _e427 = lit_1;
lit_1 = (_e427 * 0.2f);
}
let _e429 = lit_1;
let _e430 = strength_1;
return mix(1f, _e429, clamp(_e430, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e150 = (*s_2);
param_42 = _e150;
let _e151 = (*light_2);
param_43 = _e151;
let _e152 = (*index);
param_44 = _e152;
let _e153 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e153;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e145 = (*index_1);
return (_e145 < 8i);
}
fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
var attenuation: f32;
var ratio: f32;
var window: f32;
let _e149 = (*distance_1);
let _e150 = (*distance_1);
attenuation = (1f / max((_e149 * _e150), 0.0001f));
let _e154 = (*range_4);
if (_e154 > 0f) {
let _e156 = (*distance_1);
let _e157 = (*range_4);
ratio = (_e156 / _e157);
let _e159 = ratio;
let _e160 = ratio;
let _e162 = ratio;
let _e164 = ratio;
window = clamp((1f - (((_e159 * _e160) * _e162) * _e164)), 0f, 1f);
let _e168 = window;
let _e169 = window;
let _e171 = attenuation;
attenuation = (_e171 * (_e168 * _e169));
}
let _e173 = attenuation;
return _e173;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e161 = (*halfWidth);
let _e162 = (*halfHeight);
n_1 = cross(_e161, _e162);
let _e164 = n_1;
nLen = length(_e164);
let _e166 = nLen;
if (_e166 < 0.000000000001f) {
let _e168 = (*centre);
return _e168;
}
let _e169 = nLen;
let _e170 = n_1;
n_1 = (_e170 / vec3(_e169));
let _e173 = (*centre);
let _e174 = (*world_2);
toPlane = (_e173 - _e174);
let _e176 = (*mirror);
let _e177 = n_1;
denom = dot(_e176, _e177);
let _e179 = denom;
if (abs(_e179) < 0.00001f) {
let _e182 = toPlane;
let _e183 = n_1;
let _e184 = toPlane;
let _e185 = n_1;
onPlane = (_e182 - (_e183 * dot(_e184, _e185)));
} else {
let _e189 = toPlane;
let _e190 = n_1;
let _e192 = denom;
t = (dot(_e189, _e190) / _e192);
let _e194 = t;
if (_e194 > 0f) {
let _e196 = (*mirror);
let _e197 = t;
local_4 = (_e196 * _e197);
} else {
let _e199 = toPlane;
let _e200 = n_1;
let _e201 = toPlane;
let _e202 = n_1;
local_4 = (_e199 - (_e200 * dot(_e201, _e202)));
}
let _e206 = local_4;
onPlane = _e206;
}
let _e207 = onPlane;
let _e208 = toPlane;
offset_2 = (_e207 - _e208);
let _e210 = (*halfWidth);
let _e211 = (*halfWidth);
wLen2_ = max(dot(_e210, _e211), 0.000000000001f);
let _e214 = (*halfHeight);
let _e215 = (*halfHeight);
hLen2_ = max(dot(_e214, _e215), 0.000000000001f);
let _e218 = offset_2;
let _e219 = (*halfWidth);
let _e221 = wLen2_;
u = clamp((dot(_e218, _e219) / _e221), -1f, 1f);
let _e224 = offset_2;
let _e225 = (*halfHeight);
let _e227 = hLen2_;
v = clamp((dot(_e224, _e225) / _e227), -1f, 1f);
let _e230 = (*centre);
let _e231 = (*halfWidth);
let _e232 = u;
let _e235 = (*halfHeight);
let _e236 = v;
return ((_e230 + (_e231 * _e232)) + (_e235 * _e236));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e153 = i_6;
if (_e153 < 4i) {
let _e155 = i_6;
let _e157 = (*corners)[_e155];
a_1 = normalize(_e157);
let _e159 = i_6;
let _e163 = (*corners)[((_e159 + 1i) & 3i)];
b = normalize(_e163);
let _e165 = a_1;
let _e166 = b;
angle_1 = acos(clamp(dot(_e165, _e166), -1f, 1f));
let _e170 = a_1;
let _e171 = b;
axis = cross(_e170, _e171);
let _e173 = axis;
len = length(_e173);
let _e175 = len;
if (_e175 > 0.000001f) {
let _e177 = angle_1;
let _e178 = axis;
let _e179 = len;
let _e182 = (*n_2);
let _e185 = total;
total = (_e185 + (_e177 * dot((_e178 / vec3(_e179)), _e182)));
}
continue;
} else {
break;
}
continuing {
let _e187 = i_6;
i_6 = (_e187 + 1i);
}
}
let _e189 = total;
return max((-(_e189) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e150 = (*slot_1);
let _e151 = (*slot_1);
lane = (_e150 - ((_e151 / 4i) * 4i));
let _e155 = lane;
if (_e155 == 0i) {
let _e158 = (*four)[0u];
local_5 = _e158;
} else {
let _e159 = lane;
if (_e159 == 1i) {
let _e162 = (*four)[1u];
local_6 = _e162;
} else {
let _e163 = lane;
if (_e163 == 2i) {
let _e166 = (*four)[2u];
local_7 = _e166;
} else {
let _e168 = (*four)[3u];
local_7 = _e168;
}
let _e169 = local_7;
local_6 = _e169;
}
let _e170 = local_6;
local_5 = _e170;
}
let _e171 = local_5;
return _e171;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e147 = (*slot_2);
let _e151 = light_list_info.scales[(_e147 / 4i)];
param_45 = _e151;
let _e152 = (*slot_2);
param_46 = _e152;
let _e153 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e153;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e147 = (*slot_3);
let _e151 = light_list_info.indices[(_e147 / 4i)];
param_47 = _e151;
let _e152 = (*slot_3);
param_48 = _e152;
let _e153 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e153;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e187 = (*index_2);
if (_e187 < 8i) {
let _e189 = (*index_2);
let _e192 = frag_info.light_position[_e189];
position = _e192;
let _e193 = (*index_2);
let _e196 = frag_info.light_color[_e193];
color_1 = _e196;
let _e197 = (*index_2);
let _e200 = frag_info.light_direction[_e197];
direction = _e200;
let _e201 = (*index_2);
let _e204 = frag_info.light_cone[_e201];
cone = _e204;
} else {
let _e205 = (*index_2);
slot_4 = (_e205 - 8i);
let _e207 = slot_4;
param_49 = _e207;
let _e208 = LightListRow_u0028_i1_u003b((¶m_49));
let _e212 = light_list_info.list[2u];
v_1 = ((_e208 + 0.5f) * _e212);
let _e216 = light_list_info.list[1u];
u_1 = _e216;
let _e217 = u_1;
let _e219 = v_1;
let _e221 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e217), _e219), 0f);
position = _e221;
let _e222 = u_1;
let _e224 = v_1;
let _e226 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e222), _e224), 0f);
color_1 = _e226;
let _e227 = u_1;
let _e229 = v_1;
let _e231 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e227), _e229), 0f);
direction = _e231;
let _e232 = u_1;
let _e234 = v_1;
let _e236 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e232), _e234), 0f);
cone = _e236;
let _e237 = slot_4;
param_50 = _e237;
let _e238 = LightListScale_u0028_i1_u003b((¶m_50));
let _e240 = color_1[3u];
color_1[3u] = (_e240 * _e238);
}
let _e244 = position[3u];
type_38 = _e244;
let _e245 = type_38;
if (_e245 > 2.5f) {
let _e247 = direction;
halfWidth_1 = _e247.xyz;
let _e249 = cone;
halfHeight_1 = _e249.xyz;
let _e251 = position;
let _e253 = v_world_position_1;
toCentre = (_e251.xyz - _e253);
let _e255 = toCentre;
let _e256 = halfWidth_1;
let _e258 = halfHeight_1;
corners_1[0i] = ((_e255 - _e256) - _e258);
let _e261 = toCentre;
let _e262 = halfWidth_1;
let _e264 = halfHeight_1;
corners_1[1i] = ((_e261 + _e262) - _e264);
let _e267 = toCentre;
let _e268 = halfWidth_1;
let _e270 = halfHeight_1;
corners_1[2i] = ((_e267 + _e268) + _e270);
let _e273 = toCentre;
let _e274 = halfWidth_1;
let _e276 = halfHeight_1;
corners_1[3i] = ((_e273 - _e274) + _e276);
let _e279 = corners_1;
param_51 = _e279;
let _e281 = (*s_3).n;
param_52 = _e281;
let _e282 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e282;
let _e283 = halfWidth_1;
let _e284 = halfHeight_1;
area = (length(cross(_e283, _e284)) * 4f);
let _e288 = area;
if (_e288 > 0.000000001f) {
let _e290 = area;
local_8 = (1f / _e290);
} else {
local_8 = 0f;
}
let _e292 = local_8;
radiance = _e292;
let _e293 = toCentre;
distance_2 = length(_e293);
let _e296 = direction[3u];
if (_e296 > 0f) {
let _e298 = distance_2;
let _e300 = direction[3u];
ratio_1 = (_e298 / _e300);
let _e302 = ratio_1;
let _e303 = ratio_1;
let _e305 = ratio_1;
let _e307 = ratio_1;
window_1 = clamp((1f - (((_e302 * _e303) * _e305) * _e307)), 0f, 1f);
let _e311 = window_1;
let _e312 = window_1;
let _e314 = radiance;
radiance = (_e314 * (_e311 * _e312));
}
let _e317 = (*s_3).v;
let _e320 = (*s_3).n;
mirror_1 = reflect(-(_e317), _e320);
let _e322 = position;
param_53 = _e322.xyz;
let _e324 = halfWidth_1;
param_54 = _e324;
let _e325 = halfHeight_1;
param_55 = _e325;
let _e326 = v_world_position_1;
param_56 = _e326;
let _e327 = mirror_1;
param_57 = _e327;
let _e328 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e328;
let _e329 = representative;
let _e330 = v_world_position_1;
toPoint = (_e329 - _e330);
let _e332 = toPoint;
pointDistance = length(_e332);
let _e334 = pointDistance;
if (_e334 > 0.000001f) {
let _e336 = toPoint;
let _e337 = pointDistance;
local_9 = (_e336 / vec3(_e337));
} else {
let _e341 = (*s_3).n;
local_9 = _e341;
}
let _e342 = local_9;
light_3.l = _e342;
let _e345 = light_3.l;
let _e347 = (*s_3).v;
light_3.h = normalize((_e345 + _e347));
let _e351 = formFactor;
light_3.n_dot_l = _e351;
let _e354 = (*s_3).n;
let _e356 = light_3.h;
light_3.n_dot_h = max(dot(_e354, _e356), 0f);
let _e361 = (*s_3).v;
let _e363 = light_3.h;
light_3.v_dot_h = max(dot(_e361, _e363), 0f);
let _e367 = color_1;
let _e370 = color_1[3u];
let _e372 = radiance;
light_3.radiance = ((_e367.xyz * _e370) * _e372);
let _e375 = light_3;
return _e375;
}
let _e376 = direction;
aim = normalize(_e376.xyz);
attenuation_1 = 1f;
let _e379 = type_38;
if (_e379 < 0.5f) {
let _e381 = aim;
light_3.l = -(_e381);
} else {
let _e384 = position;
let _e386 = v_world_position_1;
toLight_1 = (_e384.xyz - _e386);
let _e388 = toLight_1;
distance_3 = length(_e388);
let _e390 = distance_3;
if (_e390 < 0.000001f) {
let _e393 = (*s_3).n;
light_3.l = _e393;
let _e396 = (*s_3).n;
light_3.h = _e396;
light_3.radiance = vec3<f32>(0f, 0f, 0f);
light_3.n_dot_l = 0f;
light_3.n_dot_h = 0f;
light_3.v_dot_h = 0f;
let _e402 = light_3;
return _e402;
}
let _e403 = toLight_1;
let _e404 = distance_3;
light_3.l = (_e403 / vec3(_e404));
let _e408 = distance_3;
param_58 = _e408;
let _e410 = direction[3u];
param_59 = _e410;
let _e411 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e411;
let _e412 = type_38;
if (_e412 > 1.5f) {
let _e414 = aim;
let _e416 = light_3.l;
cosAngle = dot(_e414, -(_e416));
let _e419 = cosAngle;
let _e421 = cone[1u];
let _e424 = cone[0u];
let _e426 = cone[1u];
let _e430 = attenuation_1;
attenuation_1 = (_e430 * clamp(((_e419 - _e421) / (_e424 - _e426)), 0f, 1f));
}
}
let _e433 = light_3.l;
let _e435 = (*s_3).v;
light_3.h = normalize((_e433 + _e435));
let _e440 = (*s_3).n;
let _e442 = light_3.l;
light_3.n_dot_l = max(dot(_e440, _e442), 0f);
let _e447 = (*s_3).n;
let _e449 = light_3.h;
light_3.n_dot_h = max(dot(_e447, _e449), 0f);
let _e454 = (*s_3).v;
let _e456 = light_3.h;
light_3.v_dot_h = max(dot(_e454, _e456), 0f);
let _e460 = color_1;
let _e463 = color_1[3u];
let _e465 = attenuation_1;
light_3.radiance = ((_e460.xyz * _e463) * _e465);
let _e468 = light_3;
return _e468;
}
fn LightCount_u0028_() -> i32 {
let _e146 = frag_info.frame_params[1u];
let _e152 = light_list_info.list[0u];
return (clamp(i32((_e146 + 0.5f)), 0i, 8i) + clamp(i32((_e152 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e162 = LightCount_u0028_();
count_1 = _e162;
i_7 = 0i;
loop {
let _e163 = i_7;
if (_e163 < 32i) {
let _e165 = i_7;
let _e166 = count_1;
if (_e165 >= _e166) {
break;
}
let _e168 = i_7;
param_60 = _e168;
let _e169 = (*s_4);
param_61 = _e169;
let _e170 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e170;
let _e172 = light_4.n_dot_l;
if (_e172 <= 0f) {
continue;
}
let _e174 = i_7;
param_62 = _e174;
let _e175 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e175 {
let _e176 = (*s_4);
param_63 = _e176;
let _e177 = light_4;
param_64 = _e177;
let _e178 = i_7;
param_65 = _e178;
let _e179 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e180 = v_world_position_1;
param_66 = _e180;
let _e182 = (*s_4).n;
param_67 = _e182;
let _e183 = i_7;
param_68 = _e183;
let _e184 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e179 * _e184);
} else {
local_10 = 1f;
}
let _e186 = local_10;
visibility = _e186;
let _e187 = visibility;
if (_e187 <= 0f) {
continue;
}
let _e189 = (*s_4);
param_69 = _e189;
let _e190 = light_4;
param_70 = _e190;
let _e191 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e193 = light_4.radiance;
let _e196 = light_4.n_dot_l;
let _e198 = visibility;
let _e200 = total_1;
total_1 = (_e200 + (((_e191 * _e193) * _e196) * _e198));
continue;
} else {
break;
}
continuing {
let _e202 = i_7;
i_7 = (_e202 + 1i);
}
}
let _e204 = total_1;
return _e204;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e145 = v_lightmap_uv_1;
let _e146 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e145);
texel_2 = _e146;
let _e147 = texel_2;
let _e150 = texel_2[3u];
return ((_e147.xyz * _e150) * 8f);
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e145 = (*srgb);
let _e148 = (*srgb);
let _e153 = (*srgb);
return mix((_e145 / vec3(12.92f)), pow(((_e148 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e153));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e147 = v_texcoord_1;
let _e148 = textureSample(emissive_texture_tex, emissive_texture_smp, _e147);
param_71 = _e148.xyz;
let _e150 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e150;
let _e151 = emissive;
let _e153 = frag_info.emissive;
let _e158 = frag_info.material2_[3u];
(*s_5).emissive = ((_e151 * _e153.xyz) * _e158);
return;
}
fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var occlusion: f32;
let _e146 = v_texcoord_1;
let _e147 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e146);
occlusion = _e147.x;
let _e149 = occlusion;
let _e152 = frag_info.material2_[2u];
(*s_6).occlusion = mix(1f, _e149, clamp(_e152, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e149 = v_texcoord_1;
let _e150 = textureSample(normal_texture_tex, normal_texture_smp, _e149);
sampledTexel = _e150;
let _e151 = v_tangent_1;
t_1 = _e151.xyz;
let _e153 = t_1;
let _e155 = (*s_7).n;
let _e157 = (*s_7).n;
let _e158 = t_1;
t_1 = (_e153 - (_e155 * dot(_e157, _e158)));
let _e162 = t_1;
let _e163 = t_1;
if (dot(_e162, _e163) < 0.000000000001f) {
return;
}
let _e166 = t_1;
t_1 = normalize(_e166);
let _e169 = (*s_7).n;
let _e170 = t_1;
let _e173 = v_tangent_1[3u];
b_1 = (cross(_e169, _e170) * _e173);
let _e175 = sampledTexel;
sampled = ((_e175.xyz * 2f) - vec3(1f));
let _e182 = frag_info.material2_[1u];
let _e183 = sampled;
let _e185 = (_e183.xy * _e182);
sampled[0u] = _e185.x;
sampled[1u] = _e185.y;
let _e190 = t_1;
let _e192 = sampled[0u];
let _e194 = b_1;
let _e196 = sampled[1u];
let _e200 = (*s_7).n;
let _e202 = sampled[2u];
(*s_7).n = normalize((((_e190 * _e192) + (_e194 * _e196)) + (_e200 * _e202)));
let _e208 = (*s_7).n;
let _e210 = (*s_7).v;
(*s_7).n_dot_v = max(dot(_e208, _e210), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e148 = (*s_8);
param_72 = _e148;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e149 = param_72;
(*s_8) = _e149;
let _e150 = (*s_8);
param_73 = _e150;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e151 = param_73;
(*s_8) = _e151;
let _e152 = (*s_8);
param_74 = _e152;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e153 = param_74;
(*s_8) = _e153;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_9: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e151 = v_texcoord_1;
let _e152 = textureSample(base_color_texture_tex, base_color_texture_smp, _e151);
texel_3 = _e152;
let _e153 = texel_3;
param_75 = _e153.xyz;
let _e155 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e157 = frag_info.base_color;
param_76 = _e157.xyz;
let _e159 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e161 = v_color_1;
s_9.albedo = ((_e155 * _e159) * _e161.xyz);
let _e166 = texel_3[3u];
let _e169 = frag_info.base_color[3u];
let _e172 = v_color_1[3u];
s_9.alpha = ((_e166 * _e169) * _e172);
let _e177 = frag_info.material2_[0u];
cutoff = _e177;
let _e178 = cutoff;
if (_e178 >= 0f) {
let _e181 = s_9.alpha;
let _e182 = cutoff;
if (_e181 < _e182) {
discard;
}
} else {
let _e184 = cutoff;
if (_e184 < -1.5f) {
let _e186 = v_world_position_1;
anchored = floor((_e186 * 16f));
let _e189 = anchored;
noise_1 = fract((sin(dot(_e189, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e195 = s_9.alpha;
let _e196 = noise_1;
if (_e195 < _e196) {
discard;
}
}
}
let _e198 = v_normal_1;
s_9.n = normalize(_e198);
let _e202 = frag_info.camera_position;
let _e204 = v_world_position_1;
s_9.v = normalize((_e202.xyz - _e204));
let _e209 = s_9.n;
let _e211 = s_9.v;
s_9.n_dot_v = max(dot(_e209, _e211), 0.0001f);
let _e217 = frag_info.material[0u];
s_9.metallic = clamp(_e217, 0f, 1f);
let _e222 = frag_info.material[1u];
s_9.roughness = clamp(_e222, 0.02f, 1f);
let _e226 = frag_info.ambient_ground;
let _e229 = frag_info.ambient_sky;
let _e233 = s_9.n[1u];
let _e240 = frag_info.material[2u];
s_9.ambient = (mix(_e226.xyz, _e229.xyz, vec3(((_e233 * 0.5f) + 0.5f))) * _e240);
let _e245 = frag_info.frame_params[0u];
s_9.exposure = max(_e245, 0f);
s_9.occlusion = 1f;
s_9.emissive = vec3<f32>(0f, 0f, 0f);
let _e250 = s_9;
return _e250;
}
fn main_1() {
var s_10: Surface;
var param_77: Surface;
var ambient: vec3<f32>;
var param_78: Surface;
var param_79: vec3<f32>;
var param_80: f32;
var param_81: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e151 = ReadSurface_u0028_();
s_10 = _e151;
let _e152 = s_10;
param_77 = _e152;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e153 = param_77;
s_10 = _e153;
let _e155 = s_10.albedo;
let _e157 = s_10.ambient;
let _e158 = SampleLightmap_u0028_();
let _e162 = s_10.occlusion;
ambient = ((_e155 * (_e157 + _e158)) * _e162);
let _e164 = s_10;
param_78 = _e164;
let _e165 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e167 = s_10.occlusion;
let _e169 = ambient;
let _e172 = s_10.emissive;
param_79 = (((_e165 * _e167) + _e169) + _e172);
let _e175 = s_10.alpha;
param_80 = _e175;
let _e177 = s_10.roughness;
param_81 = _e177;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_79), (¶m_80), (¶m_81));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BlinnPhong': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e148 = (*n)[0u];
let _e151 = (*n)[1u];
let _e155 = (*n)[2u];
let _e158 = (*n);
(*n) = (_e158 / vec3(((abs(_e148) + abs(_e151)) + abs(_e155))));
let _e161 = (*n);
e = _e161.xy;
let _e164 = (*n)[2u];
if (_e164 < 0f) {
let _e166 = (*n);
let _e172 = (*n)[0u];
let _e176 = (*n)[1u];
e = ((vec2(1f) - abs(_e166.yx)) * vec2<f32>(select(-1f, 1f, (_e172 >= 0f)), select(-1f, 1f, (_e176 >= 0f))));
}
let _e181 = e;
return ((_e181 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e145 = v_world_position_1;
let _e147 = fog_info.eye;
let _e151 = fog_info.forward;
return dot((_e145 - _e147.xyz), _e151.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e147 = g_debug_surface_on;
if _e147 {
let _e148 = g_debug_surface;
let _e149 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e148.x, _e148.y, _e148.z, _e149);
return;
}
let _e154 = v_normal_1;
param = normalize(_e154);
let _e156 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e157 = (*roughness);
let _e159 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e156.x, _e156.y, clamp(_e157, 0f, 1f), _e159);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e145 = v_world_position_1;
let _e147 = fog_info.eye;
return distance(_e145, _e147.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e150 = fog_info.fog[3u];
density = _e150;
let _e151 = density;
if (_e151 <= 0f) {
let _e153 = (*color);
return _e153;
}
let _e154 = EyeDistance_u0028_();
d = _e154;
let _e156 = fog_info.fog;
let _e158 = (*color);
let _e159 = density;
let _e161 = d;
return mix(_e156.xyz, _e158, vec3(clamp(exp((-(_e159) * _e161)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e150 = (*linearColor);
param_1 = _e150;
let _e151 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e152 = (*alpha);
frag_color = vec4<f32>(_e151.x, _e151.y, _e151.z, _e152);
let _e157 = (*roughness_1);
param_2 = _e157;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var shininess: f32;
var specular: f32;
let _e150 = (*s).roughness;
shininess = mix(256f, 4f, _e150);
let _e153 = (*light).n_dot_h;
let _e154 = shininess;
let _e158 = frag_info.material[3u];
specular = (pow(_e153, _e154) * _e158);
let _e161 = (*s).albedo;
let _e162 = specular;
return (_e161 + vec3(_e162));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e146 = (*i);
if (_e146 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e148 = (*i);
if (_e148 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e150 = (*i);
if (_e150 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e152 = (*i);
if (_e152 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e154 = (*i);
if (_e154 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e156 = (*i);
if (_e156 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e158 = (*i);
if (_e158 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e151 = (*i_1);
param_3 = _e151;
let _e152 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e152;
let _e154 = p[0u];
let _e155 = (*ca);
let _e158 = p[1u];
let _e159 = (*sa);
let _e163 = p[0u];
let _e164 = (*sa);
let _e167 = p[1u];
let _e168 = (*ca);
let _e172 = (*radius);
return (vec2<f32>(((_e154 * _e155) - (_e158 * _e159)), ((_e163 * _e164) + (_e167 * _e168))) * _e172);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e154 = point_shadow.params[0u];
inset = _e154;
let _e155 = (*uv);
let _e156 = (*offset);
let _e158 = inset;
let _e159 = inset;
local = clamp((_e155 + _e156), vec2(_e158), vec2((1f - _e159)));
let _e164 = local;
let _e165 = (*tile);
atlas = ((_e164 + _e165) * vec2<f32>(0.16666667f, 0.16666667f));
let _e170 = point_shadow.params3_[0u];
if (_e170 > 0.5f) {
let _e173 = atlas[1u];
atlas[1u] = (1f - _e173);
}
let _e176 = atlas;
let _e177 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e176, 0f);
let _e179 = atlas;
let _e180 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e179, 0f);
let _e183 = (*range);
return (min(_e177.x, _e180.x) * _e183);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e155 = (*uv_1);
param_4 = _e155;
let _e156 = (*offset_1);
param_5 = _e156;
let _e157 = (*tile_1);
param_6 = _e157;
let _e158 = (*range_1);
param_7 = _e158;
let _e159 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e159;
let _e160 = stored;
let _e161 = (*range_1);
if (_e160 >= (_e161 * 0.999f)) {
return 1f;
}
let _e164 = (*receiver);
let _e165 = stored;
return select(1f, 0f, (_e164 > _e165));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e176 = point_shadow.params2_[1u];
lightRadius = _e176;
let _e179 = point_shadow.params2_[0u];
minRadius = _e179;
let _e182 = point_shadow.params2_[2u];
maxRadius = _e182;
let _e183 = lightRadius;
if (_e183 <= 0f) {
let _e185 = (*uv_2);
param_8 = _e185;
param_9 = vec2<f32>(0f, 0f);
let _e186 = (*tile_2);
param_10 = _e186;
let _e187 = (*range_2);
param_11 = _e187;
let _e188 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e188;
let _e189 = minRadius;
return _e189;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e190 = i_2;
if (_e190 < 8i) {
let _e192 = i_2;
param_12 = _e192;
let _e193 = (*ca_1);
param_13 = _e193;
let _e194 = (*sa_1);
param_14 = _e194;
let _e195 = maxRadius;
param_15 = _e195;
let _e196 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e197 = (*uv_2);
param_16 = _e197;
param_17 = _e196;
let _e198 = (*tile_2);
param_18 = _e198;
let _e199 = (*range_2);
param_19 = _e199;
let _e200 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e200;
let _e201 = stored_1;
let _e202 = (*range_2);
if (_e201 >= (_e202 * 0.999f)) {
continue;
}
let _e205 = stored_1;
let _e206 = (*receiver_1);
if (_e205 >= _e206) {
continue;
}
let _e208 = stored_1;
let _e209 = sum;
sum = (_e209 + _e208);
let _e211 = count;
count = (_e211 + 1f);
continue;
} else {
break;
}
continuing {
let _e213 = i_2;
i_2 = (_e213 + 1i);
}
}
let _e215 = count;
if (_e215 < 0.5f) {
return -1f;
}
let _e217 = sum;
let _e218 = count;
blocker = max((_e217 / _e218), 0.0001f);
let _e221 = blocker;
(*blockerOut) = _e221;
let _e222 = lightRadius;
let _e223 = (*receiver_1);
let _e224 = blocker;
let _e228 = blocker;
world = ((_e222 * max((_e223 - _e224), 0f)) / _e228);
let _e230 = world;
let _e231 = (*receiver_1);
let _e233 = (*tanHalf);
let _e236 = minRadius;
let _e237 = maxRadius;
return clamp((_e230 / ((2f * _e231) * _e233)), _e236, _e237);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1526_: bool;
var phi_1588_: bool;
let _e198 = (*lightIndex);
let _e202 = point_shadow.slots[_e198][0u];
slot = i32((_e202 + 0.5f));
let _e205 = (*lightIndex);
let _e209 = point_shadow.slots[_e205][0u];
if (_e209 < 0f) {
return 1f;
}
let _e213 = point_shadow.params[2u];
strength = _e213;
let _e214 = strength;
if (_e214 <= 0f) {
return 1f;
}
let _e216 = slot;
let _e219 = point_shadow.lights[_e216];
let _e221 = (*world_1);
toLight = (_e219.xyz - _e221);
let _e223 = toLight;
toLightLength = max(length(_e223), 0.000001f);
let _e226 = (*normal);
let _e227 = toLight;
let _e228 = toLightLength;
nDotL = max(dot(_e226, (_e227 / vec3(_e228))), 0.15f);
let _e233 = nDotL;
let _e234 = nDotL;
let _e239 = nDotL;
let _e240 = nDotL;
slope = min((sqrt(max((1f - (_e233 * _e234)), 0f)) / (_e239 * _e240)), 8f);
let _e244 = toLightLength;
let _e246 = (*lightIndex);
let _e250 = point_shadow.slots[_e246][2u];
let _e255 = point_shadow.params3_[1u];
texel = (((2f * _e244) * max(_e250, 0.0001f)) * _e255);
let _e257 = (*world_1);
let _e258 = (*normal);
let _e259 = texel;
let _e263 = point_shadow.params[3u];
let _e265 = slope;
origin = (_e257 + (((_e258 * _e259) * _e263) * (1f + _e265)));
let _e269 = origin;
let _e270 = slot;
let _e273 = point_shadow.lights[_e270];
toFragment = (_e269 - _e273.xyz);
let _e276 = toFragment;
distance_ = length(_e276);
let _e278 = slot;
let _e282 = point_shadow.lights[_e278][3u];
range_3 = max(_e282, 0.0001f);
let _e284 = distance_;
let _e285 = range_3;
if (_e284 >= _e285) {
return 1f;
}
face = 0i;
let _e287 = (*lightIndex);
let _e291 = point_shadow.slots[_e287][1u];
if (_e291 < 0.5f) {
let _e293 = toFragment;
a = abs(_e293);
let _e296 = a[0u];
let _e298 = a[1u];
let _e299 = (_e296 >= _e298);
phi_1526_ = _e299;
if _e299 {
let _e301 = a[0u];
let _e303 = a[2u];
phi_1526_ = (_e301 >= _e303);
}
let _e306 = phi_1526_;
if _e306 {
let _e308 = toFragment[0u];
face = select(1i, 0i, (_e308 > 0f));
} else {
let _e312 = a[1u];
let _e314 = a[2u];
if (_e312 >= _e314) {
let _e317 = toFragment[1u];
face = select(3i, 2i, (_e317 > 0f));
} else {
let _e321 = toFragment[2u];
face = select(5i, 4i, (_e321 > 0f));
}
}
}
let _e324 = slot;
let _e326 = face;
let _e330 = point_shadow.faces[((_e324 * 6i) + _e326)];
let _e331 = origin;
clip = (_e330 * vec4<f32>(_e331.x, _e331.y, _e331.z, 1f));
let _e338 = clip[3u];
if (_e338 <= 0f) {
return 1f;
}
let _e340 = clip;
let _e343 = clip[3u];
ndc = (_e340.xy / vec2(_e343));
let _e347 = ndc[0u];
let _e349 = (abs(_e347) > 1f);
phi_1588_ = _e349;
if !(_e349) {
let _e352 = ndc[1u];
phi_1588_ = (abs(_e352) > 1f);
}
let _e356 = phi_1588_;
if _e356 {
return 1f;
}
let _e358 = ndc[0u];
let _e362 = ndc[1u];
uv_3 = vec2<f32>(((_e358 * 0.5f) + 0.5f), (0.5f - (_e362 * 0.5f)));
let _e366 = face;
let _e368 = slot;
tile_3 = vec2<f32>(f32(_e366), f32(_e368));
let _e371 = distance_;
let _e374 = point_shadow.params[1u];
receiver_2 = (_e371 - _e374);
let _e376 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e376.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e382 = noise;
angle = (_e382 * 6.2831855f);
let _e384 = angle;
ca_2 = cos(_e384);
let _e386 = angle;
sa_2 = sin(_e386);
let _e388 = (*lightIndex);
let _e392 = point_shadow.slots[_e388][2u];
tanHalf_1 = max(_e392, 0.0001f);
blocker_1 = -1f;
let _e394 = uv_3;
param_20 = _e394;
let _e395 = tile_3;
param_21 = _e395;
let _e396 = range_3;
param_22 = _e396;
let _e397 = receiver_2;
param_23 = _e397;
let _e398 = ca_2;
param_24 = _e398;
let _e399 = sa_2;
param_25 = _e399;
let _e400 = tanHalf_1;
param_26 = _e400;
let _e401 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e402 = param_27;
blocker_1 = _e402;
radius_1 = _e401;
let _e405 = point_shadow.params2_[3u];
if (_e405 > 0.5f) {
g_debug_surface_on = true;
let _e407 = radius_1;
if (_e407 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e409 = radius_1;
let _e412 = point_shadow.params2_[2u];
let _e416 = blocker_1;
let _e417 = range_3;
local_1 = vec3<f32>(clamp((_e409 / max(_e412, 0.000001f)), 0f, 1f), clamp((_e416 / _e417), 0f, 1f), 0f);
}
let _e421 = local_1;
g_debug_surface = _e421;
}
let _e422 = radius_1;
if (_e422 < 0f) {
return 1f;
}
let _e424 = uv_3;
param_28 = _e424;
param_29 = vec2<f32>(0f, 0f);
let _e425 = tile_3;
param_30 = _e425;
let _e426 = range_3;
param_31 = _e426;
let _e427 = receiver_2;
param_32 = _e427;
let _e428 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e428;
let _e429 = radius_1;
if (_e429 > 0f) {
i_3 = 0i;
loop {
let _e431 = i_3;
if (_e431 < 8i) {
let _e433 = i_3;
param_33 = _e433;
let _e434 = ca_2;
param_34 = _e434;
let _e435 = sa_2;
param_35 = _e435;
let _e436 = radius_1;
param_36 = _e436;
let _e437 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e438 = uv_3;
param_37 = _e438;
param_38 = _e437;
let _e439 = tile_3;
param_39 = _e439;
let _e440 = range_3;
param_40 = _e440;
let _e441 = receiver_2;
param_41 = _e441;
let _e442 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e443 = lit;
lit = (_e443 + _e442);
continue;
} else {
break;
}
continuing {
let _e445 = i_3;
i_3 = (_e445 + 1i);
}
}
let _e447 = lit;
lit = (_e447 * 0.11111111f);
}
let _e449 = lit;
let _e450 = strength;
return mix(1f, _e449, clamp(_e450, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2035_: bool;
var phi_2046_: bool;
var phi_2136_: bool;
var phi_2143_: bool;
var phi_2150_: bool;
let _e184 = frag_info.shadow_params[3u];
strength_1 = _e184;
let _e185 = strength_1;
if (_e185 <= 0f) {
return 1f;
}
let _e187 = (*lightIndex_1);
let _e190 = frag_info.frame_params[2u];
if (_e187 != i32((_e190 + 0.5f))) {
return 1f;
}
let _e194 = v_world_position_1;
let _e196 = (*s_1).n;
let _e199 = frag_info.shadow_params[2u];
origin_1 = (_e194 + (_e196 * _e199));
let _e204 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e204 + 0.5f));
let _e207 = v_world_position_1;
let _e209 = frag_info.camera_position;
viewDistance = length((_e207 - _e209.xyz));
cascade = 0i;
let _e213 = cascadeCount;
let _e214 = (_e213 > 1i);
phi_2035_ = _e214;
if _e214 {
let _e215 = viewDistance;
let _e218 = frag_info.shadow_cascades[0u];
phi_2035_ = (_e215 > _e218);
}
let _e221 = phi_2035_;
if _e221 {
cascade = 1i;
}
let _e222 = cascadeCount;
let _e223 = (_e222 > 2i);
phi_2046_ = _e223;
if _e223 {
let _e224 = viewDistance;
let _e227 = frag_info.shadow_cascades[1u];
phi_2046_ = (_e224 > _e227);
}
let _e230 = phi_2046_;
if _e230 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e231 = attempt;
if (_e231 < 3i) {
let _e233 = cascade;
let _e234 = attempt;
which = (_e233 + _e234);
let _e236 = which;
let _e237 = cascadeCount;
if (_e236 >= _e237) {
break;
}
let _e239 = which;
if (_e239 == 0i) {
let _e242 = frag_info.shadow_matrix;
local_2 = _e242;
} else {
let _e243 = which;
if (_e243 == 1i) {
let _e246 = frag_info.shadow_matrix_far;
local_3 = _e246;
} else {
let _e248 = frag_info.shadow_matrix_farthest;
local_3 = _e248;
}
let _e249 = local_3;
local_2 = _e249;
}
let _e250 = local_2;
matrix = _e250;
let _e251 = matrix;
let _e252 = origin_1;
lightSpace = (_e251 * vec4<f32>(_e252.x, _e252.y, _e252.z, 1f));
let _e259 = lightSpace[3u];
if (_e259 <= 0f) {
continue;
}
let _e261 = lightSpace;
let _e264 = lightSpace[3u];
candidate = (_e261.xyz / vec3(_e264));
let _e268 = candidate[0u];
let _e272 = candidate[1u];
inTile = vec2<f32>(((_e268 * 0.5f) + 0.5f), (0.5f - (_e272 * 0.5f)));
let _e277 = inTile[0u];
let _e278 = (_e277 < 0f);
phi_2136_ = _e278;
if !(_e278) {
let _e281 = inTile[0u];
phi_2136_ = (_e281 > 1f);
}
let _e284 = phi_2136_;
phi_2143_ = _e284;
if !(_e284) {
let _e287 = inTile[1u];
phi_2143_ = (_e287 < 0f);
}
let _e290 = phi_2143_;
phi_2150_ = _e290;
if !(_e290) {
let _e293 = inTile[1u];
phi_2150_ = (_e293 > 1f);
}
let _e296 = phi_2150_;
if _e296 {
continue;
}
let _e298 = candidate[2u];
if (_e298 > 1f) {
continue;
}
let _e301 = inTile[0u];
let _e302 = which;
let _e305 = cascadeCount;
let _e309 = inTile[1u];
uv_4 = vec2<f32>(((_e301 + f32(_e302)) / f32(_e305)), _e309);
let _e311 = candidate;
projected = _e311;
let _e312 = which;
cascade = _e312;
found = true;
break;
} else {
break;
}
continuing {
let _e313 = attempt;
attempt = (_e313 + 1i);
}
}
let _e315 = found;
if !(_e315) {
return 1f;
}
let _e319 = frag_info.shadow_params[1u];
bias = _e319;
let _e322 = frag_info.shadow_params[0u];
let _e325 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e322, _e325);
let _e329 = frag_info.ambient_ground[3u];
softness = _e329;
lit_1 = 0f;
let _e330 = softness;
if (_e330 <= 0f) {
y = -1i;
loop {
let _e332 = y;
if (_e332 <= 1i) {
x = -1i;
loop {
let _e334 = x;
if (_e334 <= 1i) {
let _e336 = uv_4;
let _e337 = x;
let _e339 = y;
let _e342 = texel_1;
let _e345 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e336 + (vec2<f32>(f32(_e337), f32(_e339)) * _e342)), 0f);
occluder = _e345.x;
let _e348 = projected[2u];
let _e349 = bias;
let _e351 = occluder;
let _e354 = lit_1;
lit_1 = (_e354 + select(1f, 0f, ((_e348 - _e349) > _e351)));
continue;
} else {
break;
}
continuing {
let _e356 = x;
x = (_e356 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e358 = y;
y = (_e358 + 1i);
}
}
let _e360 = lit_1;
lit_1 = (_e360 * 0.11111111f);
} else {
let _e362 = softness;
searchRadius = clamp((_e362 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e365 = i_4;
if (_e365 < 5i) {
let _e367 = uv_4;
let _e368 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e370 = indexable[_e368];
let _e371 = texel_1;
let _e373 = searchRadius;
let _e376 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e367 + ((_e370 * _e371) * _e373)), 0f);
occluder_1 = _e376.x;
let _e379 = projected[2u];
let _e380 = bias;
let _e382 = occluder_1;
if ((_e379 - _e380) > _e382) {
let _e384 = occluder_1;
let _e385 = blockerSum;
blockerSum = (_e385 + _e384);
let _e387 = blockerCount;
blockerCount = (_e387 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e389 = i_4;
i_4 = (_e389 + 1i);
}
}
let _e391 = blockerCount;
if (_e391 <= 0f) {
return 1f;
}
let _e394 = projected[2u];
let _e395 = blockerSum;
let _e396 = blockerCount;
gap = max((_e394 - (_e395 / _e396)), 0f);
let _e400 = gap;
let _e401 = softness;
radius_2 = clamp((_e400 * _e401), 1f, 16f);
i_5 = 0i;
loop {
let _e404 = i_5;
if (_e404 < 5i) {
let _e406 = uv_4;
let _e407 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e409 = indexable_1[_e407];
let _e410 = texel_1;
let _e412 = radius_2;
let _e415 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e406 + ((_e409 * _e410) * _e412)), 0f);
occluder_2 = _e415.x;
let _e418 = projected[2u];
let _e419 = bias;
let _e421 = occluder_2;
let _e424 = lit_1;
lit_1 = (_e424 + select(1f, 0f, ((_e418 - _e419) > _e421)));
continue;
} else {
break;
}
continuing {
let _e426 = i_5;
i_5 = (_e426 + 1i);
}
}
let _e428 = lit_1;
lit_1 = (_e428 * 0.2f);
}
let _e430 = lit_1;
let _e431 = strength_1;
return mix(1f, _e430, clamp(_e431, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e151 = (*s_2);
param_42 = _e151;
let _e152 = (*light_2);
param_43 = _e152;
let _e153 = (*index);
param_44 = _e153;
let _e154 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e154;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e146 = (*index_1);
return (_e146 < 8i);
}
fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
var attenuation: f32;
var ratio: f32;
var window: f32;
let _e150 = (*distance_1);
let _e151 = (*distance_1);
attenuation = (1f / max((_e150 * _e151), 0.0001f));
let _e155 = (*range_4);
if (_e155 > 0f) {
let _e157 = (*distance_1);
let _e158 = (*range_4);
ratio = (_e157 / _e158);
let _e160 = ratio;
let _e161 = ratio;
let _e163 = ratio;
let _e165 = ratio;
window = clamp((1f - (((_e160 * _e161) * _e163) * _e165)), 0f, 1f);
let _e169 = window;
let _e170 = window;
let _e172 = attenuation;
attenuation = (_e172 * (_e169 * _e170));
}
let _e174 = attenuation;
return _e174;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e162 = (*halfWidth);
let _e163 = (*halfHeight);
n_1 = cross(_e162, _e163);
let _e165 = n_1;
nLen = length(_e165);
let _e167 = nLen;
if (_e167 < 0.000000000001f) {
let _e169 = (*centre);
return _e169;
}
let _e170 = nLen;
let _e171 = n_1;
n_1 = (_e171 / vec3(_e170));
let _e174 = (*centre);
let _e175 = (*world_2);
toPlane = (_e174 - _e175);
let _e177 = (*mirror);
let _e178 = n_1;
denom = dot(_e177, _e178);
let _e180 = denom;
if (abs(_e180) < 0.00001f) {
let _e183 = toPlane;
let _e184 = n_1;
let _e185 = toPlane;
let _e186 = n_1;
onPlane = (_e183 - (_e184 * dot(_e185, _e186)));
} else {
let _e190 = toPlane;
let _e191 = n_1;
let _e193 = denom;
t = (dot(_e190, _e191) / _e193);
let _e195 = t;
if (_e195 > 0f) {
let _e197 = (*mirror);
let _e198 = t;
local_4 = (_e197 * _e198);
} else {
let _e200 = toPlane;
let _e201 = n_1;
let _e202 = toPlane;
let _e203 = n_1;
local_4 = (_e200 - (_e201 * dot(_e202, _e203)));
}
let _e207 = local_4;
onPlane = _e207;
}
let _e208 = onPlane;
let _e209 = toPlane;
offset_2 = (_e208 - _e209);
let _e211 = (*halfWidth);
let _e212 = (*halfWidth);
wLen2_ = max(dot(_e211, _e212), 0.000000000001f);
let _e215 = (*halfHeight);
let _e216 = (*halfHeight);
hLen2_ = max(dot(_e215, _e216), 0.000000000001f);
let _e219 = offset_2;
let _e220 = (*halfWidth);
let _e222 = wLen2_;
u = clamp((dot(_e219, _e220) / _e222), -1f, 1f);
let _e225 = offset_2;
let _e226 = (*halfHeight);
let _e228 = hLen2_;
v = clamp((dot(_e225, _e226) / _e228), -1f, 1f);
let _e231 = (*centre);
let _e232 = (*halfWidth);
let _e233 = u;
let _e236 = (*halfHeight);
let _e237 = v;
return ((_e231 + (_e232 * _e233)) + (_e236 * _e237));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e154 = i_6;
if (_e154 < 4i) {
let _e156 = i_6;
let _e158 = (*corners)[_e156];
a_1 = normalize(_e158);
let _e160 = i_6;
let _e164 = (*corners)[((_e160 + 1i) & 3i)];
b = normalize(_e164);
let _e166 = a_1;
let _e167 = b;
angle_1 = acos(clamp(dot(_e166, _e167), -1f, 1f));
let _e171 = a_1;
let _e172 = b;
axis = cross(_e171, _e172);
let _e174 = axis;
len = length(_e174);
let _e176 = len;
if (_e176 > 0.000001f) {
let _e178 = angle_1;
let _e179 = axis;
let _e180 = len;
let _e183 = (*n_2);
let _e186 = total;
total = (_e186 + (_e178 * dot((_e179 / vec3(_e180)), _e183)));
}
continue;
} else {
break;
}
continuing {
let _e188 = i_6;
i_6 = (_e188 + 1i);
}
}
let _e190 = total;
return max((-(_e190) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e151 = (*slot_1);
let _e152 = (*slot_1);
lane = (_e151 - ((_e152 / 4i) * 4i));
let _e156 = lane;
if (_e156 == 0i) {
let _e159 = (*four)[0u];
local_5 = _e159;
} else {
let _e160 = lane;
if (_e160 == 1i) {
let _e163 = (*four)[1u];
local_6 = _e163;
} else {
let _e164 = lane;
if (_e164 == 2i) {
let _e167 = (*four)[2u];
local_7 = _e167;
} else {
let _e169 = (*four)[3u];
local_7 = _e169;
}
let _e170 = local_7;
local_6 = _e170;
}
let _e171 = local_6;
local_5 = _e171;
}
let _e172 = local_5;
return _e172;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e148 = (*slot_2);
let _e152 = light_list_info.scales[(_e148 / 4i)];
param_45 = _e152;
let _e153 = (*slot_2);
param_46 = _e153;
let _e154 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e154;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e148 = (*slot_3);
let _e152 = light_list_info.indices[(_e148 / 4i)];
param_47 = _e152;
let _e153 = (*slot_3);
param_48 = _e153;
let _e154 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e154;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e188 = (*index_2);
if (_e188 < 8i) {
let _e190 = (*index_2);
let _e193 = frag_info.light_position[_e190];
position = _e193;
let _e194 = (*index_2);
let _e197 = frag_info.light_color[_e194];
color_1 = _e197;
let _e198 = (*index_2);
let _e201 = frag_info.light_direction[_e198];
direction = _e201;
let _e202 = (*index_2);
let _e205 = frag_info.light_cone[_e202];
cone = _e205;
} else {
let _e206 = (*index_2);
slot_4 = (_e206 - 8i);
let _e208 = slot_4;
param_49 = _e208;
let _e209 = LightListRow_u0028_i1_u003b((¶m_49));
let _e213 = light_list_info.list[2u];
v_1 = ((_e209 + 0.5f) * _e213);
let _e217 = light_list_info.list[1u];
u_1 = _e217;
let _e218 = u_1;
let _e220 = v_1;
let _e222 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e218), _e220), 0f);
position = _e222;
let _e223 = u_1;
let _e225 = v_1;
let _e227 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e223), _e225), 0f);
color_1 = _e227;
let _e228 = u_1;
let _e230 = v_1;
let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e228), _e230), 0f);
direction = _e232;
let _e233 = u_1;
let _e235 = v_1;
let _e237 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e233), _e235), 0f);
cone = _e237;
let _e238 = slot_4;
param_50 = _e238;
let _e239 = LightListScale_u0028_i1_u003b((¶m_50));
let _e241 = color_1[3u];
color_1[3u] = (_e241 * _e239);
}
let _e245 = position[3u];
type_38 = _e245;
let _e246 = type_38;
if (_e246 > 2.5f) {
let _e248 = direction;
halfWidth_1 = _e248.xyz;
let _e250 = cone;
halfHeight_1 = _e250.xyz;
let _e252 = position;
let _e254 = v_world_position_1;
toCentre = (_e252.xyz - _e254);
let _e256 = toCentre;
let _e257 = halfWidth_1;
let _e259 = halfHeight_1;
corners_1[0i] = ((_e256 - _e257) - _e259);
let _e262 = toCentre;
let _e263 = halfWidth_1;
let _e265 = halfHeight_1;
corners_1[1i] = ((_e262 + _e263) - _e265);
let _e268 = toCentre;
let _e269 = halfWidth_1;
let _e271 = halfHeight_1;
corners_1[2i] = ((_e268 + _e269) + _e271);
let _e274 = toCentre;
let _e275 = halfWidth_1;
let _e277 = halfHeight_1;
corners_1[3i] = ((_e274 - _e275) + _e277);
let _e280 = corners_1;
param_51 = _e280;
let _e282 = (*s_3).n;
param_52 = _e282;
let _e283 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e283;
let _e284 = halfWidth_1;
let _e285 = halfHeight_1;
area = (length(cross(_e284, _e285)) * 4f);
let _e289 = area;
if (_e289 > 0.000000001f) {
let _e291 = area;
local_8 = (1f / _e291);
} else {
local_8 = 0f;
}
let _e293 = local_8;
radiance = _e293;
let _e294 = toCentre;
distance_2 = length(_e294);
let _e297 = direction[3u];
if (_e297 > 0f) {
let _e299 = distance_2;
let _e301 = direction[3u];
ratio_1 = (_e299 / _e301);
let _e303 = ratio_1;
let _e304 = ratio_1;
let _e306 = ratio_1;
let _e308 = ratio_1;
window_1 = clamp((1f - (((_e303 * _e304) * _e306) * _e308)), 0f, 1f);
let _e312 = window_1;
let _e313 = window_1;
let _e315 = radiance;
radiance = (_e315 * (_e312 * _e313));
}
let _e318 = (*s_3).v;
let _e321 = (*s_3).n;
mirror_1 = reflect(-(_e318), _e321);
let _e323 = position;
param_53 = _e323.xyz;
let _e325 = halfWidth_1;
param_54 = _e325;
let _e326 = halfHeight_1;
param_55 = _e326;
let _e327 = v_world_position_1;
param_56 = _e327;
let _e328 = mirror_1;
param_57 = _e328;
let _e329 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e329;
let _e330 = representative;
let _e331 = v_world_position_1;
toPoint = (_e330 - _e331);
let _e333 = toPoint;
pointDistance = length(_e333);
let _e335 = pointDistance;
if (_e335 > 0.000001f) {
let _e337 = toPoint;
let _e338 = pointDistance;
local_9 = (_e337 / vec3(_e338));
} else {
let _e342 = (*s_3).n;
local_9 = _e342;
}
let _e343 = local_9;
light_3.l = _e343;
let _e346 = light_3.l;
let _e348 = (*s_3).v;
light_3.h = normalize((_e346 + _e348));
let _e352 = formFactor;
light_3.n_dot_l = _e352;
let _e355 = (*s_3).n;
let _e357 = light_3.h;
light_3.n_dot_h = max(dot(_e355, _e357), 0f);
let _e362 = (*s_3).v;
let _e364 = light_3.h;
light_3.v_dot_h = max(dot(_e362, _e364), 0f);
let _e368 = color_1;
let _e371 = color_1[3u];
let _e373 = radiance;
light_3.radiance = ((_e368.xyz * _e371) * _e373);
let _e376 = light_3;
return _e376;
}
let _e377 = direction;
aim = normalize(_e377.xyz);
attenuation_1 = 1f;
let _e380 = type_38;
if (_e380 < 0.5f) {
let _e382 = aim;
light_3.l = -(_e382);
} else {
let _e385 = position;
let _e387 = v_world_position_1;
toLight_1 = (_e385.xyz - _e387);
let _e389 = toLight_1;
distance_3 = length(_e389);
let _e391 = distance_3;
if (_e391 < 0.000001f) {
let _e394 = (*s_3).n;
light_3.l = _e394;
let _e397 = (*s_3).n;
light_3.h = _e397;
light_3.radiance = vec3<f32>(0f, 0f, 0f);
light_3.n_dot_l = 0f;
light_3.n_dot_h = 0f;
light_3.v_dot_h = 0f;
let _e403 = light_3;
return _e403;
}
let _e404 = toLight_1;
let _e405 = distance_3;
light_3.l = (_e404 / vec3(_e405));
let _e409 = distance_3;
param_58 = _e409;
let _e411 = direction[3u];
param_59 = _e411;
let _e412 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e412;
let _e413 = type_38;
if (_e413 > 1.5f) {
let _e415 = aim;
let _e417 = light_3.l;
cosAngle = dot(_e415, -(_e417));
let _e420 = cosAngle;
let _e422 = cone[1u];
let _e425 = cone[0u];
let _e427 = cone[1u];
let _e431 = attenuation_1;
attenuation_1 = (_e431 * clamp(((_e420 - _e422) / (_e425 - _e427)), 0f, 1f));
}
}
let _e434 = light_3.l;
let _e436 = (*s_3).v;
light_3.h = normalize((_e434 + _e436));
let _e441 = (*s_3).n;
let _e443 = light_3.l;
light_3.n_dot_l = max(dot(_e441, _e443), 0f);
let _e448 = (*s_3).n;
let _e450 = light_3.h;
light_3.n_dot_h = max(dot(_e448, _e450), 0f);
let _e455 = (*s_3).v;
let _e457 = light_3.h;
light_3.v_dot_h = max(dot(_e455, _e457), 0f);
let _e461 = color_1;
let _e464 = color_1[3u];
let _e466 = attenuation_1;
light_3.radiance = ((_e461.xyz * _e464) * _e466);
let _e469 = light_3;
return _e469;
}
fn LightCount_u0028_() -> i32 {
let _e147 = frag_info.frame_params[1u];
let _e153 = light_list_info.list[0u];
return (clamp(i32((_e147 + 0.5f)), 0i, 8i) + clamp(i32((_e153 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e163 = LightCount_u0028_();
count_1 = _e163;
i_7 = 0i;
loop {
let _e164 = i_7;
if (_e164 < 32i) {
let _e166 = i_7;
let _e167 = count_1;
if (_e166 >= _e167) {
break;
}
let _e169 = i_7;
param_60 = _e169;
let _e170 = (*s_4);
param_61 = _e170;
let _e171 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e171;
let _e173 = light_4.n_dot_l;
if (_e173 <= 0f) {
continue;
}
let _e175 = i_7;
param_62 = _e175;
let _e176 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e176 {
let _e177 = (*s_4);
param_63 = _e177;
let _e178 = light_4;
param_64 = _e178;
let _e179 = i_7;
param_65 = _e179;
let _e180 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e181 = v_world_position_1;
param_66 = _e181;
let _e183 = (*s_4).n;
param_67 = _e183;
let _e184 = i_7;
param_68 = _e184;
let _e185 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e180 * _e185);
} else {
local_10 = 1f;
}
let _e187 = local_10;
visibility = _e187;
let _e188 = visibility;
if (_e188 <= 0f) {
continue;
}
let _e190 = (*s_4);
param_69 = _e190;
let _e191 = light_4;
param_70 = _e191;
let _e192 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e194 = light_4.radiance;
let _e197 = light_4.n_dot_l;
let _e199 = visibility;
let _e201 = total_1;
total_1 = (_e201 + (((_e192 * _e194) * _e197) * _e199));
continue;
} else {
break;
}
continuing {
let _e203 = i_7;
i_7 = (_e203 + 1i);
}
}
let _e205 = total_1;
return _e205;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e146 = v_lightmap_uv_1;
let _e147 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e146);
texel_2 = _e147;
let _e148 = texel_2;
let _e151 = texel_2[3u];
return ((_e148.xyz * _e151) * 8f);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e147 = v_texcoord_1;
let _e148 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e147);
orm = _e148.xyz;
let _e151 = (*s_5).metallic;
let _e153 = orm[2u];
(*s_5).metallic = clamp((_e151 * _e153), 0f, 1f);
let _e158 = (*s_5).roughness;
let _e160 = orm[1u];
(*s_5).roughness = clamp((_e158 * _e160), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e146 = (*srgb);
let _e149 = (*srgb);
let _e154 = (*srgb);
return mix((_e146 / vec3(12.92f)), pow(((_e149 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e154));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e148 = v_texcoord_1;
let _e149 = textureSample(emissive_texture_tex, emissive_texture_smp, _e148);
param_71 = _e149.xyz;
let _e151 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e151;
let _e152 = emissive;
let _e154 = frag_info.emissive;
let _e159 = frag_info.material2_[3u];
(*s_6).emissive = ((_e152 * _e154.xyz) * _e159);
return;
}
fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
var occlusion: f32;
let _e147 = v_texcoord_1;
let _e148 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e147);
occlusion = _e148.x;
let _e150 = occlusion;
let _e153 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e150, clamp(_e153, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e150 = v_texcoord_1;
let _e151 = textureSample(normal_texture_tex, normal_texture_smp, _e150);
sampledTexel = _e151;
let _e152 = v_tangent_1;
t_1 = _e152.xyz;
let _e154 = t_1;
let _e156 = (*s_8).n;
let _e158 = (*s_8).n;
let _e159 = t_1;
t_1 = (_e154 - (_e156 * dot(_e158, _e159)));
let _e163 = t_1;
let _e164 = t_1;
if (dot(_e163, _e164) < 0.000000000001f) {
return;
}
let _e167 = t_1;
t_1 = normalize(_e167);
let _e170 = (*s_8).n;
let _e171 = t_1;
let _e174 = v_tangent_1[3u];
b_1 = (cross(_e170, _e171) * _e174);
let _e176 = sampledTexel;
sampled = ((_e176.xyz * 2f) - vec3(1f));
let _e183 = frag_info.material2_[1u];
let _e184 = sampled;
let _e186 = (_e184.xy * _e183);
sampled[0u] = _e186.x;
sampled[1u] = _e186.y;
let _e191 = t_1;
let _e193 = sampled[0u];
let _e195 = b_1;
let _e197 = sampled[1u];
let _e201 = (*s_8).n;
let _e203 = sampled[2u];
(*s_8).n = normalize((((_e191 * _e193) + (_e195 * _e197)) + (_e201 * _e203)));
let _e209 = (*s_8).n;
let _e211 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e209, _e211), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e149 = (*s_9);
param_72 = _e149;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e150 = param_72;
(*s_9) = _e150;
let _e151 = (*s_9);
param_73 = _e151;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e152 = param_73;
(*s_9) = _e152;
let _e153 = (*s_9);
param_74 = _e153;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e154 = param_74;
(*s_9) = _e154;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e152 = v_texcoord_1;
let _e153 = textureSample(base_color_texture_tex, base_color_texture_smp, _e152);
texel_3 = _e153;
let _e154 = texel_3;
param_75 = _e154.xyz;
let _e156 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e158 = frag_info.base_color;
param_76 = _e158.xyz;
let _e160 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e162 = v_color_1;
s_10.albedo = ((_e156 * _e160) * _e162.xyz);
let _e167 = texel_3[3u];
let _e170 = frag_info.base_color[3u];
let _e173 = v_color_1[3u];
s_10.alpha = ((_e167 * _e170) * _e173);
let _e178 = frag_info.material2_[0u];
cutoff = _e178;
let _e179 = cutoff;
if (_e179 >= 0f) {
let _e182 = s_10.alpha;
let _e183 = cutoff;
if (_e182 < _e183) {
discard;
}
} else {
let _e185 = cutoff;
if (_e185 < -1.5f) {
let _e187 = v_world_position_1;
anchored = floor((_e187 * 16f));
let _e190 = anchored;
noise_1 = fract((sin(dot(_e190, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e196 = s_10.alpha;
let _e197 = noise_1;
if (_e196 < _e197) {
discard;
}
}
}
let _e199 = v_normal_1;
s_10.n = normalize(_e199);
let _e203 = frag_info.camera_position;
let _e205 = v_world_position_1;
s_10.v = normalize((_e203.xyz - _e205));
let _e210 = s_10.n;
let _e212 = s_10.v;
s_10.n_dot_v = max(dot(_e210, _e212), 0.0001f);
let _e218 = frag_info.material[0u];
s_10.metallic = clamp(_e218, 0f, 1f);
let _e223 = frag_info.material[1u];
s_10.roughness = clamp(_e223, 0.02f, 1f);
let _e227 = frag_info.ambient_ground;
let _e230 = frag_info.ambient_sky;
let _e234 = s_10.n[1u];
let _e241 = frag_info.material[2u];
s_10.ambient = (mix(_e227.xyz, _e230.xyz, vec3(((_e234 * 0.5f) + 0.5f))) * _e241);
let _e246 = frag_info.frame_params[0u];
s_10.exposure = max(_e246, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e251 = s_10;
return _e251;
}
fn main_1() {
var s_11: Surface;
var param_77: Surface;
var param_78: Surface;
var ambient: vec3<f32>;
var param_79: Surface;
var param_80: vec3<f32>;
var param_81: f32;
var param_82: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e153 = ReadSurface_u0028_();
s_11 = _e153;
let _e154 = s_11;
param_77 = _e154;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e155 = param_77;
s_11 = _e155;
let _e156 = s_11;
param_78 = _e156;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e157 = param_78;
s_11 = _e157;
let _e159 = s_11.albedo;
let _e161 = s_11.ambient;
let _e162 = SampleLightmap_u0028_();
let _e166 = s_11.occlusion;
ambient = ((_e159 * (_e161 + _e162)) * _e166);
let _e168 = s_11;
param_79 = _e168;
let _e169 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e171 = s_11.occlusion;
let _e173 = ambient;
let _e176 = s_11.emissive;
param_80 = (((_e169 * _e171) + _e173) + _e176);
let _e179 = s_11.alpha;
param_81 = _e179;
let _e181 = s_11.roughness;
param_82 = _e181;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_80), (¶m_81), (¶m_82));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Pbr': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(10)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(22)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var point_shadow_texture_smp: sampler;
@group(1) @binding(20)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(12)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(14)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(18)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(16)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(24)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var shadow_texture_smp: sampler;
@group(1) @binding(8)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(9)
var environment_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e165 = (*n)[0u];
let _e168 = (*n)[1u];
let _e172 = (*n)[2u];
let _e175 = (*n);
(*n) = (_e175 / vec3(((abs(_e165) + abs(_e168)) + abs(_e172))));
let _e178 = (*n);
e = _e178.xy;
let _e181 = (*n)[2u];
if (_e181 < 0f) {
let _e183 = (*n);
let _e189 = (*n)[0u];
let _e193 = (*n)[1u];
e = ((vec2(1f) - abs(_e183.yx)) * vec2<f32>(select(-1f, 1f, (_e189 >= 0f)), select(-1f, 1f, (_e193 >= 0f))));
}
let _e198 = e;
return ((_e198 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e162 = v_world_position_1;
let _e164 = fog_info.eye;
let _e168 = fog_info.forward;
return dot((_e162 - _e164.xyz), _e168.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e164 = g_debug_surface_on;
if _e164 {
let _e165 = g_debug_surface;
let _e166 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e165.x, _e165.y, _e165.z, _e166);
return;
}
let _e171 = v_normal_1;
param = normalize(_e171);
let _e173 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e174 = (*roughness);
let _e176 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e173.x, _e173.y, clamp(_e174, 0f, 1f), _e176);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e162 = v_world_position_1;
let _e164 = fog_info.eye;
return distance(_e162, _e164.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e167 = fog_info.fog[3u];
density = _e167;
let _e168 = density;
if (_e168 <= 0f) {
let _e170 = (*color);
return _e170;
}
let _e171 = EyeDistance_u0028_();
d = _e171;
let _e173 = fog_info.fog;
let _e175 = (*color);
let _e176 = density;
let _e178 = d;
return mix(_e173.xyz, _e175, vec3(clamp(exp((-(_e176) * _e178)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e167 = (*linearColor);
param_1 = _e167;
let _e168 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e169 = (*alpha);
frag_color = vec4<f32>(_e168.x, _e168.y, _e168.z, _e169);
let _e174 = (*roughness_1);
param_2 = _e174;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
var f: f32;
let _e165 = (*v_dot_h);
f = pow((1f - _e165), 5f);
let _e168 = (*f0_);
let _e169 = (*f0_);
let _e171 = f;
return (_e168 + ((vec3<f32>(1f, 1f, 1f) - _e169) * _e171));
}
fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_1: ptr<function, f32>) -> f32 {
var a2_: f32;
var lambda_v: f32;
var lambda_l: f32;
let _e168 = (*alpha_1);
let _e169 = (*alpha_1);
a2_ = (_e168 * _e169);
let _e171 = (*n_dot_l);
let _e172 = (*n_dot_v);
let _e173 = (*n_dot_v);
let _e175 = a2_;
let _e178 = a2_;
lambda_v = (_e171 * sqrt((((_e172 * _e173) * (1f - _e175)) + _e178)));
let _e182 = (*n_dot_v);
let _e183 = (*n_dot_l);
let _e184 = (*n_dot_l);
let _e186 = a2_;
let _e189 = a2_;
lambda_l = (_e182 * sqrt((((_e183 * _e184) * (1f - _e186)) + _e189)));
let _e193 = lambda_v;
let _e194 = lambda_l;
return (0.5f / max((_e193 + _e194), 0.00001f));
}
fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_2: ptr<function, f32>) -> f32 {
var a: f32;
var k: f32;
let _e166 = (*n_dot_h);
let _e167 = (*alpha_2);
a = (_e166 * _e167);
let _e169 = (*alpha_2);
let _e170 = (*n_dot_h);
let _e171 = (*n_dot_h);
let _e174 = a;
let _e175 = a;
k = (_e169 / max(((1f - (_e170 * _e171)) + (_e174 * _e175)), 0.000001f));
let _e180 = k;
let _e181 = k;
return ((_e180 * _e181) * 0.31830987f);
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var alpha_3: f32;
var f0_1: vec3<f32>;
var diffuseColor: vec3<f32>;
var d_1: f32;
var param_3: f32;
var param_4: f32;
var vis: f32;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var f_1: vec3<f32>;
var param_8: vec3<f32>;
var param_9: f32;
var specular: vec3<f32>;
var diffuse: vec3<f32>;
let _e180 = (*s).roughness;
let _e182 = (*s).roughness;
alpha_3 = (_e180 * _e182);
let _e185 = (*s).albedo;
let _e187 = (*s).metallic;
f0_1 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e185, vec3(_e187));
let _e191 = (*s).albedo;
let _e193 = (*s).metallic;
diffuseColor = (_e191 * (1f - _e193));
let _e197 = (*light).n_dot_h;
param_3 = _e197;
let _e198 = alpha_3;
param_4 = _e198;
let _e199 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
d_1 = _e199;
let _e201 = (*s).n_dot_v;
param_5 = _e201;
let _e203 = (*light).n_dot_l;
param_6 = _e203;
let _e204 = alpha_3;
param_7 = _e204;
let _e205 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
vis = _e205;
let _e206 = f0_1;
param_8 = _e206;
let _e208 = (*light).v_dot_h;
param_9 = _e208;
let _e209 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
f_1 = _e209;
let _e210 = d_1;
let _e211 = vis;
let _e213 = f_1;
let _e217 = frag_info.material[3u];
specular = ((_e213 * (_e210 * _e211)) * _e217);
let _e219 = diffuseColor;
let _e220 = f_1;
diffuse = ((_e219 * (vec3<f32>(1f, 1f, 1f) - _e220)) / vec3(3.1415927f));
let _e225 = diffuse;
let _e226 = specular;
return ((_e225 + _e226) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e163 = (*i);
if (_e163 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e165 = (*i);
if (_e165 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e167 = (*i);
if (_e167 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e169 = (*i);
if (_e169 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e171 = (*i);
if (_e171 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e173 = (*i);
if (_e173 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e175 = (*i);
if (_e175 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_10: i32;
let _e168 = (*i_1);
param_10 = _e168;
let _e169 = PointShadowDiskTap_u0028_i1_u003b((¶m_10));
p = _e169;
let _e171 = p[0u];
let _e172 = (*ca);
let _e175 = p[1u];
let _e176 = (*sa);
let _e180 = p[0u];
let _e181 = (*sa);
let _e184 = p[1u];
let _e185 = (*ca);
let _e189 = (*radius);
return (vec2<f32>(((_e171 * _e172) - (_e175 * _e176)), ((_e180 * _e181) + (_e184 * _e185))) * _e189);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e171 = point_shadow.params[0u];
inset = _e171;
let _e172 = (*uv);
let _e173 = (*offset);
let _e175 = inset;
let _e176 = inset;
local = clamp((_e172 + _e173), vec2(_e175), vec2((1f - _e176)));
let _e181 = local;
let _e182 = (*tile);
atlas = ((_e181 + _e182) * vec2<f32>(0.16666667f, 0.16666667f));
let _e187 = point_shadow.params3_[0u];
if (_e187 > 0.5f) {
let _e190 = atlas[1u];
atlas[1u] = (1f - _e190);
}
let _e193 = atlas;
let _e194 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e193, 0f);
let _e196 = atlas;
let _e197 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e196, 0f);
let _e200 = (*range);
return (min(_e194.x, _e197.x) * _e200);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: vec2<f32>;
var param_14: f32;
let _e172 = (*uv_1);
param_11 = _e172;
let _e173 = (*offset_1);
param_12 = _e173;
let _e174 = (*tile_1);
param_13 = _e174;
let _e175 = (*range_1);
param_14 = _e175;
let _e176 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_11), (¶m_12), (¶m_13), (¶m_14));
stored = _e176;
let _e177 = stored;
let _e178 = (*range_1);
if (_e177 >= (_e178 * 0.999f)) {
return 1f;
}
let _e181 = (*receiver);
let _e182 = stored;
return select(1f, 0f, (_e181 > _e182));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_19: i32;
var param_20: f32;
var param_21: f32;
var param_22: f32;
var param_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: vec2<f32>;
var param_26: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e193 = point_shadow.params2_[1u];
lightRadius = _e193;
let _e196 = point_shadow.params2_[0u];
minRadius = _e196;
let _e199 = point_shadow.params2_[2u];
maxRadius = _e199;
let _e200 = lightRadius;
if (_e200 <= 0f) {
let _e202 = (*uv_2);
param_15 = _e202;
param_16 = vec2<f32>(0f, 0f);
let _e203 = (*tile_2);
param_17 = _e203;
let _e204 = (*range_2);
param_18 = _e204;
let _e205 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
(*blockerOut) = _e205;
let _e206 = minRadius;
return _e206;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e207 = i_2;
if (_e207 < 8i) {
let _e209 = i_2;
param_19 = _e209;
let _e210 = (*ca_1);
param_20 = _e210;
let _e211 = (*sa_1);
param_21 = _e211;
let _e212 = maxRadius;
param_22 = _e212;
let _e213 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
let _e214 = (*uv_2);
param_23 = _e214;
param_24 = _e213;
let _e215 = (*tile_2);
param_25 = _e215;
let _e216 = (*range_2);
param_26 = _e216;
let _e217 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
stored_1 = _e217;
let _e218 = stored_1;
let _e219 = (*range_2);
if (_e218 >= (_e219 * 0.999f)) {
continue;
}
let _e222 = stored_1;
let _e223 = (*receiver_1);
if (_e222 >= _e223) {
continue;
}
let _e225 = stored_1;
let _e226 = sum;
sum = (_e226 + _e225);
let _e228 = count;
count = (_e228 + 1f);
continue;
} else {
break;
}
continuing {
let _e230 = i_2;
i_2 = (_e230 + 1i);
}
}
let _e232 = count;
if (_e232 < 0.5f) {
return -1f;
}
let _e234 = sum;
let _e235 = count;
blocker = max((_e234 / _e235), 0.0001f);
let _e238 = blocker;
(*blockerOut) = _e238;
let _e239 = lightRadius;
let _e240 = (*receiver_1);
let _e241 = blocker;
let _e245 = blocker;
world = ((_e239 * max((_e240 - _e241), 0f)) / _e245);
let _e247 = world;
let _e248 = (*receiver_1);
let _e250 = (*tanHalf);
let _e253 = minRadius;
let _e254 = maxRadius;
return clamp((_e247 / ((2f * _e248) * _e250)), _e253, _e254);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a_1: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: f32;
var param_30: f32;
var param_31: f32;
var param_32: f32;
var param_33: f32;
var param_34: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_35: vec2<f32>;
var param_36: vec2<f32>;
var param_37: vec2<f32>;
var param_38: f32;
var param_39: f32;
var i_3: i32;
var param_40: i32;
var param_41: f32;
var param_42: f32;
var param_43: f32;
var param_44: vec2<f32>;
var param_45: vec2<f32>;
var param_46: vec2<f32>;
var param_47: f32;
var param_48: f32;
var phi_1546_: bool;
var phi_1608_: bool;
let _e215 = (*lightIndex);
let _e219 = point_shadow.slots[_e215][0u];
slot = i32((_e219 + 0.5f));
let _e222 = (*lightIndex);
let _e226 = point_shadow.slots[_e222][0u];
if (_e226 < 0f) {
return 1f;
}
let _e230 = point_shadow.params[2u];
strength = _e230;
let _e231 = strength;
if (_e231 <= 0f) {
return 1f;
}
let _e233 = slot;
let _e236 = point_shadow.lights[_e233];
let _e238 = (*world_1);
toLight = (_e236.xyz - _e238);
let _e240 = toLight;
toLightLength = max(length(_e240), 0.000001f);
let _e243 = (*normal);
let _e244 = toLight;
let _e245 = toLightLength;
nDotL = max(dot(_e243, (_e244 / vec3(_e245))), 0.15f);
let _e250 = nDotL;
let _e251 = nDotL;
let _e256 = nDotL;
let _e257 = nDotL;
slope = min((sqrt(max((1f - (_e250 * _e251)), 0f)) / (_e256 * _e257)), 8f);
let _e261 = toLightLength;
let _e263 = (*lightIndex);
let _e267 = point_shadow.slots[_e263][2u];
let _e272 = point_shadow.params3_[1u];
texel = (((2f * _e261) * max(_e267, 0.0001f)) * _e272);
let _e274 = (*world_1);
let _e275 = (*normal);
let _e276 = texel;
let _e280 = point_shadow.params[3u];
let _e282 = slope;
origin = (_e274 + (((_e275 * _e276) * _e280) * (1f + _e282)));
let _e286 = origin;
let _e287 = slot;
let _e290 = point_shadow.lights[_e287];
toFragment = (_e286 - _e290.xyz);
let _e293 = toFragment;
distance_ = length(_e293);
let _e295 = slot;
let _e299 = point_shadow.lights[_e295][3u];
range_3 = max(_e299, 0.0001f);
let _e301 = distance_;
let _e302 = range_3;
if (_e301 >= _e302) {
return 1f;
}
face = 0i;
let _e304 = (*lightIndex);
let _e308 = point_shadow.slots[_e304][1u];
if (_e308 < 0.5f) {
let _e310 = toFragment;
a_1 = abs(_e310);
let _e313 = a_1[0u];
let _e315 = a_1[1u];
let _e316 = (_e313 >= _e315);
phi_1546_ = _e316;
if _e316 {
let _e318 = a_1[0u];
let _e320 = a_1[2u];
phi_1546_ = (_e318 >= _e320);
}
let _e323 = phi_1546_;
if _e323 {
let _e325 = toFragment[0u];
face = select(1i, 0i, (_e325 > 0f));
} else {
let _e329 = a_1[1u];
let _e331 = a_1[2u];
if (_e329 >= _e331) {
let _e334 = toFragment[1u];
face = select(3i, 2i, (_e334 > 0f));
} else {
let _e338 = toFragment[2u];
face = select(5i, 4i, (_e338 > 0f));
}
}
}
let _e341 = slot;
let _e343 = face;
let _e347 = point_shadow.faces[((_e341 * 6i) + _e343)];
let _e348 = origin;
clip = (_e347 * vec4<f32>(_e348.x, _e348.y, _e348.z, 1f));
let _e355 = clip[3u];
if (_e355 <= 0f) {
return 1f;
}
let _e357 = clip;
let _e360 = clip[3u];
ndc = (_e357.xy / vec2(_e360));
let _e364 = ndc[0u];
let _e366 = (abs(_e364) > 1f);
phi_1608_ = _e366;
if !(_e366) {
let _e369 = ndc[1u];
phi_1608_ = (abs(_e369) > 1f);
}
let _e373 = phi_1608_;
if _e373 {
return 1f;
}
let _e375 = ndc[0u];
let _e379 = ndc[1u];
uv_3 = vec2<f32>(((_e375 * 0.5f) + 0.5f), (0.5f - (_e379 * 0.5f)));
let _e383 = face;
let _e385 = slot;
tile_3 = vec2<f32>(f32(_e383), f32(_e385));
let _e388 = distance_;
let _e391 = point_shadow.params[1u];
receiver_2 = (_e388 - _e391);
let _e393 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e393.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e399 = noise;
angle = (_e399 * 6.2831855f);
let _e401 = angle;
ca_2 = cos(_e401);
let _e403 = angle;
sa_2 = sin(_e403);
let _e405 = (*lightIndex);
let _e409 = point_shadow.slots[_e405][2u];
tanHalf_1 = max(_e409, 0.0001f);
blocker_1 = -1f;
let _e411 = uv_3;
param_27 = _e411;
let _e412 = tile_3;
param_28 = _e412;
let _e413 = range_3;
param_29 = _e413;
let _e414 = receiver_2;
param_30 = _e414;
let _e415 = ca_2;
param_31 = _e415;
let _e416 = sa_2;
param_32 = _e416;
let _e417 = tanHalf_1;
param_33 = _e417;
let _e418 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32), (¶m_33), (¶m_34));
let _e419 = param_34;
blocker_1 = _e419;
radius_1 = _e418;
let _e422 = point_shadow.params2_[3u];
if (_e422 > 0.5f) {
g_debug_surface_on = true;
let _e424 = radius_1;
if (_e424 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e426 = radius_1;
let _e429 = point_shadow.params2_[2u];
let _e433 = blocker_1;
let _e434 = range_3;
local_1 = vec3<f32>(clamp((_e426 / max(_e429, 0.000001f)), 0f, 1f), clamp((_e433 / _e434), 0f, 1f), 0f);
}
let _e438 = local_1;
g_debug_surface = _e438;
}
let _e439 = radius_1;
if (_e439 < 0f) {
return 1f;
}
let _e441 = uv_3;
param_35 = _e441;
param_36 = vec2<f32>(0f, 0f);
let _e442 = tile_3;
param_37 = _e442;
let _e443 = range_3;
param_38 = _e443;
let _e444 = receiver_2;
param_39 = _e444;
let _e445 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
lit = _e445;
let _e446 = radius_1;
if (_e446 > 0f) {
i_3 = 0i;
loop {
let _e448 = i_3;
if (_e448 < 8i) {
let _e450 = i_3;
param_40 = _e450;
let _e451 = ca_2;
param_41 = _e451;
let _e452 = sa_2;
param_42 = _e452;
let _e453 = radius_1;
param_43 = _e453;
let _e454 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43));
let _e455 = uv_3;
param_44 = _e455;
param_45 = _e454;
let _e456 = tile_3;
param_46 = _e456;
let _e457 = range_3;
param_47 = _e457;
let _e458 = receiver_2;
param_48 = _e458;
let _e459 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_44), (¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e460 = lit;
lit = (_e460 + _e459);
continue;
} else {
break;
}
continuing {
let _e462 = i_3;
i_3 = (_e462 + 1i);
}
}
let _e464 = lit;
lit = (_e464 * 0.11111111f);
}
let _e466 = lit;
let _e467 = strength;
return mix(1f, _e466, clamp(_e467, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2055_: bool;
var phi_2066_: bool;
var phi_2156_: bool;
var phi_2163_: bool;
var phi_2170_: bool;
let _e201 = frag_info.shadow_params[3u];
strength_1 = _e201;
let _e202 = strength_1;
if (_e202 <= 0f) {
return 1f;
}
let _e204 = (*lightIndex_1);
let _e207 = frag_info.frame_params[2u];
if (_e204 != i32((_e207 + 0.5f))) {
return 1f;
}
let _e211 = v_world_position_1;
let _e213 = (*s_1).n;
let _e216 = frag_info.shadow_params[2u];
origin_1 = (_e211 + (_e213 * _e216));
let _e221 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e221 + 0.5f));
let _e224 = v_world_position_1;
let _e226 = frag_info.camera_position;
viewDistance = length((_e224 - _e226.xyz));
cascade = 0i;
let _e230 = cascadeCount;
let _e231 = (_e230 > 1i);
phi_2055_ = _e231;
if _e231 {
let _e232 = viewDistance;
let _e235 = frag_info.shadow_cascades[0u];
phi_2055_ = (_e232 > _e235);
}
let _e238 = phi_2055_;
if _e238 {
cascade = 1i;
}
let _e239 = cascadeCount;
let _e240 = (_e239 > 2i);
phi_2066_ = _e240;
if _e240 {
let _e241 = viewDistance;
let _e244 = frag_info.shadow_cascades[1u];
phi_2066_ = (_e241 > _e244);
}
let _e247 = phi_2066_;
if _e247 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e248 = attempt;
if (_e248 < 3i) {
let _e250 = cascade;
let _e251 = attempt;
which = (_e250 + _e251);
let _e253 = which;
let _e254 = cascadeCount;
if (_e253 >= _e254) {
break;
}
let _e256 = which;
if (_e256 == 0i) {
let _e259 = frag_info.shadow_matrix;
local_2 = _e259;
} else {
let _e260 = which;
if (_e260 == 1i) {
let _e263 = frag_info.shadow_matrix_far;
local_3 = _e263;
} else {
let _e265 = frag_info.shadow_matrix_farthest;
local_3 = _e265;
}
let _e266 = local_3;
local_2 = _e266;
}
let _e267 = local_2;
matrix = _e267;
let _e268 = matrix;
let _e269 = origin_1;
lightSpace = (_e268 * vec4<f32>(_e269.x, _e269.y, _e269.z, 1f));
let _e276 = lightSpace[3u];
if (_e276 <= 0f) {
continue;
}
let _e278 = lightSpace;
let _e281 = lightSpace[3u];
candidate = (_e278.xyz / vec3(_e281));
let _e285 = candidate[0u];
let _e289 = candidate[1u];
inTile = vec2<f32>(((_e285 * 0.5f) + 0.5f), (0.5f - (_e289 * 0.5f)));
let _e294 = inTile[0u];
let _e295 = (_e294 < 0f);
phi_2156_ = _e295;
if !(_e295) {
let _e298 = inTile[0u];
phi_2156_ = (_e298 > 1f);
}
let _e301 = phi_2156_;
phi_2163_ = _e301;
if !(_e301) {
let _e304 = inTile[1u];
phi_2163_ = (_e304 < 0f);
}
let _e307 = phi_2163_;
phi_2170_ = _e307;
if !(_e307) {
let _e310 = inTile[1u];
phi_2170_ = (_e310 > 1f);
}
let _e313 = phi_2170_;
if _e313 {
continue;
}
let _e315 = candidate[2u];
if (_e315 > 1f) {
continue;
}
let _e318 = inTile[0u];
let _e319 = which;
let _e322 = cascadeCount;
let _e326 = inTile[1u];
uv_4 = vec2<f32>(((_e318 + f32(_e319)) / f32(_e322)), _e326);
let _e328 = candidate;
projected = _e328;
let _e329 = which;
cascade = _e329;
found = true;
break;
} else {
break;
}
continuing {
let _e330 = attempt;
attempt = (_e330 + 1i);
}
}
let _e332 = found;
if !(_e332) {
return 1f;
}
let _e336 = frag_info.shadow_params[1u];
bias = _e336;
let _e339 = frag_info.shadow_params[0u];
let _e342 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e339, _e342);
let _e346 = frag_info.ambient_ground[3u];
softness = _e346;
lit_1 = 0f;
let _e347 = softness;
if (_e347 <= 0f) {
y = -1i;
loop {
let _e349 = y;
if (_e349 <= 1i) {
x = -1i;
loop {
let _e351 = x;
if (_e351 <= 1i) {
let _e353 = uv_4;
let _e354 = x;
let _e356 = y;
let _e359 = texel_1;
let _e362 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e353 + (vec2<f32>(f32(_e354), f32(_e356)) * _e359)), 0f);
occluder = _e362.x;
let _e365 = projected[2u];
let _e366 = bias;
let _e368 = occluder;
let _e371 = lit_1;
lit_1 = (_e371 + select(1f, 0f, ((_e365 - _e366) > _e368)));
continue;
} else {
break;
}
continuing {
let _e373 = x;
x = (_e373 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e375 = y;
y = (_e375 + 1i);
}
}
let _e377 = lit_1;
lit_1 = (_e377 * 0.11111111f);
} else {
let _e379 = softness;
searchRadius = clamp((_e379 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e382 = i_4;
if (_e382 < 5i) {
let _e384 = uv_4;
let _e385 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e387 = indexable[_e385];
let _e388 = texel_1;
let _e390 = searchRadius;
let _e393 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e384 + ((_e387 * _e388) * _e390)), 0f);
occluder_1 = _e393.x;
let _e396 = projected[2u];
let _e397 = bias;
let _e399 = occluder_1;
if ((_e396 - _e397) > _e399) {
let _e401 = occluder_1;
let _e402 = blockerSum;
blockerSum = (_e402 + _e401);
let _e404 = blockerCount;
blockerCount = (_e404 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e406 = i_4;
i_4 = (_e406 + 1i);
}
}
let _e408 = blockerCount;
if (_e408 <= 0f) {
return 1f;
}
let _e411 = projected[2u];
let _e412 = blockerSum;
let _e413 = blockerCount;
gap = max((_e411 - (_e412 / _e413)), 0f);
let _e417 = gap;
let _e418 = softness;
radius_2 = clamp((_e417 * _e418), 1f, 16f);
i_5 = 0i;
loop {
let _e421 = i_5;
if (_e421 < 5i) {
let _e423 = uv_4;
let _e424 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e426 = indexable_1[_e424];
let _e427 = texel_1;
let _e429 = radius_2;
let _e432 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e423 + ((_e426 * _e427) * _e429)), 0f);
occluder_2 = _e432.x;
let _e435 = projected[2u];
let _e436 = bias;
let _e438 = occluder_2;
let _e441 = lit_1;
lit_1 = (_e441 + select(1f, 0f, ((_e435 - _e436) > _e438)));
continue;
} else {
break;
}
continuing {
let _e443 = i_5;
i_5 = (_e443 + 1i);
}
}
let _e445 = lit_1;
lit_1 = (_e445 * 0.2f);
}
let _e447 = lit_1;
let _e448 = strength_1;
return mix(1f, _e447, clamp(_e448, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_49: Surface;
var param_50: LightSample;
var param_51: i32;
let _e168 = (*s_2);
param_49 = _e168;
let _e169 = (*light_2);
param_50 = _e169;
let _e170 = (*index);
param_51 = _e170;
let _e171 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_49), (¶m_50), (¶m_51));
return _e171;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e163 = (*index_1);
return (_e163 < 8i);
}
fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
var attenuation: f32;
var ratio: f32;
var window: f32;
let _e167 = (*distance_1);
let _e168 = (*distance_1);
attenuation = (1f / max((_e167 * _e168), 0.0001f));
let _e172 = (*range_4);
if (_e172 > 0f) {
let _e174 = (*distance_1);
let _e175 = (*range_4);
ratio = (_e174 / _e175);
let _e177 = ratio;
let _e178 = ratio;
let _e180 = ratio;
let _e182 = ratio;
window = clamp((1f - (((_e177 * _e178) * _e180) * _e182)), 0f, 1f);
let _e186 = window;
let _e187 = window;
let _e189 = attenuation;
attenuation = (_e189 * (_e186 * _e187));
}
let _e191 = attenuation;
return _e191;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e179 = (*halfWidth);
let _e180 = (*halfHeight);
n_1 = cross(_e179, _e180);
let _e182 = n_1;
nLen = length(_e182);
let _e184 = nLen;
if (_e184 < 0.000000000001f) {
let _e186 = (*centre);
return _e186;
}
let _e187 = nLen;
let _e188 = n_1;
n_1 = (_e188 / vec3(_e187));
let _e191 = (*centre);
let _e192 = (*world_2);
toPlane = (_e191 - _e192);
let _e194 = (*mirror);
let _e195 = n_1;
denom = dot(_e194, _e195);
let _e197 = denom;
if (abs(_e197) < 0.00001f) {
let _e200 = toPlane;
let _e201 = n_1;
let _e202 = toPlane;
let _e203 = n_1;
onPlane = (_e200 - (_e201 * dot(_e202, _e203)));
} else {
let _e207 = toPlane;
let _e208 = n_1;
let _e210 = denom;
t = (dot(_e207, _e208) / _e210);
let _e212 = t;
if (_e212 > 0f) {
let _e214 = (*mirror);
let _e215 = t;
local_4 = (_e214 * _e215);
} else {
let _e217 = toPlane;
let _e218 = n_1;
let _e219 = toPlane;
let _e220 = n_1;
local_4 = (_e217 - (_e218 * dot(_e219, _e220)));
}
let _e224 = local_4;
onPlane = _e224;
}
let _e225 = onPlane;
let _e226 = toPlane;
offset_2 = (_e225 - _e226);
let _e228 = (*halfWidth);
let _e229 = (*halfWidth);
wLen2_ = max(dot(_e228, _e229), 0.000000000001f);
let _e232 = (*halfHeight);
let _e233 = (*halfHeight);
hLen2_ = max(dot(_e232, _e233), 0.000000000001f);
let _e236 = offset_2;
let _e237 = (*halfWidth);
let _e239 = wLen2_;
u = clamp((dot(_e236, _e237) / _e239), -1f, 1f);
let _e242 = offset_2;
let _e243 = (*halfHeight);
let _e245 = hLen2_;
v = clamp((dot(_e242, _e243) / _e245), -1f, 1f);
let _e248 = (*centre);
let _e249 = (*halfWidth);
let _e250 = u;
let _e253 = (*halfHeight);
let _e254 = v;
return ((_e248 + (_e249 * _e250)) + (_e253 * _e254));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_2: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e171 = i_6;
if (_e171 < 4i) {
let _e173 = i_6;
let _e175 = (*corners)[_e173];
a_2 = normalize(_e175);
let _e177 = i_6;
let _e181 = (*corners)[((_e177 + 1i) & 3i)];
b = normalize(_e181);
let _e183 = a_2;
let _e184 = b;
angle_1 = acos(clamp(dot(_e183, _e184), -1f, 1f));
let _e188 = a_2;
let _e189 = b;
axis = cross(_e188, _e189);
let _e191 = axis;
len = length(_e191);
let _e193 = len;
if (_e193 > 0.000001f) {
let _e195 = angle_1;
let _e196 = axis;
let _e197 = len;
let _e200 = (*n_2);
let _e203 = total;
total = (_e203 + (_e195 * dot((_e196 / vec3(_e197)), _e200)));
}
continue;
} else {
break;
}
continuing {
let _e205 = i_6;
i_6 = (_e205 + 1i);
}
}
let _e207 = total;
return max((-(_e207) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e168 = (*slot_1);
let _e169 = (*slot_1);
lane = (_e168 - ((_e169 / 4i) * 4i));
let _e173 = lane;
if (_e173 == 0i) {
let _e176 = (*four)[0u];
local_5 = _e176;
} else {
let _e177 = lane;
if (_e177 == 1i) {
let _e180 = (*four)[1u];
local_6 = _e180;
} else {
let _e181 = lane;
if (_e181 == 2i) {
let _e184 = (*four)[2u];
local_7 = _e184;
} else {
let _e186 = (*four)[3u];
local_7 = _e186;
}
let _e187 = local_7;
local_6 = _e187;
}
let _e188 = local_6;
local_5 = _e188;
}
let _e189 = local_5;
return _e189;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_52: vec4<f32>;
var param_53: i32;
let _e165 = (*slot_2);
let _e169 = light_list_info.scales[(_e165 / 4i)];
param_52 = _e169;
let _e170 = (*slot_2);
param_53 = _e170;
let _e171 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_52), (¶m_53));
return _e171;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_54: vec4<f32>;
var param_55: i32;
let _e165 = (*slot_3);
let _e169 = light_list_info.indices[(_e165 / 4i)];
param_54 = _e169;
let _e170 = (*slot_3);
param_55 = _e170;
let _e171 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_54), (¶m_55));
return _e171;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_56: i32;
var u_1: f32;
var param_57: i32;
var type_39: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_58: array<vec3<f32>, 4>;
var param_59: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_60: vec3<f32>;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var param_63: vec3<f32>;
var param_64: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_65: f32;
var param_66: f32;
var cosAngle: f32;
let _e205 = (*index_2);
if (_e205 < 8i) {
let _e207 = (*index_2);
let _e210 = frag_info.light_position[_e207];
position = _e210;
let _e211 = (*index_2);
let _e214 = frag_info.light_color[_e211];
color_1 = _e214;
let _e215 = (*index_2);
let _e218 = frag_info.light_direction[_e215];
direction = _e218;
let _e219 = (*index_2);
let _e222 = frag_info.light_cone[_e219];
cone = _e222;
} else {
let _e223 = (*index_2);
slot_4 = (_e223 - 8i);
let _e225 = slot_4;
param_56 = _e225;
let _e226 = LightListRow_u0028_i1_u003b((¶m_56));
let _e230 = light_list_info.list[2u];
v_1 = ((_e226 + 0.5f) * _e230);
let _e234 = light_list_info.list[1u];
u_1 = _e234;
let _e235 = u_1;
let _e237 = v_1;
let _e239 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e235), _e237), 0f);
position = _e239;
let _e240 = u_1;
let _e242 = v_1;
let _e244 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e240), _e242), 0f);
color_1 = _e244;
let _e245 = u_1;
let _e247 = v_1;
let _e249 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e245), _e247), 0f);
direction = _e249;
let _e250 = u_1;
let _e252 = v_1;
let _e254 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e250), _e252), 0f);
cone = _e254;
let _e255 = slot_4;
param_57 = _e255;
let _e256 = LightListScale_u0028_i1_u003b((¶m_57));
let _e258 = color_1[3u];
color_1[3u] = (_e258 * _e256);
}
let _e262 = position[3u];
type_39 = _e262;
let _e263 = type_39;
if (_e263 > 2.5f) {
let _e265 = direction;
halfWidth_1 = _e265.xyz;
let _e267 = cone;
halfHeight_1 = _e267.xyz;
let _e269 = position;
let _e271 = v_world_position_1;
toCentre = (_e269.xyz - _e271);
let _e273 = toCentre;
let _e274 = halfWidth_1;
let _e276 = halfHeight_1;
corners_1[0i] = ((_e273 - _e274) - _e276);
let _e279 = toCentre;
let _e280 = halfWidth_1;
let _e282 = halfHeight_1;
corners_1[1i] = ((_e279 + _e280) - _e282);
let _e285 = toCentre;
let _e286 = halfWidth_1;
let _e288 = halfHeight_1;
corners_1[2i] = ((_e285 + _e286) + _e288);
let _e291 = toCentre;
let _e292 = halfWidth_1;
let _e294 = halfHeight_1;
corners_1[3i] = ((_e291 - _e292) + _e294);
let _e297 = corners_1;
param_58 = _e297;
let _e299 = (*s_3).n;
param_59 = _e299;
let _e300 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_58), (¶m_59));
formFactor = _e300;
let _e301 = halfWidth_1;
let _e302 = halfHeight_1;
area = (length(cross(_e301, _e302)) * 4f);
let _e306 = area;
if (_e306 > 0.000000001f) {
let _e308 = area;
local_8 = (1f / _e308);
} else {
local_8 = 0f;
}
let _e310 = local_8;
radiance = _e310;
let _e311 = toCentre;
distance_2 = length(_e311);
let _e314 = direction[3u];
if (_e314 > 0f) {
let _e316 = distance_2;
let _e318 = direction[3u];
ratio_1 = (_e316 / _e318);
let _e320 = ratio_1;
let _e321 = ratio_1;
let _e323 = ratio_1;
let _e325 = ratio_1;
window_1 = clamp((1f - (((_e320 * _e321) * _e323) * _e325)), 0f, 1f);
let _e329 = window_1;
let _e330 = window_1;
let _e332 = radiance;
radiance = (_e332 * (_e329 * _e330));
}
let _e335 = (*s_3).v;
let _e338 = (*s_3).n;
mirror_1 = reflect(-(_e335), _e338);
let _e340 = position;
param_60 = _e340.xyz;
let _e342 = halfWidth_1;
param_61 = _e342;
let _e343 = halfHeight_1;
param_62 = _e343;
let _e344 = v_world_position_1;
param_63 = _e344;
let _e345 = mirror_1;
param_64 = _e345;
let _e346 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63), (¶m_64));
representative = _e346;
let _e347 = representative;
let _e348 = v_world_position_1;
toPoint = (_e347 - _e348);
let _e350 = toPoint;
pointDistance = length(_e350);
let _e352 = pointDistance;
if (_e352 > 0.000001f) {
let _e354 = toPoint;
let _e355 = pointDistance;
local_9 = (_e354 / vec3(_e355));
} else {
let _e359 = (*s_3).n;
local_9 = _e359;
}
let _e360 = local_9;
light_3.l = _e360;
let _e363 = light_3.l;
let _e365 = (*s_3).v;
light_3.h = normalize((_e363 + _e365));
let _e369 = formFactor;
light_3.n_dot_l = _e369;
let _e372 = (*s_3).n;
let _e374 = light_3.h;
light_3.n_dot_h = max(dot(_e372, _e374), 0f);
let _e379 = (*s_3).v;
let _e381 = light_3.h;
light_3.v_dot_h = max(dot(_e379, _e381), 0f);
let _e385 = color_1;
let _e388 = color_1[3u];
let _e390 = radiance;
light_3.radiance = ((_e385.xyz * _e388) * _e390);
let _e393 = light_3;
return _e393;
}
let _e394 = direction;
aim = normalize(_e394.xyz);
attenuation_1 = 1f;
let _e397 = type_39;
if (_e397 < 0.5f) {
let _e399 = aim;
light_3.l = -(_e399);
} else {
let _e402 = position;
let _e404 = v_world_position_1;
toLight_1 = (_e402.xyz - _e404);
let _e406 = toLight_1;
distance_3 = length(_e406);
let _e408 = distance_3;
if (_e408 < 0.000001f) {
let _e411 = (*s_3).n;
light_3.l = _e411;
let _e414 = (*s_3).n;
light_3.h = _e414;
light_3.radiance = vec3<f32>(0f, 0f, 0f);
light_3.n_dot_l = 0f;
light_3.n_dot_h = 0f;
light_3.v_dot_h = 0f;
let _e420 = light_3;
return _e420;
}
let _e421 = toLight_1;
let _e422 = distance_3;
light_3.l = (_e421 / vec3(_e422));
let _e426 = distance_3;
param_65 = _e426;
let _e428 = direction[3u];
param_66 = _e428;
let _e429 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_65), (¶m_66));
attenuation_1 = _e429;
let _e430 = type_39;
if (_e430 > 1.5f) {
let _e432 = aim;
let _e434 = light_3.l;
cosAngle = dot(_e432, -(_e434));
let _e437 = cosAngle;
let _e439 = cone[1u];
let _e442 = cone[0u];
let _e444 = cone[1u];
let _e448 = attenuation_1;
attenuation_1 = (_e448 * clamp(((_e437 - _e439) / (_e442 - _e444)), 0f, 1f));
}
}
let _e451 = light_3.l;
let _e453 = (*s_3).v;
light_3.h = normalize((_e451 + _e453));
let _e458 = (*s_3).n;
let _e460 = light_3.l;
light_3.n_dot_l = max(dot(_e458, _e460), 0f);
let _e465 = (*s_3).n;
let _e467 = light_3.h;
light_3.n_dot_h = max(dot(_e465, _e467), 0f);
let _e472 = (*s_3).v;
let _e474 = light_3.h;
light_3.v_dot_h = max(dot(_e472, _e474), 0f);
let _e478 = color_1;
let _e481 = color_1[3u];
let _e483 = attenuation_1;
light_3.radiance = ((_e478.xyz * _e481) * _e483);
let _e486 = light_3;
return _e486;
}
fn LightCount_u0028_() -> i32 {
let _e164 = frag_info.frame_params[1u];
let _e170 = light_list_info.list[0u];
return (clamp(i32((_e164 + 0.5f)), 0i, 8i) + clamp(i32((_e170 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_67: i32;
var param_68: Surface;
var visibility: f32;
var param_69: i32;
var local_10: f32;
var param_70: Surface;
var param_71: LightSample;
var param_72: i32;
var param_73: vec3<f32>;
var param_74: vec3<f32>;
var param_75: i32;
var param_76: Surface;
var param_77: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e180 = LightCount_u0028_();
count_1 = _e180;
i_7 = 0i;
loop {
let _e181 = i_7;
if (_e181 < 32i) {
let _e183 = i_7;
let _e184 = count_1;
if (_e183 >= _e184) {
break;
}
let _e186 = i_7;
param_67 = _e186;
let _e187 = (*s_4);
param_68 = _e187;
let _e188 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_67), (¶m_68));
light_4 = _e188;
let _e190 = light_4.n_dot_l;
if (_e190 <= 0f) {
continue;
}
let _e192 = i_7;
param_69 = _e192;
let _e193 = LightHasShadow_u0028_i1_u003b((¶m_69));
if _e193 {
let _e194 = (*s_4);
param_70 = _e194;
let _e195 = light_4;
param_71 = _e195;
let _e196 = i_7;
param_72 = _e196;
let _e197 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_70), (¶m_71), (¶m_72));
let _e198 = v_world_position_1;
param_73 = _e198;
let _e200 = (*s_4).n;
param_74 = _e200;
let _e201 = i_7;
param_75 = _e201;
let _e202 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_73), (¶m_74), (¶m_75));
local_10 = (_e197 * _e202);
} else {
local_10 = 1f;
}
let _e204 = local_10;
visibility = _e204;
let _e205 = visibility;
if (_e205 <= 0f) {
continue;
}
let _e207 = (*s_4);
param_76 = _e207;
let _e208 = light_4;
param_77 = _e208;
let _e209 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_76), (¶m_77));
let _e211 = light_4.radiance;
let _e214 = light_4.n_dot_l;
let _e216 = visibility;
let _e218 = total_1;
total_1 = (_e218 + (((_e209 * _e211) * _e214) * _e216));
continue;
} else {
break;
}
continuing {
let _e220 = i_7;
i_7 = (_e220 + 1i);
}
}
let _e222 = total_1;
return _e222;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e163 = v_lightmap_uv_1;
let _e164 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e163);
texel_2 = _e164;
let _e165 = texel_2;
let _e168 = texel_2[3u];
return ((_e165.xyz * _e168) * 8f);
}
fn EnvBrdfApprox_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v_1: ptr<function, f32>) -> vec2<f32> {
var r: vec4<f32>;
var a004_: f32;
let _e166 = (*roughness_2);
r = ((vec4<f32>(-1f, -0.0275f, -0.572f, 0.022f) * _e166) + vec4<f32>(1f, 0.0425f, 1.04f, -0.04f));
let _e170 = r[0u];
let _e172 = r[0u];
let _e174 = (*n_dot_v_1);
let _e179 = r[0u];
let _e182 = r[1u];
a004_ = ((min((_e170 * _e172), exp2((-9.28f * _e174))) * _e179) + _e182);
let _e184 = a004_;
let _e186 = r;
return ((vec2<f32>(-1.04f, 1.04f) * _e184) + _e186.zw);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e164 = v_texcoord_1;
let _e165 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e164);
orm = _e165.xyz;
let _e168 = (*s_5).metallic;
let _e170 = orm[2u];
(*s_5).metallic = clamp((_e168 * _e170), 0f, 1f);
let _e175 = (*s_5).roughness;
let _e177 = orm[1u];
(*s_5).roughness = clamp((_e175 * _e177), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e163 = (*srgb);
let _e166 = (*srgb);
let _e171 = (*srgb);
return mix((_e163 / vec3(12.92f)), pow(((_e166 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e171));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_78: vec3<f32>;
let _e165 = v_texcoord_1;
let _e166 = textureSample(emissive_texture_tex, emissive_texture_smp, _e165);
param_78 = _e166.xyz;
let _e168 = SrgbToLinear_u0028_vf3_u003b((¶m_78));
emissive = _e168;
let _e169 = emissive;
let _e171 = frag_info.emissive;
let _e176 = frag_info.material2_[3u];
(*s_6).emissive = ((_e169 * _e171.xyz) * _e176);
return;
}
fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
var occlusion: f32;
let _e164 = v_texcoord_1;
let _e165 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e164);
occlusion = _e165.x;
let _e167 = occlusion;
let _e170 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e167, clamp(_e170, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e167 = v_texcoord_1;
let _e168 = textureSample(normal_texture_tex, normal_texture_smp, _e167);
sampledTexel = _e168;
let _e169 = v_tangent_1;
t_1 = _e169.xyz;
let _e171 = t_1;
let _e173 = (*s_8).n;
let _e175 = (*s_8).n;
let _e176 = t_1;
t_1 = (_e171 - (_e173 * dot(_e175, _e176)));
let _e180 = t_1;
let _e181 = t_1;
if (dot(_e180, _e181) < 0.000000000001f) {
return;
}
let _e184 = t_1;
t_1 = normalize(_e184);
let _e187 = (*s_8).n;
let _e188 = t_1;
let _e191 = v_tangent_1[3u];
b_1 = (cross(_e187, _e188) * _e191);
let _e193 = sampledTexel;
sampled = ((_e193.xyz * 2f) - vec3(1f));
let _e200 = frag_info.material2_[1u];
let _e201 = sampled;
let _e203 = (_e201.xy * _e200);
sampled[0u] = _e203.x;
sampled[1u] = _e203.y;
let _e208 = t_1;
let _e210 = sampled[0u];
let _e212 = b_1;
let _e214 = sampled[1u];
let _e218 = (*s_8).n;
let _e220 = sampled[2u];
(*s_8).n = normalize((((_e208 * _e210) + (_e212 * _e214)) + (_e218 * _e220)));
let _e226 = (*s_8).n;
let _e228 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e226, _e228), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_79: Surface;
var param_80: Surface;
var param_81: Surface;
let _e166 = (*s_9);
param_79 = _e166;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e167 = param_79;
(*s_9) = _e167;
let _e168 = (*s_9);
param_80 = _e168;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_80));
let _e169 = param_80;
(*s_9) = _e169;
let _e170 = (*s_9);
param_81 = _e170;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_81));
let _e171 = param_81;
(*s_9) = _e171;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_82: vec3<f32>;
var param_83: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e169 = v_texcoord_1;
let _e170 = textureSample(base_color_texture_tex, base_color_texture_smp, _e169);
texel_3 = _e170;
let _e171 = texel_3;
param_82 = _e171.xyz;
let _e173 = SrgbToLinear_u0028_vf3_u003b((¶m_82));
let _e175 = frag_info.base_color;
param_83 = _e175.xyz;
let _e177 = SrgbToLinear_u0028_vf3_u003b((¶m_83));
let _e179 = v_color_1;
s_10.albedo = ((_e173 * _e177) * _e179.xyz);
let _e184 = texel_3[3u];
let _e187 = frag_info.base_color[3u];
let _e190 = v_color_1[3u];
s_10.alpha = ((_e184 * _e187) * _e190);
let _e195 = frag_info.material2_[0u];
cutoff = _e195;
let _e196 = cutoff;
if (_e196 >= 0f) {
let _e199 = s_10.alpha;
let _e200 = cutoff;
if (_e199 < _e200) {
discard;
}
} else {
let _e202 = cutoff;
if (_e202 < -1.5f) {
let _e204 = v_world_position_1;
anchored = floor((_e204 * 16f));
let _e207 = anchored;
noise_1 = fract((sin(dot(_e207, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e213 = s_10.alpha;
let _e214 = noise_1;
if (_e213 < _e214) {
discard;
}
}
}
let _e216 = v_normal_1;
s_10.n = normalize(_e216);
let _e220 = frag_info.camera_position;
let _e222 = v_world_position_1;
s_10.v = normalize((_e220.xyz - _e222));
let _e227 = s_10.n;
let _e229 = s_10.v;
s_10.n_dot_v = max(dot(_e227, _e229), 0.0001f);
let _e235 = frag_info.material[0u];
s_10.metallic = clamp(_e235, 0f, 1f);
let _e240 = frag_info.material[1u];
s_10.roughness = clamp(_e240, 0.02f, 1f);
let _e244 = frag_info.ambient_ground;
let _e247 = frag_info.ambient_sky;
let _e251 = s_10.n[1u];
let _e258 = frag_info.material[2u];
s_10.ambient = (mix(_e244.xyz, _e247.xyz, vec3(((_e251 * 0.5f) + 0.5f))) * _e258);
let _e263 = frag_info.frame_params[0u];
s_10.exposure = max(_e263, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e268 = s_10;
return _e268;
}
fn main_1() {
var s_11: Surface;
var param_84: Surface;
var param_85: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var ambient: vec3<f32>;
var levels: f32;
var f0_2: vec3<f32>;
var reflected: vec3<f32>;
var irradiance: vec3<f32>;
var prefiltered: vec3<f32>;
var ab: vec2<f32>;
var param_86: f32;
var param_87: f32;
var param_88: Surface;
var param_89: vec3<f32>;
var param_90: f32;
var param_91: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e180 = ReadSurface_u0028_();
s_11 = _e180;
let _e181 = s_11;
param_84 = _e181;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_84));
let _e182 = param_84;
s_11 = _e182;
let _e183 = s_11;
param_85 = _e183;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_85));
let _e184 = param_85;
s_11 = _e184;
let _e186 = s_11.metallic;
metallic = clamp(_e186, 0f, 1f);
let _e189 = s_11.albedo;
let _e190 = metallic;
diffuseColor_1 = (_e189 * (1f - _e190));
let _e193 = diffuseColor_1;
let _e195 = s_11.ambient;
let _e198 = s_11.occlusion;
ambient = ((_e193 * _e195) * _e198);
let _e202 = frag_info.frame_params[3u];
levels = _e202;
let _e203 = levels;
if (_e203 > 0f) {
let _e206 = s_11.albedo;
let _e207 = metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e206, vec3(_e207));
let _e211 = s_11.v;
let _e214 = s_11.n;
reflected = reflect(-(_e211), _e214);
let _e217 = s_11.n;
let _e218 = levels;
let _e219 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e217, _e218);
irradiance = _e219.xyz;
let _e221 = reflected;
let _e223 = s_11.roughness;
let _e224 = levels;
let _e226 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e221, (_e223 * _e224));
prefiltered = _e226.xyz;
let _e229 = s_11.roughness;
param_86 = _e229;
let _e231 = s_11.n_dot_v;
param_87 = _e231;
let _e232 = EnvBrdfApprox_u0028_f1_u003b_f1_u003b((¶m_86), (¶m_87));
ab = _e232;
let _e233 = diffuseColor_1;
let _e234 = irradiance;
let _e236 = prefiltered;
let _e237 = f0_2;
let _e239 = ab[0u];
let _e242 = ab[1u];
let _e249 = frag_info.material[2u];
let _e252 = s_11.occlusion;
ambient = ((((_e233 * _e234) + (_e236 * ((_e237 * _e239) + vec3(_e242)))) * _e249) * _e252);
}
let _e254 = diffuseColor_1;
let _e255 = SampleLightmap_u0028_();
let _e258 = s_11.occlusion;
let _e260 = ambient;
ambient = (_e260 + ((_e254 * _e255) * _e258));
let _e262 = s_11;
param_88 = _e262;
let _e263 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_88));
let _e265 = s_11.occlusion;
let _e267 = ambient;
let _e270 = s_11.emissive;
param_89 = (((_e263 * _e265) + _e267) + _e270);
let _e273 = s_11.alpha;
param_90 = _e273;
let _e275 = s_11.roughness;
param_91 = _e275;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_89), (¶m_90), (¶m_91));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 24,
samplerBinding: 25,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Toon': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e152 = (*n)[0u];
let _e155 = (*n)[1u];
let _e159 = (*n)[2u];
let _e162 = (*n);
(*n) = (_e162 / vec3(((abs(_e152) + abs(_e155)) + abs(_e159))));
let _e165 = (*n);
e = _e165.xy;
let _e168 = (*n)[2u];
if (_e168 < 0f) {
let _e170 = (*n);
let _e176 = (*n)[0u];
let _e180 = (*n)[1u];
e = ((vec2(1f) - abs(_e170.yx)) * vec2<f32>(select(-1f, 1f, (_e176 >= 0f)), select(-1f, 1f, (_e180 >= 0f))));
}
let _e185 = e;
return ((_e185 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e149 = v_world_position_1;
let _e151 = fog_info.eye;
let _e155 = fog_info.forward;
return dot((_e149 - _e151.xyz), _e155.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e151 = g_debug_surface_on;
if _e151 {
let _e152 = g_debug_surface;
let _e153 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e152.x, _e152.y, _e152.z, _e153);
return;
}
let _e158 = v_normal_1;
param = normalize(_e158);
let _e160 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e161 = (*roughness);
let _e163 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e160.x, _e160.y, clamp(_e161, 0f, 1f), _e163);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e149 = v_world_position_1;
let _e151 = fog_info.eye;
return distance(_e149, _e151.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e154 = fog_info.fog[3u];
density = _e154;
let _e155 = density;
if (_e155 <= 0f) {
let _e157 = (*color);
return _e157;
}
let _e158 = EyeDistance_u0028_();
d = _e158;
let _e160 = fog_info.fog;
let _e162 = (*color);
let _e163 = density;
let _e165 = d;
return mix(_e160.xyz, _e162, vec3(clamp(exp((-(_e163) * _e165)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e154 = (*linearColor);
param_1 = _e154;
let _e155 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e156 = (*alpha);
frag_color = vec4<f32>(_e155.x, _e155.y, _e155.z, _e156);
let _e161 = (*roughness_1);
param_2 = _e161;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var bands: f32;
var quantized: f32;
var fraction: f32;
var ramp: f32;
let _e156 = (*s).roughness;
bands = mix(5f, 2f, _e156);
let _e159 = (*light).n_dot_l;
let _e160 = bands;
let _e163 = bands;
quantized = (floor((_e159 * _e160)) / _e163);
let _e166 = (*light).n_dot_l;
let _e167 = bands;
fraction = fract((_e166 * _e167));
let _e170 = fraction;
let _e172 = bands;
let _e174 = quantized;
quantized = (_e174 + (smoothstep(0.85f, 1f, _e170) / _e172));
let _e176 = quantized;
let _e178 = (*light).n_dot_l;
ramp = (_e176 / max(_e178, 0.001f));
let _e182 = (*s).albedo;
let _e183 = ramp;
return (_e182 * _e183);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e150 = (*i);
if (_e150 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e152 = (*i);
if (_e152 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e154 = (*i);
if (_e154 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e156 = (*i);
if (_e156 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e158 = (*i);
if (_e158 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e160 = (*i);
if (_e160 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e162 = (*i);
if (_e162 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e155 = (*i_1);
param_3 = _e155;
let _e156 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e156;
let _e158 = p[0u];
let _e159 = (*ca);
let _e162 = p[1u];
let _e163 = (*sa);
let _e167 = p[0u];
let _e168 = (*sa);
let _e171 = p[1u];
let _e172 = (*ca);
let _e176 = (*radius);
return (vec2<f32>(((_e158 * _e159) - (_e162 * _e163)), ((_e167 * _e168) + (_e171 * _e172))) * _e176);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e158 = point_shadow.params[0u];
inset = _e158;
let _e159 = (*uv);
let _e160 = (*offset);
let _e162 = inset;
let _e163 = inset;
local = clamp((_e159 + _e160), vec2(_e162), vec2((1f - _e163)));
let _e168 = local;
let _e169 = (*tile);
atlas = ((_e168 + _e169) * vec2<f32>(0.16666667f, 0.16666667f));
let _e174 = point_shadow.params3_[0u];
if (_e174 > 0.5f) {
let _e177 = atlas[1u];
atlas[1u] = (1f - _e177);
}
let _e180 = atlas;
let _e181 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e180, 0f);
let _e183 = atlas;
let _e184 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e183, 0f);
let _e187 = (*range);
return (min(_e181.x, _e184.x) * _e187);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e159 = (*uv_1);
param_4 = _e159;
let _e160 = (*offset_1);
param_5 = _e160;
let _e161 = (*tile_1);
param_6 = _e161;
let _e162 = (*range_1);
param_7 = _e162;
let _e163 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e163;
let _e164 = stored;
let _e165 = (*range_1);
if (_e164 >= (_e165 * 0.999f)) {
return 1f;
}
let _e168 = (*receiver);
let _e169 = stored;
return select(1f, 0f, (_e168 > _e169));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e180 = point_shadow.params2_[1u];
lightRadius = _e180;
let _e183 = point_shadow.params2_[0u];
minRadius = _e183;
let _e186 = point_shadow.params2_[2u];
maxRadius = _e186;
let _e187 = lightRadius;
if (_e187 <= 0f) {
let _e189 = (*uv_2);
param_8 = _e189;
param_9 = vec2<f32>(0f, 0f);
let _e190 = (*tile_2);
param_10 = _e190;
let _e191 = (*range_2);
param_11 = _e191;
let _e192 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e192;
let _e193 = minRadius;
return _e193;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e194 = i_2;
if (_e194 < 8i) {
let _e196 = i_2;
param_12 = _e196;
let _e197 = (*ca_1);
param_13 = _e197;
let _e198 = (*sa_1);
param_14 = _e198;
let _e199 = maxRadius;
param_15 = _e199;
let _e200 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e201 = (*uv_2);
param_16 = _e201;
param_17 = _e200;
let _e202 = (*tile_2);
param_18 = _e202;
let _e203 = (*range_2);
param_19 = _e203;
let _e204 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e204;
let _e205 = stored_1;
let _e206 = (*range_2);
if (_e205 >= (_e206 * 0.999f)) {
continue;
}
let _e209 = stored_1;
let _e210 = (*receiver_1);
if (_e209 >= _e210) {
continue;
}
let _e212 = stored_1;
let _e213 = sum;
sum = (_e213 + _e212);
let _e215 = count;
count = (_e215 + 1f);
continue;
} else {
break;
}
continuing {
let _e217 = i_2;
i_2 = (_e217 + 1i);
}
}
let _e219 = count;
if (_e219 < 0.5f) {
return -1f;
}
let _e221 = sum;
let _e222 = count;
blocker = max((_e221 / _e222), 0.0001f);
let _e225 = blocker;
(*blockerOut) = _e225;
let _e226 = lightRadius;
let _e227 = (*receiver_1);
let _e228 = blocker;
let _e232 = blocker;
world = ((_e226 * max((_e227 - _e228), 0f)) / _e232);
let _e234 = world;
let _e235 = (*receiver_1);
let _e237 = (*tanHalf);
let _e240 = minRadius;
let _e241 = maxRadius;
return clamp((_e234 / ((2f * _e235) * _e237)), _e240, _e241);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1526_: bool;
var phi_1588_: bool;
let _e202 = (*lightIndex);
let _e206 = point_shadow.slots[_e202][0u];
slot = i32((_e206 + 0.5f));
let _e209 = (*lightIndex);
let _e213 = point_shadow.slots[_e209][0u];
if (_e213 < 0f) {
return 1f;
}
let _e217 = point_shadow.params[2u];
strength = _e217;
let _e218 = strength;
if (_e218 <= 0f) {
return 1f;
}
let _e220 = slot;
let _e223 = point_shadow.lights[_e220];
let _e225 = (*world_1);
toLight = (_e223.xyz - _e225);
let _e227 = toLight;
toLightLength = max(length(_e227), 0.000001f);
let _e230 = (*normal);
let _e231 = toLight;
let _e232 = toLightLength;
nDotL = max(dot(_e230, (_e231 / vec3(_e232))), 0.15f);
let _e237 = nDotL;
let _e238 = nDotL;
let _e243 = nDotL;
let _e244 = nDotL;
slope = min((sqrt(max((1f - (_e237 * _e238)), 0f)) / (_e243 * _e244)), 8f);
let _e248 = toLightLength;
let _e250 = (*lightIndex);
let _e254 = point_shadow.slots[_e250][2u];
let _e259 = point_shadow.params3_[1u];
texel = (((2f * _e248) * max(_e254, 0.0001f)) * _e259);
let _e261 = (*world_1);
let _e262 = (*normal);
let _e263 = texel;
let _e267 = point_shadow.params[3u];
let _e269 = slope;
origin = (_e261 + (((_e262 * _e263) * _e267) * (1f + _e269)));
let _e273 = origin;
let _e274 = slot;
let _e277 = point_shadow.lights[_e274];
toFragment = (_e273 - _e277.xyz);
let _e280 = toFragment;
distance_ = length(_e280);
let _e282 = slot;
let _e286 = point_shadow.lights[_e282][3u];
range_3 = max(_e286, 0.0001f);
let _e288 = distance_;
let _e289 = range_3;
if (_e288 >= _e289) {
return 1f;
}
face = 0i;
let _e291 = (*lightIndex);
let _e295 = point_shadow.slots[_e291][1u];
if (_e295 < 0.5f) {
let _e297 = toFragment;
a = abs(_e297);
let _e300 = a[0u];
let _e302 = a[1u];
let _e303 = (_e300 >= _e302);
phi_1526_ = _e303;
if _e303 {
let _e305 = a[0u];
let _e307 = a[2u];
phi_1526_ = (_e305 >= _e307);
}
let _e310 = phi_1526_;
if _e310 {
let _e312 = toFragment[0u];
face = select(1i, 0i, (_e312 > 0f));
} else {
let _e316 = a[1u];
let _e318 = a[2u];
if (_e316 >= _e318) {
let _e321 = toFragment[1u];
face = select(3i, 2i, (_e321 > 0f));
} else {
let _e325 = toFragment[2u];
face = select(5i, 4i, (_e325 > 0f));
}
}
}
let _e328 = slot;
let _e330 = face;
let _e334 = point_shadow.faces[((_e328 * 6i) + _e330)];
let _e335 = origin;
clip = (_e334 * vec4<f32>(_e335.x, _e335.y, _e335.z, 1f));
let _e342 = clip[3u];
if (_e342 <= 0f) {
return 1f;
}
let _e344 = clip;
let _e347 = clip[3u];
ndc = (_e344.xy / vec2(_e347));
let _e351 = ndc[0u];
let _e353 = (abs(_e351) > 1f);
phi_1588_ = _e353;
if !(_e353) {
let _e356 = ndc[1u];
phi_1588_ = (abs(_e356) > 1f);
}
let _e360 = phi_1588_;
if _e360 {
return 1f;
}
let _e362 = ndc[0u];
let _e366 = ndc[1u];
uv_3 = vec2<f32>(((_e362 * 0.5f) + 0.5f), (0.5f - (_e366 * 0.5f)));
let _e370 = face;
let _e372 = slot;
tile_3 = vec2<f32>(f32(_e370), f32(_e372));
let _e375 = distance_;
let _e378 = point_shadow.params[1u];
receiver_2 = (_e375 - _e378);
let _e380 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e380.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e386 = noise;
angle = (_e386 * 6.2831855f);
let _e388 = angle;
ca_2 = cos(_e388);
let _e390 = angle;
sa_2 = sin(_e390);
let _e392 = (*lightIndex);
let _e396 = point_shadow.slots[_e392][2u];
tanHalf_1 = max(_e396, 0.0001f);
blocker_1 = -1f;
let _e398 = uv_3;
param_20 = _e398;
let _e399 = tile_3;
param_21 = _e399;
let _e400 = range_3;
param_22 = _e400;
let _e401 = receiver_2;
param_23 = _e401;
let _e402 = ca_2;
param_24 = _e402;
let _e403 = sa_2;
param_25 = _e403;
let _e404 = tanHalf_1;
param_26 = _e404;
let _e405 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e406 = param_27;
blocker_1 = _e406;
radius_1 = _e405;
let _e409 = point_shadow.params2_[3u];
if (_e409 > 0.5f) {
g_debug_surface_on = true;
let _e411 = radius_1;
if (_e411 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e413 = radius_1;
let _e416 = point_shadow.params2_[2u];
let _e420 = blocker_1;
let _e421 = range_3;
local_1 = vec3<f32>(clamp((_e413 / max(_e416, 0.000001f)), 0f, 1f), clamp((_e420 / _e421), 0f, 1f), 0f);
}
let _e425 = local_1;
g_debug_surface = _e425;
}
let _e426 = radius_1;
if (_e426 < 0f) {
return 1f;
}
let _e428 = uv_3;
param_28 = _e428;
param_29 = vec2<f32>(0f, 0f);
let _e429 = tile_3;
param_30 = _e429;
let _e430 = range_3;
param_31 = _e430;
let _e431 = receiver_2;
param_32 = _e431;
let _e432 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e432;
let _e433 = radius_1;
if (_e433 > 0f) {
i_3 = 0i;
loop {
let _e435 = i_3;
if (_e435 < 8i) {
let _e437 = i_3;
param_33 = _e437;
let _e438 = ca_2;
param_34 = _e438;
let _e439 = sa_2;
param_35 = _e439;
let _e440 = radius_1;
param_36 = _e440;
let _e441 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e442 = uv_3;
param_37 = _e442;
param_38 = _e441;
let _e443 = tile_3;
param_39 = _e443;
let _e444 = range_3;
param_40 = _e444;
let _e445 = receiver_2;
param_41 = _e445;
let _e446 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e447 = lit;
lit = (_e447 + _e446);
continue;
} else {
break;
}
continuing {
let _e449 = i_3;
i_3 = (_e449 + 1i);
}
}
let _e451 = lit;
lit = (_e451 * 0.11111111f);
}
let _e453 = lit;
let _e454 = strength;
return mix(1f, _e453, clamp(_e454, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2035_: bool;
var phi_2046_: bool;
var phi_2136_: bool;
var phi_2143_: bool;
var phi_2150_: bool;
let _e188 = frag_info.shadow_params[3u];
strength_1 = _e188;
let _e189 = strength_1;
if (_e189 <= 0f) {
return 1f;
}
let _e191 = (*lightIndex_1);
let _e194 = frag_info.frame_params[2u];
if (_e191 != i32((_e194 + 0.5f))) {
return 1f;
}
let _e198 = v_world_position_1;
let _e200 = (*s_1).n;
let _e203 = frag_info.shadow_params[2u];
origin_1 = (_e198 + (_e200 * _e203));
let _e208 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e208 + 0.5f));
let _e211 = v_world_position_1;
let _e213 = frag_info.camera_position;
viewDistance = length((_e211 - _e213.xyz));
cascade = 0i;
let _e217 = cascadeCount;
let _e218 = (_e217 > 1i);
phi_2035_ = _e218;
if _e218 {
let _e219 = viewDistance;
let _e222 = frag_info.shadow_cascades[0u];
phi_2035_ = (_e219 > _e222);
}
let _e225 = phi_2035_;
if _e225 {
cascade = 1i;
}
let _e226 = cascadeCount;
let _e227 = (_e226 > 2i);
phi_2046_ = _e227;
if _e227 {
let _e228 = viewDistance;
let _e231 = frag_info.shadow_cascades[1u];
phi_2046_ = (_e228 > _e231);
}
let _e234 = phi_2046_;
if _e234 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e235 = attempt;
if (_e235 < 3i) {
let _e237 = cascade;
let _e238 = attempt;
which = (_e237 + _e238);
let _e240 = which;
let _e241 = cascadeCount;
if (_e240 >= _e241) {
break;
}
let _e243 = which;
if (_e243 == 0i) {
let _e246 = frag_info.shadow_matrix;
local_2 = _e246;
} else {
let _e247 = which;
if (_e247 == 1i) {
let _e250 = frag_info.shadow_matrix_far;
local_3 = _e250;
} else {
let _e252 = frag_info.shadow_matrix_farthest;
local_3 = _e252;
}
let _e253 = local_3;
local_2 = _e253;
}
let _e254 = local_2;
matrix = _e254;
let _e255 = matrix;
let _e256 = origin_1;
lightSpace = (_e255 * vec4<f32>(_e256.x, _e256.y, _e256.z, 1f));
let _e263 = lightSpace[3u];
if (_e263 <= 0f) {
continue;
}
let _e265 = lightSpace;
let _e268 = lightSpace[3u];
candidate = (_e265.xyz / vec3(_e268));
let _e272 = candidate[0u];
let _e276 = candidate[1u];
inTile = vec2<f32>(((_e272 * 0.5f) + 0.5f), (0.5f - (_e276 * 0.5f)));
let _e281 = inTile[0u];
let _e282 = (_e281 < 0f);
phi_2136_ = _e282;
if !(_e282) {
let _e285 = inTile[0u];
phi_2136_ = (_e285 > 1f);
}
let _e288 = phi_2136_;
phi_2143_ = _e288;
if !(_e288) {
let _e291 = inTile[1u];
phi_2143_ = (_e291 < 0f);
}
let _e294 = phi_2143_;
phi_2150_ = _e294;
if !(_e294) {
let _e297 = inTile[1u];
phi_2150_ = (_e297 > 1f);
}
let _e300 = phi_2150_;
if _e300 {
continue;
}
let _e302 = candidate[2u];
if (_e302 > 1f) {
continue;
}
let _e305 = inTile[0u];
let _e306 = which;
let _e309 = cascadeCount;
let _e313 = inTile[1u];
uv_4 = vec2<f32>(((_e305 + f32(_e306)) / f32(_e309)), _e313);
let _e315 = candidate;
projected = _e315;
let _e316 = which;
cascade = _e316;
found = true;
break;
} else {
break;
}
continuing {
let _e317 = attempt;
attempt = (_e317 + 1i);
}
}
let _e319 = found;
if !(_e319) {
return 1f;
}
let _e323 = frag_info.shadow_params[1u];
bias = _e323;
let _e326 = frag_info.shadow_params[0u];
let _e329 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e326, _e329);
let _e333 = frag_info.ambient_ground[3u];
softness = _e333;
lit_1 = 0f;
let _e334 = softness;
if (_e334 <= 0f) {
y = -1i;
loop {
let _e336 = y;
if (_e336 <= 1i) {
x = -1i;
loop {
let _e338 = x;
if (_e338 <= 1i) {
let _e340 = uv_4;
let _e341 = x;
let _e343 = y;
let _e346 = texel_1;
let _e349 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e340 + (vec2<f32>(f32(_e341), f32(_e343)) * _e346)), 0f);
occluder = _e349.x;
let _e352 = projected[2u];
let _e353 = bias;
let _e355 = occluder;
let _e358 = lit_1;
lit_1 = (_e358 + select(1f, 0f, ((_e352 - _e353) > _e355)));
continue;
} else {
break;
}
continuing {
let _e360 = x;
x = (_e360 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e362 = y;
y = (_e362 + 1i);
}
}
let _e364 = lit_1;
lit_1 = (_e364 * 0.11111111f);
} else {
let _e366 = softness;
searchRadius = clamp((_e366 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e369 = i_4;
if (_e369 < 5i) {
let _e371 = uv_4;
let _e372 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e374 = indexable[_e372];
let _e375 = texel_1;
let _e377 = searchRadius;
let _e380 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e371 + ((_e374 * _e375) * _e377)), 0f);
occluder_1 = _e380.x;
let _e383 = projected[2u];
let _e384 = bias;
let _e386 = occluder_1;
if ((_e383 - _e384) > _e386) {
let _e388 = occluder_1;
let _e389 = blockerSum;
blockerSum = (_e389 + _e388);
let _e391 = blockerCount;
blockerCount = (_e391 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e393 = i_4;
i_4 = (_e393 + 1i);
}
}
let _e395 = blockerCount;
if (_e395 <= 0f) {
return 1f;
}
let _e398 = projected[2u];
let _e399 = blockerSum;
let _e400 = blockerCount;
gap = max((_e398 - (_e399 / _e400)), 0f);
let _e404 = gap;
let _e405 = softness;
radius_2 = clamp((_e404 * _e405), 1f, 16f);
i_5 = 0i;
loop {
let _e408 = i_5;
if (_e408 < 5i) {
let _e410 = uv_4;
let _e411 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e413 = indexable_1[_e411];
let _e414 = texel_1;
let _e416 = radius_2;
let _e419 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e410 + ((_e413 * _e414) * _e416)), 0f);
occluder_2 = _e419.x;
let _e422 = projected[2u];
let _e423 = bias;
let _e425 = occluder_2;
let _e428 = lit_1;
lit_1 = (_e428 + select(1f, 0f, ((_e422 - _e423) > _e425)));
continue;
} else {
break;
}
continuing {
let _e430 = i_5;
i_5 = (_e430 + 1i);
}
}
let _e432 = lit_1;
lit_1 = (_e432 * 0.2f);
}
let _e434 = lit_1;
let _e435 = strength_1;
return mix(1f, _e434, clamp(_e435, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e155 = (*s_2);
param_42 = _e155;
let _e156 = (*light_2);
param_43 = _e156;
let _e157 = (*index);
param_44 = _e157;
let _e158 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e158;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e150 = (*index_1);
return (_e150 < 8i);
}
fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
var attenuation: f32;
var ratio: f32;
var window: f32;
let _e154 = (*distance_1);
let _e155 = (*distance_1);
attenuation = (1f / max((_e154 * _e155), 0.0001f));
let _e159 = (*range_4);
if (_e159 > 0f) {
let _e161 = (*distance_1);
let _e162 = (*range_4);
ratio = (_e161 / _e162);
let _e164 = ratio;
let _e165 = ratio;
let _e167 = ratio;
let _e169 = ratio;
window = clamp((1f - (((_e164 * _e165) * _e167) * _e169)), 0f, 1f);
let _e173 = window;
let _e174 = window;
let _e176 = attenuation;
attenuation = (_e176 * (_e173 * _e174));
}
let _e178 = attenuation;
return _e178;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e166 = (*halfWidth);
let _e167 = (*halfHeight);
n_1 = cross(_e166, _e167);
let _e169 = n_1;
nLen = length(_e169);
let _e171 = nLen;
if (_e171 < 0.000000000001f) {
let _e173 = (*centre);
return _e173;
}
let _e174 = nLen;
let _e175 = n_1;
n_1 = (_e175 / vec3(_e174));
let _e178 = (*centre);
let _e179 = (*world_2);
toPlane = (_e178 - _e179);
let _e181 = (*mirror);
let _e182 = n_1;
denom = dot(_e181, _e182);
let _e184 = denom;
if (abs(_e184) < 0.00001f) {
let _e187 = toPlane;
let _e188 = n_1;
let _e189 = toPlane;
let _e190 = n_1;
onPlane = (_e187 - (_e188 * dot(_e189, _e190)));
} else {
let _e194 = toPlane;
let _e195 = n_1;
let _e197 = denom;
t = (dot(_e194, _e195) / _e197);
let _e199 = t;
if (_e199 > 0f) {
let _e201 = (*mirror);
let _e202 = t;
local_4 = (_e201 * _e202);
} else {
let _e204 = toPlane;
let _e205 = n_1;
let _e206 = toPlane;
let _e207 = n_1;
local_4 = (_e204 - (_e205 * dot(_e206, _e207)));
}
let _e211 = local_4;
onPlane = _e211;
}
let _e212 = onPlane;
let _e213 = toPlane;
offset_2 = (_e212 - _e213);
let _e215 = (*halfWidth);
let _e216 = (*halfWidth);
wLen2_ = max(dot(_e215, _e216), 0.000000000001f);
let _e219 = (*halfHeight);
let _e220 = (*halfHeight);
hLen2_ = max(dot(_e219, _e220), 0.000000000001f);
let _e223 = offset_2;
let _e224 = (*halfWidth);
let _e226 = wLen2_;
u = clamp((dot(_e223, _e224) / _e226), -1f, 1f);
let _e229 = offset_2;
let _e230 = (*halfHeight);
let _e232 = hLen2_;
v = clamp((dot(_e229, _e230) / _e232), -1f, 1f);
let _e235 = (*centre);
let _e236 = (*halfWidth);
let _e237 = u;
let _e240 = (*halfHeight);
let _e241 = v;
return ((_e235 + (_e236 * _e237)) + (_e240 * _e241));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e158 = i_6;
if (_e158 < 4i) {
let _e160 = i_6;
let _e162 = (*corners)[_e160];
a_1 = normalize(_e162);
let _e164 = i_6;
let _e168 = (*corners)[((_e164 + 1i) & 3i)];
b = normalize(_e168);
let _e170 = a_1;
let _e171 = b;
angle_1 = acos(clamp(dot(_e170, _e171), -1f, 1f));
let _e175 = a_1;
let _e176 = b;
axis = cross(_e175, _e176);
let _e178 = axis;
len = length(_e178);
let _e180 = len;
if (_e180 > 0.000001f) {
let _e182 = angle_1;
let _e183 = axis;
let _e184 = len;
let _e187 = (*n_2);
let _e190 = total;
total = (_e190 + (_e182 * dot((_e183 / vec3(_e184)), _e187)));
}
continue;
} else {
break;
}
continuing {
let _e192 = i_6;
i_6 = (_e192 + 1i);
}
}
let _e194 = total;
return max((-(_e194) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e155 = (*slot_1);
let _e156 = (*slot_1);
lane = (_e155 - ((_e156 / 4i) * 4i));
let _e160 = lane;
if (_e160 == 0i) {
let _e163 = (*four)[0u];
local_5 = _e163;
} else {
let _e164 = lane;
if (_e164 == 1i) {
let _e167 = (*four)[1u];
local_6 = _e167;
} else {
let _e168 = lane;
if (_e168 == 2i) {
let _e171 = (*four)[2u];
local_7 = _e171;
} else {
let _e173 = (*four)[3u];
local_7 = _e173;
}
let _e174 = local_7;
local_6 = _e174;
}
let _e175 = local_6;
local_5 = _e175;
}
let _e176 = local_5;
return _e176;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e152 = (*slot_2);
let _e156 = light_list_info.scales[(_e152 / 4i)];
param_45 = _e156;
let _e157 = (*slot_2);
param_46 = _e157;
let _e158 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e158;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e152 = (*slot_3);
let _e156 = light_list_info.indices[(_e152 / 4i)];
param_47 = _e156;
let _e157 = (*slot_3);
param_48 = _e157;
let _e158 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e158;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e192 = (*index_2);
if (_e192 < 8i) {
let _e194 = (*index_2);
let _e197 = frag_info.light_position[_e194];
position = _e197;
let _e198 = (*index_2);
let _e201 = frag_info.light_color[_e198];
color_1 = _e201;
let _e202 = (*index_2);
let _e205 = frag_info.light_direction[_e202];
direction = _e205;
let _e206 = (*index_2);
let _e209 = frag_info.light_cone[_e206];
cone = _e209;
} else {
let _e210 = (*index_2);
slot_4 = (_e210 - 8i);
let _e212 = slot_4;
param_49 = _e212;
let _e213 = LightListRow_u0028_i1_u003b((¶m_49));
let _e217 = light_list_info.list[2u];
v_1 = ((_e213 + 0.5f) * _e217);
let _e221 = light_list_info.list[1u];
u_1 = _e221;
let _e222 = u_1;
let _e224 = v_1;
let _e226 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e222), _e224), 0f);
position = _e226;
let _e227 = u_1;
let _e229 = v_1;
let _e231 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e227), _e229), 0f);
color_1 = _e231;
let _e232 = u_1;
let _e234 = v_1;
let _e236 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e232), _e234), 0f);
direction = _e236;
let _e237 = u_1;
let _e239 = v_1;
let _e241 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e237), _e239), 0f);
cone = _e241;
let _e242 = slot_4;
param_50 = _e242;
let _e243 = LightListScale_u0028_i1_u003b((¶m_50));
let _e245 = color_1[3u];
color_1[3u] = (_e245 * _e243);
}
let _e249 = position[3u];
type_38 = _e249;
let _e250 = type_38;
if (_e250 > 2.5f) {
let _e252 = direction;
halfWidth_1 = _e252.xyz;
let _e254 = cone;
halfHeight_1 = _e254.xyz;
let _e256 = position;
let _e258 = v_world_position_1;
toCentre = (_e256.xyz - _e258);
let _e260 = toCentre;
let _e261 = halfWidth_1;
let _e263 = halfHeight_1;
corners_1[0i] = ((_e260 - _e261) - _e263);
let _e266 = toCentre;
let _e267 = halfWidth_1;
let _e269 = halfHeight_1;
corners_1[1i] = ((_e266 + _e267) - _e269);
let _e272 = toCentre;
let _e273 = halfWidth_1;
let _e275 = halfHeight_1;
corners_1[2i] = ((_e272 + _e273) + _e275);
let _e278 = toCentre;
let _e279 = halfWidth_1;
let _e281 = halfHeight_1;
corners_1[3i] = ((_e278 - _e279) + _e281);
let _e284 = corners_1;
param_51 = _e284;
let _e286 = (*s_3).n;
param_52 = _e286;
let _e287 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e287;
let _e288 = halfWidth_1;
let _e289 = halfHeight_1;
area = (length(cross(_e288, _e289)) * 4f);
let _e293 = area;
if (_e293 > 0.000000001f) {
let _e295 = area;
local_8 = (1f / _e295);
} else {
local_8 = 0f;
}
let _e297 = local_8;
radiance = _e297;
let _e298 = toCentre;
distance_2 = length(_e298);
let _e301 = direction[3u];
if (_e301 > 0f) {
let _e303 = distance_2;
let _e305 = direction[3u];
ratio_1 = (_e303 / _e305);
let _e307 = ratio_1;
let _e308 = ratio_1;
let _e310 = ratio_1;
let _e312 = ratio_1;
window_1 = clamp((1f - (((_e307 * _e308) * _e310) * _e312)), 0f, 1f);
let _e316 = window_1;
let _e317 = window_1;
let _e319 = radiance;
radiance = (_e319 * (_e316 * _e317));
}
let _e322 = (*s_3).v;
let _e325 = (*s_3).n;
mirror_1 = reflect(-(_e322), _e325);
let _e327 = position;
param_53 = _e327.xyz;
let _e329 = halfWidth_1;
param_54 = _e329;
let _e330 = halfHeight_1;
param_55 = _e330;
let _e331 = v_world_position_1;
param_56 = _e331;
let _e332 = mirror_1;
param_57 = _e332;
let _e333 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e333;
let _e334 = representative;
let _e335 = v_world_position_1;
toPoint = (_e334 - _e335);
let _e337 = toPoint;
pointDistance = length(_e337);
let _e339 = pointDistance;
if (_e339 > 0.000001f) {
let _e341 = toPoint;
let _e342 = pointDistance;
local_9 = (_e341 / vec3(_e342));
} else {
let _e346 = (*s_3).n;
local_9 = _e346;
}
let _e347 = local_9;
light_3.l = _e347;
let _e350 = light_3.l;
let _e352 = (*s_3).v;
light_3.h = normalize((_e350 + _e352));
let _e356 = formFactor;
light_3.n_dot_l = _e356;
let _e359 = (*s_3).n;
let _e361 = light_3.h;
light_3.n_dot_h = max(dot(_e359, _e361), 0f);
let _e366 = (*s_3).v;
let _e368 = light_3.h;
light_3.v_dot_h = max(dot(_e366, _e368), 0f);
let _e372 = color_1;
let _e375 = color_1[3u];
let _e377 = radiance;
light_3.radiance = ((_e372.xyz * _e375) * _e377);
let _e380 = light_3;
return _e380;
}
let _e381 = direction;
aim = normalize(_e381.xyz);
attenuation_1 = 1f;
let _e384 = type_38;
if (_e384 < 0.5f) {
let _e386 = aim;
light_3.l = -(_e386);
} else {
let _e389 = position;
let _e391 = v_world_position_1;
toLight_1 = (_e389.xyz - _e391);
let _e393 = toLight_1;
distance_3 = length(_e393);
let _e395 = distance_3;
if (_e395 < 0.000001f) {
let _e398 = (*s_3).n;
light_3.l = _e398;
let _e401 = (*s_3).n;
light_3.h = _e401;
light_3.radiance = vec3<f32>(0f, 0f, 0f);
light_3.n_dot_l = 0f;
light_3.n_dot_h = 0f;
light_3.v_dot_h = 0f;
let _e407 = light_3;
return _e407;
}
let _e408 = toLight_1;
let _e409 = distance_3;
light_3.l = (_e408 / vec3(_e409));
let _e413 = distance_3;
param_58 = _e413;
let _e415 = direction[3u];
param_59 = _e415;
let _e416 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e416;
let _e417 = type_38;
if (_e417 > 1.5f) {
let _e419 = aim;
let _e421 = light_3.l;
cosAngle = dot(_e419, -(_e421));
let _e424 = cosAngle;
let _e426 = cone[1u];
let _e429 = cone[0u];
let _e431 = cone[1u];
let _e435 = attenuation_1;
attenuation_1 = (_e435 * clamp(((_e424 - _e426) / (_e429 - _e431)), 0f, 1f));
}
}
let _e438 = light_3.l;
let _e440 = (*s_3).v;
light_3.h = normalize((_e438 + _e440));
let _e445 = (*s_3).n;
let _e447 = light_3.l;
light_3.n_dot_l = max(dot(_e445, _e447), 0f);
let _e452 = (*s_3).n;
let _e454 = light_3.h;
light_3.n_dot_h = max(dot(_e452, _e454), 0f);
let _e459 = (*s_3).v;
let _e461 = light_3.h;
light_3.v_dot_h = max(dot(_e459, _e461), 0f);
let _e465 = color_1;
let _e468 = color_1[3u];
let _e470 = attenuation_1;
light_3.radiance = ((_e465.xyz * _e468) * _e470);
let _e473 = light_3;
return _e473;
}
fn LightCount_u0028_() -> i32 {
let _e151 = frag_info.frame_params[1u];
let _e157 = light_list_info.list[0u];
return (clamp(i32((_e151 + 0.5f)), 0i, 8i) + clamp(i32((_e157 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e167 = LightCount_u0028_();
count_1 = _e167;
i_7 = 0i;
loop {
let _e168 = i_7;
if (_e168 < 32i) {
let _e170 = i_7;
let _e171 = count_1;
if (_e170 >= _e171) {
break;
}
let _e173 = i_7;
param_60 = _e173;
let _e174 = (*s_4);
param_61 = _e174;
let _e175 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e175;
let _e177 = light_4.n_dot_l;
if (_e177 <= 0f) {
continue;
}
let _e179 = i_7;
param_62 = _e179;
let _e180 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e180 {
let _e181 = (*s_4);
param_63 = _e181;
let _e182 = light_4;
param_64 = _e182;
let _e183 = i_7;
param_65 = _e183;
let _e184 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e185 = v_world_position_1;
param_66 = _e185;
let _e187 = (*s_4).n;
param_67 = _e187;
let _e188 = i_7;
param_68 = _e188;
let _e189 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e184 * _e189);
} else {
local_10 = 1f;
}
let _e191 = local_10;
visibility = _e191;
let _e192 = visibility;
if (_e192 <= 0f) {
continue;
}
let _e194 = (*s_4);
param_69 = _e194;
let _e195 = light_4;
param_70 = _e195;
let _e196 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e198 = light_4.radiance;
let _e201 = light_4.n_dot_l;
let _e203 = visibility;
let _e205 = total_1;
total_1 = (_e205 + (((_e196 * _e198) * _e201) * _e203));
continue;
} else {
break;
}
continuing {
let _e207 = i_7;
i_7 = (_e207 + 1i);
}
}
let _e209 = total_1;
return _e209;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e150 = v_lightmap_uv_1;
let _e151 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e150);
texel_2 = _e151;
let _e152 = texel_2;
let _e155 = texel_2[3u];
return ((_e152.xyz * _e155) * 8f);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e151 = v_texcoord_1;
let _e152 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e151);
orm = _e152.xyz;
let _e155 = (*s_5).metallic;
let _e157 = orm[2u];
(*s_5).metallic = clamp((_e155 * _e157), 0f, 1f);
let _e162 = (*s_5).roughness;
let _e164 = orm[1u];
(*s_5).roughness = clamp((_e162 * _e164), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e150 = (*srgb);
let _e153 = (*srgb);
let _e158 = (*srgb);
return mix((_e150 / vec3(12.92f)), pow(((_e153 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e158));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e152 = v_texcoord_1;
let _e153 = textureSample(emissive_texture_tex, emissive_texture_smp, _e152);
param_71 = _e153.xyz;
let _e155 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e155;
let _e156 = emissive;
let _e158 = frag_info.emissive;
let _e163 = frag_info.material2_[3u];
(*s_6).emissive = ((_e156 * _e158.xyz) * _e163);
return;
}
fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
var occlusion: f32;
let _e151 = v_texcoord_1;
let _e152 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e151);
occlusion = _e152.x;
let _e154 = occlusion;
let _e157 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e154, clamp(_e157, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e154 = v_texcoord_1;
let _e155 = textureSample(normal_texture_tex, normal_texture_smp, _e154);
sampledTexel = _e155;
let _e156 = v_tangent_1;
t_1 = _e156.xyz;
let _e158 = t_1;
let _e160 = (*s_8).n;
let _e162 = (*s_8).n;
let _e163 = t_1;
t_1 = (_e158 - (_e160 * dot(_e162, _e163)));
let _e167 = t_1;
let _e168 = t_1;
if (dot(_e167, _e168) < 0.000000000001f) {
return;
}
let _e171 = t_1;
t_1 = normalize(_e171);
let _e174 = (*s_8).n;
let _e175 = t_1;
let _e178 = v_tangent_1[3u];
b_1 = (cross(_e174, _e175) * _e178);
let _e180 = sampledTexel;
sampled = ((_e180.xyz * 2f) - vec3(1f));
let _e187 = frag_info.material2_[1u];
let _e188 = sampled;
let _e190 = (_e188.xy * _e187);
sampled[0u] = _e190.x;
sampled[1u] = _e190.y;
let _e195 = t_1;
let _e197 = sampled[0u];
let _e199 = b_1;
let _e201 = sampled[1u];
let _e205 = (*s_8).n;
let _e207 = sampled[2u];
(*s_8).n = normalize((((_e195 * _e197) + (_e199 * _e201)) + (_e205 * _e207)));
let _e213 = (*s_8).n;
let _e215 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e213, _e215), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e153 = (*s_9);
param_72 = _e153;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e154 = param_72;
(*s_9) = _e154;
let _e155 = (*s_9);
param_73 = _e155;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e156 = param_73;
(*s_9) = _e156;
let _e157 = (*s_9);
param_74 = _e157;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e158 = param_74;
(*s_9) = _e158;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e156 = v_texcoord_1;
let _e157 = textureSample(base_color_texture_tex, base_color_texture_smp, _e156);
texel_3 = _e157;
let _e158 = texel_3;
param_75 = _e158.xyz;
let _e160 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e162 = frag_info.base_color;
param_76 = _e162.xyz;
let _e164 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e166 = v_color_1;
s_10.albedo = ((_e160 * _e164) * _e166.xyz);
let _e171 = texel_3[3u];
let _e174 = frag_info.base_color[3u];
let _e177 = v_color_1[3u];
s_10.alpha = ((_e171 * _e174) * _e177);
let _e182 = frag_info.material2_[0u];
cutoff = _e182;
let _e183 = cutoff;
if (_e183 >= 0f) {
let _e186 = s_10.alpha;
let _e187 = cutoff;
if (_e186 < _e187) {
discard;
}
} else {
let _e189 = cutoff;
if (_e189 < -1.5f) {
let _e191 = v_world_position_1;
anchored = floor((_e191 * 16f));
let _e194 = anchored;
noise_1 = fract((sin(dot(_e194, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e200 = s_10.alpha;
let _e201 = noise_1;
if (_e200 < _e201) {
discard;
}
}
}
let _e203 = v_normal_1;
s_10.n = normalize(_e203);
let _e207 = frag_info.camera_position;
let _e209 = v_world_position_1;
s_10.v = normalize((_e207.xyz - _e209));
let _e214 = s_10.n;
let _e216 = s_10.v;
s_10.n_dot_v = max(dot(_e214, _e216), 0.0001f);
let _e222 = frag_info.material[0u];
s_10.metallic = clamp(_e222, 0f, 1f);
let _e227 = frag_info.material[1u];
s_10.roughness = clamp(_e227, 0.02f, 1f);
let _e231 = frag_info.ambient_ground;
let _e234 = frag_info.ambient_sky;
let _e238 = s_10.n[1u];
let _e245 = frag_info.material[2u];
s_10.ambient = (mix(_e231.xyz, _e234.xyz, vec3(((_e238 * 0.5f) + 0.5f))) * _e245);
let _e250 = frag_info.frame_params[0u];
s_10.exposure = max(_e250, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e255 = s_10;
return _e255;
}
fn main_1() {
var s_11: Surface;
var param_77: Surface;
var param_78: Surface;
var rim: f32;
var ambient: vec3<f32>;
var param_79: Surface;
var param_80: vec3<f32>;
var param_81: f32;
var param_82: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e158 = ReadSurface_u0028_();
s_11 = _e158;
let _e159 = s_11;
param_77 = _e159;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e160 = param_77;
s_11 = _e160;
let _e161 = s_11;
param_78 = _e161;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e162 = param_78;
s_11 = _e162;
let _e164 = s_11.n_dot_v;
let _e169 = frag_info.material[3u];
rim = (pow((1f - _e164), 3f) * _e169);
let _e172 = s_11.albedo;
let _e174 = s_11.ambient;
let _e175 = SampleLightmap_u0028_();
let _e179 = s_11.occlusion;
ambient = ((_e172 * (_e174 + _e175)) * _e179);
let _e181 = s_11;
param_79 = _e181;
let _e182 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e184 = s_11.occlusion;
let _e186 = ambient;
let _e188 = rim;
let _e193 = s_11.emissive;
param_80 = ((((_e182 * _e184) + _e186) + vec3((_e188 * 0.35f))) + _e193);
let _e196 = s_11.alpha;
param_81 = _e196;
let _e198 = s_11.roughness;
param_82 = _e198;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_80), (¶m_81), (¶m_82));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Normals': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e35 = (*n)[0u];
let _e38 = (*n)[1u];
let _e42 = (*n)[2u];
let _e45 = (*n);
(*n) = (_e45 / vec3(((abs(_e35) + abs(_e38)) + abs(_e42))));
let _e48 = (*n);
e = _e48.xy;
let _e51 = (*n)[2u];
if (_e51 < 0f) {
let _e53 = (*n);
let _e59 = (*n)[0u];
let _e63 = (*n)[1u];
e = ((vec2(1f) - abs(_e53.yx)) * vec2<f32>(select(-1f, 1f, (_e59 >= 0f)), select(-1f, 1f, (_e63 >= 0f))));
}
let _e68 = e;
return ((_e68 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e32 = v_world_position_1;
let _e34 = fog_info.eye;
let _e38 = fog_info.forward;
return dot((_e32 - _e34.xyz), _e38.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e34 = g_debug_surface_on;
if _e34 {
let _e35 = g_debug_surface;
let _e36 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e35.x, _e35.y, _e35.z, _e36);
return;
}
let _e41 = v_normal_1;
param = normalize(_e41);
let _e43 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e44 = (*roughness);
let _e46 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e43.x, _e43.y, clamp(_e44, 0f, 1f), _e46);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e33 = (*srgb);
let _e36 = (*srgb);
let _e41 = (*srgb);
return mix((_e33 / vec3(12.92f)), pow(((_e36 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e41));
}
fn WriteDisplayColor_u0028_vf3_u003b_f1_u003b(displayColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e36 = (*displayColor);
param_1 = _e36;
let _e37 = SrgbToLinear_u0028_vf3_u003b((¶m_1));
let _e38 = (*alpha);
frag_color = vec4<f32>(_e37.x, _e37.y, _e37.z, _e38);
param_2 = 1f;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn main_1() {
var n_1: vec3<f32>;
var param_3: vec3<f32>;
var param_4: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e35 = v_normal_1;
n_1 = normalize(_e35);
let _e37 = n_1;
param_3 = ((_e37 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
param_4 = 1f;
WriteDisplayColor_u0028_vf3_u003b_f1_u003b((¶m_3), (¶m_4));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e14 = frag_surface;
let _e15 = frag_color;
return FragmentOutput(_e14, _e15);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'DebugLine': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_line_color_1: vec4<f32>;
fn main_1() {
let _e2 = v_line_color_1;
frag_color = _e2;
return;
}
@fragment
fn main(@location(0) v_line_color: vec4<f32>) -> @location(0) vec4<f32> {
v_line_color_1 = v_line_color;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'BloomThreshold': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luminance_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e25 = (*color);
return dot(_e25, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var texel: vec2<f32>;
var sum: vec3<f32>;
var color_1: vec3<f32>;
var threshold: f32;
var knee: f32;
var brightness: f32;
var param: vec3<f32>;
var soft: f32;
var contribution: f32;
let _e34 = bloom_info.params;
texel = _e34.xy;
let _e36 = v_uv_1;
let _e37 = texel;
let _e40 = textureSample(source_texture_tex, source_texture_smp, (_e36 + (_e37 * vec2<f32>(-0.5f, -0.5f))));
let _e42 = v_uv_1;
let _e43 = texel;
let _e46 = textureSample(source_texture_tex, source_texture_smp, (_e42 + (_e43 * vec2<f32>(0.5f, -0.5f))));
let _e49 = v_uv_1;
let _e50 = texel;
let _e53 = textureSample(source_texture_tex, source_texture_smp, (_e49 + (_e50 * vec2<f32>(-0.5f, 0.5f))));
let _e56 = v_uv_1;
let _e57 = texel;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (_e57 * vec2<f32>(0.5f, 0.5f))));
sum = (((_e40.xyz + _e46.xyz) + _e53.xyz) + _e60.xyz);
let _e63 = sum;
color_1 = (_e63 * 0.25f);
let _e67 = bloom_info.params[2u];
threshold = _e67;
let _e70 = bloom_info.params[3u];
knee = max(_e70, 0.0001f);
let _e72 = color_1;
param = _e72;
let _e73 = Luminance_u0028_vf3_u003b((¶m));
brightness = _e73;
let _e74 = brightness;
let _e75 = threshold;
let _e77 = knee;
let _e79 = knee;
soft = clamp(((_e74 - _e75) + _e77), 0f, (2f * _e79));
let _e82 = soft;
let _e83 = soft;
let _e85 = knee;
soft = ((_e82 * _e83) / (4f * _e85));
let _e88 = soft;
let _e89 = brightness;
let _e90 = threshold;
let _e93 = brightness;
contribution = (max(_e88, (_e89 - _e90)) / max(_e93, 0.0001f));
let _e96 = color_1;
let _e97 = contribution;
let _e98 = (_e96 * _e97);
frag_color = vec4<f32>(_e98.x, _e98.y, _e98.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomDownsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var j: vec3<f32>;
var k: vec3<f32>;
var l: vec3<f32>;
var m: vec3<f32>;
var result: vec3<f32>;
let _e42 = bloom_info.params;
t = _e42.xy;
let _e44 = v_uv_1;
let _e45 = t;
let _e48 = textureSample(source_texture_tex, source_texture_smp, (_e44 + (vec2<f32>(-2f, 2f) * _e45)));
a = _e48.xyz;
let _e50 = v_uv_1;
let _e51 = t;
let _e54 = textureSample(source_texture_tex, source_texture_smp, (_e50 + (vec2<f32>(0f, 2f) * _e51)));
b = _e54.xyz;
let _e56 = v_uv_1;
let _e57 = t;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (vec2<f32>(2f, 2f) * _e57)));
c = _e60.xyz;
let _e62 = v_uv_1;
let _e63 = t;
let _e66 = textureSample(source_texture_tex, source_texture_smp, (_e62 + (vec2<f32>(-2f, 0f) * _e63)));
d = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = textureSample(source_texture_tex, source_texture_smp, _e68);
e = _e69.xyz;
let _e71 = v_uv_1;
let _e72 = t;
let _e75 = textureSample(source_texture_tex, source_texture_smp, (_e71 + (vec2<f32>(2f, 0f) * _e72)));
f = _e75.xyz;
let _e77 = v_uv_1;
let _e78 = t;
let _e81 = textureSample(source_texture_tex, source_texture_smp, (_e77 + (vec2<f32>(-2f, -2f) * _e78)));
g = _e81.xyz;
let _e83 = v_uv_1;
let _e84 = t;
let _e87 = textureSample(source_texture_tex, source_texture_smp, (_e83 + (vec2<f32>(0f, -2f) * _e84)));
h = _e87.xyz;
let _e89 = v_uv_1;
let _e90 = t;
let _e93 = textureSample(source_texture_tex, source_texture_smp, (_e89 + (vec2<f32>(2f, -2f) * _e90)));
i = _e93.xyz;
let _e95 = v_uv_1;
let _e96 = t;
let _e99 = textureSample(source_texture_tex, source_texture_smp, (_e95 + (vec2<f32>(-1f, 1f) * _e96)));
j = _e99.xyz;
let _e101 = v_uv_1;
let _e102 = t;
let _e105 = textureSample(source_texture_tex, source_texture_smp, (_e101 + (vec2<f32>(1f, 1f) * _e102)));
k = _e105.xyz;
let _e107 = v_uv_1;
let _e108 = t;
let _e111 = textureSample(source_texture_tex, source_texture_smp, (_e107 + (vec2<f32>(-1f, -1f) * _e108)));
l = _e111.xyz;
let _e113 = v_uv_1;
let _e114 = t;
let _e117 = textureSample(source_texture_tex, source_texture_smp, (_e113 + (vec2<f32>(1f, -1f) * _e114)));
m = _e117.xyz;
let _e119 = j;
let _e120 = k;
let _e122 = l;
let _e124 = m;
result = (((((_e119 + _e120) + _e122) + _e124) * 0.5f) * 0.25f);
let _e128 = a;
let _e129 = b;
let _e131 = d;
let _e133 = e;
let _e137 = result;
result = (_e137 + (((((_e128 + _e129) + _e131) + _e133) * 0.125f) * 0.25f));
let _e139 = b;
let _e140 = c;
let _e142 = e;
let _e144 = f;
let _e148 = result;
result = (_e148 + (((((_e139 + _e140) + _e142) + _e144) * 0.125f) * 0.25f));
let _e150 = d;
let _e151 = e;
let _e153 = g;
let _e155 = h;
let _e159 = result;
result = (_e159 + (((((_e150 + _e151) + _e153) + _e155) * 0.125f) * 0.25f));
let _e161 = e;
let _e162 = f;
let _e164 = h;
let _e166 = i;
let _e170 = result;
result = (_e170 + (((((_e161 + _e162) + _e164) + _e166) * 0.125f) * 0.25f));
let _e172 = result;
frag_color = vec4<f32>(_e172.x, _e172.y, _e172.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomUpsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var result: vec3<f32>;
var halation: f32;
let _e37 = bloom_info.params;
let _e41 = bloom_info.params[2u];
t = (_e37.xy * max(_e41, 0f));
let _e44 = v_uv_1;
let _e45 = t;
let _e48 = textureSample(source_texture_tex, source_texture_smp, (_e44 + (vec2<f32>(-1f, 1f) * _e45)));
a = _e48.xyz;
let _e50 = v_uv_1;
let _e51 = t;
let _e54 = textureSample(source_texture_tex, source_texture_smp, (_e50 + (vec2<f32>(0f, 1f) * _e51)));
b = _e54.xyz;
let _e56 = v_uv_1;
let _e57 = t;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (vec2<f32>(1f, 1f) * _e57)));
c = _e60.xyz;
let _e62 = v_uv_1;
let _e63 = t;
let _e66 = textureSample(source_texture_tex, source_texture_smp, (_e62 + (vec2<f32>(-1f, 0f) * _e63)));
d = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = textureSample(source_texture_tex, source_texture_smp, _e68);
e = _e69.xyz;
let _e71 = v_uv_1;
let _e72 = t;
let _e75 = textureSample(source_texture_tex, source_texture_smp, (_e71 + (vec2<f32>(1f, 0f) * _e72)));
f = _e75.xyz;
let _e77 = v_uv_1;
let _e78 = t;
let _e81 = textureSample(source_texture_tex, source_texture_smp, (_e77 + (vec2<f32>(-1f, -1f) * _e78)));
g = _e81.xyz;
let _e83 = v_uv_1;
let _e84 = t;
let _e87 = textureSample(source_texture_tex, source_texture_smp, (_e83 + (vec2<f32>(0f, -1f) * _e84)));
h = _e87.xyz;
let _e89 = v_uv_1;
let _e90 = t;
let _e93 = textureSample(source_texture_tex, source_texture_smp, (_e89 + (vec2<f32>(1f, -1f) * _e90)));
i = _e93.xyz;
let _e95 = e;
let _e97 = b;
let _e98 = d;
let _e100 = f;
let _e102 = h;
let _e106 = a;
let _e107 = c;
let _e109 = g;
let _e111 = i;
result = (((_e95 * 4f) + ((((_e97 + _e98) + _e100) + _e102) * 2f)) + (((_e106 + _e107) + _e109) + _e111));
let _e114 = result;
result = (_e114 * 0.0625f);
let _e118 = bloom_info.params[3u];
halation = _e118;
let _e119 = halation;
if (_e119 > 0f) {
let _e121 = halation;
let _e124 = halation;
let _e128 = result;
result = (_e128 * vec3<f32>((1f + (_e121 * 0.5f)), 1f, (1f - (_e124 * 0.35f))));
}
let _e130 = result;
frag_color = vec4<f32>(_e130.x, _e130.y, _e130.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Composite': WebGpuStage(
wgsl: r'''
struct CompositeInfo {
params: vec4<f32>,
ao_texel: vec4<f32>,
look: vec4<f32>,
look_more: vec4<f32>,
output_encode: vec4<f32>,
lift: vec4<f32>,
gamma: vec4<f32>,
gain: vec4<f32>,
contact: vec4<f32>,
}
@group(1) @binding(7)
var lut_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var lut_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> composite_info: CompositeInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var scene_texture_smp: sampler;
@group(1) @binding(3)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var bloom_texture_smp: sampler;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
@group(1) @binding(5)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var contact_shadow_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e136 = (*at)[0u];
x = i32((_e136 - (floor((_e136 / 4f)) * 4f)));
let _e143 = (*at)[1u];
y = i32((_e143 - (floor((_e143 / 4f)) * 4f)));
let _e149 = y;
let _e151 = x;
index = ((_e149 * 4i) + _e151);
value = 0f;
let _e153 = index;
if (_e153 == 0i) {
value = 0f;
} else {
let _e155 = index;
if (_e155 == 1i) {
value = 8f;
} else {
let _e157 = index;
if (_e157 == 2i) {
value = 2f;
} else {
let _e159 = index;
if (_e159 == 3i) {
value = 10f;
} else {
let _e161 = index;
if (_e161 == 4i) {
value = 12f;
} else {
let _e163 = index;
if (_e163 == 5i) {
value = 4f;
} else {
let _e165 = index;
if (_e165 == 6i) {
value = 14f;
} else {
let _e167 = index;
if (_e167 == 7i) {
value = 6f;
} else {
let _e169 = index;
if (_e169 == 8i) {
value = 3f;
} else {
let _e171 = index;
if (_e171 == 9i) {
value = 11f;
} else {
let _e173 = index;
if (_e173 == 10i) {
value = 1f;
} else {
let _e175 = index;
if (_e175 == 11i) {
value = 9f;
} else {
let _e177 = index;
if (_e177 == 12i) {
value = 15f;
} else {
let _e179 = index;
if (_e179 == 13i) {
value = 7f;
} else {
let _e181 = index;
if (_e181 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e183 = value;
return ((_e183 / 16f) - 0.5f);
}
fn Hash_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
let _e131 = (*at_1);
return fract((sin(dot(_e131, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e131 = (*linear);
let _e133 = (*linear);
let _e138 = (*linear);
return mix((_e131 * 12.92f), ((pow(max(_e133, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e138));
}
fn SampleLut_u0028_vf3_u003b_f1_u003b(color: ptr<function, vec3<f32>>, size: ptr<function, f32>) -> vec3<f32> {
var c: vec3<f32>;
var sliceWidth: f32;
var texel: f32;
var innerWidth: f32;
var u: f32;
var v: f32;
var slice: f32;
var lower: f32;
var upper: f32;
var a: vec3<f32>;
var b: vec3<f32>;
let _e143 = (*color);
c = clamp(_e143, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e145 = (*size);
sliceWidth = (1f / _e145);
let _e147 = (*size);
let _e148 = (*size);
texel = (1f / (_e147 * _e148));
let _e151 = texel;
let _e152 = (*size);
innerWidth = (_e151 * (_e152 - 1f));
let _e155 = texel;
let _e158 = c[0u];
let _e159 = innerWidth;
u = ((_e155 * 0.5f) + (_e158 * _e159));
let _e162 = (*size);
let _e165 = c[1u];
let _e166 = (*size);
let _e168 = (*size);
v = ((0.5f / _e162) + (_e165 * ((_e166 - 1f) / _e168)));
let _e173 = c[2u];
let _e174 = (*size);
slice = (_e173 * (_e174 - 1f));
let _e177 = slice;
lower = floor(_e177);
let _e179 = lower;
let _e181 = (*size);
upper = min((_e179 + 1f), (_e181 - 1f));
let _e184 = lower;
let _e185 = sliceWidth;
let _e187 = u;
let _e189 = v;
let _e191 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e184 * _e185) + _e187), _e189));
a = _e191.xyz;
let _e193 = upper;
let _e194 = sliceWidth;
let _e196 = u;
let _e198 = v;
let _e200 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e193 * _e194) + _e196), _e198));
b = _e200.xyz;
let _e202 = a;
let _e203 = b;
let _e204 = slice;
let _e205 = lower;
return mix(_e202, _e203, vec3((_e204 - _e205)));
}
fn Luma_u0028_vf3_u003b(color_1: ptr<function, vec3<f32>>) -> f32 {
let _e131 = (*color_1);
return dot(_e131, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn TonemapAgx_u0028_vf3_u003b(color_2: ptr<function, vec3<f32>>) -> vec3<f32> {
var v_1: vec3<f32>;
var v2_: vec3<f32>;
var v4_: vec3<f32>;
var luma: f32;
var param: vec3<f32>;
let _e136 = (*color_2);
v_1 = clamp(log2(max(_e136, vec3<f32>(0.0000000001f, 0.0000000001f, 0.0000000001f))), vec3<f32>(-12.47393f, -12.47393f, -12.47393f), vec3<f32>(4.026069f, 4.026069f, 4.026069f));
let _e140 = v_1;
v_1 = ((_e140 - vec3<f32>(-12.47393f, -12.47393f, -12.47393f)) / vec3(16.499998f));
let _e144 = v_1;
let _e145 = v_1;
v2_ = (_e144 * _e145);
let _e147 = v2_;
let _e148 = v2_;
v4_ = (_e147 * _e148);
let _e150 = v4_;
let _e152 = v2_;
let _e154 = v4_;
let _e156 = v_1;
let _e159 = v4_;
let _e162 = v2_;
let _e164 = v_1;
let _e167 = v2_;
let _e170 = v_1;
v_1 = ((((((((_e150 * 15.5f) * _e152) - ((_e154 * 40.14f) * _e156)) + (_e159 * 31.96f)) - ((_e162 * 6.868f) * _e164)) + (_e167 * 0.4298f)) + (_e170 * 0.1191f)) - vec3(0.00232f));
let _e175 = v_1;
v_1 = clamp(_e175, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e177 = v_1;
param = _e177;
let _e178 = Luma_u0028_vf3_u003b((¶m));
luma = _e178;
let _e179 = luma;
let _e181 = v_1;
return mix(vec3(_e179), _e181, vec3(0.84f));
}
fn TonemapAgxFull_u0028_vf3_u003b(color_3: ptr<function, vec3<f32>>) -> vec3<f32> {
var v_2: vec3<f32>;
var param_1: vec3<f32>;
let _e133 = (*color_3);
v_2 = (mat3x3<f32>(vec3<f32>(0.84247905f, 0.042328242f, 0.042375654f), vec3<f32>(0.0784336f, 0.87846863f, 0.0784336f), vec3<f32>(0.079223745f, 0.07916613f, 0.879143f)) * _e133);
let _e135 = v_2;
param_1 = _e135;
let _e136 = TonemapAgx_u0028_vf3_u003b((¶m_1));
v_2 = _e136;
let _e137 = v_2;
return clamp((mat3x3<f32>(vec3<f32>(1.196879f, -0.052896854f, -0.052971635f), vec3<f32>(-0.09802088f, 1.1519032f, -0.09804345f), vec3<f32>(-0.09902974f, -0.098961174f, 1.1510737f)) * _e137), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapReinhard_u0028_vf3_u003b(color_4: ptr<function, vec3<f32>>) -> vec3<f32> {
var numerator: vec3<f32>;
let _e132 = (*color_4);
let _e133 = (*color_4);
numerator = (_e132 * (vec3<f32>(1f, 1f, 1f) + (_e133 / vec3<f32>(16f, 16f, 16f))));
let _e137 = numerator;
let _e138 = (*color_4);
return clamp((_e137 / (vec3<f32>(1f, 1f, 1f) + _e138)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAces_u0028_vf3_u003b(color_5: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e131 = (*color_5);
let _e132 = (*color_5);
let _e137 = (*color_5);
let _e138 = (*color_5);
return clamp(((_e131 * ((_e132 * 2.51f) + vec3(0.03f))) / ((_e137 * ((_e138 * 2.43f) + vec3(0.59f))) + vec3(0.14f))), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapNeutral_u0028_vf3_u003b(color_6: ptr<function, vec3<f32>>) -> vec3<f32> {
var minChannel: f32;
var offset: f32;
var local: f32;
var peak: f32;
var newPeak: f32;
var desaturate: f32;
let _e138 = (*color_6)[0u];
let _e140 = (*color_6)[1u];
let _e142 = (*color_6)[2u];
minChannel = min(_e138, min(_e140, _e142));
let _e145 = minChannel;
if (_e145 < 0.08f) {
let _e147 = minChannel;
let _e148 = minChannel;
let _e150 = minChannel;
local = (_e147 - ((6.25f * _e148) * _e150));
} else {
local = 0.04f;
}
let _e153 = local;
offset = _e153;
let _e154 = offset;
let _e155 = (*color_6);
(*color_6) = (_e155 - vec3(_e154));
let _e159 = (*color_6)[0u];
let _e161 = (*color_6)[1u];
let _e163 = (*color_6)[2u];
peak = max(_e159, max(_e161, _e163));
let _e166 = peak;
if (_e166 < 0.76f) {
let _e168 = (*color_6);
return _e168;
}
let _e169 = peak;
newPeak = (1f - (0.0576f / ((_e169 + 0.24f) - 0.76f)));
let _e174 = newPeak;
let _e175 = peak;
let _e177 = (*color_6);
(*color_6) = (_e177 * (_e174 / _e175));
let _e179 = peak;
let _e180 = newPeak;
desaturate = (1f - (1f / ((0.15f * (_e179 - _e180)) + 1f)));
let _e186 = (*color_6);
let _e187 = newPeak;
let _e189 = desaturate;
return mix(_e186, vec3(_e187), vec3(_e189));
}
fn TonemapBy_u0028_vf3_u003b_i1_u003b(color_7: ptr<function, vec3<f32>>, curve: ptr<function, i32>) -> vec3<f32> {
var param_2: vec3<f32>;
var param_3: vec3<f32>;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
let _e137 = (*curve);
if (_e137 == 1i) {
let _e139 = (*color_7);
param_2 = _e139;
let _e140 = TonemapNeutral_u0028_vf3_u003b((¶m_2));
return _e140;
}
let _e141 = (*curve);
if (_e141 == 2i) {
let _e143 = (*color_7);
param_3 = _e143;
let _e144 = TonemapAces_u0028_vf3_u003b((¶m_3));
return _e144;
}
let _e145 = (*curve);
if (_e145 == 3i) {
let _e147 = (*color_7);
param_4 = _e147;
let _e148 = TonemapAgx_u0028_vf3_u003b((¶m_4));
return _e148;
}
let _e149 = (*curve);
if (_e149 == 4i) {
let _e151 = (*color_7);
param_5 = _e151;
let _e152 = TonemapReinhard_u0028_vf3_u003b((¶m_5));
return _e152;
}
let _e153 = (*curve);
if (_e153 == 5i) {
let _e155 = (*color_7);
param_6 = _e155;
let _e156 = TonemapAgxFull_u0028_vf3_u003b((¶m_6));
return _e156;
}
let _e157 = (*color_7);
return _e157;
}
fn main_1() {
var dispersion: f32;
var fromCentre: vec2<f32>;
var step_uv: vec2<f32>;
var scene: vec4<f32>;
var bloom: vec3<f32>;
var half_texel: vec2<f32>;
var ao: f32;
var contact: f32;
var color_8: vec3<f32>;
var param_7: vec3<f32>;
var param_8: i32;
var contrast: f32;
var saturation: f32;
var temperature: f32;
var param_9: vec3<f32>;
var lift: vec3<f32>;
var gammaCurve: vec3<f32>;
var gain: vec3<f32>;
var balance: f32;
var tint: f32;
var lutStrength: f32;
var graded: vec3<f32>;
var param_10: vec3<f32>;
var param_11: f32;
var vignette: f32;
var fromCentre_1: vec2<f32>;
var aspect: f32;
var radius: f32;
var encoded: vec3<f32>;
var param_12: vec3<f32>;
var grain: f32;
var param_13: vec2<f32>;
var dither: f32;
var param_14: vec2<f32>;
let _e166 = composite_info.look[3u];
dispersion = _e166;
let _e167 = dispersion;
if (_e167 > 0f) {
let _e169 = v_uv_1;
fromCentre = (_e169 - vec2<f32>(0.5f, 0.5f));
let _e171 = fromCentre;
let _e172 = dispersion;
step_uv = (_e171 * _e172);
let _e174 = v_uv_1;
let _e175 = textureSample(scene_texture_tex, scene_texture_smp, _e174);
scene = _e175;
let _e176 = v_uv_1;
let _e177 = step_uv;
let _e179 = textureSample(scene_texture_tex, scene_texture_smp, (_e176 + _e177));
scene[0u] = _e179.x;
let _e182 = v_uv_1;
let _e183 = step_uv;
let _e185 = textureSample(scene_texture_tex, scene_texture_smp, (_e182 - _e183));
scene[2u] = _e185.z;
} else {
let _e188 = v_uv_1;
let _e189 = textureSample(scene_texture_tex, scene_texture_smp, _e188);
scene = _e189;
}
let _e190 = v_uv_1;
let _e191 = textureSample(bloom_texture_tex, bloom_texture_smp, _e190);
bloom = _e191.xyz;
let _e194 = composite_info.ao_texel;
half_texel = (_e194.xy * 0.5f);
let _e197 = v_uv_1;
let _e199 = half_texel[0u];
let _e201 = half_texel[1u];
let _e204 = textureSample(ao_texture_tex, ao_texture_smp, (_e197 + vec2<f32>(_e199, _e201)));
let _e206 = v_uv_1;
let _e208 = half_texel[0u];
let _e211 = half_texel[1u];
let _e214 = textureSample(ao_texture_tex, ao_texture_smp, (_e206 + vec2<f32>(-(_e208), _e211)));
let _e217 = v_uv_1;
let _e219 = half_texel[0u];
let _e221 = half_texel[1u];
let _e225 = textureSample(ao_texture_tex, ao_texture_smp, (_e217 + vec2<f32>(_e219, -(_e221))));
let _e228 = v_uv_1;
let _e230 = half_texel[0u];
let _e233 = half_texel[1u];
let _e237 = textureSample(ao_texture_tex, ao_texture_smp, (_e228 + vec2<f32>(-(_e230), -(_e233))));
ao = (0.25f * (((_e204.x + _e214.x) + _e225.x) + _e237.x));
let _e241 = ao;
let _e244 = composite_info.params[3u];
ao = mix(1f, _e241, clamp(_e244, 0f, 1f));
let _e247 = v_uv_1;
let _e248 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e247);
contact = _e248.x;
let _e250 = contact;
let _e253 = composite_info.contact[0u];
let _e256 = ao;
ao = (_e256 * mix(1f, _e250, clamp(_e253, 0f, 1f)));
let _e258 = scene;
let _e260 = ao;
let _e262 = bloom;
let _e265 = composite_info.params[1u];
color_8 = ((_e258.xyz * _e260) + (_e262 * _e265));
let _e270 = composite_info.params[0u];
let _e272 = color_8;
color_8 = (_e272 * max(_e270, 0f));
let _e276 = composite_info.params[2u];
let _e279 = color_8;
param_7 = _e279;
param_8 = i32((_e276 + 0.5f));
let _e280 = TonemapBy_u0028_vf3_u003b_i1_u003b((¶m_7), (¶m_8));
color_8 = _e280;
let _e283 = composite_info.look[0u];
contrast = _e283;
let _e286 = composite_info.look[1u];
saturation = _e286;
let _e289 = composite_info.look[2u];
temperature = _e289;
let _e290 = color_8;
let _e292 = contrast;
color_8 = (((_e290 - vec3<f32>(0.5f, 0.5f, 0.5f)) * _e292) + vec3<f32>(0.5f, 0.5f, 0.5f));
let _e295 = color_8;
param_9 = _e295;
let _e296 = Luma_u0028_vf3_u003b((¶m_9));
let _e298 = color_8;
let _e299 = saturation;
color_8 = mix(vec3(_e296), _e298, vec3(_e299));
let _e302 = temperature;
let _e305 = temperature;
let _e309 = color_8;
color_8 = (_e309 * vec3<f32>((1f + (_e302 * 0.1f)), 1f, (1f - (_e305 * 0.1f))));
let _e312 = composite_info.lift;
lift = _e312.xyz;
let _e315 = composite_info.gamma;
gammaCurve = _e315.xyz;
let _e318 = composite_info.gain;
gain = _e318.xyz;
let _e320 = color_8;
let _e321 = lift;
color_8 = (_e320 + _e321);
let _e323 = color_8;
color_8 = max(_e323, vec3<f32>(0f, 0f, 0f));
let _e325 = gammaCurve;
if any((_e325 != vec3<f32>(1f, 1f, 1f))) {
let _e328 = color_8;
let _e329 = gammaCurve;
color_8 = pow(_e328, (vec3<f32>(1f, 1f, 1f) / _e329));
}
let _e332 = gain;
let _e333 = color_8;
color_8 = (_e333 * _e332);
let _e337 = composite_info.output_encode[1u];
balance = _e337;
let _e340 = composite_info.output_encode[2u];
tint = _e340;
let _e341 = balance;
let _e343 = tint;
if ((_e341 != 0f) || (_e343 != 0f)) {
let _e346 = balance;
let _e349 = tint;
let _e352 = balance;
let _e356 = color_8;
color_8 = (_e356 * vec3<f32>((1f + (_e346 * 0.2f)), (1f + (_e349 * 0.15f)), (1f - (_e352 * 0.2f))));
let _e358 = tint;
let _e361 = color_8[0u];
color_8[0u] = (_e361 - (_e358 * 0.075f));
let _e364 = tint;
let _e367 = color_8[2u];
color_8[2u] = (_e367 - (_e364 * 0.075f));
}
let _e372 = composite_info.ao_texel[2u];
lutStrength = _e372;
let _e373 = lutStrength;
if (_e373 > 0f) {
let _e377 = composite_info.ao_texel[3u];
let _e379 = color_8;
param_10 = _e379;
param_11 = max(_e377, 2f);
let _e380 = SampleLut_u0028_vf3_u003b_f1_u003b((¶m_10), (¶m_11));
graded = _e380;
let _e381 = color_8;
let _e382 = graded;
let _e383 = lutStrength;
color_8 = mix(_e381, _e382, vec3(clamp(_e383, 0f, 1f)));
}
let _e389 = composite_info.look_more[0u];
vignette = _e389;
let _e390 = vignette;
if (_e390 > 0f) {
let _e392 = v_uv_1;
fromCentre_1 = (_e392 - vec2<f32>(0.5f, 0.5f));
let _e396 = composite_info.look_more[3u];
aspect = max(_e396, 0.0001f);
let _e398 = aspect;
let _e401 = composite_info.look_more[1u];
let _e404 = fromCentre_1[0u];
fromCentre_1[0u] = (_e404 * mix(1f, _e398, _e401));
let _e407 = fromCentre_1;
radius = (length(_e407) * 1.4142135f);
let _e410 = vignette;
let _e412 = radius;
let _e415 = color_8;
color_8 = (_e415 * mix(1f, (1f - _e410), clamp(_e412, 0f, 1f)));
}
let _e417 = color_8;
param_12 = max(_e417, vec3<f32>(0f, 0f, 0f));
let _e419 = LinearToSrgb_u0028_vf3_u003b((¶m_12));
encoded = _e419;
let _e422 = composite_info.look_more[2u];
grain = _e422;
let _e423 = grain;
if (_e423 > 0f) {
let _e425 = gl_FragCoord_1;
param_13 = _e425.xy;
let _e427 = Hash_u0028_vf2_u003b((¶m_13));
let _e429 = grain;
let _e432 = encoded;
encoded = (_e432 + vec3(((_e427 - 0.5f) * _e429)));
}
let _e436 = composite_info.output_encode[0u];
dither = _e436;
let _e437 = dither;
if (_e437 > 0f) {
let _e439 = gl_FragCoord_1;
param_14 = _e439.xy;
let _e441 = BayerCell_u0028_vf2_u003b((¶m_14));
let _e442 = dither;
let _e445 = encoded;
encoded = (_e445 + vec3((_e441 * _e442)));
}
let _e447 = encoded;
let _e449 = scene[3u];
frag_color = vec4<f32>(_e447.x, _e447.y, _e447.z, _e449);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'CompositeInfo',
group: 1,
binding: 0,
sizeInBytes: 144,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ao_texel',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'look', offsetInBytes: 32, sizeInBytes: 16),
WebGpuBlockMember(
name: 'look_more',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'output_encode',
offsetInBytes: 64,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'lift', offsetInBytes: 80, sizeInBytes: 16),
WebGpuBlockMember(
name: 'gamma',
offsetInBytes: 96,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'gain',
offsetInBytes: 112,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'contact',
offsetInBytes: 128,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'bloom_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'contact_shadow_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lut_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Fxaa': WebGpuStage(
wgsl: r'''
struct FxaaInfo {
params: vec4<f32>,
sharpen: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fxaa_info: FxaaInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn MinChannel_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> f32 {
let _e25 = (*v)[0u];
let _e27 = (*v)[1u];
let _e29 = (*v)[2u];
return min(_e25, min(_e27, _e29));
}
fn Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, n: ptr<function, vec3<f32>>, s: ptr<function, vec3<f32>>, w: ptr<function, vec3<f32>>, e: ptr<function, vec3<f32>>) -> vec3<f32> {
var strength: f32;
var lowest: vec3<f32>;
var highest: vec3<f32>;
var room: vec3<f32>;
var amount: f32;
var param: vec3<f32>;
var average: vec3<f32>;
let _e37 = fxaa_info.sharpen[0u];
strength = _e37;
let _e38 = strength;
if (_e38 <= 0f) {
let _e40 = (*centre);
return _e40;
}
let _e41 = (*centre);
let _e42 = (*n);
let _e43 = (*s);
let _e45 = (*w);
let _e46 = (*e);
lowest = min(_e41, min(min(_e42, _e43), min(_e45, _e46)));
let _e50 = (*centre);
let _e51 = (*n);
let _e52 = (*s);
let _e54 = (*w);
let _e55 = (*e);
highest = max(_e50, max(max(_e51, _e52), max(_e54, _e55)));
let _e59 = lowest;
let _e60 = highest;
let _e63 = highest;
room = (min(_e59, (vec3<f32>(1f, 1f, 1f) - _e60)) / max(_e63, vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
let _e66 = room;
param = _e66;
let _e67 = MinChannel_u0028_vf3_u003b((¶m));
amount = clamp(sqrt(clamp(_e67, 0f, 1f)), 0f, 1f);
let _e71 = (*n);
let _e72 = (*s);
let _e74 = (*w);
let _e76 = (*e);
average = ((((_e71 + _e72) + _e74) + _e76) * 0.25f);
let _e79 = (*centre);
let _e80 = (*centre);
let _e81 = average;
let _e83 = amount;
let _e85 = strength;
return (_e79 + (((_e80 - _e81) * _e83) * _e85));
}
fn Weight_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e24 = (*color);
return dot(_e24, vec3<f32>(0.299f, 0.587f, 0.114f));
}
fn main_1() {
var texel: vec2<f32>;
var middle: vec3<f32>;
var mid: f32;
var param_1: vec3<f32>;
var northRgb: vec3<f32>;
var southRgb: vec3<f32>;
var westRgb: vec3<f32>;
var eastRgb: vec3<f32>;
var north: f32;
var param_2: vec3<f32>;
var south: f32;
var param_3: vec3<f32>;
var west: f32;
var param_4: vec3<f32>;
var east: f32;
var param_5: vec3<f32>;
var lowest_1: f32;
var highest_1: f32;
var contrast: f32;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var param_10: vec3<f32>;
var vertical: f32;
var horizontal: f32;
var horizontalEdge: bool;
var towards: f32;
var local: f32;
var away: f32;
var local_1: f32;
var step_length: f32;
var local_2: f32;
var average_1: f32;
var blend: f32;
var offset: vec2<f32>;
var local_3: vec2<f32>;
var smoothed: vec3<f32>;
var param_11: vec3<f32>;
var param_12: vec3<f32>;
var param_13: vec3<f32>;
var param_14: vec3<f32>;
var param_15: vec3<f32>;
let _e67 = fxaa_info.params;
texel = _e67.xy;
let _e69 = v_uv_1;
let _e70 = textureSampleLevel(source_texture_tex, source_texture_smp, _e69, 0f);
middle = _e70.xyz;
let _e72 = middle;
param_1 = _e72;
let _e73 = Weight_u0028_vf3_u003b((¶m_1));
mid = _e73;
let _e74 = v_uv_1;
let _e76 = texel[1u];
let _e80 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e74 + vec2<f32>(0f, -(_e76))), 0f);
northRgb = _e80.xyz;
let _e82 = v_uv_1;
let _e84 = texel[1u];
let _e87 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e82 + vec2<f32>(0f, _e84)), 0f);
southRgb = _e87.xyz;
let _e89 = v_uv_1;
let _e91 = texel[0u];
let _e95 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e89 + vec2<f32>(-(_e91), 0f)), 0f);
westRgb = _e95.xyz;
let _e97 = v_uv_1;
let _e99 = texel[0u];
let _e102 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e97 + vec2<f32>(_e99, 0f)), 0f);
eastRgb = _e102.xyz;
let _e104 = northRgb;
param_2 = _e104;
let _e105 = Weight_u0028_vf3_u003b((¶m_2));
north = _e105;
let _e106 = southRgb;
param_3 = _e106;
let _e107 = Weight_u0028_vf3_u003b((¶m_3));
south = _e107;
let _e108 = westRgb;
param_4 = _e108;
let _e109 = Weight_u0028_vf3_u003b((¶m_4));
west = _e109;
let _e110 = eastRgb;
param_5 = _e110;
let _e111 = Weight_u0028_vf3_u003b((¶m_5));
east = _e111;
let _e112 = mid;
let _e113 = north;
let _e114 = south;
let _e116 = west;
let _e117 = east;
lowest_1 = min(_e112, min(min(_e113, _e114), min(_e116, _e117)));
let _e121 = mid;
let _e122 = north;
let _e123 = south;
let _e125 = west;
let _e126 = east;
highest_1 = max(_e121, max(max(_e122, _e123), max(_e125, _e126)));
let _e130 = highest_1;
let _e131 = lowest_1;
contrast = (_e130 - _e131);
let _e133 = contrast;
let _e134 = highest_1;
let _e137 = fxaa_info.params[2u];
if (_e133 < max(0.0312f, (_e134 * _e137))) {
let _e141 = middle;
param_6 = _e141;
let _e142 = northRgb;
param_7 = _e142;
let _e143 = southRgb;
param_8 = _e143;
let _e144 = westRgb;
param_9 = _e144;
let _e145 = eastRgb;
param_10 = _e145;
let _e146 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9), (¶m_10));
frag_color = vec4<f32>(_e146.x, _e146.y, _e146.z, 1f);
return;
}
let _e151 = north;
let _e152 = south;
let _e154 = mid;
vertical = abs(((_e151 + _e152) - (2f * _e154)));
let _e158 = west;
let _e159 = east;
let _e161 = mid;
horizontal = abs(((_e158 + _e159) - (2f * _e161)));
let _e165 = vertical;
let _e166 = horizontal;
horizontalEdge = (_e165 >= _e166);
let _e168 = horizontalEdge;
if _e168 {
let _e169 = south;
let _e170 = mid;
local = (_e169 - _e170);
} else {
let _e172 = east;
let _e173 = mid;
local = (_e172 - _e173);
}
let _e175 = local;
towards = _e175;
let _e176 = horizontalEdge;
if _e176 {
let _e177 = north;
let _e178 = mid;
local_1 = (_e177 - _e178);
} else {
let _e180 = west;
let _e181 = mid;
local_1 = (_e180 - _e181);
}
let _e183 = local_1;
away = _e183;
let _e184 = horizontalEdge;
if _e184 {
let _e186 = texel[1u];
local_2 = _e186;
} else {
let _e188 = texel[0u];
local_2 = _e188;
}
let _e189 = local_2;
step_length = _e189;
let _e190 = away;
let _e192 = towards;
if (abs(_e190) > abs(_e192)) {
let _e195 = step_length;
step_length = -(_e195);
}
let _e197 = north;
let _e198 = south;
let _e200 = west;
let _e202 = east;
average_1 = ((((_e197 + _e198) + _e200) + _e202) * 0.25f);
let _e205 = average_1;
let _e206 = mid;
let _e209 = contrast;
blend = clamp((abs((_e205 - _e206)) / max(_e209, 0.00001f)), 0f, 1f);
let _e213 = blend;
let _e214 = blend;
let _e218 = fxaa_info.params[3u];
blend = ((_e213 * _e214) * _e218);
let _e220 = horizontalEdge;
if _e220 {
let _e221 = step_length;
let _e222 = blend;
local_3 = vec2<f32>(0f, (_e221 * _e222));
} else {
let _e225 = step_length;
let _e226 = blend;
local_3 = vec2<f32>((_e225 * _e226), 0f);
}
let _e229 = local_3;
offset = _e229;
let _e230 = v_uv_1;
let _e231 = offset;
let _e233 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e230 + _e231), 0f);
smoothed = _e233.xyz;
let _e235 = smoothed;
param_11 = _e235;
let _e236 = northRgb;
param_12 = _e236;
let _e237 = southRgb;
param_13 = _e237;
let _e238 = westRgb;
param_14 = _e238;
let _e239 = eastRgb;
param_15 = _e239;
let _e240 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_11), (¶m_12), (¶m_13), (¶m_14), (¶m_15));
frag_color = vec4<f32>(_e240.x, _e240.y, _e240.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FxaaInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'sharpen',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MrtProbe': WebGpuStage(
wgsl: r'''
struct FragmentOutput {
@location(0) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
}
var<private> out_first: vec4<f32>;
var<private> out_second: vec4<f32>;
var<private> v_uv_1: vec2<f32>;
fn main_1() {
out_first = vec4<f32>(0.25f, 0.5f, 0.75f, 1f);
out_second = vec4<f32>(0.75f, 0.5f, 0.25f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> FragmentOutput {
v_uv_1 = v_uv;
main_1();
let _e4 = out_first;
let _e5 = out_second;
return FragmentOutput(_e4, _e5);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'ShadowDepth': WebGpuStage(
wgsl: r'''
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e17 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e17, 0f, 0f, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'Particle': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn main_1() {
var centred: vec2<f32>;
var radius: f32;
var falloff: f32;
var intensity: f32;
var fogged: f32;
let _e16 = v_uv_1;
centred = ((_e16 * 2f) - vec2(1f));
let _e20 = centred;
radius = length(_e20);
let _e22 = radius;
falloff = (1f - smoothstep(0f, 1f, _e22));
let _e25 = falloff;
let _e26 = falloff;
intensity = (_e25 * _e26);
fogged = 1f;
let _e30 = fog_info.fog[3u];
if (_e30 > 0f) {
let _e34 = fog_info.fog[3u];
let _e36 = v_world_position_1;
let _e38 = fog_info.eye;
fogged = clamp(exp((-(_e34) * distance(_e36, _e38.xyz))), 0f, 1f);
}
let _e44 = v_color_1;
let _e47 = v_color_1[3u];
let _e49 = intensity;
let _e51 = fogged;
let _e52 = (((_e44.xyz * _e47) * _e49) * _e51);
frag_color = vec4<f32>(_e52.x, _e52.y, _e52.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleTextured': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
@group(1) @binding(1)
var particle_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var particle_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var texel: vec4<f32>;
var fogged: f32;
var scale: f32;
let _e15 = v_uv_1;
let _e16 = textureSample(particle_texture_tex, particle_texture_smp, _e15);
texel = _e16;
fogged = 1f;
let _e19 = fog_info.fog[3u];
if (_e19 > 0f) {
let _e23 = fog_info.fog[3u];
let _e25 = v_world_position_1;
let _e27 = fog_info.eye;
fogged = clamp(exp((-(_e23) * distance(_e25, _e27.xyz))), 0f, 1f);
}
let _e34 = v_color_1[3u];
let _e36 = texel[3u];
let _e38 = fogged;
scale = ((_e34 * _e36) * _e38);
let _e40 = v_color_1;
let _e42 = texel;
let _e45 = scale;
let _e46 = ((_e40.xyz * _e42.xyz) * _e45);
frag_color = vec4<f32>(_e46.x, _e46.y, _e46.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'particle_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Splat': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var power: f32;
var alpha: f32;
var colour: vec3<f32>;
var visibility: f32;
let _e17 = v_uv_1;
let _e18 = v_uv_1;
power = (-0.5f * dot(_e17, _e18));
let _e21 = power;
if (_e21 < -4.5f) {
discard;
}
let _e24 = v_color_1[3u];
let _e25 = power;
alpha = (_e24 * exp(_e25));
let _e28 = alpha;
if (_e28 < 0.003921569f) {
discard;
}
let _e30 = v_color_1;
colour = _e30.xyz;
let _e34 = fog_info.fog[3u];
if (_e34 > 0f) {
let _e38 = fog_info.fog[3u];
let _e40 = v_world_position_1;
let _e42 = fog_info.eye;
visibility = clamp(exp((-(_e38) * distance(_e40, _e42.xyz))), 0f, 1f);
let _e49 = fog_info.fog;
let _e51 = colour;
let _e52 = visibility;
colour = mix(_e49.xyz, _e51, vec3(_e52));
}
let _e55 = colour;
let _e56 = alpha;
let _e57 = (_e55 * _e56);
let _e58 = alpha;
frag_color = vec4<f32>(_e57.x, _e57.y, _e57.z, _e58);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleMesh': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn main_1() {
var to_eye: vec3<f32>;
var distance_to_eye: f32;
var n: vec3<f32>;
var facing: f32;
var local: f32;
var intensity: f32;
var fogged: f32;
let _e19 = fog_info.eye;
let _e21 = v_world_position_1;
to_eye = (_e19.xyz - _e21);
let _e23 = to_eye;
distance_to_eye = length(_e23);
let _e25 = v_normal_1;
n = normalize(_e25);
let _e27 = distance_to_eye;
if (_e27 > 0f) {
let _e29 = n;
let _e30 = to_eye;
let _e31 = distance_to_eye;
local = abs(dot(_e29, (_e30 / vec3(_e31))));
} else {
local = 1f;
}
let _e36 = local;
facing = _e36;
let _e37 = facing;
intensity = mix(0.35f, 1f, _e37);
fogged = 1f;
let _e41 = fog_info.fog[3u];
if (_e41 > 0f) {
let _e45 = fog_info.fog[3u];
let _e47 = distance_to_eye;
fogged = clamp(exp((-(_e45) * _e47)), 0f, 1f);
}
let _e51 = v_color_1;
let _e54 = v_color_1[3u];
let _e56 = intensity;
let _e58 = fogged;
let _e59 = (((_e51.xyz * _e54) * _e56) * _e58);
frag_color = vec4<f32>(_e59.x, _e59.y, _e59.z, 1f);
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'Reflections': WebGpuStage(
wgsl: r'''
struct ReflectionInfo {
view_projection: mat4x4<f32>,
inverse_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> reflection_info: ReflectionInfo;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e31 = (*at);
let _e33 = reflection_info.camera;
let _e37 = reflection_info.forward;
return dot((_e31 - _e33.xyz), _e37.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e32 = (*ndc)[0u];
let _e36 = (*ndc)[1u];
return vec2<f32>(((_e32 * 0.5f) + 0.5f), (0.5f - (_e36 * 0.5f)));
}
fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, origin: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>) {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
let _e37 = (*uv)[0u];
let _e41 = (*uv)[1u];
xy = vec2<f32>(((_e37 * 2f) - 1f), (1f - (_e41 * 2f)));
let _e46 = reflection_info.inverse_view_projection;
let _e47 = xy;
nearH = (_e46 * vec4<f32>(_e47.x, _e47.y, 0f, 1f));
let _e53 = reflection_info.inverse_view_projection;
let _e54 = xy;
farH = (_e53 * vec4<f32>(_e54.x, _e54.y, 1f, 1f));
let _e59 = nearH;
let _e62 = nearH[3u];
(*origin) = (_e59.xyz / vec3(_e62));
let _e65 = farH;
let _e68 = farH[3u];
let _e71 = (*origin);
(*along) = normalize(((_e65.xyz / vec3(_e68)) - _e71));
return;
}
fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var origin_1: vec3<f32>;
var along_1: vec3<f32>;
var param: vec2<f32>;
var param_1: vec3<f32>;
var param_2: vec3<f32>;
var axis: vec3<f32>;
let _e38 = (*uv_1);
param = _e38;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m), (¶m_1), (¶m_2));
let _e39 = param_1;
origin_1 = _e39;
let _e40 = param_2;
along_1 = _e40;
let _e42 = reflection_info.forward;
axis = _e42.xyz;
let _e44 = origin_1;
let _e45 = along_1;
let _e46 = (*depth);
let _e47 = origin_1;
let _e49 = reflection_info.camera;
let _e52 = axis;
let _e55 = along_1;
let _e56 = axis;
return (_e44 + (_e45 * ((_e46 - dot((_e47 - _e49.xyz), _e52)) / dot(_e55, _e56))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e35 = (*e);
(*e) = ((_e35 * 2f) - vec2(1f));
let _e39 = (*e);
let _e41 = (*e)[0u];
let _e45 = (*e)[1u];
n = vec3<f32>(_e39.x, _e39.y, ((1f - abs(_e41)) - abs(_e45)));
let _e52 = n[2u];
t = max(-(_e52), 0f);
let _e56 = n[0u];
if (_e56 >= 0f) {
let _e58 = t;
local = -(_e58);
} else {
let _e60 = t;
local = _e60;
}
let _e61 = local;
let _e63 = n[0u];
n[0u] = (_e63 + _e61);
let _e67 = n[1u];
if (_e67 >= 0f) {
let _e69 = t;
local_1 = -(_e69);
} else {
let _e71 = t;
local_1 = _e71;
}
let _e72 = local_1;
let _e74 = n[1u];
n[1u] = (_e74 + _e72);
let _e77 = n;
return normalize(_e77);
}
fn main_1() {
var surface: vec4<f32>;
var scene: vec3<f32>;
var debugOnly: bool;
var background: vec3<f32>;
var normal: vec3<f32>;
var param_3: vec2<f32>;
var roughness: f32;
var polish: f32;
var position: vec3<f32>;
var param_4: vec2<f32>;
var param_5: f32;
var rayOrigin: vec3<f32>;
var viewRay: vec3<f32>;
var param_6: vec2<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var toEye: vec3<f32>;
var facing: f32;
var ray: vec3<f32>;
var steps: i32;
var stride: f32;
var thickness: f32;
var intensity: f32;
var march: vec3<f32>;
var hitColor: vec3<f32>;
var hit: f32;
var travelled: f32;
var i: i32;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_2: vec2<f32>;
var param_9: vec2<f32>;
var sceneDepth: f32;
var marchDepth: f32;
var param_10: vec3<f32>;
var seen: vec3<f32>;
var param_11: vec2<f32>;
var param_12: f32;
var behind: f32;
var edge: vec2<f32>;
var border: f32;
var fresnel: f32;
var reflection: vec3<f32>;
var local_2: vec3<f32>;
var phi_403_: bool;
var phi_410_: bool;
var phi_417_: bool;
let _e74 = v_uv_1;
let _e75 = textureSample(surface_texture_tex, surface_texture_smp, _e74);
surface = _e75;
let _e76 = v_uv_1;
let _e77 = textureSample(scene_texture_tex, scene_texture_smp, _e76);
scene = _e77.xyz;
let _e81 = reflection_info.screen[3u];
debugOnly = (_e81 > 0.5f);
let _e83 = debugOnly;
let _e84 = scene;
background = select(_e84, vec3<f32>(0f, 0f, 0f), vec3(_e83));
let _e88 = surface[3u];
if (_e88 <= 0f) {
let _e90 = background;
frag_color = vec4<f32>(_e90.x, _e90.y, _e90.z, 1f);
return;
}
let _e95 = surface;
param_3 = _e95.xy;
let _e97 = DecodeOctahedral_u0028_vf2_u003b((¶m_3));
normal = _e97;
let _e99 = surface[2u];
roughness = _e99;
let _e100 = roughness;
polish = (1f - smoothstep(0.18f, 0.45f, _e100));
let _e103 = polish;
if (_e103 <= 0f) {
let _e105 = background;
frag_color = vec4<f32>(_e105.x, _e105.y, _e105.z, 1f);
return;
}
let _e110 = v_uv_1;
param_4 = _e110;
let _e112 = surface[3u];
param_5 = _e112;
let _e113 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_4), (¶m_5));
position = _e113;
let _e114 = v_uv_1;
param_6 = _e114;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_6), (¶m_7), (¶m_8));
let _e115 = param_7;
rayOrigin = _e115;
let _e116 = param_8;
viewRay = _e116;
let _e117 = viewRay;
toEye = -(_e117);
let _e119 = normal;
let _e120 = toEye;
facing = dot(_e119, _e120);
let _e122 = facing;
if (_e122 <= 0.05f) {
let _e124 = background;
frag_color = vec4<f32>(_e124.x, _e124.y, _e124.z, 1f);
return;
}
let _e129 = toEye;
let _e131 = normal;
ray = reflect(-(_e129), _e131);
let _e135 = reflection_info.params[0u];
steps = i32(_e135);
let _e139 = reflection_info.params[1u];
stride = _e139;
let _e142 = reflection_info.params[2u];
thickness = _e142;
let _e145 = reflection_info.params[3u];
intensity = _e145;
let _e146 = position;
let _e147 = normal;
let _e150 = ray;
let _e151 = stride;
march = ((_e146 + (_e147 * 0.02f)) + (_e150 * _e151));
hitColor = vec3<f32>(0f, 0f, 0f);
hit = 0f;
let _e154 = stride;
travelled = _e154;
i = 0i;
loop {
let _e155 = i;
if (_e155 < 64i) {
let _e157 = i;
let _e158 = steps;
if (_e157 >= _e158) {
break;
}
let _e161 = reflection_info.view_projection;
let _e162 = march;
clip = (_e161 * vec4<f32>(_e162.x, _e162.y, _e162.z, 1f));
let _e169 = clip[3u];
if (_e169 <= 0f) {
break;
}
let _e171 = clip;
let _e174 = clip[3u];
ndc_1 = (_e171.xyz / vec3(_e174));
let _e177 = ndc_1;
param_9 = _e177.xy;
let _e179 = UvFromNdc_u0028_vf2_u003b((¶m_9));
uv_2 = _e179;
let _e181 = uv_2[0u];
let _e182 = (_e181 < 0f);
phi_403_ = _e182;
if !(_e182) {
let _e185 = uv_2[0u];
phi_403_ = (_e185 > 1f);
}
let _e188 = phi_403_;
phi_410_ = _e188;
if !(_e188) {
let _e191 = uv_2[1u];
phi_410_ = (_e191 < 0f);
}
let _e194 = phi_410_;
phi_417_ = _e194;
if !(_e194) {
let _e197 = uv_2[1u];
phi_417_ = (_e197 > 1f);
}
let _e200 = phi_417_;
if _e200 {
break;
}
let _e201 = uv_2;
let _e202 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e201, 0f);
sceneDepth = _e202.w;
let _e204 = march;
param_10 = _e204;
let _e205 = DepthOf_u0028_vf3_u003b((¶m_10));
marchDepth = _e205;
let _e206 = sceneDepth;
let _e208 = marchDepth;
let _e209 = sceneDepth;
if ((_e206 > 0f) && (_e208 > _e209)) {
let _e212 = uv_2;
param_11 = _e212;
let _e213 = sceneDepth;
param_12 = _e213;
let _e214 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_11), (¶m_12));
seen = _e214;
let _e215 = march;
let _e216 = seen;
behind = distance(_e215, _e216);
let _e218 = behind;
let _e219 = thickness;
if (_e218 < _e219) {
let _e221 = uv_2;
let _e222 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e221, 0f);
hitColor = _e222.xyz;
let _e224 = uv_2;
edge = abs(((_e224 * 2f) - vec2(1f)));
let _e230 = edge[0u];
let _e232 = edge[1u];
border = (1f - max(_e230, _e232));
let _e235 = border;
hit = smoothstep(0f, 0.15f, _e235);
break;
}
}
let _e237 = ray;
let _e238 = stride;
let _e240 = march;
march = (_e240 + (_e237 * _e238));
let _e242 = stride;
let _e243 = travelled;
travelled = (_e243 + _e242);
continue;
} else {
break;
}
continuing {
let _e245 = i;
i = (_e245 + 1i);
}
}
let _e247 = facing;
fresnel = pow((1f - _e247), 4f);
let _e250 = hitColor;
let _e251 = hit;
let _e253 = intensity;
let _e255 = polish;
let _e257 = fresnel;
reflection = ((((_e250 * _e251) * _e253) * _e255) * (0.15f + (0.85f * _e257)));
let _e261 = debugOnly;
if _e261 {
let _e262 = reflection;
local_2 = _e262;
} else {
let _e263 = scene;
let _e264 = reflection;
local_2 = (_e263 + _e264);
}
let _e266 = local_2;
frag_color = vec4<f32>(_e266.x, _e266.y, _e266.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ReflectionInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Ssao': WebGpuStage(
wgsl: r'''
struct SsaoInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> ssao_info: SsaoInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e82 = (*at);
let _e84 = ssao_info.camera;
let _e88 = ssao_info.forward;
return dot((_e82 - _e84.xyz), _e88.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e83 = (*ndc)[0u];
let _e87 = (*ndc)[1u];
return vec2<f32>(((_e83 * 0.5f) + 0.5f), (0.5f - (_e87 * 0.5f)));
}
fn KernelTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec3<f32> {
let _e82 = (*i);
if (_e82 == 0i) {
return vec3<f32>(0.5381f, 0.1856f, 0.4319f);
}
let _e84 = (*i);
if (_e84 == 1i) {
return vec3<f32>(0.1379f, 0.2486f, 0.443f);
}
let _e86 = (*i);
if (_e86 == 2i) {
return vec3<f32>(0.3371f, 0.5679f, 0.0057f);
}
let _e88 = (*i);
if (_e88 == 3i) {
return vec3<f32>(-0.6999f, -0.0451f, 0.0019f);
}
let _e90 = (*i);
if (_e90 == 4i) {
return vec3<f32>(0.0689f, -0.1598f, -0.8547f);
}
let _e92 = (*i);
if (_e92 == 5i) {
return vec3<f32>(0.056f, 0.0069f, -0.1843f);
}
let _e94 = (*i);
if (_e94 == 6i) {
return vec3<f32>(-0.0146f, 0.1402f, 0.0762f);
}
let _e96 = (*i);
if (_e96 == 7i) {
return vec3<f32>(0.01f, -0.1924f, -0.0344f);
}
let _e98 = (*i);
if (_e98 == 8i) {
return vec3<f32>(-0.3577f, -0.5301f, -0.4358f);
}
let _e100 = (*i);
if (_e100 == 9i) {
return vec3<f32>(-0.3169f, 0.1063f, 0.0158f);
}
let _e102 = (*i);
if (_e102 == 10i) {
return vec3<f32>(0.0103f, -0.5869f, 0.0046f);
}
return vec3<f32>(-0.0897f, -0.494f, 0.3287f);
}
fn Rotation_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixel: vec2<f32>;
var oddX: bool;
var oddY: bool;
let _e85 = (*uv);
let _e87 = ssao_info.screen;
pixel = floor((_e85 / _e87.xy));
let _e92 = pixel[0u];
oddX = ((_e92 - (floor((_e92 / 2f)) * 2f)) >= 1f);
let _e99 = pixel[1u];
oddY = ((_e99 - (floor((_e99 / 2f)) * 2f)) >= 1f);
let _e105 = oddX;
let _e106 = oddY;
if (_e105 && _e106) {
return vec2<f32>(-0.7071f, -0.7071f);
}
let _e108 = oddX;
if _e108 {
return vec2<f32>(0.7071f, -0.7071f);
}
let _e109 = oddY;
if _e109 {
return vec2<f32>(-0.7071f, 0.7071f);
}
return vec2<f32>(1f, 0f);
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var axis: vec3<f32>;
let _e90 = (*uv_1)[0u];
let _e94 = (*uv_1)[1u];
xy = vec2<f32>(((_e90 * 2f) - 1f), (1f - (_e94 * 2f)));
let _e99 = ssao_info.inverse_view_projection;
let _e100 = xy;
nearH = (_e99 * vec4<f32>(_e100.x, _e100.y, 0f, 1f));
let _e106 = ssao_info.inverse_view_projection;
let _e107 = xy;
farH = (_e106 * vec4<f32>(_e107.x, _e107.y, 1f, 1f));
let _e112 = nearH;
let _e115 = nearH[3u];
origin = (_e112.xyz / vec3(_e115));
let _e118 = farH;
let _e121 = farH[3u];
let _e124 = origin;
along = normalize(((_e118.xyz / vec3(_e121)) - _e124));
let _e128 = ssao_info.forward;
axis = _e128.xyz;
let _e130 = origin;
let _e131 = along;
let _e132 = (*depth);
let _e133 = origin;
let _e135 = ssao_info.camera;
let _e138 = axis;
let _e141 = along;
let _e142 = axis;
return (_e130 + (_e131 * ((_e132 - dot((_e133 - _e135.xyz), _e138)) / dot(_e141, _e142))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e86 = (*e);
(*e) = ((_e86 * 2f) - vec2(1f));
let _e90 = (*e);
let _e92 = (*e)[0u];
let _e96 = (*e)[1u];
n = vec3<f32>(_e90.x, _e90.y, ((1f - abs(_e92)) - abs(_e96)));
let _e103 = n[2u];
t = max(-(_e103), 0f);
let _e107 = n[0u];
if (_e107 >= 0f) {
let _e109 = t;
local = -(_e109);
} else {
let _e111 = t;
local = _e111;
}
let _e112 = local;
let _e114 = n[0u];
n[0u] = (_e114 + _e112);
let _e118 = n[1u];
if (_e118 >= 0f) {
let _e120 = t;
local_1 = -(_e120);
} else {
let _e122 = t;
local_1 = _e122;
}
let _e123 = local_1;
let _e125 = n[1u];
n[1u] = (_e125 + _e123);
let _e128 = n;
return normalize(_e128);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param: vec2<f32>;
var radius: f32;
var samples: i32;
var origin_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var rot: vec2<f32>;
var param_3: vec2<f32>;
var occluded: f32;
var i_1: i32;
var tap: vec3<f32>;
var param_4: i32;
var spun: vec3<f32>;
var at_1: vec3<f32>;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_2: vec2<f32>;
var param_5: vec2<f32>;
var there: vec4<f32>;
var param_6: vec3<f32>;
var seen: vec3<f32>;
var param_7: vec2<f32>;
var param_8: f32;
var phi_506_: bool;
let _e106 = v_uv_1;
let _e107 = textureSample(surface_texture_tex, surface_texture_smp, _e106);
surface = _e107;
let _e109 = surface[3u];
if (_e109 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e111 = surface;
param = _e111.xy;
let _e113 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e113;
let _e116 = ssao_info.params[0u];
radius = max(_e116, 0.0001f);
let _e120 = ssao_info.params[1u];
samples = clamp(i32((_e120 + 0.5f)), 1i, 12i);
let _e124 = v_uv_1;
param_1 = _e124;
let _e126 = surface[3u];
param_2 = _e126;
let _e127 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_1), (¶m_2));
let _e128 = normal;
let _e131 = ssao_info.params[3u];
origin_1 = (_e127 + (_e128 * _e131));
let _e134 = v_uv_1;
param_3 = _e134;
let _e135 = Rotation_u0028_vf2_u003b((¶m_3));
rot = _e135;
occluded = 0f;
i_1 = 0i;
loop {
let _e136 = i_1;
if (_e136 < 12i) {
let _e138 = i_1;
let _e139 = samples;
if (_e138 >= _e139) {
break;
}
let _e141 = i_1;
param_4 = _e141;
let _e142 = KernelTap_u0028_i1_u003b((¶m_4));
tap = _e142;
let _e144 = tap[0u];
let _e146 = rot[0u];
let _e149 = tap[1u];
let _e151 = rot[1u];
let _e155 = tap[0u];
let _e157 = rot[1u];
let _e160 = tap[1u];
let _e162 = rot[0u];
let _e166 = tap[2u];
spun = vec3<f32>(((_e144 * _e146) - (_e149 * _e151)), ((_e155 * _e157) + (_e160 * _e162)), _e166);
let _e168 = spun;
let _e169 = normal;
if (dot(_e168, _e169) < 0f) {
let _e172 = spun;
spun = -(_e172);
}
let _e174 = origin_1;
let _e175 = spun;
let _e176 = radius;
at_1 = (_e174 + (_e175 * _e176));
let _e180 = ssao_info.view_projection;
let _e181 = at_1;
clip = (_e180 * vec4<f32>(_e181.x, _e181.y, _e181.z, 1f));
let _e188 = clip[3u];
if (_e188 <= 0f) {
continue;
}
let _e190 = clip;
let _e193 = clip[3u];
ndc_1 = (_e190.xyz / vec3(_e193));
let _e197 = ndc_1[0u];
let _e199 = (abs(_e197) > 1f);
phi_506_ = _e199;
if !(_e199) {
let _e202 = ndc_1[1u];
phi_506_ = (abs(_e202) > 1f);
}
let _e206 = phi_506_;
if _e206 {
continue;
}
let _e207 = ndc_1;
param_5 = _e207.xy;
let _e209 = UvFromNdc_u0028_vf2_u003b((¶m_5));
uv_2 = _e209;
let _e210 = uv_2;
let _e211 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e210, 0f);
there = _e211;
let _e213 = there[3u];
if (_e213 <= 0f) {
continue;
}
let _e216 = there[3u];
let _e217 = at_1;
param_6 = _e217;
let _e218 = DepthOf_u0028_vf3_u003b((¶m_6));
if (_e216 >= _e218) {
continue;
}
let _e220 = uv_2;
param_7 = _e220;
let _e222 = there[3u];
param_8 = _e222;
let _e223 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_7), (¶m_8));
seen = _e223;
let _e224 = radius;
let _e225 = seen;
let _e226 = origin_1;
let _e231 = occluded;
occluded = (_e231 + smoothstep(0f, 1f, (_e224 / max(distance(_e225, _e226), 0.0001f))));
continue;
} else {
break;
}
continuing {
let _e233 = i_1;
i_1 = (_e233 + 1i);
}
}
let _e235 = occluded;
let _e236 = samples;
frag_color = vec4(clamp((1f - (_e235 / f32(_e236))), 0f, 1f));
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'SsaoInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'SsaoBlur': WebGpuStage(
wgsl: r'''
struct SsaoBlurInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> blur_info: SsaoBlurInfo;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
fn main_1() {
var taps: f32;
var centre: f32;
var centreDepth: f32;
var falloff: f32;
var total: f32;
var weightSum: f32;
var i: i32;
var offset: f32;
var steps: array<vec2<f32>, 4>;
var s: i32;
var at: vec2<f32>;
var depth: f32;
var closeness: f32;
var weight: f32;
var blurred: f32;
let _e38 = blur_info.params[2u];
taps = _e38;
let _e39 = v_uv_1;
let _e40 = textureSample(ao_texture_tex, ao_texture_smp, _e39);
centre = _e40.x;
let _e42 = taps;
if (_e42 < 1f) {
let _e44 = centre;
frag_color = vec4<f32>(_e44, _e44, _e44, 1f);
return;
}
let _e46 = v_uv_1;
let _e47 = textureSample(surface_texture_tex, surface_texture_smp, _e46);
centreDepth = _e47.w;
let _e51 = blur_info.params[3u];
falloff = max(_e51, 0.0001f);
let _e53 = centre;
total = _e53;
weightSum = 1f;
i = 1i;
loop {
let _e54 = i;
if (_e54 <= 8i) {
let _e56 = i;
let _e58 = taps;
if (f32(_e56) > _e58) {
break;
}
let _e60 = i;
offset = f32(_e60);
let _e64 = blur_info.params[0u];
let _e65 = offset;
steps[0i] = vec2<f32>((_e64 * _e65), 0f);
let _e71 = blur_info.params[0u];
let _e73 = offset;
steps[1i] = vec2<f32>((-(_e71) * _e73), 0f);
let _e79 = blur_info.params[1u];
let _e80 = offset;
steps[2i] = vec2<f32>(0f, (_e79 * _e80));
let _e86 = blur_info.params[1u];
let _e88 = offset;
steps[3i] = vec2<f32>(0f, (-(_e86) * _e88));
s = 0i;
loop {
let _e92 = s;
if (_e92 < 4i) {
let _e94 = v_uv_1;
let _e95 = s;
let _e97 = steps[_e95];
at = (_e94 + _e97);
let _e99 = at;
let _e100 = textureSample(surface_texture_tex, surface_texture_smp, _e99);
depth = _e100.w;
let _e102 = depth;
let _e103 = centreDepth;
let _e107 = falloff;
closeness = exp((-(abs((_e102 - _e103))) / _e107));
let _e110 = closeness;
let _e111 = offset;
weight = (_e110 / _e111);
let _e113 = at;
let _e114 = textureSample(ao_texture_tex, ao_texture_smp, _e113);
let _e116 = weight;
let _e118 = total;
total = (_e118 + (_e114.x * _e116));
let _e120 = weight;
let _e121 = weightSum;
weightSum = (_e121 + _e120);
continue;
} else {
break;
}
continuing {
let _e123 = s;
s = (_e123 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e125 = i;
i = (_e125 + 1i);
}
}
let _e127 = total;
let _e128 = weightSum;
blurred = (_e127 / _e128);
let _e130 = blurred;
frag_color = vec4<f32>(_e130, _e130, _e130, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'SsaoBlurInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ContactShadow': WebGpuStage(
wgsl: r'''
struct ContactShadowInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
to_light: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> contact_info: ContactShadowInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e23 = (*at);
let _e25 = contact_info.camera;
let _e29 = contact_info.forward;
return dot((_e23 - _e25.xyz), _e29.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e24 = (*ndc)[0u];
let _e28 = (*ndc)[1u];
return vec2<f32>(((_e24 * 0.5f) + 0.5f), (0.5f - (_e28 * 0.5f)));
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var axis: vec3<f32>;
let _e31 = (*uv)[0u];
let _e35 = (*uv)[1u];
xy = vec2<f32>(((_e31 * 2f) - 1f), (1f - (_e35 * 2f)));
let _e40 = contact_info.inverse_view_projection;
let _e41 = xy;
nearH = (_e40 * vec4<f32>(_e41.x, _e41.y, 0f, 1f));
let _e47 = contact_info.inverse_view_projection;
let _e48 = xy;
farH = (_e47 * vec4<f32>(_e48.x, _e48.y, 1f, 1f));
let _e53 = nearH;
let _e56 = nearH[3u];
origin = (_e53.xyz / vec3(_e56));
let _e59 = farH;
let _e62 = farH[3u];
let _e65 = origin;
along = normalize(((_e59.xyz / vec3(_e62)) - _e65));
let _e69 = contact_info.forward;
axis = _e69.xyz;
let _e71 = origin;
let _e72 = along;
let _e73 = (*depth);
let _e74 = origin;
let _e76 = contact_info.camera;
let _e79 = axis;
let _e82 = along;
let _e83 = axis;
return (_e71 + (_e72 * ((_e73 - dot((_e74 - _e76.xyz), _e79)) / dot(_e82, _e83))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e27 = (*e);
(*e) = ((_e27 * 2f) - vec2(1f));
let _e31 = (*e);
let _e33 = (*e)[0u];
let _e37 = (*e)[1u];
n = vec3<f32>(_e31.x, _e31.y, ((1f - abs(_e33)) - abs(_e37)));
let _e44 = n[2u];
t = max(-(_e44), 0f);
let _e48 = n[0u];
if (_e48 >= 0f) {
let _e50 = t;
local = -(_e50);
} else {
let _e52 = t;
local = _e52;
}
let _e53 = local;
let _e55 = n[0u];
n[0u] = (_e55 + _e53);
let _e59 = n[1u];
if (_e59 >= 0f) {
let _e61 = t;
local_1 = -(_e61);
} else {
let _e63 = t;
local_1 = _e63;
}
let _e64 = local_1;
let _e66 = n[1u];
n[1u] = (_e66 + _e64);
let _e69 = n;
return normalize(_e69);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param: vec2<f32>;
var toLight: vec3<f32>;
var reach: f32;
var steps: i32;
var thickness: f32;
var origin_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var stride: f32;
var i: i32;
var at_1: vec3<f32>;
var clip: vec4<f32>;
var uv_1: vec2<f32>;
var param_3: vec2<f32>;
var there: vec4<f32>;
var marched: f32;
var param_4: vec3<f32>;
var gap: f32;
var phi_331_: bool;
var phi_338_: bool;
var phi_345_: bool;
let _e42 = v_uv_1;
let _e43 = textureSample(surface_texture_tex, surface_texture_smp, _e42);
surface = _e43;
let _e45 = surface[3u];
if (_e45 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e47 = surface;
param = _e47.xy;
let _e49 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e49;
let _e51 = contact_info.to_light;
toLight = normalize(_e51.xyz);
let _e54 = normal;
let _e55 = toLight;
if (dot(_e54, _e55) <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e60 = contact_info.params[0u];
reach = max(_e60, 0.0001f);
let _e64 = contact_info.params[1u];
steps = clamp(i32((_e64 + 0.5f)), 1i, 16i);
let _e70 = contact_info.params[2u];
thickness = max(_e70, 0.0001f);
let _e72 = v_uv_1;
param_1 = _e72;
let _e74 = surface[3u];
param_2 = _e74;
let _e75 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_1), (¶m_2));
let _e76 = normal;
let _e79 = contact_info.params[3u];
origin_1 = (_e75 + (_e76 * _e79));
let _e82 = reach;
let _e83 = steps;
stride = (_e82 / f32(_e83));
i = 0i;
loop {
let _e86 = i;
if (_e86 < 16i) {
let _e88 = i;
let _e89 = steps;
if (_e88 >= _e89) {
break;
}
let _e91 = origin_1;
let _e92 = toLight;
let _e93 = stride;
let _e94 = i;
at_1 = (_e91 + (_e92 * (_e93 * f32((_e94 + 1i)))));
let _e101 = contact_info.view_projection;
let _e102 = at_1;
clip = (_e101 * vec4<f32>(_e102.x, _e102.y, _e102.z, 1f));
let _e109 = clip[3u];
if (_e109 <= 0f) {
break;
}
let _e111 = clip;
let _e114 = clip[3u];
param_3 = (_e111.xy / vec2(_e114));
let _e117 = UvFromNdc_u0028_vf2_u003b((¶m_3));
uv_1 = _e117;
let _e119 = uv_1[0u];
let _e120 = (_e119 < 0f);
phi_331_ = _e120;
if !(_e120) {
let _e123 = uv_1[0u];
phi_331_ = (_e123 > 1f);
}
let _e126 = phi_331_;
phi_338_ = _e126;
if !(_e126) {
let _e129 = uv_1[1u];
phi_338_ = (_e129 < 0f);
}
let _e132 = phi_338_;
phi_345_ = _e132;
if !(_e132) {
let _e135 = uv_1[1u];
phi_345_ = (_e135 > 1f);
}
let _e138 = phi_345_;
if _e138 {
break;
}
let _e139 = uv_1;
let _e140 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e139, 0f);
there = _e140;
let _e142 = there[3u];
if (_e142 <= 0f) {
continue;
}
let _e144 = at_1;
param_4 = _e144;
let _e145 = DepthOf_u0028_vf3_u003b((¶m_4));
marched = _e145;
let _e146 = marched;
let _e148 = there[3u];
gap = (_e146 - _e148);
let _e150 = gap;
let _e152 = gap;
let _e153 = thickness;
if ((_e150 > 0f) && (_e152 < _e153)) {
let _e156 = i;
let _e158 = steps;
frag_color = vec4((f32(_e156) / f32(_e158)));
return;
}
continue;
} else {
break;
}
continuing {
let _e162 = i;
i = (_e162 + 1i);
}
}
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ContactShadowInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'to_light',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LightShafts': WebGpuStage(
wgsl: r'''
struct ShaftInfo {
inverse_view_projection: mat4x4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
scatter: vec4<f32>,
cascades: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> shaft_info: ShaftInfo;
@group(1) @binding(3)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var shadow_texture_smp: sampler;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
fn LitAt_u0028_vf3_u003b_f1_u003b(world: ptr<function, vec3<f32>>, viewDistance: ptr<function, f32>) -> f32 {
var cascadeCount: i32;
var cascade: i32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local: mat4x4<f32>;
var local_1: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var uv: vec2<f32>;
var stored: f32;
var phi_176_: bool;
var phi_187_: bool;
var phi_273_: bool;
var phi_280_: bool;
var phi_287_: bool;
let _e66 = shaft_info.cascades[2u];
cascadeCount = i32((_e66 + 0.5f));
cascade = 0i;
let _e69 = cascadeCount;
let _e70 = (_e69 > 1i);
phi_176_ = _e70;
if _e70 {
let _e71 = (*viewDistance);
let _e74 = shaft_info.cascades[0u];
phi_176_ = (_e71 > _e74);
}
let _e77 = phi_176_;
if _e77 {
cascade = 1i;
}
let _e78 = cascadeCount;
let _e79 = (_e78 > 2i);
phi_187_ = _e79;
if _e79 {
let _e80 = (*viewDistance);
let _e83 = shaft_info.cascades[1u];
phi_187_ = (_e80 > _e83);
}
let _e86 = phi_187_;
if _e86 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e87 = attempt;
if (_e87 < 3i) {
let _e89 = cascade;
let _e90 = attempt;
which = (_e89 + _e90);
let _e92 = which;
let _e93 = cascadeCount;
if (_e92 >= _e93) {
break;
}
let _e95 = which;
if (_e95 == 0i) {
let _e98 = shaft_info.shadow_matrix;
local = _e98;
} else {
let _e99 = which;
if (_e99 == 1i) {
let _e102 = shaft_info.shadow_matrix_far;
local_1 = _e102;
} else {
let _e104 = shaft_info.shadow_matrix_farthest;
local_1 = _e104;
}
let _e105 = local_1;
local = _e105;
}
let _e106 = local;
matrix = _e106;
let _e107 = matrix;
let _e108 = (*world);
lightSpace = (_e107 * vec4<f32>(_e108.x, _e108.y, _e108.z, 1f));
let _e115 = lightSpace[3u];
if (_e115 <= 0f) {
continue;
}
let _e117 = lightSpace;
let _e120 = lightSpace[3u];
candidate = (_e117.xyz / vec3(_e120));
let _e124 = candidate[0u];
let _e128 = candidate[1u];
inTile = vec2<f32>(((_e124 * 0.5f) + 0.5f), (0.5f - (_e128 * 0.5f)));
let _e133 = inTile[0u];
let _e134 = (_e133 < 0f);
phi_273_ = _e134;
if !(_e134) {
let _e137 = inTile[0u];
phi_273_ = (_e137 > 1f);
}
let _e140 = phi_273_;
phi_280_ = _e140;
if !(_e140) {
let _e143 = inTile[1u];
phi_280_ = (_e143 < 0f);
}
let _e146 = phi_280_;
phi_287_ = _e146;
if !(_e146) {
let _e149 = inTile[1u];
phi_287_ = (_e149 > 1f);
}
let _e152 = phi_287_;
if _e152 {
continue;
}
let _e154 = candidate[2u];
if (_e154 > 1f) {
continue;
}
let _e157 = inTile[0u];
let _e158 = which;
let _e161 = cascadeCount;
let _e165 = inTile[1u];
uv = vec2<f32>(((_e157 + f32(_e158)) / f32(_e161)), _e165);
let _e167 = uv;
let _e168 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e167, 0f);
stored = _e168.x;
let _e171 = candidate[2u];
let _e174 = shaft_info.cascades[3u];
let _e176 = stored;
return select(1f, 0f, ((_e171 - _e174) > _e176));
} else {
break;
}
continuing {
let _e179 = attempt;
attempt = (_e179 + 1i);
}
}
return 1f;
}
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e56 = (*at)[0u];
x = i32((_e56 - (floor((_e56 / 4f)) * 4f)));
let _e63 = (*at)[1u];
y = i32((_e63 - (floor((_e63 / 4f)) * 4f)));
let _e69 = y;
let _e71 = x;
index = ((_e69 * 4i) + _e71);
value = 0f;
let _e73 = index;
if (_e73 == 0i) {
value = 0f;
} else {
let _e75 = index;
if (_e75 == 1i) {
value = 8f;
} else {
let _e77 = index;
if (_e77 == 2i) {
value = 2f;
} else {
let _e79 = index;
if (_e79 == 3i) {
value = 10f;
} else {
let _e81 = index;
if (_e81 == 4i) {
value = 12f;
} else {
let _e83 = index;
if (_e83 == 5i) {
value = 4f;
} else {
let _e85 = index;
if (_e85 == 6i) {
value = 14f;
} else {
let _e87 = index;
if (_e87 == 7i) {
value = 6f;
} else {
let _e89 = index;
if (_e89 == 8i) {
value = 3f;
} else {
let _e91 = index;
if (_e91 == 9i) {
value = 11f;
} else {
let _e93 = index;
if (_e93 == 10i) {
value = 1f;
} else {
let _e95 = index;
if (_e95 == 11i) {
value = 9f;
} else {
let _e97 = index;
if (_e97 == 12i) {
value = 15f;
} else {
let _e99 = index;
if (_e99 == 13i) {
value = 7f;
} else {
let _e101 = index;
if (_e101 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e103 = value;
return (_e103 / 16f);
}
fn main_1() {
var scene: vec4<f32>;
var steps: i32;
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var surfaceDepth: f32;
var cosine: f32;
var toSurface: f32;
var local_2: f32;
var distance_: f32;
var stride: f32;
var offset: f32;
var param: vec2<f32>;
var lit: f32;
var i: i32;
var travelled: f32;
var at_1: vec3<f32>;
var param_1: vec3<f32>;
var param_2: f32;
var shaft: vec3<f32>;
let _e72 = v_uv_1;
let _e73 = textureSample(scene_texture_tex, scene_texture_smp, _e72);
scene = _e73;
let _e76 = shaft_info.forward[3u];
steps = i32((_e76 + 0.5f));
let _e79 = steps;
if (_e79 < 1i) {
let _e81 = scene;
frag_color = _e81;
return;
}
let _e83 = v_uv_1[0u];
let _e87 = v_uv_1[1u];
xy = vec2<f32>(((_e83 * 2f) - 1f), (1f - (_e87 * 2f)));
let _e92 = shaft_info.inverse_view_projection;
let _e93 = xy;
nearH = (_e92 * vec4<f32>(_e93.x, _e93.y, 0f, 1f));
let _e99 = shaft_info.inverse_view_projection;
let _e100 = xy;
farH = (_e99 * vec4<f32>(_e100.x, _e100.y, 1f, 1f));
let _e105 = nearH;
let _e108 = nearH[3u];
origin = (_e105.xyz / vec3(_e108));
let _e111 = farH;
let _e114 = farH[3u];
let _e117 = origin;
along = normalize(((_e111.xyz / vec3(_e114)) - _e117));
let _e120 = v_uv_1;
let _e121 = textureSample(surface_texture_tex, surface_texture_smp, _e120);
surfaceDepth = _e121.w;
let _e123 = along;
let _e125 = shaft_info.forward;
cosine = max(dot(_e123, _e125.xyz), 0.0001f);
let _e129 = surfaceDepth;
if (_e129 > 0f) {
let _e131 = surfaceDepth;
let _e132 = cosine;
local_2 = (_e131 / _e132);
} else {
local_2 = 1000000000f;
}
let _e134 = local_2;
toSurface = _e134;
let _e137 = shaft_info.camera[3u];
let _e138 = toSurface;
distance_ = min(_e137, _e138);
let _e140 = distance_;
if (_e140 <= 0f) {
let _e142 = scene;
frag_color = _e142;
return;
}
let _e143 = distance_;
let _e144 = steps;
stride = (_e143 / f32(_e144));
let _e147 = gl_FragCoord_1;
param = _e147.xy;
let _e149 = BayerCell_u0028_vf2_u003b((¶m));
let _e150 = stride;
offset = (_e149 * _e150);
lit = 0f;
i = 0i;
loop {
let _e152 = i;
if (_e152 < 64i) {
let _e154 = i;
let _e155 = steps;
if (_e154 >= _e155) {
break;
}
let _e157 = offset;
let _e158 = i;
let _e160 = stride;
travelled = (_e157 + (f32(_e158) * _e160));
let _e163 = origin;
let _e164 = along;
let _e165 = travelled;
at_1 = (_e163 + (_e164 * _e165));
let _e168 = travelled;
let _e169 = cosine;
let _e171 = at_1;
param_1 = _e171;
param_2 = (_e168 * _e169);
let _e172 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_1), (¶m_2));
let _e173 = lit;
lit = (_e173 + _e172);
continue;
} else {
break;
}
continuing {
let _e175 = i;
i = (_e175 + 1i);
}
}
let _e178 = shaft_info.scatter;
let _e180 = lit;
let _e181 = steps;
shaft = (_e178.xyz * (_e180 / f32(_e181)));
let _e185 = scene;
let _e187 = shaft;
let _e188 = (_e185.xyz + _e187);
let _e190 = scene[3u];
frag_color = vec4<f32>(_e188.x, _e188.y, _e188.z, _e190);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShaftInfo',
group: 1,
binding: 0,
sizeInBytes: 320,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 128,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 192,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 256,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'scatter',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cascades',
offsetInBytes: 304,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DepthOfField': WebGpuStage(
wgsl: r'''
struct DofInfo {
lens: vec4<f32>,
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> dof_info: DofInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
fn CircleAt_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {
var focus: f32;
var focal: f32;
var fnumber: f32;
var denominator: f32;
var diameter: f32;
let _e29 = dof_info.lens[0u];
focus = max(_e29, 0.001f);
let _e33 = dof_info.lens[1u];
focal = max(_e33, 0.0001f);
let _e37 = dof_info.lens[2u];
fnumber = max(_e37, 0.001f);
let _e39 = (*depth);
if (_e39 <= 0f) {
return 0f;
}
let _e41 = fnumber;
let _e42 = focus;
let _e43 = focal;
denominator = max((_e41 * (_e42 - _e43)), 0.000001f);
let _e47 = (*depth);
let _e48 = focus;
let _e51 = (*depth);
let _e53 = focal;
let _e54 = focal;
let _e57 = denominator;
diameter = (((abs((_e47 - _e48)) / _e51) * (_e53 * _e54)) / _e57);
let _e59 = diameter;
let _e63 = dof_info.params[3u];
let _e67 = dof_info.params[2u];
return min(((_e59 * 0.5f) * _e63), max(_e67, 0f));
}
fn main_1() {
var centre: vec4<f32>;
var samples: i32;
var centreDepth: f32;
var radius: f32;
var param: f32;
var total: vec3<f32>;
var weight: f32;
var i: i32;
var t: f32;
var r: f32;
var angle: f32;
var at: vec2<f32>;
var tap: vec4<f32>;
var tapDepth: f32;
var tapRadius: f32;
var param_1: f32;
var reach: f32;
let _e38 = v_uv_1;
let _e39 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e38, 0f);
centre = _e39;
let _e42 = dof_info.lens[3u];
samples = i32((_e42 + 0.5f));
let _e45 = samples;
if (_e45 < 1i) {
let _e47 = centre;
frag_color = _e47;
return;
}
let _e48 = v_uv_1;
let _e49 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e48, 0f);
centreDepth = _e49.w;
let _e51 = centreDepth;
param = _e51;
let _e52 = CircleAt_u0028_f1_u003b((¶m));
radius = _e52;
let _e53 = radius;
if (_e53 < 0.5f) {
let _e55 = centre;
frag_color = _e55;
return;
}
let _e56 = centre;
total = _e56.xyz;
weight = 1f;
i = 1i;
loop {
let _e58 = i;
if (_e58 <= 64i) {
let _e60 = i;
let _e61 = samples;
if (_e60 > _e61) {
break;
}
let _e63 = i;
let _e65 = samples;
t = (f32(_e63) / f32(_e65));
let _e68 = t;
let _e70 = radius;
r = (sqrt(_e68) * _e70);
let _e72 = i;
angle = (f32(_e72) * 2.3999631f);
let _e75 = v_uv_1;
let _e76 = angle;
let _e78 = angle;
let _e81 = r;
let _e84 = dof_info.params;
at = (_e75 + ((vec2<f32>(cos(_e76), sin(_e78)) * _e81) * _e84.xy));
let _e88 = at;
let _e89 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e88, 0f);
tap = _e89;
let _e90 = at;
let _e91 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e90, 0f);
tapDepth = _e91.w;
let _e93 = tapDepth;
param_1 = _e93;
let _e94 = CircleAt_u0028_f1_u003b((¶m_1));
tapRadius = _e94;
let _e95 = r;
let _e96 = tapRadius;
let _e97 = radius;
reach = select(0f, 1f, (_e95 <= max(_e96, _e97)));
let _e101 = tap;
let _e103 = reach;
let _e105 = total;
total = (_e105 + (_e101.xyz * _e103));
let _e107 = reach;
let _e108 = weight;
weight = (_e108 + _e107);
continue;
} else {
break;
}
continuing {
let _e110 = i;
i = (_e110 + 1i);
}
}
let _e112 = total;
let _e113 = weight;
let _e115 = (_e112 / vec3(_e113));
let _e117 = centre[3u];
frag_color = vec4<f32>(_e115.x, _e115.y, _e115.z, _e117);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'DofInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'lens', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ViewportShade': WebGpuStage(
wgsl: r'''
struct ShadeInfo {
params: vec4<f32>,
screen: vec4<f32>,
light: vec4<f32>,
}
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> shade_info: ShadeInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e27 = (*e);
(*e) = ((_e27 * 2f) - vec2(1f));
let _e31 = (*e);
let _e33 = (*e)[0u];
let _e37 = (*e)[1u];
n = vec3<f32>(_e31.x, _e31.y, ((1f - abs(_e33)) - abs(_e37)));
let _e44 = n[2u];
t = max(-(_e44), 0f);
let _e48 = n[0u];
if (_e48 >= 0f) {
let _e50 = t;
local = -(_e50);
} else {
let _e52 = t;
local = _e52;
}
let _e53 = local;
let _e55 = n[0u];
n[0u] = (_e55 + _e53);
let _e59 = n[1u];
if (_e59 >= 0f) {
let _e61 = t;
local_1 = -(_e61);
} else {
let _e63 = t;
local_1 = _e63;
}
let _e64 = local_1;
let _e66 = n[1u];
n[1u] = (_e66 + _e64);
let _e69 = n;
return normalize(_e69);
}
fn main_1() {
var scene: vec4<f32>;
var mode: i32;
var mix_amount: f32;
var surface: vec4<f32>;
var depth: f32;
var normal: vec3<f32>;
var param: vec2<f32>;
var shaded: vec3<f32>;
var ambient: f32;
var lambert: f32;
var texel: vec2<f32>;
var depthEdge: f32;
var normalEdge: f32;
var offsets: array<vec2<f32>, 4>;
var i: i32;
var tap: vec4<f32>;
var param_1: vec2<f32>;
var depthHit: f32;
var normalHit: f32;
var edge: f32;
var texel_1: vec2<f32>;
var right: vec3<f32>;
var param_2: vec2<f32>;
var left: vec3<f32>;
var param_3: vec2<f32>;
var down: vec3<f32>;
var param_4: vec2<f32>;
var up: vec3<f32>;
var param_5: vec2<f32>;
var curvature: f32;
var cavity: f32;
var ridge: f32;
let _e54 = v_uv_1;
let _e55 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e54, 0f);
scene = _e55;
let _e58 = shade_info.params[0u];
mode = i32((_e58 + 0.5f));
let _e63 = shade_info.params[1u];
mix_amount = clamp(_e63, 0f, 1f);
let _e65 = mode;
let _e67 = mix_amount;
if ((_e65 < 1i) || (_e67 <= 0f)) {
let _e70 = scene;
frag_color = _e70;
return;
}
let _e71 = v_uv_1;
let _e72 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e71, 0f);
surface = _e72;
let _e74 = surface[3u];
depth = _e74;
let _e75 = depth;
if (_e75 <= 0f) {
let _e77 = scene;
frag_color = _e77;
return;
}
let _e78 = surface;
param = _e78.xy;
let _e80 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e80;
let _e81 = scene;
shaded = _e81.xyz;
let _e83 = mode;
if (_e83 == 1i) {
let _e85 = normal;
shaded = ((_e85 * 0.5f) + vec3(0.5f));
} else {
let _e89 = mode;
if (_e89 == 2i) {
let _e93 = shade_info.params[2u];
ambient = clamp(_e93, 0f, 1f);
let _e95 = normal;
let _e97 = shade_info.light;
lambert = max(dot(_e95, normalize(_e97.xyz)), 0f);
let _e102 = ambient;
let _e103 = ambient;
let _e105 = lambert;
shaded = vec3((_e102 + ((1f - _e103) * _e105)));
} else {
let _e109 = mode;
if (_e109 == 3i) {
let _e112 = shade_info.screen;
let _e116 = shade_info.screen[2u];
texel = (_e112.xy * max(_e116, 1f));
depthEdge = 0f;
normalEdge = 0f;
let _e120 = texel[0u];
let _e123 = texel[0u];
let _e127 = texel[1u];
let _e130 = texel[1u];
offsets = array<vec2<f32>, 4>(vec2<f32>(_e120, 0f), vec2<f32>(-(_e123), 0f), vec2<f32>(0f, _e127), vec2<f32>(0f, -(_e130)));
i = 0i;
loop {
let _e134 = i;
if (_e134 < 4i) {
let _e136 = v_uv_1;
let _e137 = i;
let _e139 = offsets[_e137];
let _e141 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e136 + _e139), 0f);
tap = _e141;
let _e143 = tap[3u];
if (_e143 <= 0f) {
depthEdge = 1f;
continue;
}
let _e145 = depthEdge;
let _e147 = tap[3u];
let _e148 = depth;
depthEdge = max(_e145, abs((_e147 - _e148)));
let _e152 = normalEdge;
let _e153 = tap;
param_1 = _e153.xy;
let _e155 = DecodeOctahedral_u0028_vf2_u003b((¶m_1));
let _e156 = normal;
normalEdge = max(_e152, (1f - dot(_e155, _e156)));
continue;
} else {
break;
}
continuing {
let _e160 = i;
i = (_e160 + 1i);
}
}
let _e164 = shade_info.params[2u];
let _e166 = depthEdge;
depthHit = step(max(_e164, 0.0001f), _e166);
let _e170 = shade_info.params[3u];
let _e172 = normalEdge;
normalHit = step(max(_e170, 0.0001f), _e172);
let _e174 = depthHit;
let _e175 = normalHit;
edge = max(_e174, _e175);
let _e177 = scene;
let _e179 = edge;
shaded = (_e177.xyz * (1f - _e179));
} else {
let _e182 = mode;
if (_e182 == 4i) {
let _e185 = shade_info.screen;
texel_1 = _e185.xy;
let _e187 = v_uv_1;
let _e189 = texel_1[0u];
let _e192 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e187 + vec2<f32>(_e189, 0f)), 0f);
param_2 = _e192.xy;
let _e194 = DecodeOctahedral_u0028_vf2_u003b((¶m_2));
right = _e194;
let _e195 = v_uv_1;
let _e197 = texel_1[0u];
let _e200 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e195 - vec2<f32>(_e197, 0f)), 0f);
param_3 = _e200.xy;
let _e202 = DecodeOctahedral_u0028_vf2_u003b((¶m_3));
left = _e202;
let _e203 = v_uv_1;
let _e205 = texel_1[1u];
let _e208 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e203 + vec2<f32>(0f, _e205)), 0f);
param_4 = _e208.xy;
let _e210 = DecodeOctahedral_u0028_vf2_u003b((¶m_4));
down = _e210;
let _e211 = v_uv_1;
let _e213 = texel_1[1u];
let _e216 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e211 - vec2<f32>(0f, _e213)), 0f);
param_5 = _e216.xy;
let _e218 = DecodeOctahedral_u0028_vf2_u003b((¶m_5));
up = _e218;
let _e220 = right[0u];
let _e222 = left[0u];
let _e225 = down[1u];
let _e227 = up[1u];
let _e232 = shade_info.params[2u];
curvature = (((_e220 - _e222) + (_e225 - _e227)) * max(_e232, 0f));
let _e235 = curvature;
let _e240 = shade_info.params[3u];
cavity = (clamp(-(_e235), 0f, 1f) * clamp(_e240, 0f, 1f));
let _e243 = curvature;
ridge = clamp(_e243, 0f, 1f);
let _e245 = ridge;
let _e248 = cavity;
shaded = vec3(clamp(((0.5f + (_e245 * 0.5f)) - _e248), 0f, 1f));
}
}
}
}
let _e252 = scene;
let _e254 = shaded;
let _e255 = mix_amount;
let _e257 = mix(_e252.xyz, _e254, vec3(_e255));
let _e259 = scene[3u];
frag_color = vec4<f32>(_e257.x, _e257.y, _e257.z, _e259);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShadeInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'light',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ProbePrefilter': WebGpuStage(
wgsl: r'''
struct ProbeInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var capture_texture_tex: texture_cube<f32>;
@group(1) @binding(2)
var capture_texture_smp: sampler;
fn FaceDirection_u0028_i1_u003b_vf2_u003b(face: ptr<function, i32>, st: ptr<function, vec2<f32>>) -> vec3<f32> {
var u: f32;
var v: f32;
let _e31 = (*st)[0u];
u = ((_e31 * 2f) - 1f);
let _e35 = (*st)[1u];
v = ((_e35 * 2f) - 1f);
let _e38 = (*face);
if (_e38 == 0i) {
let _e40 = v;
let _e42 = u;
return normalize(vec3<f32>(1f, -(_e40), -(_e42)));
}
let _e46 = (*face);
if (_e46 == 1i) {
let _e48 = v;
let _e50 = u;
return normalize(vec3<f32>(-1f, -(_e48), _e50));
}
let _e53 = (*face);
if (_e53 == 2i) {
let _e55 = u;
let _e56 = v;
return normalize(vec3<f32>(_e55, 1f, _e56));
}
let _e59 = (*face);
if (_e59 == 3i) {
let _e61 = u;
let _e62 = v;
return normalize(vec3<f32>(_e61, -1f, -(_e62)));
}
let _e66 = (*face);
if (_e66 == 4i) {
let _e68 = u;
let _e69 = v;
return normalize(vec3<f32>(_e68, -(_e69), 1f));
}
let _e73 = u;
let _e75 = v;
return normalize(vec3<f32>(-(_e73), -(_e75), -1f));
}
fn main_1() {
var face_1: i32;
var roughness: f32;
var lod: f32;
var samples: i32;
var axis: vec3<f32>;
var param: i32;
var param_1: vec2<f32>;
var alpha: f32;
var power: f32;
var up: vec3<f32>;
var right: vec3<f32>;
var ahead: vec3<f32>;
var sum: vec3<f32>;
var weight: f32;
var i: i32;
var z: f32;
var radius: f32;
var theta: f32;
var spread: f32;
var tap: vec3<f32>;
var dir: vec3<f32>;
var cosine: f32;
var local: vec3<f32>;
let _e51 = probe_info.params[0u];
face_1 = i32((_e51 + 0.5f));
let _e56 = probe_info.params[1u];
roughness = _e56;
let _e59 = probe_info.params[2u];
lod = _e59;
let _e62 = probe_info.params[3u];
samples = clamp(i32((_e62 + 0.5f)), 1i, 128i);
let _e66 = face_1;
param = _e66;
let _e67 = v_uv_1;
param_1 = _e67;
let _e68 = FaceDirection_u0028_i1_u003b_vf2_u003b((¶m), (¶m_1));
axis = _e68;
let _e69 = samples;
if (_e69 == 1i) {
let _e71 = axis;
let _e72 = lod;
let _e73 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e71, _e72);
let _e74 = _e73.xyz;
frag_color = vec4<f32>(_e74.x, _e74.y, _e74.z, 1f);
return;
}
let _e79 = roughness;
let _e80 = roughness;
alpha = max((_e79 * _e80), 0.001f);
let _e83 = alpha;
let _e84 = alpha;
power = ((2f / (_e83 * _e84)) - 2f);
let _e89 = axis[2u];
up = select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e89) < 0.999f)));
let _e94 = up;
let _e95 = axis;
right = normalize(cross(_e94, _e95));
let _e98 = axis;
let _e99 = right;
ahead = cross(_e98, _e99);
sum = vec3<f32>(0f, 0f, 0f);
weight = 0f;
i = 0i;
loop {
let _e101 = i;
if (_e101 < 128i) {
let _e103 = i;
let _e104 = samples;
if (_e103 >= _e104) {
break;
}
let _e106 = i;
let _e109 = samples;
z = (1f - ((f32(_e106) + 0.5f) / f32(_e109)));
let _e113 = z;
let _e114 = z;
radius = sqrt(max((1f - (_e113 * _e114)), 0f));
let _e119 = i;
theta = (2.3999631f * f32(_e119));
let _e122 = z;
let _e123 = power;
spread = pow(_e122, (1f / (_e123 + 1f)));
let _e127 = radius;
let _e128 = theta;
let _e131 = spread;
let _e134 = radius;
let _e135 = theta;
let _e138 = spread;
let _e141 = spread;
tap = normalize(vec3<f32>(((_e127 * cos(_e128)) * (1f - _e131)), ((_e134 * sin(_e135)) * (1f - _e138)), _e141));
let _e144 = right;
let _e146 = tap[0u];
let _e148 = ahead;
let _e150 = tap[1u];
let _e153 = axis;
let _e155 = tap[2u];
dir = (((_e144 * _e146) + (_e148 * _e150)) + (_e153 * _e155));
let _e158 = dir;
let _e159 = axis;
cosine = dot(_e158, _e159);
let _e161 = cosine;
if (_e161 <= 0f) {
continue;
}
let _e163 = dir;
let _e164 = lod;
let _e165 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e163, _e164);
let _e167 = cosine;
let _e169 = sum;
sum = (_e169 + (_e165.xyz * _e167));
let _e171 = cosine;
let _e172 = weight;
weight = (_e172 + _e171);
continue;
} else {
break;
}
continuing {
let _e174 = i;
i = (_e174 + 1i);
}
}
let _e176 = weight;
if (_e176 > 0f) {
let _e178 = sum;
let _e179 = weight;
local = (_e178 / vec3(_e179));
} else {
local = vec3<f32>(0f, 0f, 0f);
}
let _e182 = local;
frag_color = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ProbeInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'capture_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.cube,
),
],
),
'ShadowDistance': WebGpuStage(
wgsl: r'''
struct ShadowLight {
light: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(0)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var range: f32;
var distance_: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e22 = shadow_light.light[3u];
range = max(_e22, 0.0001f);
let _e24 = v_world_position_1;
let _e26 = shadow_light.light;
distance_ = length((_e24 - _e26.xyz));
let _e30 = distance_;
let _e31 = range;
frag_color = vec4<f32>(clamp((_e30 / _e31), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShadowLight',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ShadowDepthMasked': WebGpuStage(
wgsl: r'''
struct MaskInfo {
mask: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var alpha: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e24 = v_texcoord_1;
let _e25 = textureSample(base_color_texture_tex, base_color_texture_smp, _e24);
let _e29 = mask_info.mask[1u];
alpha = (_e25.w * _e29);
let _e31 = alpha;
let _e34 = mask_info.mask[0u];
if (_e31 < _e34) {
discard;
}
let _e37 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e37, 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
gl_FragCoord_1 = gl_FragCoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'MaskInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ShadowDistanceMasked': WebGpuStage(
wgsl: r'''
struct MaskInfo {
mask: vec4<f32>,
}
struct ShadowLight {
light: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
@group(1) @binding(1)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var alpha: f32;
var range: f32;
var distance_: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e26 = v_texcoord_1;
let _e27 = textureSample(base_color_texture_tex, base_color_texture_smp, _e26);
let _e31 = mask_info.mask[1u];
alpha = (_e27.w * _e31);
let _e33 = alpha;
let _e36 = mask_info.mask[0u];
if (_e33 < _e36) {
discard;
}
let _e40 = shadow_light.light[3u];
range = max(_e40, 0.0001f);
let _e42 = v_world_position_1;
let _e44 = shadow_light.light;
distance_ = length((_e42 - _e44.xyz));
let _e48 = distance_;
let _e49 = range;
frag_color = vec4<f32>(clamp((_e48 / _e49), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'MaskInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'ShadowLight',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ShadowTileReset': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_uv_1: vec2<f32>;
fn main_1() {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'Sky': WebGpuStage(
wgsl: r'''
var<private> v_ray_1: vec3<f32>;
var<private> v_zenith_1: vec4<f32>;
var<private> v_nadir_1: vec4<f32>;
var<private> v_horizon_1: vec4<f32>;
var<private> v_sun_1: vec4<f32>;
var<private> v_glow_1: vec4<f32>;
var<private> v_disc_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var direction: vec3<f32>;
var height: f32;
var far: vec3<f32>;
var local: vec3<f32>;
var t: f32;
var colour: vec3<f32>;
var towards: f32;
var disc: f32;
var local_1: f32;
let _e26 = v_ray_1;
direction = normalize(_e26);
let _e29 = direction[1u];
height = clamp(_e29, -1f, 1f);
let _e31 = height;
if (_e31 >= 0f) {
let _e33 = v_zenith_1;
local = _e33.xyz;
} else {
let _e35 = v_nadir_1;
local = _e35.xyz;
}
let _e37 = local;
far = _e37;
let _e38 = height;
t = abs(_e38);
let _e40 = t;
let _e41 = t;
let _e43 = t;
t = ((_e40 * _e41) * (3f - (2f * _e43)));
let _e47 = v_horizon_1;
let _e49 = far;
let _e50 = t;
colour = mix(_e47.xyz, _e49, vec3(_e50));
let _e53 = direction;
let _e54 = v_sun_1;
towards = dot(_e53, _e54.xyz);
let _e57 = towards;
if (_e57 > 0f) {
let _e59 = v_glow_1;
let _e62 = v_glow_1[3u];
let _e63 = towards;
let _e65 = v_sun_1[3u];
let _e69 = colour;
colour = (_e69 + (_e59.xyz * (_e62 * pow(_e63, _e65))));
}
let _e72 = v_disc_1[1u];
if (_e72 > 0f) {
let _e75 = v_disc_1[0u];
let _e77 = v_disc_1[1u];
let _e80 = v_disc_1[0u];
let _e81 = towards;
local_1 = smoothstep((_e75 - _e77), _e80, _e81);
} else {
let _e84 = v_disc_1[0u];
let _e85 = towards;
local_1 = step(_e84, _e85);
}
let _e87 = local_1;
disc = _e87;
let _e88 = v_glow_1;
let _e90 = disc;
let _e92 = v_disc_1[2u];
let _e95 = colour;
colour = (_e95 + (_e88.xyz * (_e90 * _e92)));
let _e97 = colour;
frag_color = vec4<f32>(_e97.x, _e97.y, _e97.z, 1f);
return;
}
@fragment
fn main(@location(4) v_ray: vec3<f32>, @location(7) v_zenith: vec4<f32>, @location(3) v_nadir: vec4<f32>, @location(2) v_horizon: vec4<f32>, @location(5) v_sun: vec4<f32>, @location(1) v_glow: vec4<f32>, @location(0) v_disc: vec4<f32>) -> @location(0) vec4<f32> {
v_ray_1 = v_ray;
v_zenith_1 = v_zenith;
v_nadir_1 = v_nadir;
v_horizon_1 = v_horizon;
v_sun_1 = v_sun;
v_glow_1 = v_glow;
v_disc_1 = v_disc;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyCube': WebGpuStage(
wgsl: r'''
@group(1) @binding(0)
var sky_texture_tex: texture_cube<f32>;
@group(1) @binding(1)
var sky_texture_smp: sampler;
var<private> v_ray_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_tint_1: vec4<f32>;
fn main_1() {
var texel: vec3<f32>;
var linear: vec3<f32>;
let _e15 = v_ray_1;
let _e17 = textureSample(sky_texture_tex, sky_texture_smp, normalize(_e15));
texel = _e17.xyz;
let _e19 = texel;
let _e22 = texel;
let _e28 = texel;
linear = mix((_e19 / vec3(12.92f)), pow(((_e22 + vec3(0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e28));
let _e31 = linear;
let _e32 = v_tint_1;
let _e34 = (_e31 * _e32.xyz);
frag_color = vec4<f32>(_e34.x, _e34.y, _e34.z, 1f);
return;
}
@fragment
fn main(@location(4) v_ray: vec3<f32>, @location(6) v_tint: vec4<f32>) -> @location(0) vec4<f32> {
v_ray_1 = v_ray;
v_tint_1 = v_tint;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'sky_texture',
group: 1,
textureBinding: 0,
samplerBinding: 1,
dimension: WebGpuTextureDimension.cube,
),
],
),
'Luminance': WebGpuStage(
wgsl: r'''
struct LuminanceInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> luminance_info: LuminanceInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luma_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e21 = (*color);
return dot(_e21, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var footprint: vec2<f32>;
var sum: f32;
var j: i32;
var i: i32;
var offset: vec2<f32>;
var param: vec3<f32>;
var mean: f32;
var stops: f32;
var encoded: f32;
let _e30 = luminance_info.params;
footprint = _e30.xy;
sum = 0f;
j = 0i;
loop {
let _e32 = j;
if (_e32 < 4i) {
i = 0i;
loop {
let _e34 = i;
if (_e34 < 4i) {
let _e36 = i;
let _e38 = j;
let _e47 = footprint;
offset = ((((vec2<f32>(f32(_e36), f32(_e38)) + vec2(0.5f)) / vec2(4f)) - vec2(0.5f)) * _e47);
let _e49 = v_uv_1;
let _e50 = offset;
let _e52 = textureSample(scene_texture_tex, scene_texture_smp, (_e49 + _e50));
param = _e52.xyz;
let _e54 = Luma_u0028_vf3_u003b((¶m));
let _e55 = sum;
sum = (_e55 + _e54);
continue;
} else {
break;
}
continuing {
let _e57 = i;
i = (_e57 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e59 = j;
j = (_e59 + 1i);
}
}
let _e61 = sum;
mean = (_e61 / 16f);
let _e63 = mean;
stops = log2(max(_e63, 0.000001f));
let _e66 = stops;
let _e69 = luminance_info.params[2u];
let _e73 = luminance_info.params[3u];
encoded = clamp(((_e66 - _e69) * _e73), 0f, 1f);
let _e76 = encoded;
frag_color = vec4<f32>(_e76, _e76, _e76, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'LuminanceInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ObjectId': WebGpuStage(
wgsl: r'''
struct IdInfo {
id: vec4<f32>,
mask: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(0)
var<uniform> id_info: IdInfo;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var cutoff: f32;
var alpha: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e26 = id_info.mask[0u];
cutoff = _e26;
let _e27 = cutoff;
if (_e27 >= 0f) {
let _e29 = v_texcoord_1;
let _e30 = textureSample(base_color_texture_tex, base_color_texture_smp, _e29);
let _e34 = id_info.mask[1u];
let _e37 = v_color_1[3u];
alpha = ((_e30.w * _e34) * _e37);
let _e39 = alpha;
let _e40 = cutoff;
if (_e39 < _e40) {
discard;
}
}
let _e43 = id_info.id;
let _e44 = _e43.xyz;
frag_color = vec4<f32>(_e44.x, _e44.y, _e44.z, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'IdInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'id', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'mask', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VertexTextureProbe': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_sampled_1: vec4<f32>;
fn main_1() {
let _e2 = v_sampled_1;
frag_color = _e2;
return;
}
@fragment
fn main(@location(0) v_sampled: vec4<f32>) -> @location(0) vec4<f32> {
v_sampled_1 = v_sampled;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
},
);