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>;
var mirrored: bool;
var local: f32;
let _e41 = position_3;
morphed_position = _e41;
let _e42 = normal_3;
morphed_normal = _e42;
let _e43 = tangent_3;
morphed_tangent = _e43;
let _e44 = morphed_position;
param_7 = _e44;
let _e45 = morphed_normal;
param_8 = _e45;
let _e46 = morphed_tangent;
param_9 = _e46;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e47 = param_7;
morphed_position = _e47;
let _e48 = param_8;
morphed_normal = _e48;
let _e49 = param_9;
morphed_tangent = _e49;
let _e51 = frame_info.model;
let _e52 = morphed_position;
world = (_e51 * vec4<f32>(_e52.x, _e52.y, _e52.z, 1f));
let _e58 = world;
v_world_position = _e58.xyz;
let _e61 = frame_info.normal_matrix;
let _e69 = morphed_normal;
v_normal = (mat3x3<f32>(_e61[0].xyz, _e61[1].xyz, _e61[2].xyz) * _e69);
let _e71 = texcoord_1;
v_texcoord = _e71;
let _e73 = frame_info.model;
mirrored = (determinant(mat3x3<f32>(_e73[0].xyz, _e73[1].xyz, _e73[2].xyz)) < 0f);
let _e84 = frame_info.model;
let _e92 = morphed_tangent;
let _e94 = (mat3x3<f32>(_e84[0].xyz, _e84[1].xyz, _e84[2].xyz) * _e92.xyz);
let _e95 = mirrored;
if _e95 {
let _e97 = morphed_tangent[3u];
local = -(_e97);
} else {
let _e100 = morphed_tangent[3u];
local = _e100;
}
let _e101 = local;
v_tangent = vec4<f32>(_e94.x, _e94.y, _e94.z, _e101);
let _e106 = color_1;
v_color = _e106;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e108 = frame_info.mvp;
let _e109 = morphed_position;
unnamed.gl_Position = (_e108 * vec4<f32>(_e109.x, _e109.y, _e109.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 _e47 = (*t);
let _e51 = (*rowStep);
row = ((f32((_e47 * 3i)) + 0.5f) * _e51);
let _e53 = (*column);
let _e54 = row;
let _e56 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e53, _e54), 0f);
let _e58 = (*weight);
let _e60 = (*position_1);
(*position_1) = (_e60 + (_e56.xyz * _e58));
let _e62 = (*column);
let _e63 = row;
let _e64 = (*rowStep);
let _e67 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e62, (_e63 + _e64)), 0f);
let _e69 = (*weight);
let _e71 = (*normal_1);
(*normal_1) = (_e71 + (_e67.xyz * _e69));
let _e73 = (*column);
let _e74 = row;
let _e75 = (*rowStep);
let _e79 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e73, (_e74 + (_e75 * 2f))), 0f);
let _e81 = (*weight);
let _e83 = (*tangent_1);
let _e85 = (_e83.xyz + (_e79.xyz * _e81));
(*tangent_1)[0u] = _e85.x;
(*tangent_1)[1u] = _e85.y;
(*tangent_1)[2u] = _e85.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e39 = gl_VertexIndex_1;
let _e44 = morph_info.morph_params[1u];
return ((f32(_e39) + 0.5f) * _e44);
}
fn MorphCount_u0028_() -> i32 {
let _e41 = morph_info.morph_params[0u];
return i32((_e41 + 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 _e54 = MorphCount_u0028_();
count = _e54;
let _e55 = count;
if (_e55 <= 0i) {
return;
}
let _e57 = MorphColumn_u0028_();
column_1 = _e57;
let _e60 = morph_info.morph_params[2u];
rowStep_1 = _e60;
i = 0i;
loop {
let _e61 = i;
if (_e61 < 8i) {
let _e63 = i;
let _e64 = count;
if (_e63 >= _e64) {
break;
}
let _e66 = i;
let _e68 = i;
let _e79 = morph_info.morph_weights[(_e66 / 4i)][(_e68 - (i32(floor((f32(_e68) / f32(4i)))) * 4i))];
weight_1 = _e79;
let _e80 = weight_1;
if (_e80 == 0f) {
continue;
}
let _e82 = i;
param = _e82;
let _e83 = weight_1;
param_1 = _e83;
let _e84 = column_1;
param_2 = _e84;
let _e85 = rowStep_1;
param_3 = _e85;
let _e86 = (*position_2);
param_4 = _e86;
let _e87 = (*normal_2);
param_5 = _e87;
let _e88 = (*tangent_2);
param_6 = _e88;
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 _e89 = param_4;
(*position_2) = _e89;
let _e90 = param_5;
(*normal_2) = _e90;
let _e91 = param_6;
(*tangent_2) = _e91;
continue;
} else {
break;
}
continuing {
let _e92 = i;
i = (_e92 + 1i);
}
}
return;
}
fn JointIndex_u0028_f1_u003b(joint: ptr<function, f32>) -> i32 {
let _e40 = (*joint);
return clamp(i32(_e40), 0i, 63i);
}
fn SkinMatrix_u0028_() -> mat4x4<f32> {
var total: f32;
var w: vec4<f32>;
var local: vec4<f32>;
var param_7: f32;
var param_8: f32;
var param_9: f32;
var param_10: f32;
let _e47 = weights_1[0u];
let _e49 = weights_1[1u];
let _e52 = weights_1[2u];
let _e55 = weights_1[3u];
total = (((_e47 + _e49) + _e52) + _e55);
let _e57 = total;
if (_e57 > 0.00001f) {
let _e59 = weights_1;
let _e60 = total;
local = (_e59 / vec4(_e60));
} else {
local = vec4<f32>(1f, 0f, 0f, 0f);
}
let _e63 = local;
w = _e63;
let _e65 = w[0u];
let _e67 = joints_1[0u];
param_7 = _e67;
let _e68 = JointIndex_u0028_f1_u003b((¶m_7));
let _e71 = skin_info.joint_matrices[_e68];
let _e72 = (_e71 * _e65);
let _e74 = w[1u];
let _e76 = joints_1[1u];
param_8 = _e76;
let _e77 = JointIndex_u0028_f1_u003b((¶m_8));
let _e80 = skin_info.joint_matrices[_e77];
let _e81 = (_e80 * _e74);
let _e94 = mat4x4<f32>((_e72[0] + _e81[0]), (_e72[1] + _e81[1]), (_e72[2] + _e81[2]), (_e72[3] + _e81[3]));
let _e96 = w[2u];
let _e98 = joints_1[2u];
param_9 = _e98;
let _e99 = JointIndex_u0028_f1_u003b((¶m_9));
let _e102 = skin_info.joint_matrices[_e99];
let _e103 = (_e102 * _e96);
let _e116 = mat4x4<f32>((_e94[0] + _e103[0]), (_e94[1] + _e103[1]), (_e94[2] + _e103[2]), (_e94[3] + _e103[3]));
let _e118 = w[3u];
let _e120 = joints_1[3u];
param_10 = _e120;
let _e121 = JointIndex_u0028_f1_u003b((¶m_10));
let _e124 = skin_info.joint_matrices[_e121];
let _e125 = (_e124 * _e118);
return mat4x4<f32>((_e116[0] + _e125[0]), (_e116[1] + _e125[1]), (_e116[2] + _e125[2]), (_e116[3] + _e125[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_11: vec3<f32>;
var param_12: vec3<f32>;
var param_13: vec4<f32>;
var skinnedModel: mat4x4<f32>;
var world: vec4<f32>;
var skinRotation: mat3x3<f32>;
var mirrored: bool;
var local_1: f32;
let _e51 = SkinMatrix_u0028_();
skin = _e51;
let _e52 = position_3;
morphed_position = _e52;
let _e53 = normal_3;
morphed_normal = _e53;
let _e54 = tangent_3;
morphed_tangent = _e54;
let _e55 = morphed_position;
param_11 = _e55;
let _e56 = morphed_normal;
param_12 = _e56;
let _e57 = morphed_tangent;
param_13 = _e57;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_11), (¶m_12), (¶m_13));
let _e58 = param_11;
morphed_position = _e58;
let _e59 = param_12;
morphed_normal = _e59;
let _e60 = param_13;
morphed_tangent = _e60;
let _e62 = frame_info.model;
let _e63 = skin;
skinnedModel = (_e62 * _e63);
let _e65 = skinnedModel;
let _e66 = morphed_position;
world = (_e65 * vec4<f32>(_e66.x, _e66.y, _e66.z, 1f));
let _e72 = world;
v_world_position = _e72.xyz;
let _e74 = skin;
skinRotation = mat3x3<f32>(_e74[0].xyz, _e74[1].xyz, _e74[2].xyz);
let _e83 = frame_info.normal_matrix;
let _e91 = skinRotation;
let _e92 = morphed_normal;
v_normal = (mat3x3<f32>(_e83[0].xyz, _e83[1].xyz, _e83[2].xyz) * (_e91 * _e92));
let _e96 = frame_info.model;
let _e106 = skinRotation;
mirrored = ((determinant(mat3x3<f32>(_e96[0].xyz, _e96[1].xyz, _e96[2].xyz)) < 0f) != (determinant(_e106) < 0f));
let _e111 = frame_info.model;
let _e119 = skinRotation;
let _e120 = morphed_tangent;
let _e123 = (mat3x3<f32>(_e111[0].xyz, _e111[1].xyz, _e111[2].xyz) * (_e119 * _e120.xyz));
let _e124 = mirrored;
if _e124 {
let _e126 = morphed_tangent[3u];
local_1 = -(_e126);
} else {
let _e129 = morphed_tangent[3u];
local_1 = _e129;
}
let _e130 = local_1;
v_tangent = vec4<f32>(_e123.x, _e123.y, _e123.z, _e130);
let _e135 = texcoord_1;
v_texcoord = _e135;
let _e136 = color_1;
v_color = _e136;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e138 = frame_info.mvp;
let _e139 = skin;
let _e140 = morphed_position;
unnamed.gl_Position = (_e138 * (_e139 * vec4<f32>(_e140.x, _e140.y, _e140.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>;
var mirrored: bool;
var local_1: f32;
let _e54 = i_row0_1[0u];
let _e56 = i_row1_1[0u];
let _e58 = i_row2_1[0u];
let _e59 = vec4<f32>(_e54, _e56, _e58, 0f);
let _e61 = i_row0_1[1u];
let _e63 = i_row1_1[1u];
let _e65 = i_row2_1[1u];
let _e66 = vec4<f32>(_e61, _e63, _e65, 0f);
let _e68 = i_row0_1[2u];
let _e70 = i_row1_1[2u];
let _e72 = i_row2_1[2u];
let _e73 = vec4<f32>(_e68, _e70, _e72, 0f);
let _e75 = i_row0_1[3u];
let _e77 = i_row1_1[3u];
let _e79 = i_row2_1[3u];
let _e80 = vec4<f32>(_e75, _e77, _e79, 1f);
instance_1 = mat4x4<f32>(vec4<f32>(_e59.x, _e59.y, _e59.z, _e59.w), vec4<f32>(_e66.x, _e66.y, _e66.z, _e66.w), vec4<f32>(_e73.x, _e73.y, _e73.z, _e73.w), vec4<f32>(_e80.x, _e80.y, _e80.z, _e80.w));
let _e102 = position_4;
morphed_position = _e102;
let _e103 = normal_4;
morphed_normal = _e103;
let _e104 = tangent_4;
morphed_tangent = _e104;
let _e105 = gl_InstanceIndex_1;
param_17 = _e105;
let _e106 = morphed_position;
param_18 = _e106;
let _e107 = morphed_normal;
param_19 = _e107;
let _e108 = morphed_tangent;
param_20 = _e108;
ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e109 = param_18;
morphed_position = _e109;
let _e110 = param_19;
morphed_normal = _e110;
let _e111 = param_20;
morphed_tangent = _e111;
let _e112 = instance_1;
let _e113 = morphed_position;
local = (_e112 * vec4<f32>(_e113.x, _e113.y, _e113.z, 1f));
let _e120 = frame_info.model;
let _e121 = local;
world = (_e120 * _e121);
let _e123 = world;
v_world_position = _e123.xyz;
let _e125 = instance_1;
rotation = mat3x3<f32>(_e125[0].xyz, _e125[1].xyz, _e125[2].xyz);
let _e134 = frame_info.normal_matrix;
let _e142 = rotation;
let _e143 = morphed_normal;
v_normal = (mat3x3<f32>(_e134[0].xyz, _e134[1].xyz, _e134[2].xyz) * normalize((_e142 * _e143)));
let _e147 = texcoord_1;
v_texcoord = _e147;
let _e149 = frame_info.model;
let _e159 = rotation;
mirrored = ((determinant(mat3x3<f32>(_e149[0].xyz, _e149[1].xyz, _e149[2].xyz)) < 0f) != (determinant(_e159) < 0f));
let _e164 = frame_info.model;
let _e172 = rotation;
let _e173 = morphed_tangent;
let _e176 = (mat3x3<f32>(_e164[0].xyz, _e164[1].xyz, _e164[2].xyz) * (_e172 * _e173.xyz));
let _e177 = mirrored;
if _e177 {
let _e179 = morphed_tangent[3u];
local_1 = -(_e179);
} else {
let _e182 = morphed_tangent[3u];
local_1 = _e182;
}
let _e183 = local_1;
v_tangent = vec4<f32>(_e176.x, _e176.y, _e176.z, _e183);
let _e188 = color_1;
let _e189 = i_color_1;
v_color = (_e188 * _e189);
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e192 = frame_info.mvp;
let _e193 = local;
unnamed.gl_Position = (_e192 * _e193);
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>;
var mirrored: bool;
var local: f32;
let _e41 = position_3;
morphed_position = _e41;
let _e42 = normal_3;
morphed_normal = _e42;
let _e43 = tangent_3;
morphed_tangent = _e43;
let _e44 = morphed_position;
param_7 = _e44;
let _e45 = morphed_normal;
param_8 = _e45;
let _e46 = morphed_tangent;
param_9 = _e46;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e47 = param_7;
morphed_position = _e47;
let _e48 = param_8;
morphed_normal = _e48;
let _e49 = param_9;
morphed_tangent = _e49;
let _e51 = frame_info.model;
let _e52 = morphed_position;
world = (_e51 * vec4<f32>(_e52.x, _e52.y, _e52.z, 1f));
let _e58 = world;
v_world_position = _e58.xyz;
let _e61 = frame_info.normal_matrix;
let _e69 = morphed_normal;
v_normal = (mat3x3<f32>(_e61[0].xyz, _e61[1].xyz, _e61[2].xyz) * _e69);
let _e71 = texcoord_1;
v_texcoord = _e71;
let _e73 = frame_info.model;
mirrored = (determinant(mat3x3<f32>(_e73[0].xyz, _e73[1].xyz, _e73[2].xyz)) < 0f);
let _e84 = frame_info.model;
let _e92 = morphed_tangent;
let _e94 = (mat3x3<f32>(_e84[0].xyz, _e84[1].xyz, _e84[2].xyz) * _e92.xyz);
let _e95 = mirrored;
if _e95 {
let _e97 = morphed_tangent[3u];
local = -(_e97);
} else {
let _e100 = morphed_tangent[3u];
local = _e100;
}
let _e101 = local;
v_tangent = vec4<f32>(_e94.x, _e94.y, _e94.z, _e101);
v_color = vec4<f32>(1f, 1f, 1f, 1f);
let _e106 = color_1;
v_lightmap_uv = _e106.xy;
let _e109 = frame_info.mvp;
let _e110 = morphed_position;
unnamed.gl_Position = (_e109 * vec4<f32>(_e110.x, _e110.y, _e110.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,
),
],
),
'VelocityVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct PrevFrameInfo {
current_mvp: mat4x4<f32>,
previous_mvp: mat4x4<f32>,
previous_morph_weights: array<vec4<f32>, 2>,
camera: vec4<f32>,
forward: 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(0) member: vec4<f32>,
@location(1) member_1: f32,
@location(2) member_2: vec4<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;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
var<private> position_3: vec3<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
let _e27 = (*world);
let _e30 = prev_info.camera;
let _e34 = prev_info.forward;
return dot((_e27.xyz - _e30.xyz), _e34.xyz);
}
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: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
var row: f32;
let _e34 = (*t);
let _e38 = (*rowStep);
row = ((f32((_e34 * 3i)) + 0.5f) * _e38);
let _e40 = (*column);
let _e41 = row;
let _e43 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e40, _e41), 0f);
let _e45 = (*weight);
let _e47 = (*position_1);
(*position_1) = (_e47 + (_e43.xyz * _e45));
let _e49 = (*column);
let _e50 = row;
let _e51 = (*rowStep);
let _e54 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e49, (_e50 + _e51)), 0f);
let _e56 = (*weight);
let _e58 = (*normal);
(*normal) = (_e58 + (_e54.xyz * _e56));
let _e60 = (*column);
let _e61 = row;
let _e62 = (*rowStep);
let _e66 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e60, (_e61 + (_e62 * 2f))), 0f);
let _e68 = (*weight);
let _e70 = (*tangent);
let _e72 = (_e70.xyz + (_e66.xyz * _e68));
(*tangent)[0u] = _e72.x;
(*tangent)[1u] = _e72.y;
(*tangent)[2u] = _e72.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e26 = gl_VertexIndex_1;
let _e31 = morph_info.morph_params[1u];
return ((f32(_e26) + 0.5f) * _e31);
}
fn MorphCount_u0028_() -> i32 {
let _e28 = morph_info.morph_params[0u];
return i32((_e28 + 0.5f));
}
fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var normal_1: vec3<f32>;
var tangent_1: vec4<f32>;
var i: i32;
var weight_1: f32;
var local: 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 _e44 = MorphCount_u0028_();
count = _e44;
let _e45 = count;
if (_e45 <= 0i) {
let _e47 = (*position_2);
return _e47;
}
let _e48 = MorphColumn_u0028_();
column_1 = _e48;
let _e51 = morph_info.morph_params[2u];
rowStep_1 = _e51;
normal_1 = vec3<f32>(0f, 0f, 0f);
tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
i = 0i;
loop {
let _e52 = i;
if (_e52 < 8i) {
let _e54 = i;
let _e55 = count;
if (_e54 >= _e55) {
break;
}
let _e57 = i;
if (_e57 < 4i) {
let _e59 = i;
let _e61 = (*w0_)[_e59];
local = _e61;
} else {
let _e62 = i;
let _e65 = (*w1_)[(_e62 - 4i)];
local = _e65;
}
let _e66 = local;
weight_1 = _e66;
let _e67 = weight_1;
if (_e67 == 0f) {
continue;
}
let _e69 = i;
param = _e69;
let _e70 = weight_1;
param_1 = _e70;
let _e71 = column_1;
param_2 = _e71;
let _e72 = rowStep_1;
param_3 = _e72;
let _e73 = (*position_2);
param_4 = _e73;
let _e74 = normal_1;
param_5 = _e74;
let _e75 = tangent_1;
param_6 = _e75;
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 _e76 = param_4;
(*position_2) = _e76;
let _e77 = param_5;
normal_1 = _e77;
let _e78 = param_6;
tangent_1 = _e78;
continue;
} else {
break;
}
continuing {
let _e79 = i;
i = (_e79 + 1i);
}
}
let _e81 = (*position_2);
return _e81;
}
fn main_1() {
var now: vec3<f32>;
var param_7: vec3<f32>;
var param_8: vec4<f32>;
var param_9: vec4<f32>;
var then: vec3<f32>;
var param_10: vec3<f32>;
var param_11: vec4<f32>;
var param_12: vec4<f32>;
var param_13: vec4<f32>;
let _e35 = position_3;
param_7 = _e35;
let _e38 = morph_info.morph_weights[0i];
param_8 = _e38;
let _e41 = morph_info.morph_weights[1i];
param_9 = _e41;
let _e42 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
now = _e42;
let _e43 = position_3;
param_10 = _e43;
let _e46 = prev_info.previous_morph_weights[0i];
param_11 = _e46;
let _e49 = prev_info.previous_morph_weights[1i];
param_12 = _e49;
let _e50 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_10), (¶m_11), (¶m_12));
then = _e50;
let _e52 = prev_info.current_mvp;
let _e53 = now;
v_current = (_e52 * vec4<f32>(_e53.x, _e53.y, _e53.z, 1f));
let _e60 = frame_info.model;
let _e61 = now;
param_13 = (_e60 * vec4<f32>(_e61.x, _e61.y, _e61.z, 1f));
let _e67 = DepthAlongAxis_u0028_vf4_u003b((¶m_13));
v_depth = _e67;
let _e69 = prev_info.previous_mvp;
let _e70 = then;
v_previous = (_e69 * vec4<f32>(_e70.x, _e70.y, _e70.z, 1f));
let _e77 = frame_info.mvp;
let _e78 = now;
unnamed.gl_Position = (_e77 * vec4<f32>(_e78.x, _e78.y, _e78.z, 1f));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
main_1();
let _e10 = v_current;
let _e11 = v_depth;
let _e12 = v_previous;
let _e13 = unnamed.gl_Position;
return VertexOutput(_e10, _e11, _e12, _e13);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
],
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: 'PrevFrameInfo',
group: 0,
binding: 2,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'current_mvp',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_mvp',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_morph_weights',
offsetInBytes: 128,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VelocitySkinnedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct PrevFrameInfo {
current_mvp: mat4x4<f32>,
previous_mvp: mat4x4<f32>,
previous_morph_weights: array<vec4<f32>, 2>,
camera: vec4<f32>,
forward: 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(0) member: vec4<f32>,
@location(1) member_1: f32,
@location(2) member_2: vec4<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(4)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(5)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
@group(0) @binding(6)
var prev_joint_texture_tex: texture_2d<f32>;
@group(0) @binding(7)
var prev_joint_texture_smp: sampler;
var<private> weights_1: vec4<f32>;
var<private> joints_1: vec4<f32>;
@group(0) @binding(3)
var<uniform> skin_info: SkinInfo;
var<private> position_3: vec3<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
let _e42 = (*world);
let _e45 = prev_info.camera;
let _e49 = prev_info.forward;
return dot((_e42.xyz - _e45.xyz), _e49.xyz);
}
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: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
var row: f32;
let _e49 = (*t);
let _e53 = (*rowStep);
row = ((f32((_e49 * 3i)) + 0.5f) * _e53);
let _e55 = (*column);
let _e56 = row;
let _e58 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e55, _e56), 0f);
let _e60 = (*weight);
let _e62 = (*position_1);
(*position_1) = (_e62 + (_e58.xyz * _e60));
let _e64 = (*column);
let _e65 = row;
let _e66 = (*rowStep);
let _e69 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e64, (_e65 + _e66)), 0f);
let _e71 = (*weight);
let _e73 = (*normal);
(*normal) = (_e73 + (_e69.xyz * _e71));
let _e75 = (*column);
let _e76 = row;
let _e77 = (*rowStep);
let _e81 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e75, (_e76 + (_e77 * 2f))), 0f);
let _e83 = (*weight);
let _e85 = (*tangent);
let _e87 = (_e85.xyz + (_e81.xyz * _e83));
(*tangent)[0u] = _e87.x;
(*tangent)[1u] = _e87.y;
(*tangent)[2u] = _e87.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e41 = gl_VertexIndex_1;
let _e46 = morph_info.morph_params[1u];
return ((f32(_e41) + 0.5f) * _e46);
}
fn MorphCount_u0028_() -> i32 {
let _e43 = morph_info.morph_params[0u];
return i32((_e43 + 0.5f));
}
fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var normal_1: vec3<f32>;
var tangent_1: vec4<f32>;
var i: i32;
var weight_1: f32;
var local: 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 _e59 = MorphCount_u0028_();
count = _e59;
let _e60 = count;
if (_e60 <= 0i) {
let _e62 = (*position_2);
return _e62;
}
let _e63 = MorphColumn_u0028_();
column_1 = _e63;
let _e66 = morph_info.morph_params[2u];
rowStep_1 = _e66;
normal_1 = vec3<f32>(0f, 0f, 0f);
tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
i = 0i;
loop {
let _e67 = i;
if (_e67 < 8i) {
let _e69 = i;
let _e70 = count;
if (_e69 >= _e70) {
break;
}
let _e72 = i;
if (_e72 < 4i) {
let _e74 = i;
let _e76 = (*w0_)[_e74];
local = _e76;
} else {
let _e77 = i;
let _e80 = (*w1_)[(_e77 - 4i)];
local = _e80;
}
let _e81 = local;
weight_1 = _e81;
let _e82 = weight_1;
if (_e82 == 0f) {
continue;
}
let _e84 = i;
param = _e84;
let _e85 = weight_1;
param_1 = _e85;
let _e86 = column_1;
param_2 = _e86;
let _e87 = rowStep_1;
param_3 = _e87;
let _e88 = (*position_2);
param_4 = _e88;
let _e89 = normal_1;
param_5 = _e89;
let _e90 = tangent_1;
param_6 = _e90;
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 _e91 = param_4;
(*position_2) = _e91;
let _e92 = param_5;
normal_1 = _e92;
let _e93 = param_6;
tangent_1 = _e93;
continue;
} else {
break;
}
continuing {
let _e94 = i;
i = (_e94 + 1i);
}
}
let _e96 = (*position_2);
return _e96;
}
fn PrevJoint_u0028_f1_u003b(joint: ptr<function, f32>) -> mat4x4<f32> {
var v: f32;
let _e43 = (*joint);
v = ((_e43 + 0.5f) / 64f);
let _e46 = v;
let _e48 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.125f, _e46), 0f);
let _e49 = v;
let _e51 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.375f, _e49), 0f);
let _e52 = v;
let _e54 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.625f, _e52), 0f);
let _e55 = v;
let _e57 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.875f, _e55), 0f);
return mat4x4<f32>(vec4<f32>(_e48.x, _e48.y, _e48.z, _e48.w), vec4<f32>(_e51.x, _e51.y, _e51.z, _e51.w), vec4<f32>(_e54.x, _e54.y, _e54.z, _e54.w), vec4<f32>(_e57.x, _e57.y, _e57.z, _e57.w));
}
fn JointIndex_u0028_f1_u003b(joint_1: ptr<function, f32>) -> i32 {
let _e42 = (*joint_1);
return clamp(i32(_e42), 0i, 63i);
}
fn BlendWeights_u0028_() -> vec4<f32> {
var total: f32;
var local_1: vec4<f32>;
let _e44 = weights_1[0u];
let _e46 = weights_1[1u];
let _e49 = weights_1[2u];
let _e52 = weights_1[3u];
total = (((_e44 + _e46) + _e49) + _e52);
let _e54 = total;
if (_e54 > 0.00001f) {
let _e56 = weights_1;
let _e57 = total;
local_1 = (_e56 / vec4(_e57));
} else {
local_1 = vec4<f32>(1f, 0f, 0f, 0f);
}
let _e60 = local_1;
return _e60;
}
fn main_1() {
var w: vec4<f32>;
var j: vec4<i32>;
var param_7: f32;
var param_8: f32;
var param_9: f32;
var param_10: f32;
var skin: mat4x4<f32>;
var prevSkin: mat4x4<f32>;
var param_11: f32;
var param_12: f32;
var param_13: f32;
var param_14: f32;
var now: vec3<f32>;
var param_15: vec3<f32>;
var param_16: vec4<f32>;
var param_17: vec4<f32>;
var then: vec3<f32>;
var param_18: vec3<f32>;
var param_19: vec4<f32>;
var param_20: vec4<f32>;
var posed: vec4<f32>;
var param_21: vec4<f32>;
let _e63 = BlendWeights_u0028_();
w = _e63;
let _e65 = joints_1[0u];
param_7 = _e65;
let _e66 = JointIndex_u0028_f1_u003b((¶m_7));
let _e68 = joints_1[1u];
param_8 = _e68;
let _e69 = JointIndex_u0028_f1_u003b((¶m_8));
let _e71 = joints_1[2u];
param_9 = _e71;
let _e72 = JointIndex_u0028_f1_u003b((¶m_9));
let _e74 = joints_1[3u];
param_10 = _e74;
let _e75 = JointIndex_u0028_f1_u003b((¶m_10));
j = vec4<i32>(_e66, _e69, _e72, _e75);
let _e78 = w[0u];
let _e80 = j[0u];
let _e83 = skin_info.joint_matrices[_e80];
let _e84 = (_e83 * _e78);
let _e86 = w[1u];
let _e88 = j[1u];
let _e91 = skin_info.joint_matrices[_e88];
let _e92 = (_e91 * _e86);
let _e105 = mat4x4<f32>((_e84[0] + _e92[0]), (_e84[1] + _e92[1]), (_e84[2] + _e92[2]), (_e84[3] + _e92[3]));
let _e107 = w[2u];
let _e109 = j[2u];
let _e112 = skin_info.joint_matrices[_e109];
let _e113 = (_e112 * _e107);
let _e126 = mat4x4<f32>((_e105[0] + _e113[0]), (_e105[1] + _e113[1]), (_e105[2] + _e113[2]), (_e105[3] + _e113[3]));
let _e128 = w[3u];
let _e130 = j[3u];
let _e133 = skin_info.joint_matrices[_e130];
let _e134 = (_e133 * _e128);
skin = mat4x4<f32>((_e126[0] + _e134[0]), (_e126[1] + _e134[1]), (_e126[2] + _e134[2]), (_e126[3] + _e134[3]));
let _e149 = w[0u];
let _e151 = j[0u];
param_11 = f32(_e151);
let _e153 = PrevJoint_u0028_f1_u003b((¶m_11));
let _e154 = (_e153 * _e149);
let _e156 = w[1u];
let _e158 = j[1u];
param_12 = f32(_e158);
let _e160 = PrevJoint_u0028_f1_u003b((¶m_12));
let _e161 = (_e160 * _e156);
let _e174 = mat4x4<f32>((_e154[0] + _e161[0]), (_e154[1] + _e161[1]), (_e154[2] + _e161[2]), (_e154[3] + _e161[3]));
let _e176 = w[2u];
let _e178 = j[2u];
param_13 = f32(_e178);
let _e180 = PrevJoint_u0028_f1_u003b((¶m_13));
let _e181 = (_e180 * _e176);
let _e194 = mat4x4<f32>((_e174[0] + _e181[0]), (_e174[1] + _e181[1]), (_e174[2] + _e181[2]), (_e174[3] + _e181[3]));
let _e196 = w[3u];
let _e198 = j[3u];
param_14 = f32(_e198);
let _e200 = PrevJoint_u0028_f1_u003b((¶m_14));
let _e201 = (_e200 * _e196);
prevSkin = mat4x4<f32>((_e194[0] + _e201[0]), (_e194[1] + _e201[1]), (_e194[2] + _e201[2]), (_e194[3] + _e201[3]));
let _e215 = position_3;
param_15 = _e215;
let _e218 = morph_info.morph_weights[0i];
param_16 = _e218;
let _e221 = morph_info.morph_weights[1i];
param_17 = _e221;
let _e222 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_15), (¶m_16), (¶m_17));
now = _e222;
let _e223 = position_3;
param_18 = _e223;
let _e226 = prev_info.previous_morph_weights[0i];
param_19 = _e226;
let _e229 = prev_info.previous_morph_weights[1i];
param_20 = _e229;
let _e230 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_18), (¶m_19), (¶m_20));
then = _e230;
let _e231 = skin;
let _e232 = now;
posed = (_e231 * vec4<f32>(_e232.x, _e232.y, _e232.z, 1f));
let _e239 = prev_info.current_mvp;
let _e240 = posed;
v_current = (_e239 * _e240);
let _e243 = frame_info.model;
let _e244 = posed;
param_21 = (_e243 * _e244);
let _e246 = DepthAlongAxis_u0028_vf4_u003b((¶m_21));
v_depth = _e246;
let _e248 = prev_info.previous_mvp;
let _e249 = prevSkin;
let _e250 = then;
v_previous = (_e248 * (_e249 * vec4<f32>(_e250.x, _e250.y, _e250.z, 1f)));
let _e258 = frame_info.mvp;
let _e259 = posed;
unnamed.gl_Position = (_e258 * _e259);
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(2) weights: vec4<f32>, @location(1) joints: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
weights_1 = weights;
joints_1 = joints;
position_3 = position;
main_1();
let _e14 = v_current;
let _e15 = v_depth;
let _e16 = v_previous;
let _e17 = unnamed.gl_Position;
return VertexOutput(_e14, _e15, _e16, _e17);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'joints',
location: 1,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'weights',
location: 2,
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: 'PrevFrameInfo',
group: 0,
binding: 2,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'current_mvp',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_mvp',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_morph_weights',
offsetInBytes: 128,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'SkinInfo',
group: 0,
binding: 3,
sizeInBytes: 4096,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'joint_matrices',
offsetInBytes: 0,
sizeInBytes: 4096,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'prev_joint_texture',
group: 0,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VelocityInstancedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct PrevFrameInfo {
current_mvp: mat4x4<f32>,
previous_mvp: mat4x4<f32>,
previous_morph_weights: array<vec4<f32>, 2>,
camera: vec4<f32>,
forward: 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(0) member: vec4<f32>,
@location(1) member_1: f32,
@location(2) member_2: vec4<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;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
var<private> position_3: vec3<f32>;
var<private> i_row0_1: vec4<f32>;
var<private> i_row1_1: vec4<f32>;
var<private> i_row2_1: vec4<f32>;
var<private> i_prev_row0_1: vec4<f32>;
var<private> i_prev_row1_1: vec4<f32>;
var<private> i_prev_row2_1: vec4<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
let _e34 = (*world);
let _e37 = prev_info.camera;
let _e41 = prev_info.forward;
return dot((_e34.xyz - _e37.xyz), _e41.xyz);
}
fn Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b(row0_: ptr<function, vec4<f32>>, row1_: ptr<function, vec4<f32>>, row2_: ptr<function, vec4<f32>>) -> mat4x4<f32> {
let _e37 = (*row0_)[0u];
let _e39 = (*row1_)[0u];
let _e41 = (*row2_)[0u];
let _e42 = vec4<f32>(_e37, _e39, _e41, 0f);
let _e44 = (*row0_)[1u];
let _e46 = (*row1_)[1u];
let _e48 = (*row2_)[1u];
let _e49 = vec4<f32>(_e44, _e46, _e48, 0f);
let _e51 = (*row0_)[2u];
let _e53 = (*row1_)[2u];
let _e55 = (*row2_)[2u];
let _e56 = vec4<f32>(_e51, _e53, _e55, 0f);
let _e58 = (*row0_)[3u];
let _e60 = (*row1_)[3u];
let _e62 = (*row2_)[3u];
let _e63 = vec4<f32>(_e58, _e60, _e62, 1f);
return mat4x4<f32>(vec4<f32>(_e42.x, _e42.y, _e42.z, _e42.w), vec4<f32>(_e49.x, _e49.y, _e49.z, _e49.w), vec4<f32>(_e56.x, _e56.y, _e56.z, _e56.w), vec4<f32>(_e63.x, _e63.y, _e63.z, _e63.w));
}
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: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
var row: f32;
let _e41 = (*t);
let _e45 = (*rowStep);
row = ((f32((_e41 * 3i)) + 0.5f) * _e45);
let _e47 = (*column);
let _e48 = row;
let _e50 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e47, _e48), 0f);
let _e52 = (*weight);
let _e54 = (*position_1);
(*position_1) = (_e54 + (_e50.xyz * _e52));
let _e56 = (*column);
let _e57 = row;
let _e58 = (*rowStep);
let _e61 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e56, (_e57 + _e58)), 0f);
let _e63 = (*weight);
let _e65 = (*normal);
(*normal) = (_e65 + (_e61.xyz * _e63));
let _e67 = (*column);
let _e68 = row;
let _e69 = (*rowStep);
let _e73 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e67, (_e68 + (_e69 * 2f))), 0f);
let _e75 = (*weight);
let _e77 = (*tangent);
let _e79 = (_e77.xyz + (_e73.xyz * _e75));
(*tangent)[0u] = _e79.x;
(*tangent)[1u] = _e79.y;
(*tangent)[2u] = _e79.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e33 = gl_VertexIndex_1;
let _e38 = morph_info.morph_params[1u];
return ((f32(_e33) + 0.5f) * _e38);
}
fn MorphCount_u0028_() -> i32 {
let _e35 = morph_info.morph_params[0u];
return i32((_e35 + 0.5f));
}
fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var normal_1: vec3<f32>;
var tangent_1: vec4<f32>;
var i: i32;
var weight_1: f32;
var local: 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 _e51 = MorphCount_u0028_();
count = _e51;
let _e52 = count;
if (_e52 <= 0i) {
let _e54 = (*position_2);
return _e54;
}
let _e55 = MorphColumn_u0028_();
column_1 = _e55;
let _e58 = morph_info.morph_params[2u];
rowStep_1 = _e58;
normal_1 = vec3<f32>(0f, 0f, 0f);
tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
i = 0i;
loop {
let _e59 = i;
if (_e59 < 8i) {
let _e61 = i;
let _e62 = count;
if (_e61 >= _e62) {
break;
}
let _e64 = i;
if (_e64 < 4i) {
let _e66 = i;
let _e68 = (*w0_)[_e66];
local = _e68;
} else {
let _e69 = i;
let _e72 = (*w1_)[(_e69 - 4i)];
local = _e72;
}
let _e73 = local;
weight_1 = _e73;
let _e74 = weight_1;
if (_e74 == 0f) {
continue;
}
let _e76 = i;
param = _e76;
let _e77 = weight_1;
param_1 = _e77;
let _e78 = column_1;
param_2 = _e78;
let _e79 = rowStep_1;
param_3 = _e79;
let _e80 = (*position_2);
param_4 = _e80;
let _e81 = normal_1;
param_5 = _e81;
let _e82 = tangent_1;
param_6 = _e82;
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 _e83 = param_4;
(*position_2) = _e83;
let _e84 = param_5;
normal_1 = _e84;
let _e85 = param_6;
tangent_1 = _e85;
continue;
} else {
break;
}
continuing {
let _e86 = i;
i = (_e86 + 1i);
}
}
let _e88 = (*position_2);
return _e88;
}
fn main_1() {
var now: vec3<f32>;
var param_7: vec3<f32>;
var param_8: vec4<f32>;
var param_9: vec4<f32>;
var then: vec3<f32>;
var param_10: vec3<f32>;
var param_11: vec4<f32>;
var param_12: vec4<f32>;
var local_1: vec4<f32>;
var param_13: vec4<f32>;
var param_14: vec4<f32>;
var param_15: vec4<f32>;
var before: vec4<f32>;
var param_16: vec4<f32>;
var param_17: vec4<f32>;
var param_18: vec4<f32>;
var param_19: vec4<f32>;
let _e50 = position_3;
param_7 = _e50;
let _e53 = morph_info.morph_weights[0i];
param_8 = _e53;
let _e56 = morph_info.morph_weights[1i];
param_9 = _e56;
let _e57 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
now = _e57;
let _e58 = position_3;
param_10 = _e58;
let _e61 = prev_info.previous_morph_weights[0i];
param_11 = _e61;
let _e64 = prev_info.previous_morph_weights[1i];
param_12 = _e64;
let _e65 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((¶m_10), (¶m_11), (¶m_12));
then = _e65;
let _e66 = i_row0_1;
param_13 = _e66;
let _e67 = i_row1_1;
param_14 = _e67;
let _e68 = i_row2_1;
param_15 = _e68;
let _e69 = Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b((¶m_13), (¶m_14), (¶m_15));
let _e70 = now;
local_1 = (_e69 * vec4<f32>(_e70.x, _e70.y, _e70.z, 1f));
let _e76 = i_prev_row0_1;
param_16 = _e76;
let _e77 = i_prev_row1_1;
param_17 = _e77;
let _e78 = i_prev_row2_1;
param_18 = _e78;
let _e79 = Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b((¶m_16), (¶m_17), (¶m_18));
let _e80 = then;
before = (_e79 * vec4<f32>(_e80.x, _e80.y, _e80.z, 1f));
let _e87 = prev_info.current_mvp;
let _e88 = local_1;
v_current = (_e87 * _e88);
let _e91 = frame_info.model;
let _e92 = local_1;
param_19 = (_e91 * _e92);
let _e94 = DepthAlongAxis_u0028_vf4_u003b((¶m_19));
v_depth = _e94;
let _e96 = prev_info.previous_mvp;
let _e97 = before;
v_previous = (_e96 * _e97);
let _e100 = frame_info.mvp;
let _e101 = local_1;
unnamed.gl_Position = (_e100 * _e101);
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) i_row0_: vec4<f32>, @location(2) i_row1_: vec4<f32>, @location(3) i_row2_: vec4<f32>, @location(4) i_prev_row0_: vec4<f32>, @location(5) i_prev_row1_: vec4<f32>, @location(6) i_prev_row2_: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
i_row0_1 = i_row0_;
i_row1_1 = i_row1_;
i_row2_1 = i_row2_;
i_prev_row0_1 = i_prev_row0_;
i_prev_row1_1 = i_prev_row1_;
i_prev_row2_1 = i_prev_row2_;
main_1();
let _e22 = v_current;
let _e23 = v_depth;
let _e24 = v_previous;
let _e25 = unnamed.gl_Position;
return VertexOutput(_e22, _e23, _e24, _e25);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_row0',
location: 1,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row1',
location: 2,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row2',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_prev_row0',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_prev_row1',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_prev_row2',
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: 'PrevFrameInfo',
group: 0,
binding: 2,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'current_mvp',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_mvp',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_morph_weights',
offsetInBytes: 128,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 3,
samplerBinding: 4,
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,
),
],
),
'ImpostorVertex': WebGpuStage(
wgsl: r'''
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(0)
var<uniform> frame_info: FrameInfo;
var<private> tangent_1: vec4<f32>;
var<private> position_1: vec3<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> normal_1: vec3<f32>;
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> 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 ImpostorRight_u0028_vf3_u003b(d: ptr<function, vec3<f32>>) -> vec3<f32> {
var up: vec3<f32>;
let _e32 = (*d)[1u];
up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e32) > 0.999f)));
let _e37 = up;
let _e38 = (*d);
return normalize(cross(_e37, _e38));
}
fn MvpRow_u0028_i1_u003b(r: ptr<function, i32>) -> vec4<f32> {
let _e30 = (*r);
let _e34 = frame_info.mvp[0][_e30];
let _e35 = (*r);
let _e39 = frame_info.mvp[1][_e35];
let _e40 = (*r);
let _e44 = frame_info.mvp[2][_e40];
let _e45 = (*r);
let _e49 = frame_info.mvp[3][_e45];
return vec4<f32>(_e34, _e39, _e44, _e49);
}
fn main_1() {
var radius: f32;
var centre: vec3<f32>;
var rx: vec4<f32>;
var param: i32;
var ry: vec4<f32>;
var param_1: i32;
var rz: vec4<f32>;
var param_2: i32;
var rw: vec4<f32>;
var param_3: i32;
var yw: vec3<f32>;
var wx: vec3<f32>;
var xy: vec3<f32>;
var det: f32;
var eye: vec3<f32>;
var toEye: vec3<f32>;
var local: vec3<f32>;
var d_1: vec3<f32>;
var right: vec3<f32>;
var param_4: vec3<f32>;
var up_1: vec3<f32>;
var corner: vec3<f32>;
let _e52 = tangent_1[3u];
radius = _e52;
let _e53 = position_1;
let _e55 = texcoord_1[0u];
let _e59 = texcoord_1[1u];
let _e63 = radius;
centre = (_e53 - (vec3<f32>(((_e55 * 2f) - 1f), (1f - (_e59 * 2f)), 0f) * _e63));
param = 0i;
let _e66 = MvpRow_u0028_i1_u003b((¶m));
rx = _e66;
param_1 = 1i;
let _e67 = MvpRow_u0028_i1_u003b((¶m_1));
ry = _e67;
param_2 = 2i;
let _e68 = MvpRow_u0028_i1_u003b((¶m_2));
rz = _e68;
param_3 = 3i;
let _e69 = MvpRow_u0028_i1_u003b((¶m_3));
rw = _e69;
let _e70 = ry;
let _e72 = rw;
yw = cross(_e70.xyz, _e72.xyz);
let _e75 = rw;
let _e77 = rx;
wx = cross(_e75.xyz, _e77.xyz);
let _e80 = rx;
let _e82 = ry;
xy = cross(_e80.xyz, _e82.xyz);
let _e85 = rx;
let _e87 = yw;
det = dot(_e85.xyz, _e87);
let _e90 = rx[3u];
let _e91 = yw;
let _e94 = ry[3u];
let _e95 = wx;
let _e99 = rw[3u];
let _e100 = xy;
let _e104 = det;
let _e107 = det;
eye = (-((((_e91 * _e90) + (_e95 * _e94)) + (_e100 * _e99))) / vec3(select(1f, _e107, (abs(_e104) > 0.00000000000000000001f))));
let _e111 = det;
if (abs(_e111) > 0.00000000000000000001f) {
let _e114 = eye;
let _e115 = centre;
local = (_e114 - _e115);
} else {
let _e117 = rz;
local = -(_e117.xyz);
}
let _e120 = local;
toEye = _e120;
let _e121 = toEye;
let _e122 = toEye;
let _e125 = toEye;
let _e126 = normal_1;
d_1 = normalize(select(_e126, _e125, vec3((dot(_e121, _e122) > 0.00000000000000000001f))));
let _e130 = d_1;
param_4 = _e130;
let _e131 = ImpostorRight_u0028_vf3_u003b((¶m_4));
right = _e131;
let _e132 = d_1;
let _e133 = right;
up_1 = cross(_e132, _e133);
let _e135 = centre;
let _e136 = right;
let _e138 = texcoord_1[0u];
let _e142 = up_1;
let _e144 = texcoord_1[1u];
let _e149 = radius;
corner = (_e135 + (((_e136 * ((_e138 * 2f) - 1f)) + (_e142 * (1f - (_e144 * 2f)))) * _e149));
let _e153 = frame_info.model;
let _e154 = corner;
v_world_position = (_e153 * vec4<f32>(_e154.x, _e154.y, _e154.z, 1f)).xyz;
let _e162 = frame_info.normal_matrix;
let _e170 = d_1;
v_normal = normalize((mat3x3<f32>(_e162[0].xyz, _e162[1].xyz, _e162[2].xyz) * _e170));
let _e174 = frame_info.model;
let _e182 = right;
let _e184 = normalize((mat3x3<f32>(_e174[0].xyz, _e174[1].xyz, _e174[2].xyz) * _e182));
v_tangent = vec4<f32>(_e184.x, _e184.y, _e184.z, 1f);
let _e189 = texcoord_1;
v_texcoord = _e189;
let _e190 = d_1;
let _e192 = color_1[3u];
v_color = vec4<f32>(_e190.x, _e190.y, _e190.z, _e192);
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e198 = frame_info.mvp;
let _e199 = corner;
unnamed.gl_Position = (_e198 * vec4<f32>(_e199.x, _e199.y, _e199.z, 1f));
return;
}
@vertex
fn main(@location(3) tangent: vec4<f32>, @location(0) position: vec3<f32>, @location(2) texcoord: vec2<f32>, @location(1) normal: vec3<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
tangent_1 = tangent;
position_1 = position;
texcoord_1 = texcoord;
normal_1 = normal;
color_1 = color;
main_1();
let _e18 = v_world_position;
let _e19 = v_normal;
let _e20 = v_tangent;
let _e21 = v_texcoord;
let _e22 = v_color;
let _e23 = v_lightmap_uv;
let _e24 = unnamed.gl_Position;
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,
),
],
),
],
samplers: <WebGpuSampler>[],
),
},
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>,
shadow_bias: vec4<f32>,
target_origin: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@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>;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e75 = v_world_position_1;
let _e77 = fog_info.eye;
let _e81 = fog_info.forward;
return dot((_e75 - _e77.xyz), _e81.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e80 = ViewDepth_u0028_();
z = abs(_e80);
let _e82 = z;
near = (_e82 / 5f);
let _e84 = z;
far = (_e84 / 200f);
let _e86 = far;
let _e87 = far;
let _e89 = far;
far3_ = ((_e86 * _e87) * _e89);
let _e91 = (*alpha);
let _e92 = near;
let _e93 = near;
let _e96 = far3_;
let _e97 = far3_;
return (_e91 * clamp((10f / ((0.00001f + (_e92 * _e93)) + (_e96 * _e97))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e84 = fog_info.forward[3u];
mode = _e84;
let _e85 = mode;
if (_e85 > 0.5f) {
let _e88 = frag_color[3u];
alpha_1 = _e88;
let _e89 = alpha_1;
param = _e89;
let _e90 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e90;
let _e91 = frag_color;
let _e93 = weight;
let _e94 = (_e91.xyz * _e93);
let _e95 = alpha_1;
let _e96 = weight;
accumulate = vec4<f32>(_e94.x, _e94.y, _e94.z, (_e95 * _e96));
let _e102 = mode;
let _e104 = mode;
revealage = ((_e102 > 1.5f) && (_e104 < 2.5f));
let _e107 = revealage;
if _e107 {
let _e108 = alpha_1;
local = vec4(_e108);
} else {
let _e110 = accumulate;
local = _e110;
}
let _e111 = local;
frag_color = _e111;
let _e112 = mode;
if (_e112 > 2.5f) {
let _e114 = alpha_1;
frag_surface = vec4(_e114);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e78 = (*n)[0u];
let _e81 = (*n)[1u];
let _e85 = (*n)[2u];
let _e88 = (*n);
(*n) = (_e88 / vec3(((abs(_e78) + abs(_e81)) + abs(_e85))));
let _e91 = (*n);
e = _e91.xy;
let _e94 = (*n)[2u];
if (_e94 < 0f) {
let _e96 = (*n);
let _e102 = (*n)[0u];
let _e106 = (*n)[1u];
e = ((vec2(1f) - abs(_e96.yx)) * vec2<f32>(select(-1f, 1f, (_e102 >= 0f)), select(-1f, 1f, (_e106 >= 0f))));
}
let _e111 = e;
return ((_e111 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e76 = (*linear);
let _e78 = (*linear);
let _e82 = (*linear);
return mix((_e76 * 12.92f), ((pow(_e78, 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), _e82));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e79 = g_albedo;
param_1 = clamp(_e79, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e81 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e81.x, _e81.y, _e81.z, 1f);
let _e86 = g_debug_surface_on;
if _e86 {
let _e87 = g_debug_surface;
let _e88 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e87.x, _e87.y, _e87.z, _e88);
return;
}
let _e93 = v_normal_1;
geometric = normalize(_e93);
let _e95 = gl_FrontFacing_1;
if !(_e95) {
let _e97 = geometric;
geometric = -(_e97);
}
let _e99 = geometric;
param_2 = _e99;
let _e100 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e101 = (*roughness);
let _e103 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e100.x, _e100.y, clamp(_e101, 0f, 1f), _e103);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e75 = v_world_position_1;
let _e77 = fog_info.eye;
return distance(_e75, _e77.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e80 = fog_info.fog[3u];
density = _e80;
let _e81 = density;
if (_e81 <= 0f) {
let _e83 = (*color);
return _e83;
}
let _e84 = EyeDistance_u0028_();
d = _e84;
let _e86 = fog_info.fog;
let _e88 = (*color);
let _e89 = density;
let _e91 = d;
return mix(_e86.xyz, _e88, vec3(clamp(exp((-(_e89) * _e91)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e81 = g_premultiply;
let _e82 = (*alpha_2);
weight_1 = select(1f, _e82, _e81);
let _e84 = (*linearColor);
param_3 = _e84;
let _e85 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e86 = weight_1;
let _e87 = (_e85 * _e86);
let _e88 = (*alpha_2);
frag_color = vec4<f32>(_e87.x, _e87.y, _e87.z, _e88);
let _e93 = (*roughness_1);
param_4 = _e93;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
var param_5: vec3<f32>;
var param_6: f32;
var param_7: f32;
let _e80 = (*linearColor_1);
param_5 = _e80;
let _e81 = (*alpha_3);
param_6 = _e81;
param_7 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e76 = (*srgb);
let _e79 = (*srgb);
let _e84 = (*srgb);
return mix((_e76 / vec3(12.92f)), pow(((_e79 + 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), _e84));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e77 = frag_info.target_origin[1u];
return _e77;
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise: f32;
let _e82 = v_texcoord_1;
let _e83 = MaterialLodBias_u0028_();
let _e84 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e82, _e83);
texel = _e84;
let _e85 = texel;
param_8 = _e85.xyz;
let _e87 = SrgbToLinear_u0028_vf3_u003b((¶m_8));
let _e89 = frag_info.base_color;
param_9 = _e89.xyz;
let _e91 = SrgbToLinear_u0028_vf3_u003b((¶m_9));
let _e93 = v_color_1;
s.albedo = ((_e87 * _e91) * _e93.xyz);
let _e98 = texel[3u];
let _e101 = frag_info.base_color[3u];
let _e104 = v_color_1[3u];
s.alpha = ((_e98 * _e101) * _e104);
let _e108 = s.albedo;
g_albedo = _e108;
let _e111 = frag_info.material2_[0u];
cutoff = _e111;
let _e112 = cutoff;
if (_e112 >= 0f) {
let _e115 = s.alpha;
let _e116 = cutoff;
if (_e115 < _e116) {
discard;
}
} else {
let _e118 = cutoff;
if (_e118 < -1.5f) {
let _e120 = v_world_position_1;
anchored = floor((_e120 * 16f));
let _e123 = anchored;
noise = fract((sin(dot(_e123, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e129 = s.alpha;
let _e130 = noise;
if (_e129 < _e130) {
discard;
}
}
}
let _e132 = cutoff;
let _e134 = cutoff;
g_premultiply = ((_e132 < 0f) && (_e134 > -0.75f));
let _e137 = v_normal_1;
s.n = normalize(_e137);
let _e140 = gl_FrontFacing_1;
if !(_e140) {
let _e143 = s.n;
s.n = -(_e143);
}
let _e147 = frag_info.camera_position;
let _e149 = v_world_position_1;
s.v = normalize((_e147.xyz - _e149));
let _e154 = s.n;
let _e156 = s.v;
s.n_dot_v = max(dot(_e154, _e156), 0.0001f);
let _e162 = frag_info.material[0u];
s.metallic = clamp(_e162, 0f, 1f);
let _e167 = frag_info.material[1u];
s.roughness = clamp(_e167, 0.02f, 1f);
let _e171 = frag_info.ambient_ground;
let _e174 = frag_info.ambient_sky;
let _e178 = s.n[1u];
let _e185 = frag_info.material[2u];
s.ambient = (mix(_e171.xyz, _e174.xyz, vec3(((_e178 * 0.5f) + 0.5f))) * _e185);
let _e190 = frag_info.frame_params[0u];
s.exposure = max(_e190, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e195 = s;
return _e195;
}
fn main_1() {
var s_1: Surface;
var param_10: vec3<f32>;
var param_11: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e78 = ReadSurface_u0028_();
s_1 = _e78;
g_albedo = vec3<f32>(0f, 0f, 0f);
let _e80 = s_1.albedo;
param_10 = _e80;
let _e82 = s_1.alpha;
param_11 = _e82;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_10), (¶m_11));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @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;
gl_FrontFacing_1 = gl_FrontFacing;
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 _e17 = frag_albedo;
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e17, _e18, _e19);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
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>,
shadow_bias: vec4<f32>,
target_origin: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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(1)
var<uniform> frag_info: FragInfo;
@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>;
var<private> v_color_1: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e67 = v_world_position_1;
let _e69 = fog_info.eye;
let _e73 = fog_info.forward;
return dot((_e67 - _e69.xyz), _e73.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e72 = ViewDepth_u0028_();
z = abs(_e72);
let _e74 = z;
near = (_e74 / 5f);
let _e76 = z;
far = (_e76 / 200f);
let _e78 = far;
let _e79 = far;
let _e81 = far;
far3_ = ((_e78 * _e79) * _e81);
let _e83 = (*alpha);
let _e84 = near;
let _e85 = near;
let _e88 = far3_;
let _e89 = far3_;
return (_e83 * clamp((10f / ((0.00001f + (_e84 * _e85)) + (_e88 * _e89))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e76 = fog_info.forward[3u];
mode = _e76;
let _e77 = mode;
if (_e77 > 0.5f) {
let _e80 = frag_color[3u];
alpha_1 = _e80;
let _e81 = alpha_1;
param = _e81;
let _e82 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e82;
let _e83 = frag_color;
let _e85 = weight;
let _e86 = (_e83.xyz * _e85);
let _e87 = alpha_1;
let _e88 = weight;
accumulate = vec4<f32>(_e86.x, _e86.y, _e86.z, (_e87 * _e88));
let _e94 = mode;
let _e96 = mode;
revealage = ((_e94 > 1.5f) && (_e96 < 2.5f));
let _e99 = revealage;
if _e99 {
let _e100 = alpha_1;
local = vec4(_e100);
} else {
let _e102 = accumulate;
local = _e102;
}
let _e103 = local;
frag_color = _e103;
}
return;
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e67 = v_world_position_1;
let _e69 = fog_info.eye;
return distance(_e67, _e69.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e72 = fog_info.fog[3u];
density = _e72;
let _e73 = density;
if (_e73 <= 0f) {
let _e75 = (*color);
return _e75;
}
let _e76 = EyeDistance_u0028_();
d = _e76;
let _e78 = fog_info.fog;
let _e80 = (*color);
let _e81 = density;
let _e83 = d;
return mix(_e78.xyz, _e80, vec3(clamp(exp((-(_e81) * _e83)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_1: vec3<f32>;
var param_2: f32;
let _e73 = g_premultiply;
let _e74 = (*alpha_2);
weight_1 = select(1f, _e74, _e73);
let _e76 = (*linearColor);
param_1 = _e76;
let _e77 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e78 = weight_1;
let _e79 = (_e77 * _e78);
let _e80 = (*alpha_2);
frag_color = vec4<f32>(_e79.x, _e79.y, _e79.z, _e80);
let _e85 = (*roughness_1);
param_2 = _e85;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
WriteWeightedBlended_u0028_();
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
var param_3: vec3<f32>;
var param_4: f32;
var param_5: f32;
let _e72 = (*linearColor_1);
param_3 = _e72;
let _e73 = (*alpha_3);
param_4 = _e73;
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 _e68 = (*srgb);
let _e71 = (*srgb);
let _e76 = (*srgb);
return mix((_e68 / vec3(12.92f)), pow(((_e71 + 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), _e76));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e69 = frag_info.target_origin[1u];
return _e69;
}
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 _e74 = v_texcoord_1;
let _e75 = MaterialLodBias_u0028_();
let _e76 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e74, _e75);
texel = _e76;
let _e77 = texel;
param_6 = _e77.xyz;
let _e79 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e81 = frag_info.base_color;
param_7 = _e81.xyz;
let _e83 = SrgbToLinear_u0028_vf3_u003b((¶m_7));
let _e85 = v_color_1;
s.albedo = ((_e79 * _e83) * _e85.xyz);
let _e90 = texel[3u];
let _e93 = frag_info.base_color[3u];
let _e96 = v_color_1[3u];
s.alpha = ((_e90 * _e93) * _e96);
let _e100 = s.albedo;
g_albedo = _e100;
let _e103 = frag_info.material2_[0u];
cutoff = _e103;
let _e104 = cutoff;
if (_e104 >= 0f) {
let _e107 = s.alpha;
let _e108 = cutoff;
if (_e107 < _e108) {
discard;
}
} else {
let _e110 = cutoff;
if (_e110 < -1.5f) {
let _e112 = v_world_position_1;
anchored = floor((_e112 * 16f));
let _e115 = anchored;
noise = fract((sin(dot(_e115, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e121 = s.alpha;
let _e122 = noise;
if (_e121 < _e122) {
discard;
}
}
}
let _e124 = cutoff;
let _e126 = cutoff;
g_premultiply = ((_e124 < 0f) && (_e126 > -0.75f));
let _e129 = v_normal_1;
s.n = normalize(_e129);
let _e132 = gl_FrontFacing_1;
if !(_e132) {
let _e135 = s.n;
s.n = -(_e135);
}
let _e139 = frag_info.camera_position;
let _e141 = v_world_position_1;
s.v = normalize((_e139.xyz - _e141));
let _e146 = s.n;
let _e148 = s.v;
s.n_dot_v = max(dot(_e146, _e148), 0.0001f);
let _e154 = frag_info.material[0u];
s.metallic = clamp(_e154, 0f, 1f);
let _e159 = frag_info.material[1u];
s.roughness = clamp(_e159, 0.02f, 1f);
let _e163 = frag_info.ambient_ground;
let _e166 = frag_info.ambient_sky;
let _e170 = s.n[1u];
let _e177 = frag_info.material[2u];
s.ambient = (mix(_e163.xyz, _e166.xyz, vec3(((_e170 * 0.5f) + 0.5f))) * _e177);
let _e182 = frag_info.frame_params[0u];
s.exposure = max(_e182, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e187 = s;
return _e187;
}
fn main_1() {
var s_1: Surface;
var param_8: vec3<f32>;
var param_9: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e70 = ReadSurface_u0028_();
s_1 = _e70;
let _e72 = s_1.albedo;
param_8 = _e72;
let _e74 = s_1.alpha;
param_9 = _e74;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
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>, @builtin(front_facing) gl_FrontFacing: bool, @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;
gl_FrontFacing_1 = gl_FrontFacing;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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 IrradianceInfo {
origin: vec4<f32>,
spacing: vec4<f32>,
counts: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e174 = v_world_position_1;
let _e176 = fog_info.eye;
let _e180 = fog_info.forward;
return dot((_e174 - _e176.xyz), _e180.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e179 = ViewDepth_u0028_();
z = abs(_e179);
let _e181 = z;
near = (_e181 / 5f);
let _e183 = z;
far = (_e183 / 200f);
let _e185 = far;
let _e186 = far;
let _e188 = far;
far3_ = ((_e185 * _e186) * _e188);
let _e190 = (*alpha);
let _e191 = near;
let _e192 = near;
let _e195 = far3_;
let _e196 = far3_;
return (_e190 * clamp((10f / ((0.00001f + (_e191 * _e192)) + (_e195 * _e196))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e183 = fog_info.forward[3u];
mode = _e183;
let _e184 = mode;
if (_e184 > 0.5f) {
let _e187 = frag_color[3u];
alpha_1 = _e187;
let _e188 = alpha_1;
param = _e188;
let _e189 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e189;
let _e190 = frag_color;
let _e192 = weight;
let _e193 = (_e190.xyz * _e192);
let _e194 = alpha_1;
let _e195 = weight;
accumulate = vec4<f32>(_e193.x, _e193.y, _e193.z, (_e194 * _e195));
let _e201 = mode;
let _e203 = mode;
revealage = ((_e201 > 1.5f) && (_e203 < 2.5f));
let _e206 = revealage;
if _e206 {
let _e207 = alpha_1;
local = vec4(_e207);
} else {
let _e209 = accumulate;
local = _e209;
}
let _e210 = local;
frag_color = _e210;
let _e211 = mode;
if (_e211 > 2.5f) {
let _e213 = alpha_1;
frag_surface = vec4(_e213);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e177 = (*n)[0u];
let _e180 = (*n)[1u];
let _e184 = (*n)[2u];
let _e187 = (*n);
(*n) = (_e187 / vec3(((abs(_e177) + abs(_e180)) + abs(_e184))));
let _e190 = (*n);
e = _e190.xy;
let _e193 = (*n)[2u];
if (_e193 < 0f) {
let _e195 = (*n);
let _e201 = (*n)[0u];
let _e205 = (*n)[1u];
e = ((vec2(1f) - abs(_e195.yx)) * vec2<f32>(select(-1f, 1f, (_e201 >= 0f)), select(-1f, 1f, (_e205 >= 0f))));
}
let _e210 = e;
return ((_e210 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e175 = (*linear);
let _e177 = (*linear);
let _e181 = (*linear);
return mix((_e175 * 12.92f), ((pow(_e177, 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), _e181));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e178 = g_albedo;
param_1 = clamp(_e178, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e180 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e180.x, _e180.y, _e180.z, 1f);
let _e185 = g_debug_surface_on;
if _e185 {
let _e186 = g_debug_surface;
let _e187 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e186.x, _e186.y, _e186.z, _e187);
return;
}
let _e192 = v_normal_1;
geometric = normalize(_e192);
let _e194 = gl_FrontFacing_1;
if !(_e194) {
let _e196 = geometric;
geometric = -(_e196);
}
let _e198 = geometric;
param_2 = _e198;
let _e199 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e200 = (*roughness);
let _e202 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e199.x, _e199.y, clamp(_e200, 0f, 1f), _e202);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e174 = v_world_position_1;
let _e176 = fog_info.eye;
return distance(_e174, _e176.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e179 = fog_info.fog[3u];
density = _e179;
let _e180 = density;
if (_e180 <= 0f) {
let _e182 = (*color);
return _e182;
}
let _e183 = EyeDistance_u0028_();
d = _e183;
let _e185 = fog_info.fog;
let _e187 = (*color);
let _e188 = density;
let _e190 = d;
return mix(_e185.xyz, _e187, vec3(clamp(exp((-(_e188) * _e190)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e180 = g_premultiply;
let _e181 = (*alpha_2);
weight_1 = select(1f, _e181, _e180);
let _e183 = (*linearColor);
param_3 = _e183;
let _e184 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e185 = weight_1;
let _e186 = (_e184 * _e185);
let _e187 = (*alpha_2);
frag_color = vec4<f32>(_e186.x, _e186.y, _e186.z, _e187);
let _e192 = (*roughness_1);
param_4 = _e192;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
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_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e177 = (*s).albedo;
return _e177;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e175 = (*i);
if (_e175 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e177 = (*i);
if (_e177 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e179 = (*i);
if (_e179 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e181 = (*i);
if (_e181 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e183 = (*i);
if (_e183 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e185 = (*i);
if (_e185 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e187 = (*i);
if (_e187 == 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_5: i32;
let _e180 = (*i_1);
param_5 = _e180;
let _e181 = PointShadowDiskTap_u0028_i1_u003b((¶m_5));
p = _e181;
let _e183 = p[0u];
let _e184 = (*ca);
let _e187 = p[1u];
let _e188 = (*sa);
let _e192 = p[0u];
let _e193 = (*sa);
let _e196 = p[1u];
let _e197 = (*ca);
let _e201 = (*radius);
return (vec2<f32>(((_e183 * _e184) - (_e187 * _e188)), ((_e192 * _e193) + (_e196 * _e197))) * _e201);
}
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_1: vec2<f32>;
var atlas: vec2<f32>;
let _e183 = point_shadow.params[0u];
inset = _e183;
let _e184 = (*uv);
let _e185 = (*offset);
let _e187 = inset;
let _e188 = inset;
local_1 = clamp((_e184 + _e185), vec2(_e187), vec2((1f - _e188)));
let _e193 = local_1;
let _e194 = (*tile);
atlas = ((_e193 + _e194) * vec2<f32>(0.16666667f, 0.16666667f));
let _e199 = point_shadow.params3_[0u];
if (_e199 > 0.5f) {
let _e202 = atlas[1u];
atlas[1u] = (1f - _e202);
}
let _e205 = atlas;
let _e206 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e205, 0f);
let _e208 = atlas;
let _e209 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e208, 0f);
let _e212 = (*range);
return (min(_e206.x, _e209.x) * _e212);
}
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_6: vec2<f32>;
var param_7: vec2<f32>;
var param_8: vec2<f32>;
var param_9: f32;
let _e184 = (*uv_1);
param_6 = _e184;
let _e185 = (*offset_1);
param_7 = _e185;
let _e186 = (*tile_1);
param_8 = _e186;
let _e187 = (*range_1);
param_9 = _e187;
let _e188 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9));
stored = _e188;
let _e189 = stored;
let _e190 = (*range_1);
if (_e189 >= (_e190 * 0.999f)) {
return 1f;
}
let _e193 = (*receiver);
let _e194 = stored;
return select(1f, 0f, (_e193 > _e194));
}
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_10: vec2<f32>;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_14: i32;
var param_15: f32;
var param_16: f32;
var param_17: f32;
var param_18: vec2<f32>;
var param_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e205 = point_shadow.params2_[1u];
lightRadius = _e205;
let _e208 = point_shadow.params2_[0u];
minRadius = _e208;
let _e211 = point_shadow.params2_[2u];
maxRadius = _e211;
let _e212 = lightRadius;
if (_e212 <= 0f) {
let _e214 = (*uv_2);
param_10 = _e214;
param_11 = vec2<f32>(0f, 0f);
let _e215 = (*tile_2);
param_12 = _e215;
let _e216 = (*range_2);
param_13 = _e216;
let _e217 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13));
(*blockerOut) = _e217;
let _e218 = minRadius;
return _e218;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e219 = i_2;
if (_e219 < 8i) {
let _e221 = i_2;
param_14 = _e221;
let _e222 = (*ca_1);
param_15 = _e222;
let _e223 = (*sa_1);
param_16 = _e223;
let _e224 = maxRadius;
param_17 = _e224;
let _e225 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_14), (¶m_15), (¶m_16), (¶m_17));
let _e226 = (*uv_2);
param_18 = _e226;
param_19 = _e225;
let _e227 = (*tile_2);
param_20 = _e227;
let _e228 = (*range_2);
param_21 = _e228;
let _e229 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_18), (¶m_19), (¶m_20), (¶m_21));
stored_1 = _e229;
let _e230 = stored_1;
let _e231 = (*range_2);
if (_e230 >= (_e231 * 0.999f)) {
continue;
}
let _e234 = stored_1;
let _e235 = (*receiver_1);
if (_e234 >= _e235) {
continue;
}
let _e237 = stored_1;
let _e238 = sum;
sum = (_e238 + _e237);
let _e240 = count;
count = (_e240 + 1f);
continue;
} else {
break;
}
continuing {
let _e242 = i_2;
i_2 = (_e242 + 1i);
}
}
let _e244 = count;
if (_e244 < 0.5f) {
return -1f;
}
let _e246 = sum;
let _e247 = count;
blocker = max((_e246 / _e247), 0.0001f);
let _e250 = blocker;
(*blockerOut) = _e250;
let _e251 = lightRadius;
let _e252 = (*receiver_1);
let _e253 = blocker;
let _e257 = blocker;
world = ((_e251 * max((_e252 - _e253), 0f)) / _e257);
let _e259 = world;
let _e260 = (*receiver_1);
let _e262 = (*tanHalf);
let _e265 = minRadius;
let _e266 = maxRadius;
return clamp((_e259 / ((2f * _e260) * _e262)), _e265, _e266);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_2: vec2<f32>;
let _e176 = (*rows);
if (_e176 > 0f) {
let _e179 = gl_FragCoord_1[0u];
let _e180 = (*rows);
let _e182 = gl_FragCoord_1[1u];
local_2 = vec2<f32>(_e179, (_e180 - _e182));
} else {
let _e185 = gl_FragCoord_1;
local_2 = _e185.xy;
}
let _e187 = local_2;
return _e187;
}
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 param_22: 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_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var local_3: vec3<f32>;
var lit: f32;
var param_31: vec2<f32>;
var param_32: vec2<f32>;
var param_33: vec2<f32>;
var param_34: f32;
var param_35: f32;
var i_3: i32;
var param_36: i32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
var param_40: vec2<f32>;
var param_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: f32;
var param_44: f32;
var phi_2146_: bool;
var phi_2207_: bool;
let _e228 = (*lightIndex);
let _e232 = point_shadow.slots[_e228][0u];
slot = i32((_e232 + 0.5f));
let _e235 = (*lightIndex);
let _e239 = point_shadow.slots[_e235][0u];
if (_e239 < 0f) {
return 1f;
}
let _e243 = point_shadow.params[2u];
strength = _e243;
let _e244 = strength;
if (_e244 <= 0f) {
return 1f;
}
let _e246 = slot;
let _e249 = point_shadow.lights[_e246];
let _e251 = (*world_1);
toLight = (_e249.xyz - _e251);
let _e253 = toLight;
toLightLength = max(length(_e253), 0.000001f);
let _e256 = (*normal);
let _e257 = toLight;
let _e258 = toLightLength;
nDotL = max(dot(_e256, (_e257 / vec3(_e258))), 0.15f);
let _e263 = nDotL;
let _e264 = nDotL;
let _e269 = nDotL;
let _e270 = nDotL;
slope = min((sqrt(max((1f - (_e263 * _e264)), 0f)) / (_e269 * _e270)), 8f);
let _e274 = toLightLength;
let _e276 = (*lightIndex);
let _e280 = point_shadow.slots[_e276][2u];
let _e285 = point_shadow.params3_[1u];
texel = (((2f * _e274) * max(_e280, 0.0001f)) * _e285);
let _e287 = (*world_1);
let _e288 = (*normal);
let _e289 = texel;
let _e293 = point_shadow.params[3u];
let _e295 = slope;
origin = (_e287 + (((_e288 * _e289) * _e293) * (1f + _e295)));
let _e299 = origin;
let _e300 = slot;
let _e303 = point_shadow.lights[_e300];
toFragment = (_e299 - _e303.xyz);
let _e306 = toFragment;
distance_ = length(_e306);
let _e308 = slot;
let _e312 = point_shadow.lights[_e308][3u];
range_3 = max(_e312, 0.0001f);
let _e314 = distance_;
let _e315 = range_3;
if (_e314 >= _e315) {
return 1f;
}
face = 0i;
let _e317 = (*lightIndex);
let _e321 = point_shadow.slots[_e317][1u];
if (_e321 < 0.5f) {
let _e323 = toFragment;
a = abs(_e323);
let _e326 = a[0u];
let _e328 = a[1u];
let _e329 = (_e326 >= _e328);
phi_2146_ = _e329;
if _e329 {
let _e331 = a[0u];
let _e333 = a[2u];
phi_2146_ = (_e331 >= _e333);
}
let _e336 = phi_2146_;
if _e336 {
let _e338 = toFragment[0u];
face = select(1i, 0i, (_e338 > 0f));
} else {
let _e342 = a[1u];
let _e344 = a[2u];
if (_e342 >= _e344) {
let _e347 = toFragment[1u];
face = select(3i, 2i, (_e347 > 0f));
} else {
let _e351 = toFragment[2u];
face = select(5i, 4i, (_e351 > 0f));
}
}
}
let _e354 = slot;
let _e356 = face;
let _e360 = point_shadow.faces[((_e354 * 6i) + _e356)];
let _e361 = origin;
clip = (_e360 * vec4<f32>(_e361.x, _e361.y, _e361.z, 1f));
let _e368 = clip[3u];
if (_e368 <= 0f) {
return 1f;
}
let _e370 = clip;
let _e373 = clip[3u];
ndc = (_e370.xy / vec2(_e373));
let _e377 = ndc[0u];
let _e379 = (abs(_e377) > 1f);
phi_2207_ = _e379;
if !(_e379) {
let _e382 = ndc[1u];
phi_2207_ = (abs(_e382) > 1f);
}
let _e386 = phi_2207_;
if _e386 {
return 1f;
}
let _e388 = ndc[0u];
let _e392 = ndc[1u];
uv_3 = vec2<f32>(((_e388 * 0.5f) + 0.5f), (0.5f - (_e392 * 0.5f)));
let _e396 = face;
let _e398 = slot;
tile_3 = vec2<f32>(f32(_e396), f32(_e398));
let _e401 = distance_;
let _e404 = point_shadow.params[1u];
receiver_2 = (_e401 - _e404);
let _e408 = frag_info.target_origin[0u];
param_22 = _e408;
let _e409 = FragCoordFromTop_u0028_f1_u003b((¶m_22));
noise = fract((52.982918f * fract(dot(_e409, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e414 = noise;
angle = (_e414 * 6.2831855f);
let _e416 = angle;
ca_2 = cos(_e416);
let _e418 = angle;
sa_2 = sin(_e418);
let _e420 = (*lightIndex);
let _e424 = point_shadow.slots[_e420][2u];
tanHalf_1 = max(_e424, 0.0001f);
blocker_1 = -1f;
let _e426 = uv_3;
param_23 = _e426;
let _e427 = tile_3;
param_24 = _e427;
let _e428 = range_3;
param_25 = _e428;
let _e429 = receiver_2;
param_26 = _e429;
let _e430 = ca_2;
param_27 = _e430;
let _e431 = sa_2;
param_28 = _e431;
let _e432 = tanHalf_1;
param_29 = _e432;
let _e433 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30));
let _e434 = param_30;
blocker_1 = _e434;
radius_1 = _e433;
let _e437 = point_shadow.params2_[3u];
if (_e437 > 0.5f) {
g_debug_surface_on = true;
let _e439 = radius_1;
if (_e439 < 0f) {
local_3 = vec3<f32>(0f, 0f, 1f);
} else {
let _e441 = radius_1;
let _e444 = point_shadow.params2_[2u];
let _e448 = blocker_1;
let _e449 = range_3;
local_3 = vec3<f32>(clamp((_e441 / max(_e444, 0.000001f)), 0f, 1f), clamp((_e448 / _e449), 0f, 1f), 0f);
}
let _e453 = local_3;
g_debug_surface = _e453;
}
let _e454 = radius_1;
if (_e454 < 0f) {
return 1f;
}
let _e456 = uv_3;
param_31 = _e456;
param_32 = vec2<f32>(0f, 0f);
let _e457 = tile_3;
param_33 = _e457;
let _e458 = range_3;
param_34 = _e458;
let _e459 = receiver_2;
param_35 = _e459;
let _e460 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_31), (¶m_32), (¶m_33), (¶m_34), (¶m_35));
lit = _e460;
let _e461 = radius_1;
if (_e461 > 0f) {
i_3 = 0i;
loop {
let _e463 = i_3;
if (_e463 < 8i) {
let _e465 = i_3;
param_36 = _e465;
let _e466 = ca_2;
param_37 = _e466;
let _e467 = sa_2;
param_38 = _e467;
let _e468 = radius_1;
param_39 = _e468;
let _e469 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e470 = uv_3;
param_40 = _e470;
param_41 = _e469;
let _e471 = tile_3;
param_42 = _e471;
let _e472 = range_3;
param_43 = _e472;
let _e473 = receiver_2;
param_44 = _e473;
let _e474 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
let _e475 = lit;
lit = (_e475 + _e474);
continue;
} else {
break;
}
continuing {
let _e477 = i_3;
i_3 = (_e477 + 1i);
}
}
let _e479 = lit;
lit = (_e479 * 0.11111111f);
}
let _e481 = lit;
let _e482 = strength;
return mix(1f, _e481, clamp(_e482, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r: f32;
var theta: f32;
let _e179 = (*i_4);
let _e182 = (*n_1);
r = sqrt(((f32(_e179) + 0.5f) / f32(_e182)));
let _e186 = (*i_4);
let _e189 = (*turn);
theta = ((f32(_e186) * 2.3999631f) + _e189);
let _e191 = r;
let _e192 = theta;
let _e194 = theta;
return (vec2<f32>(cos(_e192), sin(_e194)) * _e191);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_45: f32;
let _e178 = frag_info.target_origin[0u];
param_45 = _e178;
let _e179 = FragCoordFromTop_u0028_f1_u003b((¶m_45));
let _e182 = frag_info.target_origin[3u];
at = (_e179 + vec2((5.588238f * max(_e182, 0f))));
let _e187 = at;
return fract((52.982918f * fract(dot(_e187, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_1: f32;
var pMax: f32;
var reduced: f32;
let _e183 = (*moments)[1u];
let _e185 = (*moments)[0u];
let _e187 = (*moments)[0u];
let _e190 = (*minVariance);
variance = max((_e183 - (_e185 * _e187)), _e190);
let _e192 = (*t);
let _e194 = (*moments)[0u];
d_1 = (_e192 - _e194);
let _e196 = variance;
let _e197 = variance;
let _e198 = d_1;
let _e199 = d_1;
pMax = (_e196 / (_e197 + (_e198 * _e199)));
let _e203 = pMax;
let _e204 = (*bleed);
let _e206 = (*bleed);
reduced = clamp(((_e203 - _e204) / max((1f - _e206), 0.0001f)), 0f, 1f);
let _e211 = (*t);
let _e213 = (*moments)[0u];
let _e215 = reduced;
return select(_e215, 1f, (_e211 <= _e213));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e176 = (*depth);
d_2 = ((2f * clamp(_e176, 0f, 1f)) - 1f);
let _e180 = d_2;
let _e183 = d_2;
return vec2<f32>(exp((40f * _e180)), -(exp((-5f * _e183))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_46: f32;
var scale: vec2<f32>;
var positive: f32;
var param_47: vec2<f32>;
var param_48: f32;
var param_49: f32;
var param_50: f32;
var negative: f32;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var param_54: f32;
let _e190 = (*depth_1);
param_46 = _e190;
let _e191 = EvsmWarp_u0028_f1_u003b((¶m_46));
warped = _e191;
let _e192 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e192);
let _e195 = scale[0u];
let _e197 = scale[0u];
let _e199 = (*moments_1);
param_47 = _e199.xy;
let _e202 = warped[0u];
param_48 = _e202;
param_49 = (_e195 * _e197);
let _e203 = (*bleed_1);
param_50 = _e203;
let _e204 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_47), (¶m_48), (¶m_49), (¶m_50));
positive = _e204;
let _e206 = scale[1u];
let _e208 = scale[1u];
let _e210 = (*moments_1);
param_51 = _e210.zw;
let _e213 = warped[1u];
param_52 = _e213;
param_53 = (_e206 * _e208);
let _e214 = (*bleed_1);
param_54 = _e214;
let _e215 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_51), (¶m_52), (¶m_53), (¶m_54));
negative = _e215;
let _e216 = positive;
let _e217 = negative;
return min(_e216, _e217);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_4: mat4x4<f32>;
var local_5: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_6: f32;
var local_7: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_55: vec4<f32>;
var param_56: f32;
var param_57: f32;
var y: i32;
var x: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var occluder_1: f32;
var param_58: i32;
var param_59: i32;
var param_60: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var occluder_2: f32;
var param_61: i32;
var param_62: i32;
var param_63: f32;
var phi_3242_: bool;
var phi_3253_: bool;
var phi_3409_: bool;
var phi_3416_: bool;
var phi_3423_: bool;
let _e235 = frag_info.shadow_params[3u];
strength_1 = _e235;
let _e236 = strength_1;
if (_e236 <= 0f) {
return 1f;
}
let _e238 = (*lightIndex_1);
let _e241 = frag_info.frame_params[2u];
if (_e238 != i32((_e241 + 0.5f))) {
return 1f;
}
let _e247 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e247 + 0.5f));
let _e250 = v_world_position_1;
let _e252 = frag_info.camera_position;
viewDistance = length((_e250 - _e252.xyz));
cascade = 0i;
let _e256 = cascadeCount;
let _e257 = (_e256 > 1i);
phi_3242_ = _e257;
if _e257 {
let _e258 = viewDistance;
let _e261 = frag_info.shadow_cascades[0u];
phi_3242_ = (_e258 > _e261);
}
let _e264 = phi_3242_;
if _e264 {
cascade = 1i;
}
let _e265 = cascadeCount;
let _e266 = (_e265 > 2i);
phi_3253_ = _e266;
if _e266 {
let _e267 = viewDistance;
let _e270 = frag_info.shadow_cascades[1u];
phi_3253_ = (_e267 > _e270);
}
let _e273 = phi_3253_;
if _e273 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e274 = attempt;
if (_e274 < 3i) {
let _e276 = cascade;
let _e277 = attempt;
which = (_e276 + _e277);
let _e279 = which;
let _e280 = cascadeCount;
if (_e279 >= _e280) {
break;
}
let _e282 = which;
if (_e282 == 0i) {
let _e285 = frag_info.shadow_matrix;
local_4 = _e285;
} else {
let _e286 = which;
if (_e286 == 1i) {
let _e289 = frag_info.shadow_matrix_far;
local_5 = _e289;
} else {
let _e291 = frag_info.shadow_matrix_farthest;
local_5 = _e291;
}
let _e292 = local_5;
local_4 = _e292;
}
let _e293 = local_4;
matrix = _e293;
let _e296 = matrix[0][0u];
let _e299 = matrix[1][0u];
let _e302 = matrix[2][0u];
axisX = vec3<f32>(_e296, _e299, _e302);
let _e306 = matrix[0][1u];
let _e309 = matrix[1][1u];
let _e312 = matrix[2][1u];
axisY = vec3<f32>(_e306, _e309, _e312);
let _e314 = axisX;
rowX = max(length(_e314), 0.000001f);
let _e317 = axisY;
rowY = max(length(_e317), 0.000001f);
let _e322 = frag_info.shadow_cascades[3u];
let _e324 = rowX;
texelMetres = ((2f * _e322) / _e324);
let _e328 = frag_info.shadow_cascades[3u];
let _e331 = (*s_1).n;
let _e332 = axisX;
let _e335 = rowX;
let _e336 = rowX;
let _e340 = (*s_1).n;
let _e341 = axisY;
let _e344 = rowY;
let _e345 = rowY;
reach = ((3f * _e328) * ((abs(dot(_e331, _e332)) / (_e335 * _e336)) + (abs(dot(_e340, _e341)) / (_e344 * _e345))));
let _e350 = v_world_position_1;
let _e352 = (*s_1).n;
let _e355 = frag_info.shadow_params[2u];
let _e356 = reach;
origin_1 = (_e350 + (_e352 * (_e355 + _e356)));
let _e360 = matrix;
let _e361 = origin_1;
lightSpace = (_e360 * vec4<f32>(_e361.x, _e361.y, _e361.z, 1f));
let _e368 = lightSpace[3u];
if (_e368 <= 0f) {
continue;
}
let _e370 = lightSpace;
let _e373 = lightSpace[3u];
candidate = (_e370.xyz / vec3(_e373));
let _e377 = candidate[0u];
let _e381 = candidate[1u];
inTile = vec2<f32>(((_e377 * 0.5f) + 0.5f), (0.5f - (_e381 * 0.5f)));
let _e386 = inTile[0u];
let _e387 = (_e386 < 0f);
phi_3409_ = _e387;
if !(_e387) {
let _e390 = inTile[0u];
phi_3409_ = (_e390 > 1f);
}
let _e393 = phi_3409_;
phi_3416_ = _e393;
if !(_e393) {
let _e396 = inTile[1u];
phi_3416_ = (_e396 < 0f);
}
let _e399 = phi_3416_;
phi_3423_ = _e399;
if !(_e399) {
let _e402 = inTile[1u];
phi_3423_ = (_e402 > 1f);
}
let _e405 = phi_3423_;
if _e405 {
continue;
}
let _e407 = candidate[2u];
if (_e407 > 1f) {
let _e409 = which;
let _e410 = cascadeCount;
if (_e409 < (_e410 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e415 = inTile[0u];
let _e416 = which;
let _e419 = cascadeCount;
let _e423 = inTile[1u];
uv_4 = vec2<f32>(((_e415 + f32(_e416)) / f32(_e419)), _e423);
let _e425 = candidate;
projected = _e425;
let _e426 = which;
cascade = _e426;
let _e427 = texelMetres;
cascadeTexel = _e427;
let _e430 = matrix[0][2u];
let _e433 = matrix[1][2u];
let _e436 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e430, _e433, _e436)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e441 = attempt;
attempt = (_e441 + 1i);
}
}
let _e443 = found;
if !(_e443) {
return 1f;
}
let _e445 = cascade;
if (_e445 == 0i) {
let _e449 = frag_info.shadow_bias[0u];
local_6 = _e449;
} else {
let _e450 = cascade;
if (_e450 == 1i) {
let _e454 = frag_info.shadow_bias[1u];
local_7 = _e454;
} else {
let _e457 = frag_info.shadow_bias[2u];
local_7 = _e457;
}
let _e458 = local_7;
local_6 = _e458;
}
let _e459 = local_6;
bias = _e459;
let _e462 = frag_info.shadow_params[0u];
let _e465 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e462, _e465);
let _e467 = cascade;
let _e469 = cascadeCount;
let _e473 = texel_1;
tileLo = (vec2<f32>((f32(_e467) / f32(_e469)), 0f) + (_e473 * 0.5f));
let _e476 = cascade;
let _e479 = cascadeCount;
let _e483 = texel_1;
tileHi = (vec2<f32>((f32((_e476 + 1i)) / f32(_e479)), 1f) - (_e483 * 0.5f));
let _e488 = frag_info.ambient_ground[3u];
softness = _e488;
lit_1 = 0f;
let _e489 = softness;
if (_e489 < 0f) {
let _e491 = uv_4;
let _e492 = tileLo;
let _e493 = tileHi;
let _e495 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e491, _e492, _e493), 0f);
moments_2 = _e495;
let _e497 = projected[2u];
let _e498 = bias;
let _e500 = softness;
let _e504 = moments_2;
param_55 = _e504;
param_56 = (_e497 - _e498);
param_57 = clamp((-(_e500) - 1f), 0f, 0.95f);
let _e505 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_55), (¶m_56), (¶m_57));
lit_1 = _e505;
} else {
let _e506 = softness;
if (_e506 <= 0f) {
y = -1i;
loop {
let _e508 = y;
if (_e508 <= 1i) {
x = -1i;
loop {
let _e510 = x;
if (_e510 <= 1i) {
let _e512 = uv_4;
let _e513 = x;
let _e515 = y;
let _e518 = texel_1;
let _e521 = tileLo;
let _e522 = tileHi;
let _e524 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e512 + (vec2<f32>(f32(_e513), f32(_e515)) * _e518)), _e521, _e522), 0f);
occluder = _e524.x;
let _e527 = projected[2u];
let _e528 = bias;
let _e530 = occluder;
let _e533 = lit_1;
lit_1 = (_e533 + select(1f, 0f, ((_e527 - _e528) > _e530)));
continue;
} else {
break;
}
continuing {
let _e535 = x;
x = (_e535 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e537 = y;
y = (_e537 + 1i);
}
}
let _e539 = lit_1;
lit_1 = (_e539 * 0.11111111f);
} else {
let _e541 = softness;
spread = tan(min(_e541, 0.5f));
let _e544 = ShadowNoise_u0028_();
turn_1 = (_e544 * 6.2831855f);
let _e546 = spread;
let _e548 = projected[2u];
let _e550 = cascadeDepth;
let _e552 = cascadeTexel;
searchRadius = clamp((((_e546 * _e548) * _e550) / _e552), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e555 = i_5;
if (_e555 < 16i) {
let _e557 = uv_4;
let _e558 = i_5;
param_58 = _e558;
param_59 = 16i;
let _e559 = turn_1;
param_60 = _e559;
let _e560 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60));
let _e561 = texel_1;
let _e563 = searchRadius;
let _e566 = tileLo;
let _e567 = tileHi;
let _e569 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e557 + ((_e560 * _e561) * _e563)), _e566, _e567), 0f);
occluder_1 = _e569.x;
let _e572 = projected[2u];
let _e573 = bias;
let _e575 = occluder_1;
if ((_e572 - _e573) > _e575) {
let _e577 = occluder_1;
let _e578 = blockerSum;
blockerSum = (_e578 + _e577);
let _e580 = blockerCount;
blockerCount = (_e580 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e582 = i_5;
i_5 = (_e582 + 1i);
}
}
let _e584 = blockerCount;
if (_e584 <= 0f) {
return 1f;
}
let _e587 = projected[2u];
let _e588 = blockerSum;
let _e589 = blockerCount;
let _e593 = cascadeDepth;
gap = (max((_e587 - (_e588 / _e589)), 0f) * _e593);
let _e595 = spread;
let _e596 = gap;
let _e598 = cascadeTexel;
radius_2 = clamp(((_e595 * _e596) / _e598), 1f, 16f);
i_6 = 0i;
loop {
let _e601 = i_6;
if (_e601 < 16i) {
let _e603 = uv_4;
let _e604 = turn_1;
let _e606 = i_6;
param_61 = _e606;
param_62 = 16i;
param_63 = (_e604 + 1f);
let _e607 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_61), (¶m_62), (¶m_63));
let _e608 = texel_1;
let _e610 = radius_2;
let _e613 = tileLo;
let _e614 = tileHi;
let _e616 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e603 + ((_e607 * _e608) * _e610)), _e613, _e614), 0f);
occluder_2 = _e616.x;
let _e619 = projected[2u];
let _e620 = bias;
let _e622 = occluder_2;
let _e625 = lit_1;
lit_1 = (_e625 + select(1f, 0f, ((_e619 - _e620) > _e622)));
continue;
} else {
break;
}
continuing {
let _e627 = i_6;
i_6 = (_e627 + 1i);
}
}
let _e629 = lit_1;
lit_1 = (_e629 * 0.0625f);
}
}
let _e631 = lit_1;
let _e632 = strength_1;
return mix(1f, _e631, clamp(_e632, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_64: Surface;
var param_65: LightSample;
var param_66: i32;
let _e180 = (*s_2);
param_64 = _e180;
let _e181 = (*light_2);
param_65 = _e181;
let _e182 = (*index);
param_66 = _e182;
let _e183 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_64), (¶m_65), (¶m_66));
return _e183;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e175 = (*index_1);
return (_e175 < 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 _e179 = (*distance_1);
let _e180 = (*distance_1);
attenuation = (1f / max((_e179 * _e180), 0.0001f));
let _e184 = (*range_4);
if (_e184 > 0f) {
let _e186 = (*distance_1);
let _e187 = (*range_4);
ratio = (_e186 / _e187);
let _e189 = ratio;
let _e190 = ratio;
let _e192 = ratio;
let _e194 = ratio;
window = clamp((1f - (((_e189 * _e190) * _e192) * _e194)), 0f, 1f);
let _e198 = window;
let _e199 = window;
let _e201 = attenuation;
attenuation = (_e201 * (_e198 * _e199));
}
let _e203 = attenuation;
return _e203;
}
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_2: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_8: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e191 = (*halfWidth);
let _e192 = (*halfHeight);
n_2 = cross(_e191, _e192);
let _e194 = n_2;
nLen = length(_e194);
let _e196 = nLen;
if (_e196 < 0.000000000001f) {
let _e198 = (*centre);
return _e198;
}
let _e199 = nLen;
let _e200 = n_2;
n_2 = (_e200 / vec3(_e199));
let _e203 = (*centre);
let _e204 = (*world_2);
toPlane = (_e203 - _e204);
let _e206 = (*mirror);
let _e207 = n_2;
denom = dot(_e206, _e207);
let _e209 = denom;
if (abs(_e209) < 0.00001f) {
let _e212 = toPlane;
let _e213 = n_2;
let _e214 = toPlane;
let _e215 = n_2;
onPlane = (_e212 - (_e213 * dot(_e214, _e215)));
} else {
let _e219 = toPlane;
let _e220 = n_2;
let _e222 = denom;
t_1 = (dot(_e219, _e220) / _e222);
let _e224 = t_1;
if (_e224 > 0f) {
let _e226 = (*mirror);
let _e227 = t_1;
local_8 = (_e226 * _e227);
} else {
let _e229 = toPlane;
let _e230 = n_2;
let _e231 = toPlane;
let _e232 = n_2;
local_8 = (_e229 - (_e230 * dot(_e231, _e232)));
}
let _e236 = local_8;
onPlane = _e236;
}
let _e237 = onPlane;
let _e238 = toPlane;
offset_2 = (_e237 - _e238);
let _e240 = (*halfWidth);
let _e241 = (*halfWidth);
wLen2_ = max(dot(_e240, _e241), 0.000000000001f);
let _e244 = (*halfHeight);
let _e245 = (*halfHeight);
hLen2_ = max(dot(_e244, _e245), 0.000000000001f);
let _e248 = offset_2;
let _e249 = (*halfWidth);
let _e251 = wLen2_;
u = clamp((dot(_e248, _e249) / _e251), -1f, 1f);
let _e254 = offset_2;
let _e255 = (*halfHeight);
let _e257 = hLen2_;
v = clamp((dot(_e254, _e255) / _e257), -1f, 1f);
let _e260 = (*centre);
let _e261 = (*halfWidth);
let _e262 = u;
let _e265 = (*halfHeight);
let _e266 = v;
return ((_e260 + (_e261 * _e262)) + (_e265 * _e266));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
var local_9: f32;
let _e183 = (*a_1);
let _e184 = (*a_1);
ua = (_e183 / vec3(max(length(_e184), 0.000000000001f)));
let _e189 = (*b);
let _e190 = (*b);
ub = (_e189 / vec3(max(length(_e190), 0.000000000001f)));
let _e195 = ua;
let _e196 = ub;
angle_1 = acos(clamp(dot(_e195, _e196), -1f, 1f));
let _e200 = ua;
let _e201 = ub;
axis = cross(_e200, _e201);
let _e203 = axis;
len = length(_e203);
let _e205 = len;
if (_e205 > 0.000001f) {
let _e207 = angle_1;
let _e208 = axis;
let _e209 = (*n_3);
let _e212 = len;
local_9 = ((_e207 * dot(_e208, _e209)) / _e212);
} else {
local_9 = 0f;
}
let _e214 = local_9;
return _e214;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_7: i32;
var a_2: vec3<f32>;
var b_1: vec3<f32>;
var local_10: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_11: f32;
var aAbove: bool;
var bAbove: bool;
var local_12: f32;
var param_67: vec3<f32>;
var param_68: vec3<f32>;
var param_69: vec3<f32>;
var param_70: vec3<f32>;
var param_71: vec3<f32>;
var param_72: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e197 = i_7;
if (_e197 < 4i) {
let _e199 = i_7;
let _e201 = (*corners)[_e199];
a_2 = _e201;
let _e202 = i_7;
if (_e202 == 3i) {
local_10 = 0i;
} else {
let _e204 = i_7;
local_10 = (_e204 + 1i);
}
let _e206 = local_10;
let _e208 = (*corners)[_e206];
b_1 = _e208;
let _e209 = a_2;
let _e210 = (*n_4);
ha = dot(_e209, _e210);
let _e212 = b_1;
let _e213 = (*n_4);
hb = dot(_e212, _e213);
let _e215 = ha;
let _e216 = hb;
d_3 = (_e215 - _e216);
let _e218 = a_2;
let _e219 = b_1;
let _e220 = a_2;
let _e222 = d_3;
if (abs(_e222) > 0.000000000001f) {
let _e225 = ha;
let _e226 = d_3;
local_11 = (_e225 / _e226);
} else {
local_11 = 0f;
}
let _e228 = local_11;
q = (_e218 + ((_e219 - _e220) * _e228));
let _e231 = ha;
aAbove = (_e231 > 0f);
let _e233 = hb;
bAbove = (_e233 > 0f);
let _e235 = aAbove;
let _e236 = bAbove;
if (_e235 || _e236) {
let _e238 = aAbove;
let _e239 = a_2;
let _e240 = q;
let _e243 = bAbove;
let _e244 = b_1;
let _e245 = q;
param_67 = select(_e240, _e239, vec3(_e238));
param_68 = select(_e245, _e244, vec3(_e243));
let _e248 = (*n_4);
param_69 = _e248;
let _e249 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_67), (¶m_68), (¶m_69));
local_12 = _e249;
} else {
local_12 = 0f;
}
let _e250 = local_12;
let _e251 = total;
total = (_e251 + _e250);
let _e253 = aAbove;
let _e254 = bAbove;
let _e257 = q;
let _e258 = exit;
exit = select(_e258, _e257, vec3((_e253 && !(_e254))));
let _e261 = aAbove;
let _e263 = bAbove;
let _e265 = q;
let _e266 = entry;
entry = select(_e266, _e265, vec3((!(_e261) && _e263)));
continue;
} else {
break;
}
continuing {
let _e269 = i_7;
i_7 = (_e269 + 1i);
}
}
let _e271 = exit;
param_70 = _e271;
let _e272 = entry;
param_71 = _e272;
let _e273 = (*n_4);
param_72 = _e273;
let _e274 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_70), (¶m_71), (¶m_72));
let _e275 = total;
total = (_e275 + _e274);
let _e277 = total;
return max((-(_e277) * 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_13: f32;
var local_14: f32;
var local_15: f32;
let _e180 = (*slot_1);
let _e181 = (*slot_1);
lane = (_e180 - ((_e181 / 4i) * 4i));
let _e185 = lane;
if (_e185 == 0i) {
let _e188 = (*four)[0u];
local_13 = _e188;
} else {
let _e189 = lane;
if (_e189 == 1i) {
let _e192 = (*four)[1u];
local_14 = _e192;
} else {
let _e193 = lane;
if (_e193 == 2i) {
let _e196 = (*four)[2u];
local_15 = _e196;
} else {
let _e198 = (*four)[3u];
local_15 = _e198;
}
let _e199 = local_15;
local_14 = _e199;
}
let _e200 = local_14;
local_13 = _e200;
}
let _e201 = local_13;
return _e201;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_73: vec4<f32>;
var param_74: i32;
let _e177 = (*slot_2);
let _e181 = light_list_info.scales[(_e177 / 4i)];
param_73 = _e181;
let _e182 = (*slot_2);
param_74 = _e182;
let _e183 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_73), (¶m_74));
return _e183;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e179 = light_list_info.slot_rows[0i];
let _e180 = (*row);
a_3 = abs((_e179 - vec4(_e180)));
let _e186 = light_list_info.slot_rows[1i];
let _e187 = (*row);
b_2 = abs((_e186 - vec4(_e187)));
let _e192 = a_3[0u];
let _e194 = a_3[1u];
let _e197 = a_3[2u];
let _e199 = a_3[3u];
let _e203 = b_2[0u];
let _e205 = b_2[1u];
let _e208 = b_2[2u];
let _e210 = b_2[3u];
return (min(min(min(_e192, _e194), min(_e197, _e199)), min(min(_e203, _e205), min(_e208, _e210))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_75: vec4<f32>;
var param_76: i32;
let _e177 = (*slot_3);
let _e181 = light_list_info.indices[(_e177 / 4i)];
param_75 = _e181;
let _e182 = (*slot_3);
param_76 = _e182;
let _e183 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_75), (¶m_76));
return _e183;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e176 = (*texel_2);
let _e180 = light_list_info.list[1u];
let _e182 = (*row_1);
let _e186 = light_list_info.list[2u];
let _e189 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e176 + 0.5f) * _e180), ((_e182 + 0.5f) * _e186)), 0f);
return _e189;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_77: f32;
var param_78: f32;
var param_79: vec4<f32>;
var param_80: i32;
let _e184 = g_cluster_offset;
let _e185 = (*slot_4);
entry_1 = (_e184 + f32(_e185));
let _e188 = entry_1;
row_2 = floor((_e188 / 16f));
let _e191 = entry_1;
let _e192 = row_2;
within = (_e191 - (_e192 * 16f));
let _e195 = within;
texel_3 = floor((_e195 / 4f));
let _e200 = light_list_info.cluster_depth[3u];
let _e201 = row_2;
let _e203 = texel_3;
param_77 = _e203;
param_78 = (_e200 + _e201);
let _e204 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_77), (¶m_78));
four_1 = _e204;
let _e205 = within;
let _e206 = texel_3;
let _e211 = four_1;
param_79 = _e211;
param_80 = i32(((_e205 - (_e206 * 4f)) + 0.5f));
let _e212 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_79), (¶m_80));
return _e212;
}
fn Clustered_u0028_() -> bool {
let _e176 = light_list_info.cluster_grid[3u];
return (_e176 > 0.5f);
}
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 light_3: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_16: f32;
var param_81: i32;
var param_82: i32;
var v_1: f32;
var u_1: f32;
var local_17: f32;
var param_83: f32;
var param_84: 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 behind: bool;
var formFactor: f32;
var local_18: f32;
var param_85: array<vec3<f32>, 4>;
var param_86: vec3<f32>;
var area: f32;
var radiance: f32;
var local_19: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
var param_89: vec3<f32>;
var param_90: vec3<f32>;
var param_91: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_20: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_92: f32;
var param_93: f32;
var cosAngle: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e227 = (*index_2);
if (_e227 < 8i) {
let _e229 = (*index_2);
let _e232 = frag_info.light_position[_e229];
position = _e232;
let _e233 = (*index_2);
let _e236 = frag_info.light_color[_e233];
color_1 = _e236;
let _e237 = (*index_2);
let _e240 = frag_info.light_direction[_e237];
direction = _e240;
let _e241 = (*index_2);
let _e244 = frag_info.light_cone[_e241];
cone = _e244;
} else {
let _e245 = (*index_2);
slot_5 = (_e245 - 8i);
let _e247 = Clustered_u0028_();
clustered = _e247;
let _e248 = clustered;
if _e248 {
let _e249 = slot_5;
param_81 = _e249;
let _e250 = ClusterRow_u0028_i1_u003b((¶m_81));
local_16 = _e250;
} else {
let _e251 = slot_5;
param_82 = _e251;
let _e252 = LightListRow_u0028_i1_u003b((¶m_82));
local_16 = _e252;
}
let _e253 = local_16;
listRow = _e253;
let _e254 = listRow;
let _e258 = light_list_info.list[2u];
v_1 = ((_e254 + 0.5f) * _e258);
let _e262 = light_list_info.list[1u];
u_1 = _e262;
let _e263 = u_1;
let _e265 = v_1;
let _e267 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e263), _e265), 0f);
position = _e267;
let _e268 = u_1;
let _e270 = v_1;
let _e272 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e268), _e270), 0f);
color_1 = _e272;
let _e273 = u_1;
let _e275 = v_1;
let _e277 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e273), _e275), 0f);
direction = _e277;
let _e278 = u_1;
let _e280 = v_1;
let _e282 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e278), _e280), 0f);
cone = _e282;
let _e283 = clustered;
if _e283 {
let _e284 = listRow;
param_83 = _e284;
let _e285 = InSlots_u0028_f1_u003b((¶m_83));
local_17 = select(1f, 0f, _e285);
} else {
let _e287 = slot_5;
param_84 = _e287;
let _e288 = LightListScale_u0028_i1_u003b((¶m_84));
local_17 = _e288;
}
let _e289 = local_17;
let _e291 = color_1[3u];
color_1[3u] = (_e291 * _e289);
}
let _e295 = position[3u];
type_39 = _e295;
let _e296 = type_39;
if (_e296 > 2.5f) {
let _e298 = direction;
halfWidth_1 = _e298.xyz;
let _e300 = cone;
halfHeight_1 = _e300.xyz;
let _e302 = position;
let _e304 = v_world_position_1;
toCentre = (_e302.xyz - _e304);
let _e306 = toCentre;
let _e307 = halfWidth_1;
let _e309 = halfHeight_1;
corners_1[0i] = ((_e306 - _e307) - _e309);
let _e312 = toCentre;
let _e313 = halfWidth_1;
let _e315 = halfHeight_1;
corners_1[1i] = ((_e312 + _e313) - _e315);
let _e318 = toCentre;
let _e319 = halfWidth_1;
let _e321 = halfHeight_1;
corners_1[2i] = ((_e318 + _e319) + _e321);
let _e324 = toCentre;
let _e325 = halfWidth_1;
let _e327 = halfHeight_1;
corners_1[3i] = ((_e324 - _e325) + _e327);
let _e330 = toCentre;
let _e331 = halfWidth_1;
let _e332 = halfHeight_1;
behind = (dot(_e330, cross(_e331, _e332)) >= 0f);
let _e336 = behind;
if _e336 {
local_18 = 0f;
} else {
let _e337 = corners_1;
param_85 = _e337;
let _e339 = (*s_3).n;
param_86 = _e339;
let _e340 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_85), (¶m_86));
local_18 = _e340;
}
let _e341 = local_18;
formFactor = _e341;
let _e342 = halfWidth_1;
let _e343 = halfHeight_1;
area = (length(cross(_e342, _e343)) * 4f);
let _e347 = area;
if (_e347 > 0.000000001f) {
let _e349 = area;
local_19 = (1f / _e349);
} else {
local_19 = 0f;
}
let _e351 = local_19;
radiance = _e351;
let _e352 = toCentre;
distance_2 = length(_e352);
let _e355 = direction[3u];
if (_e355 > 0f) {
let _e357 = distance_2;
let _e359 = direction[3u];
ratio_1 = (_e357 / _e359);
let _e361 = ratio_1;
let _e362 = ratio_1;
let _e364 = ratio_1;
let _e366 = ratio_1;
window_1 = clamp((1f - (((_e361 * _e362) * _e364) * _e366)), 0f, 1f);
let _e370 = window_1;
let _e371 = window_1;
let _e373 = radiance;
radiance = (_e373 * (_e370 * _e371));
}
let _e376 = (*s_3).v;
let _e379 = (*s_3).n;
mirror_1 = reflect(-(_e376), _e379);
let _e381 = position;
param_87 = _e381.xyz;
let _e383 = halfWidth_1;
param_88 = _e383;
let _e384 = halfHeight_1;
param_89 = _e384;
let _e385 = v_world_position_1;
param_90 = _e385;
let _e386 = mirror_1;
param_91 = _e386;
let _e387 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_87), (¶m_88), (¶m_89), (¶m_90), (¶m_91));
representative = _e387;
let _e388 = representative;
let _e389 = v_world_position_1;
toPoint = (_e388 - _e389);
let _e391 = toPoint;
pointDistance = length(_e391);
let _e393 = pointDistance;
if (_e393 > 0.000001f) {
let _e395 = toPoint;
let _e396 = pointDistance;
local_20 = (_e395 / vec3(_e396));
} else {
let _e400 = (*s_3).n;
local_20 = _e400;
}
let _e401 = local_20;
light_3.l = _e401;
let _e404 = light_3.l;
let _e406 = (*s_3).v;
light_3.h = normalize((_e404 + _e406));
let _e410 = formFactor;
light_3.n_dot_l = _e410;
let _e413 = (*s_3).n;
let _e415 = light_3.h;
light_3.n_dot_h = max(dot(_e413, _e415), 0f);
let _e420 = (*s_3).v;
let _e422 = light_3.h;
light_3.v_dot_h = max(dot(_e420, _e422), 0f);
let _e426 = color_1;
let _e429 = color_1[3u];
let _e431 = radiance;
light_3.radiance = ((_e426.xyz * _e429) * _e431);
let _e434 = light_3;
return _e434;
}
let _e435 = direction;
aim = normalize(_e435.xyz);
attenuation_1 = 1f;
let _e438 = type_39;
if (_e438 < 0.5f) {
let _e440 = aim;
light_3.l = -(_e440);
} else {
let _e443 = position;
let _e445 = v_world_position_1;
toLight_1 = (_e443.xyz - _e445);
let _e447 = toLight_1;
distance_3 = length(_e447);
let _e449 = distance_3;
if (_e449 < 0.000001f) {
let _e452 = (*s_3).n;
light_3.l = _e452;
let _e455 = (*s_3).n;
light_3.h = _e455;
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 _e461 = light_3;
return _e461;
}
let _e462 = toLight_1;
let _e463 = distance_3;
light_3.l = (_e462 / vec3(_e463));
let _e467 = distance_3;
param_92 = _e467;
let _e469 = direction[3u];
param_93 = _e469;
let _e470 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_92), (¶m_93));
attenuation_1 = _e470;
let _e471 = type_39;
if (_e471 > 1.5f) {
let _e473 = aim;
let _e475 = light_3.l;
cosAngle = dot(_e473, -(_e475));
let _e478 = cosAngle;
let _e480 = cone[1u];
let _e483 = cone[0u];
let _e485 = cone[1u];
let _e489 = attenuation_1;
attenuation_1 = (_e489 * clamp(((_e478 - _e480) / (_e483 - _e485)), 0f, 1f));
}
}
let _e492 = light_3.l;
let _e494 = (*s_3).v;
light_3.h = normalize((_e492 + _e494));
let _e499 = (*s_3).n;
let _e501 = light_3.l;
light_3.n_dot_l = max(dot(_e499, _e501), 0f);
let _e506 = (*s_3).n;
let _e508 = light_3.h;
light_3.n_dot_h = max(dot(_e506, _e508), 0f);
let _e513 = (*s_3).v;
let _e515 = light_3.h;
light_3.v_dot_h = max(dot(_e513, _e515), 0f);
let _e519 = color_1;
let _e522 = color_1[3u];
let _e524 = attenuation_1;
light_3.radiance = ((_e519.xyz * _e522) * _e524);
let _e527 = light_3;
return _e527;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_21: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_94: f32;
var param_95: f32;
let _e189 = light_list_info.cluster_view_projection;
let _e190 = (*world_3);
clip_1 = (_e189 * vec4<f32>(_e190.x, _e190.y, _e190.z, 1f));
let _e196 = clip_1;
let _e199 = clip_1[3u];
ndc_1 = (_e196.xy / vec2(max(_e199, 0.000001f)));
let _e204 = light_list_info.cluster_grid;
grid = _e204.xyz;
let _e208 = light_list_info.cluster_depth[0u];
near_1 = _e208;
let _e210 = ndc_1[0u];
let _e214 = grid[0u];
let _e218 = grid[0u];
tx = clamp(floor((((_e210 * 0.5f) + 0.5f) * _e214)), 0f, (_e218 - 1f));
let _e222 = ndc_1[1u];
let _e226 = grid[1u];
let _e230 = grid[1u];
ty = clamp(floor((((_e222 * 0.5f) + 0.5f) * _e226)), 0f, (_e230 - 1f));
let _e234 = clip_1[3u];
let _e235 = near_1;
if (_e234 <= _e235) {
local_21 = 0f;
} else {
let _e238 = clip_1[3u];
let _e239 = near_1;
let _e244 = light_list_info.cluster_depth[1u];
let _e248 = grid[2u];
local_21 = clamp(floor((log((_e238 / _e239)) * _e244)), 0f, (_e248 - 1f));
}
let _e251 = local_21;
tz = _e251;
let _e252 = tx;
let _e253 = ty;
let _e255 = grid[0u];
let _e258 = tz;
let _e260 = grid[0u];
let _e263 = grid[1u];
cell = ((_e252 + (_e253 * _e255)) + ((_e258 * _e260) * _e263));
let _e266 = cell;
row_3 = floor((_e266 / 4f));
let _e269 = cell;
let _e270 = row_3;
let _e275 = light_list_info.cluster_depth[2u];
let _e276 = row_3;
param_94 = (_e269 - (_e270 * 4f));
param_95 = (_e275 + _e276);
let _e278 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
header = _e278;
let _e280 = header[0u];
g_cluster_offset = _e280;
let _e282 = header[1u];
g_cluster_count = _e282;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_96: vec3<f32>;
let _e178 = light_list_info.list[0u];
tail = _e178;
let _e179 = Clustered_u0028_();
if _e179 {
let _e180 = v_world_position_1;
param_96 = _e180;
FindCluster_u0028_vf3_u003b((¶m_96));
let _e181 = g_cluster_count;
tail = _e181;
}
let _e184 = frag_info.frame_params[1u];
let _e188 = tail;
return (clamp(i32((_e184 + 0.5f)), 0i, 8i) + clamp(i32((_e188 + 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_8: i32;
var light_4: LightSample;
var param_97: i32;
var param_98: Surface;
var visibility: f32;
var param_99: i32;
var local_22: f32;
var param_100: Surface;
var param_101: LightSample;
var param_102: i32;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: i32;
var param_106: Surface;
var param_107: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e192 = LightCount_u0028_();
count_1 = _e192;
i_8 = 0i;
loop {
let _e193 = i_8;
if (_e193 < 32i) {
let _e195 = i_8;
let _e196 = count_1;
if (_e195 >= _e196) {
break;
}
let _e198 = i_8;
param_97 = _e198;
let _e199 = (*s_4);
param_98 = _e199;
let _e200 = 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_97), (¶m_98));
light_4 = _e200;
let _e202 = light_4.n_dot_l;
if (_e202 <= 0f) {
continue;
}
let _e204 = i_8;
param_99 = _e204;
let _e205 = LightHasShadow_u0028_i1_u003b((¶m_99));
if _e205 {
let _e206 = (*s_4);
param_100 = _e206;
let _e207 = light_4;
param_101 = _e207;
let _e208 = i_8;
param_102 = _e208;
let _e209 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_100), (¶m_101), (¶m_102));
let _e210 = v_world_position_1;
param_103 = _e210;
let _e212 = (*s_4).n;
param_104 = _e212;
let _e213 = i_8;
param_105 = _e213;
let _e214 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_103), (¶m_104), (¶m_105));
local_22 = (_e209 * _e214);
} else {
local_22 = 1f;
}
let _e216 = local_22;
visibility = _e216;
let _e217 = visibility;
if (_e217 <= 0f) {
continue;
}
let _e219 = (*s_4);
param_106 = _e219;
let _e220 = light_4;
param_107 = _e220;
let _e221 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_106), (¶m_107));
let _e223 = light_4.radiance;
let _e226 = light_4.n_dot_l;
let _e228 = visibility;
let _e230 = total_1;
total_1 = (_e230 + (((_e221 * _e223) * _e226) * _e228));
continue;
} else {
break;
}
continuing {
let _e232 = i_8;
i_8 = (_e232 + 1i);
}
}
let _e234 = total_1;
return _e234;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e175 = v_lightmap_uv_1;
let _e176 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e175);
texel_4 = _e176;
let _e177 = texel_4;
let _e180 = texel_4[3u];
return ((_e177.xyz * _e180) * 8f);
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e175 = (*srgb);
let _e178 = (*srgb);
let _e183 = (*srgb);
return mix((_e175 / vec3(12.92f)), pow(((_e178 + 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), _e183));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e176 = frag_info.target_origin[1u];
return _e176;
}
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_108: vec3<f32>;
let _e177 = v_texcoord_1;
let _e178 = MaterialLodBias_u0028_();
let _e179 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e177, _e178);
param_108 = _e179.xyz;
let _e181 = SrgbToLinear_u0028_vf3_u003b((¶m_108));
emissive = _e181;
let _e182 = emissive;
let _e184 = frag_info.emissive;
let _e189 = frag_info.material2_[3u];
(*s_5).emissive = ((_e182 * _e184.xyz) * _e189);
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 _e176 = v_texcoord_1;
let _e177 = MaterialLodBias_u0028_();
let _e178 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e176, _e177);
occlusion = _e178.x;
let _e180 = occlusion;
let _e183 = frag_info.material2_[2u];
(*s_6).occlusion = mix(1f, _e180, clamp(_e183, 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_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e179 = v_texcoord_1;
let _e180 = MaterialLodBias_u0028_();
let _e181 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e179, _e180);
sampledTexel = _e181;
let _e182 = v_tangent_1;
t_2 = _e182.xyz;
let _e184 = t_2;
let _e186 = (*s_7).n;
let _e188 = (*s_7).n;
let _e189 = t_2;
t_2 = (_e184 - (_e186 * dot(_e188, _e189)));
let _e193 = t_2;
let _e194 = t_2;
if (dot(_e193, _e194) < 0.000000000001f) {
return;
}
let _e197 = t_2;
t_2 = normalize(_e197);
let _e200 = (*s_7).n;
let _e201 = t_2;
let _e204 = v_tangent_1[3u];
b_3 = (cross(_e200, _e201) * _e204);
let _e206 = gl_FrontFacing_1;
if !(_e206) {
let _e208 = t_2;
t_2 = -(_e208);
}
let _e210 = sampledTexel;
sampled = ((_e210.xyz * 2f) - vec3(1f));
let _e217 = frag_info.emissive[3u];
if (_e217 > 0.5f) {
let _e219 = sampled;
let _e221 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e219.xy, _e221.xy)), 0f));
}
let _e230 = frag_info.material2_[1u];
let _e231 = sampled;
let _e233 = (_e231.xy * _e230);
sampled[0u] = _e233.x;
sampled[1u] = _e233.y;
let _e238 = t_2;
let _e240 = sampled[0u];
let _e242 = b_3;
let _e244 = sampled[1u];
let _e248 = (*s_7).n;
let _e250 = sampled[2u];
(*s_7).n = normalize((((_e238 * _e240) + (_e242 * _e244)) + (_e248 * _e250)));
let _e256 = (*s_7).n;
let _e258 = (*s_7).v;
(*s_7).n_dot_v = max(dot(_e256, _e258), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e175 = (*texel_5);
let _e179 = irradiance_info.atlas;
let _e182 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e175 + vec2(0.5f)) * _e179.xy), 0f);
return _e182;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
var at_1: vec2<f32>;
var low: vec2<f32>;
var f: vec2<f32>;
var a_4: vec4<f32>;
var param_109: vec2<f32>;
var b_4: vec4<f32>;
var param_110: vec2<f32>;
var c: vec4<f32>;
var param_111: vec2<f32>;
var d_4: vec4<f32>;
var param_112: vec2<f32>;
let _e188 = (*uv_5);
let _e189 = (*interior);
at_1 = ((vec2(1f) + (_e188 * _e189)) - vec2(0.5f));
let _e195 = at_1;
low = floor(_e195);
let _e197 = at_1;
let _e198 = low;
f = (_e197 - _e198);
let _e200 = (*corner);
let _e201 = low;
param_109 = (_e200 + _e201);
let _e203 = AtlasTexel_u0028_vf2_u003b((¶m_109));
a_4 = _e203;
let _e204 = (*corner);
let _e205 = low;
param_110 = ((_e204 + _e205) + vec2<f32>(1f, 0f));
let _e208 = AtlasTexel_u0028_vf2_u003b((¶m_110));
b_4 = _e208;
let _e209 = (*corner);
let _e210 = low;
param_111 = ((_e209 + _e210) + vec2<f32>(0f, 1f));
let _e213 = AtlasTexel_u0028_vf2_u003b((¶m_111));
c = _e213;
let _e214 = (*corner);
let _e215 = low;
param_112 = ((_e214 + _e215) + vec2<f32>(1f, 1f));
let _e218 = AtlasTexel_u0028_vf2_u003b((¶m_112));
d_4 = _e218;
let _e219 = a_4;
let _e220 = b_4;
let _e222 = f[0u];
let _e225 = c;
let _e226 = d_4;
let _e228 = f[0u];
let _e232 = f[1u];
return mix(mix(_e219, _e220, vec4(_e222)), mix(_e225, _e226, vec4(_e228)), vec4(_e232));
}
fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var sum_1: f32;
var n_5: vec3<f32>;
var xy: vec2<f32>;
let _e179 = (*direction_1)[0u];
let _e182 = (*direction_1)[1u];
let _e186 = (*direction_1)[2u];
sum_1 = ((abs(_e179) + abs(_e182)) + abs(_e186));
let _e189 = sum_1;
if (_e189 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e191 = (*direction_1);
let _e192 = sum_1;
n_5 = (_e191 / vec3(_e192));
let _e195 = n_5;
xy = _e195.xy;
let _e198 = n_5[2u];
if (_e198 < 0f) {
let _e201 = n_5[1u];
let _e205 = n_5[0u];
let _e210 = n_5[0u];
let _e214 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e201)) * select(-1f, 1f, (_e205 >= 0f))), ((1f - abs(_e210)) * select(-1f, 1f, (_e214 >= 0f))));
}
let _e219 = xy;
return ((_e219 * 0.5f) + vec2(0.5f));
}
fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var spacing: vec3<f32>;
var counts: vec3<f32>;
var irradianceTile: f32;
var depthTile: f32;
var columns: f32;
var momentsTop: f32;
var unit: vec3<f32>;
var biased: vec3<f32>;
var grid_1: vec3<f32>;
var base: vec3<f32>;
var f_1: vec3<f32>;
var total_2: vec3<f32>;
var weights: f32;
var corner_1: i32;
var offset_3: vec3<f32>;
var cell_1: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_113: vec2<f32>;
var trilinear: vec3<f32>;
var weight_2: f32;
var probePosition: vec3<f32>;
var toProbe: vec3<f32>;
var distance_4: f32;
var direction_2: vec3<f32>;
var facing: f32;
var probeWeight: f32;
var moments_3: vec2<f32>;
var param_114: vec3<f32>;
var param_115: vec2<f32>;
var param_116: f32;
var param_117: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_118: vec3<f32>;
var param_119: vec2<f32>;
var param_120: f32;
var param_121: vec2<f32>;
var local_23: vec3<f32>;
let _e221 = irradiance_info.origin;
origin_2 = _e221.xyz;
let _e224 = irradiance_info.spacing;
spacing = _e224.xyz;
let _e227 = irradiance_info.counts;
counts = _e227.xyz;
let _e231 = irradiance_info.tiles[0u];
irradianceTile = _e231;
let _e234 = irradiance_info.tiles[1u];
depthTile = _e234;
let _e237 = irradiance_info.tiles[2u];
columns = _e237;
let _e240 = irradiance_info.tiles[3u];
momentsTop = _e240;
let _e241 = (*normal_1);
unit = normalize(_e241);
let _e243 = (*world_4);
let _e244 = unit;
let _e247 = irradiance_info.spacing[3u];
let _e250 = (*view);
let _e253 = irradiance_info.counts[3u];
biased = ((_e243 + (_e244 * _e247)) + (_e250 * _e253));
let _e256 = biased;
let _e257 = origin_2;
let _e259 = spacing;
grid_1 = ((_e256 - _e257) / _e259);
let _e261 = grid_1;
let _e263 = counts;
base = clamp(floor(_e261), vec3<f32>(0f, 0f, 0f), (_e263 - vec3(2f)));
let _e267 = grid_1;
let _e268 = base;
f_1 = clamp((_e267 - _e268), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e271 = corner_1;
if (_e271 < 8i) {
let _e273 = corner_1;
let _e276 = corner_1;
let _e281 = corner_1;
offset_3 = vec3<f32>(f32((_e273 & 1i)), f32(((_e276 >> bitcast<u32>(1i)) & 1i)), f32(((_e281 >> bitcast<u32>(2i)) & 1i)));
let _e287 = base;
let _e288 = offset_3;
cell_1 = (_e287 + _e288);
let _e291 = cell_1[2u];
let _e293 = counts[1u];
let _e296 = cell_1[1u];
let _e299 = counts[0u];
let _e302 = cell_1[0u];
probe = ((((_e291 * _e293) + _e296) * _e299) + _e302);
let _e304 = probe;
let _e305 = columns;
let _e310 = probe;
let _e311 = columns;
tile_4 = vec2<f32>((_e304 - (floor((_e304 / _e305)) * _e305)), floor((_e310 / _e311)));
let _e315 = tile_4;
let _e316 = irradianceTile;
irradianceCorner = (_e315 * (_e316 + 2f));
let _e320 = tile_4[0u];
let _e321 = depthTile;
let _e324 = momentsTop;
let _e326 = tile_4[1u];
let _e327 = depthTile;
momentCorner = vec2<f32>((_e320 * (_e321 + 2f)), (_e324 + (_e326 * (_e327 + 2f))));
let _e332 = irradianceCorner;
param_113 = (_e332 + vec2(1f));
let _e335 = AtlasTexel_u0028_vf2_u003b((¶m_113));
if (_e335.w < 0.5f) {
continue;
}
let _e338 = f_1;
let _e340 = f_1;
let _e341 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e338), _e340, _e341);
let _e344 = trilinear[0u];
let _e346 = trilinear[1u];
let _e349 = trilinear[2u];
weight_2 = max(((_e344 * _e346) * _e349), 0.001f);
let _e352 = origin_2;
let _e353 = spacing;
let _e354 = cell_1;
probePosition = (_e352 + (_e353 * _e354));
let _e357 = probePosition;
let _e358 = biased;
toProbe = (_e357 - _e358);
let _e360 = toProbe;
distance_4 = length(_e360);
let _e362 = distance_4;
if (_e362 > 0.000001f) {
let _e364 = toProbe;
let _e365 = distance_4;
direction_2 = (_e364 / vec3(_e365));
let _e368 = unit;
let _e369 = probePosition;
let _e370 = (*world_4);
facing = ((dot(_e368, normalize((_e369 - _e370))) * 0.5f) + 0.5f);
let _e376 = facing;
let _e377 = facing;
probeWeight = ((_e376 * _e377) + 0.2f);
let _e380 = direction_2;
param_114 = -(_e380);
let _e382 = ProbeOctahedral_u0028_vf3_u003b((¶m_114));
let _e383 = momentCorner;
param_115 = _e383;
let _e384 = depthTile;
param_116 = _e384;
param_117 = _e382;
let _e385 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_115), (¶m_116), (¶m_117));
moments_3 = _e385.xy;
chebyshev = 1f;
let _e387 = distance_4;
let _e389 = moments_3[0u];
if (_e387 > _e389) {
let _e392 = moments_3[1u];
let _e394 = moments_3[0u];
let _e396 = moments_3[0u];
variance_1 = max((_e392 - (_e394 * _e396)), 0.000001f);
let _e400 = distance_4;
let _e402 = moments_3[0u];
difference = (_e400 - _e402);
let _e404 = variance_1;
let _e405 = variance_1;
let _e406 = difference;
let _e407 = difference;
chebyshev = (_e404 / (_e405 + (_e406 * _e407)));
let _e411 = chebyshev;
let _e412 = chebyshev;
let _e414 = chebyshev;
chebyshev = ((_e411 * _e412) * _e414);
}
let _e416 = probeWeight;
let _e417 = chebyshev;
probeWeight = max((_e416 * max(_e417, 0.05f)), 0.000001f);
let _e421 = probeWeight;
if (_e421 < 0.2f) {
let _e423 = probeWeight;
let _e424 = probeWeight;
let _e427 = probeWeight;
probeWeight = (_e427 * ((_e423 * _e424) * 25f));
}
let _e429 = probeWeight;
let _e430 = weight_2;
weight_2 = (_e430 * _e429);
}
let _e432 = unit;
param_118 = _e432;
let _e433 = ProbeOctahedral_u0028_vf3_u003b((¶m_118));
let _e434 = irradianceCorner;
param_119 = _e434;
let _e435 = irradianceTile;
param_120 = _e435;
param_121 = _e433;
let _e436 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_119), (¶m_120), (¶m_121));
let _e438 = weight_2;
let _e440 = total_2;
total_2 = (_e440 + (_e436.xyz * _e438));
let _e442 = weight_2;
let _e443 = weights;
weights = (_e443 + _e442);
continue;
} else {
break;
}
continuing {
let _e445 = corner_1;
corner_1 = (_e445 + 1i);
}
}
let _e447 = weights;
if (_e447 > 0f) {
let _e449 = total_2;
let _e450 = weights;
local_23 = (_e449 / vec3(_e450));
} else {
local_23 = vec3<f32>(0f, 0f, 0f);
}
let _e453 = local_23;
return _e453;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e176 = irradiance_info.origin[3u];
return (_e176 > 0.5f);
}
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_122: vec3<f32>;
var param_123: vec3<f32>;
var param_124: vec3<f32>;
var param_125: Surface;
var param_126: Surface;
var param_127: Surface;
let _e181 = IrradianceEnabled_u0028_();
if _e181 {
let _e182 = v_world_position_1;
param_122 = _e182;
let _e184 = (*s_8).n;
param_123 = _e184;
let _e186 = (*s_8).v;
param_124 = _e186;
let _e187 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_122), (¶m_123), (¶m_124));
let _e190 = frag_info.material[2u];
(*s_8).ambient = (_e187 * _e190);
}
let _e193 = (*s_8);
param_125 = _e193;
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_125));
let _e194 = param_125;
(*s_8) = _e194;
let _e195 = (*s_8);
param_126 = _e195;
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_126));
let _e196 = param_126;
(*s_8) = _e196;
let _e197 = (*s_8);
param_127 = _e197;
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_127));
let _e198 = param_127;
(*s_8) = _e198;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_9: Surface;
var param_128: vec3<f32>;
var param_129: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e181 = v_texcoord_1;
let _e182 = MaterialLodBias_u0028_();
let _e183 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e181, _e182);
texel_6 = _e183;
let _e184 = texel_6;
param_128 = _e184.xyz;
let _e186 = SrgbToLinear_u0028_vf3_u003b((¶m_128));
let _e188 = frag_info.base_color;
param_129 = _e188.xyz;
let _e190 = SrgbToLinear_u0028_vf3_u003b((¶m_129));
let _e192 = v_color_1;
s_9.albedo = ((_e186 * _e190) * _e192.xyz);
let _e197 = texel_6[3u];
let _e200 = frag_info.base_color[3u];
let _e203 = v_color_1[3u];
s_9.alpha = ((_e197 * _e200) * _e203);
let _e207 = s_9.albedo;
g_albedo = _e207;
let _e210 = frag_info.material2_[0u];
cutoff = _e210;
let _e211 = cutoff;
if (_e211 >= 0f) {
let _e214 = s_9.alpha;
let _e215 = cutoff;
if (_e214 < _e215) {
discard;
}
} else {
let _e217 = cutoff;
if (_e217 < -1.5f) {
let _e219 = v_world_position_1;
anchored = floor((_e219 * 16f));
let _e222 = anchored;
noise_1 = fract((sin(dot(_e222, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e228 = s_9.alpha;
let _e229 = noise_1;
if (_e228 < _e229) {
discard;
}
}
}
let _e231 = cutoff;
let _e233 = cutoff;
g_premultiply = ((_e231 < 0f) && (_e233 > -0.75f));
let _e236 = v_normal_1;
s_9.n = normalize(_e236);
let _e239 = gl_FrontFacing_1;
if !(_e239) {
let _e242 = s_9.n;
s_9.n = -(_e242);
}
let _e246 = frag_info.camera_position;
let _e248 = v_world_position_1;
s_9.v = normalize((_e246.xyz - _e248));
let _e253 = s_9.n;
let _e255 = s_9.v;
s_9.n_dot_v = max(dot(_e253, _e255), 0.0001f);
let _e261 = frag_info.material[0u];
s_9.metallic = clamp(_e261, 0f, 1f);
let _e266 = frag_info.material[1u];
s_9.roughness = clamp(_e266, 0.02f, 1f);
let _e270 = frag_info.ambient_ground;
let _e273 = frag_info.ambient_sky;
let _e277 = s_9.n[1u];
let _e284 = frag_info.material[2u];
s_9.ambient = (mix(_e270.xyz, _e273.xyz, vec3(((_e277 * 0.5f) + 0.5f))) * _e284);
let _e289 = frag_info.frame_params[0u];
s_9.exposure = max(_e289, 0f);
s_9.occlusion = 1f;
s_9.emissive = vec3<f32>(0f, 0f, 0f);
let _e294 = s_9;
return _e294;
}
fn main_1() {
var s_10: Surface;
var param_130: Surface;
var ambient: vec3<f32>;
var param_131: Surface;
var param_132: vec3<f32>;
var param_133: f32;
var param_134: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e181 = ReadSurface_u0028_();
s_10 = _e181;
let _e182 = s_10;
param_130 = _e182;
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_130));
let _e183 = param_130;
s_10 = _e183;
let _e185 = s_10.albedo;
let _e187 = s_10.ambient;
let _e188 = SampleLightmap_u0028_();
let _e192 = s_10.occlusion;
ambient = ((_e185 * (_e187 + _e188)) * _e192);
let _e194 = s_10;
param_131 = _e194;
let _e195 = 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_131));
let _e197 = s_10.occlusion;
let _e199 = ambient;
let _e202 = s_10.emissive;
param_132 = (((_e195 * _e197) + _e199) + _e202);
let _e205 = s_10.alpha;
param_133 = _e205;
let _e207 = s_10.roughness;
param_134 = _e207;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_132), (¶m_133), (¶m_134));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: 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;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'IrradianceInfo',
group: 1,
binding: 2,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'spacing',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'counts',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 3,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 4,
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: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'irradiance_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 23,
samplerBinding: 24,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 25,
samplerBinding: 26,
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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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 IrradianceInfo {
origin: vec4<f32>,
spacing: vec4<f32>,
counts: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e175 = v_world_position_1;
let _e177 = fog_info.eye;
let _e181 = fog_info.forward;
return dot((_e175 - _e177.xyz), _e181.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e180 = ViewDepth_u0028_();
z = abs(_e180);
let _e182 = z;
near = (_e182 / 5f);
let _e184 = z;
far = (_e184 / 200f);
let _e186 = far;
let _e187 = far;
let _e189 = far;
far3_ = ((_e186 * _e187) * _e189);
let _e191 = (*alpha);
let _e192 = near;
let _e193 = near;
let _e196 = far3_;
let _e197 = far3_;
return (_e191 * clamp((10f / ((0.00001f + (_e192 * _e193)) + (_e196 * _e197))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e184 = fog_info.forward[3u];
mode = _e184;
let _e185 = mode;
if (_e185 > 0.5f) {
let _e188 = frag_color[3u];
alpha_1 = _e188;
let _e189 = alpha_1;
param = _e189;
let _e190 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e190;
let _e191 = frag_color;
let _e193 = weight;
let _e194 = (_e191.xyz * _e193);
let _e195 = alpha_1;
let _e196 = weight;
accumulate = vec4<f32>(_e194.x, _e194.y, _e194.z, (_e195 * _e196));
let _e202 = mode;
let _e204 = mode;
revealage = ((_e202 > 1.5f) && (_e204 < 2.5f));
let _e207 = revealage;
if _e207 {
let _e208 = alpha_1;
local = vec4(_e208);
} else {
let _e210 = accumulate;
local = _e210;
}
let _e211 = local;
frag_color = _e211;
let _e212 = mode;
if (_e212 > 2.5f) {
let _e214 = alpha_1;
frag_surface = vec4(_e214);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e178 = (*n)[0u];
let _e181 = (*n)[1u];
let _e185 = (*n)[2u];
let _e188 = (*n);
(*n) = (_e188 / vec3(((abs(_e178) + abs(_e181)) + abs(_e185))));
let _e191 = (*n);
e = _e191.xy;
let _e194 = (*n)[2u];
if (_e194 < 0f) {
let _e196 = (*n);
let _e202 = (*n)[0u];
let _e206 = (*n)[1u];
e = ((vec2(1f) - abs(_e196.yx)) * vec2<f32>(select(-1f, 1f, (_e202 >= 0f)), select(-1f, 1f, (_e206 >= 0f))));
}
let _e211 = e;
return ((_e211 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e176 = (*linear);
let _e178 = (*linear);
let _e182 = (*linear);
return mix((_e176 * 12.92f), ((pow(_e178, 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), _e182));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e179 = g_albedo;
param_1 = clamp(_e179, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e181 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e181.x, _e181.y, _e181.z, 1f);
let _e186 = g_debug_surface_on;
if _e186 {
let _e187 = g_debug_surface;
let _e188 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e187.x, _e187.y, _e187.z, _e188);
return;
}
let _e193 = v_normal_1;
geometric = normalize(_e193);
let _e195 = gl_FrontFacing_1;
if !(_e195) {
let _e197 = geometric;
geometric = -(_e197);
}
let _e199 = geometric;
param_2 = _e199;
let _e200 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e201 = (*roughness);
let _e203 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e200.x, _e200.y, clamp(_e201, 0f, 1f), _e203);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e175 = v_world_position_1;
let _e177 = fog_info.eye;
return distance(_e175, _e177.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e180 = fog_info.fog[3u];
density = _e180;
let _e181 = density;
if (_e181 <= 0f) {
let _e183 = (*color);
return _e183;
}
let _e184 = EyeDistance_u0028_();
d = _e184;
let _e186 = fog_info.fog;
let _e188 = (*color);
let _e189 = density;
let _e191 = d;
return mix(_e186.xyz, _e188, vec3(clamp(exp((-(_e189) * _e191)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e181 = g_premultiply;
let _e182 = (*alpha_2);
weight_1 = select(1f, _e182, _e181);
let _e184 = (*linearColor);
param_3 = _e184;
let _e185 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e186 = weight_1;
let _e187 = (_e185 * _e186);
let _e188 = (*alpha_2);
frag_color = vec4<f32>(_e187.x, _e187.y, _e187.z, _e188);
let _e193 = (*roughness_1);
param_4 = _e193;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
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_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var shininess: f32;
var specular: f32;
let _e180 = (*s).roughness;
shininess = mix(256f, 4f, _e180);
let _e183 = (*light).n_dot_h;
let _e184 = shininess;
let _e188 = frag_info.material[3u];
specular = (pow(_e183, _e184) * _e188);
let _e191 = (*s).albedo;
let _e192 = specular;
return (_e191 + vec3(_e192));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e176 = (*i);
if (_e176 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e178 = (*i);
if (_e178 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e180 = (*i);
if (_e180 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e182 = (*i);
if (_e182 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e184 = (*i);
if (_e184 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e186 = (*i);
if (_e186 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e188 = (*i);
if (_e188 == 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_5: i32;
let _e181 = (*i_1);
param_5 = _e181;
let _e182 = PointShadowDiskTap_u0028_i1_u003b((¶m_5));
p = _e182;
let _e184 = p[0u];
let _e185 = (*ca);
let _e188 = p[1u];
let _e189 = (*sa);
let _e193 = p[0u];
let _e194 = (*sa);
let _e197 = p[1u];
let _e198 = (*ca);
let _e202 = (*radius);
return (vec2<f32>(((_e184 * _e185) - (_e188 * _e189)), ((_e193 * _e194) + (_e197 * _e198))) * _e202);
}
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_1: vec2<f32>;
var atlas: vec2<f32>;
let _e184 = point_shadow.params[0u];
inset = _e184;
let _e185 = (*uv);
let _e186 = (*offset);
let _e188 = inset;
let _e189 = inset;
local_1 = clamp((_e185 + _e186), vec2(_e188), vec2((1f - _e189)));
let _e194 = local_1;
let _e195 = (*tile);
atlas = ((_e194 + _e195) * vec2<f32>(0.16666667f, 0.16666667f));
let _e200 = point_shadow.params3_[0u];
if (_e200 > 0.5f) {
let _e203 = atlas[1u];
atlas[1u] = (1f - _e203);
}
let _e206 = atlas;
let _e207 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e206, 0f);
let _e209 = atlas;
let _e210 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e209, 0f);
let _e213 = (*range);
return (min(_e207.x, _e210.x) * _e213);
}
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_6: vec2<f32>;
var param_7: vec2<f32>;
var param_8: vec2<f32>;
var param_9: f32;
let _e185 = (*uv_1);
param_6 = _e185;
let _e186 = (*offset_1);
param_7 = _e186;
let _e187 = (*tile_1);
param_8 = _e187;
let _e188 = (*range_1);
param_9 = _e188;
let _e189 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9));
stored = _e189;
let _e190 = stored;
let _e191 = (*range_1);
if (_e190 >= (_e191 * 0.999f)) {
return 1f;
}
let _e194 = (*receiver);
let _e195 = stored;
return select(1f, 0f, (_e194 > _e195));
}
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_10: vec2<f32>;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_14: i32;
var param_15: f32;
var param_16: f32;
var param_17: f32;
var param_18: vec2<f32>;
var param_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e206 = point_shadow.params2_[1u];
lightRadius = _e206;
let _e209 = point_shadow.params2_[0u];
minRadius = _e209;
let _e212 = point_shadow.params2_[2u];
maxRadius = _e212;
let _e213 = lightRadius;
if (_e213 <= 0f) {
let _e215 = (*uv_2);
param_10 = _e215;
param_11 = vec2<f32>(0f, 0f);
let _e216 = (*tile_2);
param_12 = _e216;
let _e217 = (*range_2);
param_13 = _e217;
let _e218 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13));
(*blockerOut) = _e218;
let _e219 = minRadius;
return _e219;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e220 = i_2;
if (_e220 < 8i) {
let _e222 = i_2;
param_14 = _e222;
let _e223 = (*ca_1);
param_15 = _e223;
let _e224 = (*sa_1);
param_16 = _e224;
let _e225 = maxRadius;
param_17 = _e225;
let _e226 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_14), (¶m_15), (¶m_16), (¶m_17));
let _e227 = (*uv_2);
param_18 = _e227;
param_19 = _e226;
let _e228 = (*tile_2);
param_20 = _e228;
let _e229 = (*range_2);
param_21 = _e229;
let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_18), (¶m_19), (¶m_20), (¶m_21));
stored_1 = _e230;
let _e231 = stored_1;
let _e232 = (*range_2);
if (_e231 >= (_e232 * 0.999f)) {
continue;
}
let _e235 = stored_1;
let _e236 = (*receiver_1);
if (_e235 >= _e236) {
continue;
}
let _e238 = stored_1;
let _e239 = sum;
sum = (_e239 + _e238);
let _e241 = count;
count = (_e241 + 1f);
continue;
} else {
break;
}
continuing {
let _e243 = i_2;
i_2 = (_e243 + 1i);
}
}
let _e245 = count;
if (_e245 < 0.5f) {
return -1f;
}
let _e247 = sum;
let _e248 = count;
blocker = max((_e247 / _e248), 0.0001f);
let _e251 = blocker;
(*blockerOut) = _e251;
let _e252 = lightRadius;
let _e253 = (*receiver_1);
let _e254 = blocker;
let _e258 = blocker;
world = ((_e252 * max((_e253 - _e254), 0f)) / _e258);
let _e260 = world;
let _e261 = (*receiver_1);
let _e263 = (*tanHalf);
let _e266 = minRadius;
let _e267 = maxRadius;
return clamp((_e260 / ((2f * _e261) * _e263)), _e266, _e267);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_2: vec2<f32>;
let _e177 = (*rows);
if (_e177 > 0f) {
let _e180 = gl_FragCoord_1[0u];
let _e181 = (*rows);
let _e183 = gl_FragCoord_1[1u];
local_2 = vec2<f32>(_e180, (_e181 - _e183));
} else {
let _e186 = gl_FragCoord_1;
local_2 = _e186.xy;
}
let _e188 = local_2;
return _e188;
}
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 param_22: 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_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var local_3: vec3<f32>;
var lit: f32;
var param_31: vec2<f32>;
var param_32: vec2<f32>;
var param_33: vec2<f32>;
var param_34: f32;
var param_35: f32;
var i_3: i32;
var param_36: i32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
var param_40: vec2<f32>;
var param_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: f32;
var param_44: f32;
var phi_2149_: bool;
var phi_2210_: bool;
let _e229 = (*lightIndex);
let _e233 = point_shadow.slots[_e229][0u];
slot = i32((_e233 + 0.5f));
let _e236 = (*lightIndex);
let _e240 = point_shadow.slots[_e236][0u];
if (_e240 < 0f) {
return 1f;
}
let _e244 = point_shadow.params[2u];
strength = _e244;
let _e245 = strength;
if (_e245 <= 0f) {
return 1f;
}
let _e247 = slot;
let _e250 = point_shadow.lights[_e247];
let _e252 = (*world_1);
toLight = (_e250.xyz - _e252);
let _e254 = toLight;
toLightLength = max(length(_e254), 0.000001f);
let _e257 = (*normal);
let _e258 = toLight;
let _e259 = toLightLength;
nDotL = max(dot(_e257, (_e258 / vec3(_e259))), 0.15f);
let _e264 = nDotL;
let _e265 = nDotL;
let _e270 = nDotL;
let _e271 = nDotL;
slope = min((sqrt(max((1f - (_e264 * _e265)), 0f)) / (_e270 * _e271)), 8f);
let _e275 = toLightLength;
let _e277 = (*lightIndex);
let _e281 = point_shadow.slots[_e277][2u];
let _e286 = point_shadow.params3_[1u];
texel = (((2f * _e275) * max(_e281, 0.0001f)) * _e286);
let _e288 = (*world_1);
let _e289 = (*normal);
let _e290 = texel;
let _e294 = point_shadow.params[3u];
let _e296 = slope;
origin = (_e288 + (((_e289 * _e290) * _e294) * (1f + _e296)));
let _e300 = origin;
let _e301 = slot;
let _e304 = point_shadow.lights[_e301];
toFragment = (_e300 - _e304.xyz);
let _e307 = toFragment;
distance_ = length(_e307);
let _e309 = slot;
let _e313 = point_shadow.lights[_e309][3u];
range_3 = max(_e313, 0.0001f);
let _e315 = distance_;
let _e316 = range_3;
if (_e315 >= _e316) {
return 1f;
}
face = 0i;
let _e318 = (*lightIndex);
let _e322 = point_shadow.slots[_e318][1u];
if (_e322 < 0.5f) {
let _e324 = toFragment;
a = abs(_e324);
let _e327 = a[0u];
let _e329 = a[1u];
let _e330 = (_e327 >= _e329);
phi_2149_ = _e330;
if _e330 {
let _e332 = a[0u];
let _e334 = a[2u];
phi_2149_ = (_e332 >= _e334);
}
let _e337 = phi_2149_;
if _e337 {
let _e339 = toFragment[0u];
face = select(1i, 0i, (_e339 > 0f));
} else {
let _e343 = a[1u];
let _e345 = a[2u];
if (_e343 >= _e345) {
let _e348 = toFragment[1u];
face = select(3i, 2i, (_e348 > 0f));
} else {
let _e352 = toFragment[2u];
face = select(5i, 4i, (_e352 > 0f));
}
}
}
let _e355 = slot;
let _e357 = face;
let _e361 = point_shadow.faces[((_e355 * 6i) + _e357)];
let _e362 = origin;
clip = (_e361 * vec4<f32>(_e362.x, _e362.y, _e362.z, 1f));
let _e369 = clip[3u];
if (_e369 <= 0f) {
return 1f;
}
let _e371 = clip;
let _e374 = clip[3u];
ndc = (_e371.xy / vec2(_e374));
let _e378 = ndc[0u];
let _e380 = (abs(_e378) > 1f);
phi_2210_ = _e380;
if !(_e380) {
let _e383 = ndc[1u];
phi_2210_ = (abs(_e383) > 1f);
}
let _e387 = phi_2210_;
if _e387 {
return 1f;
}
let _e389 = ndc[0u];
let _e393 = ndc[1u];
uv_3 = vec2<f32>(((_e389 * 0.5f) + 0.5f), (0.5f - (_e393 * 0.5f)));
let _e397 = face;
let _e399 = slot;
tile_3 = vec2<f32>(f32(_e397), f32(_e399));
let _e402 = distance_;
let _e405 = point_shadow.params[1u];
receiver_2 = (_e402 - _e405);
let _e409 = frag_info.target_origin[0u];
param_22 = _e409;
let _e410 = FragCoordFromTop_u0028_f1_u003b((¶m_22));
noise = fract((52.982918f * fract(dot(_e410, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e415 = noise;
angle = (_e415 * 6.2831855f);
let _e417 = angle;
ca_2 = cos(_e417);
let _e419 = angle;
sa_2 = sin(_e419);
let _e421 = (*lightIndex);
let _e425 = point_shadow.slots[_e421][2u];
tanHalf_1 = max(_e425, 0.0001f);
blocker_1 = -1f;
let _e427 = uv_3;
param_23 = _e427;
let _e428 = tile_3;
param_24 = _e428;
let _e429 = range_3;
param_25 = _e429;
let _e430 = receiver_2;
param_26 = _e430;
let _e431 = ca_2;
param_27 = _e431;
let _e432 = sa_2;
param_28 = _e432;
let _e433 = tanHalf_1;
param_29 = _e433;
let _e434 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30));
let _e435 = param_30;
blocker_1 = _e435;
radius_1 = _e434;
let _e438 = point_shadow.params2_[3u];
if (_e438 > 0.5f) {
g_debug_surface_on = true;
let _e440 = radius_1;
if (_e440 < 0f) {
local_3 = vec3<f32>(0f, 0f, 1f);
} else {
let _e442 = radius_1;
let _e445 = point_shadow.params2_[2u];
let _e449 = blocker_1;
let _e450 = range_3;
local_3 = vec3<f32>(clamp((_e442 / max(_e445, 0.000001f)), 0f, 1f), clamp((_e449 / _e450), 0f, 1f), 0f);
}
let _e454 = local_3;
g_debug_surface = _e454;
}
let _e455 = radius_1;
if (_e455 < 0f) {
return 1f;
}
let _e457 = uv_3;
param_31 = _e457;
param_32 = vec2<f32>(0f, 0f);
let _e458 = tile_3;
param_33 = _e458;
let _e459 = range_3;
param_34 = _e459;
let _e460 = receiver_2;
param_35 = _e460;
let _e461 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_31), (¶m_32), (¶m_33), (¶m_34), (¶m_35));
lit = _e461;
let _e462 = radius_1;
if (_e462 > 0f) {
i_3 = 0i;
loop {
let _e464 = i_3;
if (_e464 < 8i) {
let _e466 = i_3;
param_36 = _e466;
let _e467 = ca_2;
param_37 = _e467;
let _e468 = sa_2;
param_38 = _e468;
let _e469 = radius_1;
param_39 = _e469;
let _e470 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e471 = uv_3;
param_40 = _e471;
param_41 = _e470;
let _e472 = tile_3;
param_42 = _e472;
let _e473 = range_3;
param_43 = _e473;
let _e474 = receiver_2;
param_44 = _e474;
let _e475 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
let _e476 = lit;
lit = (_e476 + _e475);
continue;
} else {
break;
}
continuing {
let _e478 = i_3;
i_3 = (_e478 + 1i);
}
}
let _e480 = lit;
lit = (_e480 * 0.11111111f);
}
let _e482 = lit;
let _e483 = strength;
return mix(1f, _e482, clamp(_e483, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r: f32;
var theta: f32;
let _e180 = (*i_4);
let _e183 = (*n_1);
r = sqrt(((f32(_e180) + 0.5f) / f32(_e183)));
let _e187 = (*i_4);
let _e190 = (*turn);
theta = ((f32(_e187) * 2.3999631f) + _e190);
let _e192 = r;
let _e193 = theta;
let _e195 = theta;
return (vec2<f32>(cos(_e193), sin(_e195)) * _e192);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_45: f32;
let _e179 = frag_info.target_origin[0u];
param_45 = _e179;
let _e180 = FragCoordFromTop_u0028_f1_u003b((¶m_45));
let _e183 = frag_info.target_origin[3u];
at = (_e180 + vec2((5.588238f * max(_e183, 0f))));
let _e188 = at;
return fract((52.982918f * fract(dot(_e188, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_1: f32;
var pMax: f32;
var reduced: f32;
let _e184 = (*moments)[1u];
let _e186 = (*moments)[0u];
let _e188 = (*moments)[0u];
let _e191 = (*minVariance);
variance = max((_e184 - (_e186 * _e188)), _e191);
let _e193 = (*t);
let _e195 = (*moments)[0u];
d_1 = (_e193 - _e195);
let _e197 = variance;
let _e198 = variance;
let _e199 = d_1;
let _e200 = d_1;
pMax = (_e197 / (_e198 + (_e199 * _e200)));
let _e204 = pMax;
let _e205 = (*bleed);
let _e207 = (*bleed);
reduced = clamp(((_e204 - _e205) / max((1f - _e207), 0.0001f)), 0f, 1f);
let _e212 = (*t);
let _e214 = (*moments)[0u];
let _e216 = reduced;
return select(_e216, 1f, (_e212 <= _e214));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e177 = (*depth);
d_2 = ((2f * clamp(_e177, 0f, 1f)) - 1f);
let _e181 = d_2;
let _e184 = d_2;
return vec2<f32>(exp((40f * _e181)), -(exp((-5f * _e184))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_46: f32;
var scale: vec2<f32>;
var positive: f32;
var param_47: vec2<f32>;
var param_48: f32;
var param_49: f32;
var param_50: f32;
var negative: f32;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var param_54: f32;
let _e191 = (*depth_1);
param_46 = _e191;
let _e192 = EvsmWarp_u0028_f1_u003b((¶m_46));
warped = _e192;
let _e193 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e193);
let _e196 = scale[0u];
let _e198 = scale[0u];
let _e200 = (*moments_1);
param_47 = _e200.xy;
let _e203 = warped[0u];
param_48 = _e203;
param_49 = (_e196 * _e198);
let _e204 = (*bleed_1);
param_50 = _e204;
let _e205 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_47), (¶m_48), (¶m_49), (¶m_50));
positive = _e205;
let _e207 = scale[1u];
let _e209 = scale[1u];
let _e211 = (*moments_1);
param_51 = _e211.zw;
let _e214 = warped[1u];
param_52 = _e214;
param_53 = (_e207 * _e209);
let _e215 = (*bleed_1);
param_54 = _e215;
let _e216 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_51), (¶m_52), (¶m_53), (¶m_54));
negative = _e216;
let _e217 = positive;
let _e218 = negative;
return min(_e217, _e218);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_4: mat4x4<f32>;
var local_5: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_6: f32;
var local_7: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_55: vec4<f32>;
var param_56: f32;
var param_57: f32;
var y: i32;
var x: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var occluder_1: f32;
var param_58: i32;
var param_59: i32;
var param_60: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var occluder_2: f32;
var param_61: i32;
var param_62: i32;
var param_63: f32;
var phi_3269_: bool;
var phi_3280_: bool;
var phi_3436_: bool;
var phi_3443_: bool;
var phi_3450_: bool;
let _e236 = frag_info.shadow_params[3u];
strength_1 = _e236;
let _e237 = strength_1;
if (_e237 <= 0f) {
return 1f;
}
let _e239 = (*lightIndex_1);
let _e242 = frag_info.frame_params[2u];
if (_e239 != i32((_e242 + 0.5f))) {
return 1f;
}
let _e248 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e248 + 0.5f));
let _e251 = v_world_position_1;
let _e253 = frag_info.camera_position;
viewDistance = length((_e251 - _e253.xyz));
cascade = 0i;
let _e257 = cascadeCount;
let _e258 = (_e257 > 1i);
phi_3269_ = _e258;
if _e258 {
let _e259 = viewDistance;
let _e262 = frag_info.shadow_cascades[0u];
phi_3269_ = (_e259 > _e262);
}
let _e265 = phi_3269_;
if _e265 {
cascade = 1i;
}
let _e266 = cascadeCount;
let _e267 = (_e266 > 2i);
phi_3280_ = _e267;
if _e267 {
let _e268 = viewDistance;
let _e271 = frag_info.shadow_cascades[1u];
phi_3280_ = (_e268 > _e271);
}
let _e274 = phi_3280_;
if _e274 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e275 = attempt;
if (_e275 < 3i) {
let _e277 = cascade;
let _e278 = attempt;
which = (_e277 + _e278);
let _e280 = which;
let _e281 = cascadeCount;
if (_e280 >= _e281) {
break;
}
let _e283 = which;
if (_e283 == 0i) {
let _e286 = frag_info.shadow_matrix;
local_4 = _e286;
} else {
let _e287 = which;
if (_e287 == 1i) {
let _e290 = frag_info.shadow_matrix_far;
local_5 = _e290;
} else {
let _e292 = frag_info.shadow_matrix_farthest;
local_5 = _e292;
}
let _e293 = local_5;
local_4 = _e293;
}
let _e294 = local_4;
matrix = _e294;
let _e297 = matrix[0][0u];
let _e300 = matrix[1][0u];
let _e303 = matrix[2][0u];
axisX = vec3<f32>(_e297, _e300, _e303);
let _e307 = matrix[0][1u];
let _e310 = matrix[1][1u];
let _e313 = matrix[2][1u];
axisY = vec3<f32>(_e307, _e310, _e313);
let _e315 = axisX;
rowX = max(length(_e315), 0.000001f);
let _e318 = axisY;
rowY = max(length(_e318), 0.000001f);
let _e323 = frag_info.shadow_cascades[3u];
let _e325 = rowX;
texelMetres = ((2f * _e323) / _e325);
let _e329 = frag_info.shadow_cascades[3u];
let _e332 = (*s_1).n;
let _e333 = axisX;
let _e336 = rowX;
let _e337 = rowX;
let _e341 = (*s_1).n;
let _e342 = axisY;
let _e345 = rowY;
let _e346 = rowY;
reach = ((3f * _e329) * ((abs(dot(_e332, _e333)) / (_e336 * _e337)) + (abs(dot(_e341, _e342)) / (_e345 * _e346))));
let _e351 = v_world_position_1;
let _e353 = (*s_1).n;
let _e356 = frag_info.shadow_params[2u];
let _e357 = reach;
origin_1 = (_e351 + (_e353 * (_e356 + _e357)));
let _e361 = matrix;
let _e362 = origin_1;
lightSpace = (_e361 * vec4<f32>(_e362.x, _e362.y, _e362.z, 1f));
let _e369 = lightSpace[3u];
if (_e369 <= 0f) {
continue;
}
let _e371 = lightSpace;
let _e374 = lightSpace[3u];
candidate = (_e371.xyz / vec3(_e374));
let _e378 = candidate[0u];
let _e382 = candidate[1u];
inTile = vec2<f32>(((_e378 * 0.5f) + 0.5f), (0.5f - (_e382 * 0.5f)));
let _e387 = inTile[0u];
let _e388 = (_e387 < 0f);
phi_3436_ = _e388;
if !(_e388) {
let _e391 = inTile[0u];
phi_3436_ = (_e391 > 1f);
}
let _e394 = phi_3436_;
phi_3443_ = _e394;
if !(_e394) {
let _e397 = inTile[1u];
phi_3443_ = (_e397 < 0f);
}
let _e400 = phi_3443_;
phi_3450_ = _e400;
if !(_e400) {
let _e403 = inTile[1u];
phi_3450_ = (_e403 > 1f);
}
let _e406 = phi_3450_;
if _e406 {
continue;
}
let _e408 = candidate[2u];
if (_e408 > 1f) {
let _e410 = which;
let _e411 = cascadeCount;
if (_e410 < (_e411 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e416 = inTile[0u];
let _e417 = which;
let _e420 = cascadeCount;
let _e424 = inTile[1u];
uv_4 = vec2<f32>(((_e416 + f32(_e417)) / f32(_e420)), _e424);
let _e426 = candidate;
projected = _e426;
let _e427 = which;
cascade = _e427;
let _e428 = texelMetres;
cascadeTexel = _e428;
let _e431 = matrix[0][2u];
let _e434 = matrix[1][2u];
let _e437 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e431, _e434, _e437)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e442 = attempt;
attempt = (_e442 + 1i);
}
}
let _e444 = found;
if !(_e444) {
return 1f;
}
let _e446 = cascade;
if (_e446 == 0i) {
let _e450 = frag_info.shadow_bias[0u];
local_6 = _e450;
} else {
let _e451 = cascade;
if (_e451 == 1i) {
let _e455 = frag_info.shadow_bias[1u];
local_7 = _e455;
} else {
let _e458 = frag_info.shadow_bias[2u];
local_7 = _e458;
}
let _e459 = local_7;
local_6 = _e459;
}
let _e460 = local_6;
bias = _e460;
let _e463 = frag_info.shadow_params[0u];
let _e466 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e463, _e466);
let _e468 = cascade;
let _e470 = cascadeCount;
let _e474 = texel_1;
tileLo = (vec2<f32>((f32(_e468) / f32(_e470)), 0f) + (_e474 * 0.5f));
let _e477 = cascade;
let _e480 = cascadeCount;
let _e484 = texel_1;
tileHi = (vec2<f32>((f32((_e477 + 1i)) / f32(_e480)), 1f) - (_e484 * 0.5f));
let _e489 = frag_info.ambient_ground[3u];
softness = _e489;
lit_1 = 0f;
let _e490 = softness;
if (_e490 < 0f) {
let _e492 = uv_4;
let _e493 = tileLo;
let _e494 = tileHi;
let _e496 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e492, _e493, _e494), 0f);
moments_2 = _e496;
let _e498 = projected[2u];
let _e499 = bias;
let _e501 = softness;
let _e505 = moments_2;
param_55 = _e505;
param_56 = (_e498 - _e499);
param_57 = clamp((-(_e501) - 1f), 0f, 0.95f);
let _e506 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_55), (¶m_56), (¶m_57));
lit_1 = _e506;
} else {
let _e507 = softness;
if (_e507 <= 0f) {
y = -1i;
loop {
let _e509 = y;
if (_e509 <= 1i) {
x = -1i;
loop {
let _e511 = x;
if (_e511 <= 1i) {
let _e513 = uv_4;
let _e514 = x;
let _e516 = y;
let _e519 = texel_1;
let _e522 = tileLo;
let _e523 = tileHi;
let _e525 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e513 + (vec2<f32>(f32(_e514), f32(_e516)) * _e519)), _e522, _e523), 0f);
occluder = _e525.x;
let _e528 = projected[2u];
let _e529 = bias;
let _e531 = occluder;
let _e534 = lit_1;
lit_1 = (_e534 + select(1f, 0f, ((_e528 - _e529) > _e531)));
continue;
} else {
break;
}
continuing {
let _e536 = x;
x = (_e536 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e538 = y;
y = (_e538 + 1i);
}
}
let _e540 = lit_1;
lit_1 = (_e540 * 0.11111111f);
} else {
let _e542 = softness;
spread = tan(min(_e542, 0.5f));
let _e545 = ShadowNoise_u0028_();
turn_1 = (_e545 * 6.2831855f);
let _e547 = spread;
let _e549 = projected[2u];
let _e551 = cascadeDepth;
let _e553 = cascadeTexel;
searchRadius = clamp((((_e547 * _e549) * _e551) / _e553), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e556 = i_5;
if (_e556 < 16i) {
let _e558 = uv_4;
let _e559 = i_5;
param_58 = _e559;
param_59 = 16i;
let _e560 = turn_1;
param_60 = _e560;
let _e561 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60));
let _e562 = texel_1;
let _e564 = searchRadius;
let _e567 = tileLo;
let _e568 = tileHi;
let _e570 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e558 + ((_e561 * _e562) * _e564)), _e567, _e568), 0f);
occluder_1 = _e570.x;
let _e573 = projected[2u];
let _e574 = bias;
let _e576 = occluder_1;
if ((_e573 - _e574) > _e576) {
let _e578 = occluder_1;
let _e579 = blockerSum;
blockerSum = (_e579 + _e578);
let _e581 = blockerCount;
blockerCount = (_e581 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e583 = i_5;
i_5 = (_e583 + 1i);
}
}
let _e585 = blockerCount;
if (_e585 <= 0f) {
return 1f;
}
let _e588 = projected[2u];
let _e589 = blockerSum;
let _e590 = blockerCount;
let _e594 = cascadeDepth;
gap = (max((_e588 - (_e589 / _e590)), 0f) * _e594);
let _e596 = spread;
let _e597 = gap;
let _e599 = cascadeTexel;
radius_2 = clamp(((_e596 * _e597) / _e599), 1f, 16f);
i_6 = 0i;
loop {
let _e602 = i_6;
if (_e602 < 16i) {
let _e604 = uv_4;
let _e605 = turn_1;
let _e607 = i_6;
param_61 = _e607;
param_62 = 16i;
param_63 = (_e605 + 1f);
let _e608 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_61), (¶m_62), (¶m_63));
let _e609 = texel_1;
let _e611 = radius_2;
let _e614 = tileLo;
let _e615 = tileHi;
let _e617 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e604 + ((_e608 * _e609) * _e611)), _e614, _e615), 0f);
occluder_2 = _e617.x;
let _e620 = projected[2u];
let _e621 = bias;
let _e623 = occluder_2;
let _e626 = lit_1;
lit_1 = (_e626 + select(1f, 0f, ((_e620 - _e621) > _e623)));
continue;
} else {
break;
}
continuing {
let _e628 = i_6;
i_6 = (_e628 + 1i);
}
}
let _e630 = lit_1;
lit_1 = (_e630 * 0.0625f);
}
}
let _e632 = lit_1;
let _e633 = strength_1;
return mix(1f, _e632, clamp(_e633, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_64: Surface;
var param_65: LightSample;
var param_66: i32;
let _e181 = (*s_2);
param_64 = _e181;
let _e182 = (*light_2);
param_65 = _e182;
let _e183 = (*index);
param_66 = _e183;
let _e184 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_64), (¶m_65), (¶m_66));
return _e184;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e176 = (*index_1);
return (_e176 < 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 _e180 = (*distance_1);
let _e181 = (*distance_1);
attenuation = (1f / max((_e180 * _e181), 0.0001f));
let _e185 = (*range_4);
if (_e185 > 0f) {
let _e187 = (*distance_1);
let _e188 = (*range_4);
ratio = (_e187 / _e188);
let _e190 = ratio;
let _e191 = ratio;
let _e193 = ratio;
let _e195 = ratio;
window = clamp((1f - (((_e190 * _e191) * _e193) * _e195)), 0f, 1f);
let _e199 = window;
let _e200 = window;
let _e202 = attenuation;
attenuation = (_e202 * (_e199 * _e200));
}
let _e204 = attenuation;
return _e204;
}
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_2: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_8: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e192 = (*halfWidth);
let _e193 = (*halfHeight);
n_2 = cross(_e192, _e193);
let _e195 = n_2;
nLen = length(_e195);
let _e197 = nLen;
if (_e197 < 0.000000000001f) {
let _e199 = (*centre);
return _e199;
}
let _e200 = nLen;
let _e201 = n_2;
n_2 = (_e201 / vec3(_e200));
let _e204 = (*centre);
let _e205 = (*world_2);
toPlane = (_e204 - _e205);
let _e207 = (*mirror);
let _e208 = n_2;
denom = dot(_e207, _e208);
let _e210 = denom;
if (abs(_e210) < 0.00001f) {
let _e213 = toPlane;
let _e214 = n_2;
let _e215 = toPlane;
let _e216 = n_2;
onPlane = (_e213 - (_e214 * dot(_e215, _e216)));
} else {
let _e220 = toPlane;
let _e221 = n_2;
let _e223 = denom;
t_1 = (dot(_e220, _e221) / _e223);
let _e225 = t_1;
if (_e225 > 0f) {
let _e227 = (*mirror);
let _e228 = t_1;
local_8 = (_e227 * _e228);
} else {
let _e230 = toPlane;
let _e231 = n_2;
let _e232 = toPlane;
let _e233 = n_2;
local_8 = (_e230 - (_e231 * dot(_e232, _e233)));
}
let _e237 = local_8;
onPlane = _e237;
}
let _e238 = onPlane;
let _e239 = toPlane;
offset_2 = (_e238 - _e239);
let _e241 = (*halfWidth);
let _e242 = (*halfWidth);
wLen2_ = max(dot(_e241, _e242), 0.000000000001f);
let _e245 = (*halfHeight);
let _e246 = (*halfHeight);
hLen2_ = max(dot(_e245, _e246), 0.000000000001f);
let _e249 = offset_2;
let _e250 = (*halfWidth);
let _e252 = wLen2_;
u = clamp((dot(_e249, _e250) / _e252), -1f, 1f);
let _e255 = offset_2;
let _e256 = (*halfHeight);
let _e258 = hLen2_;
v = clamp((dot(_e255, _e256) / _e258), -1f, 1f);
let _e261 = (*centre);
let _e262 = (*halfWidth);
let _e263 = u;
let _e266 = (*halfHeight);
let _e267 = v;
return ((_e261 + (_e262 * _e263)) + (_e266 * _e267));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
var local_9: f32;
let _e184 = (*a_1);
let _e185 = (*a_1);
ua = (_e184 / vec3(max(length(_e185), 0.000000000001f)));
let _e190 = (*b);
let _e191 = (*b);
ub = (_e190 / vec3(max(length(_e191), 0.000000000001f)));
let _e196 = ua;
let _e197 = ub;
angle_1 = acos(clamp(dot(_e196, _e197), -1f, 1f));
let _e201 = ua;
let _e202 = ub;
axis = cross(_e201, _e202);
let _e204 = axis;
len = length(_e204);
let _e206 = len;
if (_e206 > 0.000001f) {
let _e208 = angle_1;
let _e209 = axis;
let _e210 = (*n_3);
let _e213 = len;
local_9 = ((_e208 * dot(_e209, _e210)) / _e213);
} else {
local_9 = 0f;
}
let _e215 = local_9;
return _e215;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_7: i32;
var a_2: vec3<f32>;
var b_1: vec3<f32>;
var local_10: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_11: f32;
var aAbove: bool;
var bAbove: bool;
var local_12: f32;
var param_67: vec3<f32>;
var param_68: vec3<f32>;
var param_69: vec3<f32>;
var param_70: vec3<f32>;
var param_71: vec3<f32>;
var param_72: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e198 = i_7;
if (_e198 < 4i) {
let _e200 = i_7;
let _e202 = (*corners)[_e200];
a_2 = _e202;
let _e203 = i_7;
if (_e203 == 3i) {
local_10 = 0i;
} else {
let _e205 = i_7;
local_10 = (_e205 + 1i);
}
let _e207 = local_10;
let _e209 = (*corners)[_e207];
b_1 = _e209;
let _e210 = a_2;
let _e211 = (*n_4);
ha = dot(_e210, _e211);
let _e213 = b_1;
let _e214 = (*n_4);
hb = dot(_e213, _e214);
let _e216 = ha;
let _e217 = hb;
d_3 = (_e216 - _e217);
let _e219 = a_2;
let _e220 = b_1;
let _e221 = a_2;
let _e223 = d_3;
if (abs(_e223) > 0.000000000001f) {
let _e226 = ha;
let _e227 = d_3;
local_11 = (_e226 / _e227);
} else {
local_11 = 0f;
}
let _e229 = local_11;
q = (_e219 + ((_e220 - _e221) * _e229));
let _e232 = ha;
aAbove = (_e232 > 0f);
let _e234 = hb;
bAbove = (_e234 > 0f);
let _e236 = aAbove;
let _e237 = bAbove;
if (_e236 || _e237) {
let _e239 = aAbove;
let _e240 = a_2;
let _e241 = q;
let _e244 = bAbove;
let _e245 = b_1;
let _e246 = q;
param_67 = select(_e241, _e240, vec3(_e239));
param_68 = select(_e246, _e245, vec3(_e244));
let _e249 = (*n_4);
param_69 = _e249;
let _e250 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_67), (¶m_68), (¶m_69));
local_12 = _e250;
} else {
local_12 = 0f;
}
let _e251 = local_12;
let _e252 = total;
total = (_e252 + _e251);
let _e254 = aAbove;
let _e255 = bAbove;
let _e258 = q;
let _e259 = exit;
exit = select(_e259, _e258, vec3((_e254 && !(_e255))));
let _e262 = aAbove;
let _e264 = bAbove;
let _e266 = q;
let _e267 = entry;
entry = select(_e267, _e266, vec3((!(_e262) && _e264)));
continue;
} else {
break;
}
continuing {
let _e270 = i_7;
i_7 = (_e270 + 1i);
}
}
let _e272 = exit;
param_70 = _e272;
let _e273 = entry;
param_71 = _e273;
let _e274 = (*n_4);
param_72 = _e274;
let _e275 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_70), (¶m_71), (¶m_72));
let _e276 = total;
total = (_e276 + _e275);
let _e278 = total;
return max((-(_e278) * 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_13: f32;
var local_14: f32;
var local_15: f32;
let _e181 = (*slot_1);
let _e182 = (*slot_1);
lane = (_e181 - ((_e182 / 4i) * 4i));
let _e186 = lane;
if (_e186 == 0i) {
let _e189 = (*four)[0u];
local_13 = _e189;
} else {
let _e190 = lane;
if (_e190 == 1i) {
let _e193 = (*four)[1u];
local_14 = _e193;
} else {
let _e194 = lane;
if (_e194 == 2i) {
let _e197 = (*four)[2u];
local_15 = _e197;
} else {
let _e199 = (*four)[3u];
local_15 = _e199;
}
let _e200 = local_15;
local_14 = _e200;
}
let _e201 = local_14;
local_13 = _e201;
}
let _e202 = local_13;
return _e202;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_73: vec4<f32>;
var param_74: i32;
let _e178 = (*slot_2);
let _e182 = light_list_info.scales[(_e178 / 4i)];
param_73 = _e182;
let _e183 = (*slot_2);
param_74 = _e183;
let _e184 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_73), (¶m_74));
return _e184;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e180 = light_list_info.slot_rows[0i];
let _e181 = (*row);
a_3 = abs((_e180 - vec4(_e181)));
let _e187 = light_list_info.slot_rows[1i];
let _e188 = (*row);
b_2 = abs((_e187 - vec4(_e188)));
let _e193 = a_3[0u];
let _e195 = a_3[1u];
let _e198 = a_3[2u];
let _e200 = a_3[3u];
let _e204 = b_2[0u];
let _e206 = b_2[1u];
let _e209 = b_2[2u];
let _e211 = b_2[3u];
return (min(min(min(_e193, _e195), min(_e198, _e200)), min(min(_e204, _e206), min(_e209, _e211))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_75: vec4<f32>;
var param_76: i32;
let _e178 = (*slot_3);
let _e182 = light_list_info.indices[(_e178 / 4i)];
param_75 = _e182;
let _e183 = (*slot_3);
param_76 = _e183;
let _e184 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_75), (¶m_76));
return _e184;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e177 = (*texel_2);
let _e181 = light_list_info.list[1u];
let _e183 = (*row_1);
let _e187 = light_list_info.list[2u];
let _e190 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e177 + 0.5f) * _e181), ((_e183 + 0.5f) * _e187)), 0f);
return _e190;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_77: f32;
var param_78: f32;
var param_79: vec4<f32>;
var param_80: i32;
let _e185 = g_cluster_offset;
let _e186 = (*slot_4);
entry_1 = (_e185 + f32(_e186));
let _e189 = entry_1;
row_2 = floor((_e189 / 16f));
let _e192 = entry_1;
let _e193 = row_2;
within = (_e192 - (_e193 * 16f));
let _e196 = within;
texel_3 = floor((_e196 / 4f));
let _e201 = light_list_info.cluster_depth[3u];
let _e202 = row_2;
let _e204 = texel_3;
param_77 = _e204;
param_78 = (_e201 + _e202);
let _e205 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_77), (¶m_78));
four_1 = _e205;
let _e206 = within;
let _e207 = texel_3;
let _e212 = four_1;
param_79 = _e212;
param_80 = i32(((_e206 - (_e207 * 4f)) + 0.5f));
let _e213 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_79), (¶m_80));
return _e213;
}
fn Clustered_u0028_() -> bool {
let _e177 = light_list_info.cluster_grid[3u];
return (_e177 > 0.5f);
}
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 light_3: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_16: f32;
var param_81: i32;
var param_82: i32;
var v_1: f32;
var u_1: f32;
var local_17: f32;
var param_83: f32;
var param_84: 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 behind: bool;
var formFactor: f32;
var local_18: f32;
var param_85: array<vec3<f32>, 4>;
var param_86: vec3<f32>;
var area: f32;
var radiance: f32;
var local_19: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
var param_89: vec3<f32>;
var param_90: vec3<f32>;
var param_91: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_20: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_92: f32;
var param_93: f32;
var cosAngle: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e228 = (*index_2);
if (_e228 < 8i) {
let _e230 = (*index_2);
let _e233 = frag_info.light_position[_e230];
position = _e233;
let _e234 = (*index_2);
let _e237 = frag_info.light_color[_e234];
color_1 = _e237;
let _e238 = (*index_2);
let _e241 = frag_info.light_direction[_e238];
direction = _e241;
let _e242 = (*index_2);
let _e245 = frag_info.light_cone[_e242];
cone = _e245;
} else {
let _e246 = (*index_2);
slot_5 = (_e246 - 8i);
let _e248 = Clustered_u0028_();
clustered = _e248;
let _e249 = clustered;
if _e249 {
let _e250 = slot_5;
param_81 = _e250;
let _e251 = ClusterRow_u0028_i1_u003b((¶m_81));
local_16 = _e251;
} else {
let _e252 = slot_5;
param_82 = _e252;
let _e253 = LightListRow_u0028_i1_u003b((¶m_82));
local_16 = _e253;
}
let _e254 = local_16;
listRow = _e254;
let _e255 = listRow;
let _e259 = light_list_info.list[2u];
v_1 = ((_e255 + 0.5f) * _e259);
let _e263 = light_list_info.list[1u];
u_1 = _e263;
let _e264 = u_1;
let _e266 = v_1;
let _e268 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e264), _e266), 0f);
position = _e268;
let _e269 = u_1;
let _e271 = v_1;
let _e273 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e269), _e271), 0f);
color_1 = _e273;
let _e274 = u_1;
let _e276 = v_1;
let _e278 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e274), _e276), 0f);
direction = _e278;
let _e279 = u_1;
let _e281 = v_1;
let _e283 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e279), _e281), 0f);
cone = _e283;
let _e284 = clustered;
if _e284 {
let _e285 = listRow;
param_83 = _e285;
let _e286 = InSlots_u0028_f1_u003b((¶m_83));
local_17 = select(1f, 0f, _e286);
} else {
let _e288 = slot_5;
param_84 = _e288;
let _e289 = LightListScale_u0028_i1_u003b((¶m_84));
local_17 = _e289;
}
let _e290 = local_17;
let _e292 = color_1[3u];
color_1[3u] = (_e292 * _e290);
}
let _e296 = position[3u];
type_39 = _e296;
let _e297 = type_39;
if (_e297 > 2.5f) {
let _e299 = direction;
halfWidth_1 = _e299.xyz;
let _e301 = cone;
halfHeight_1 = _e301.xyz;
let _e303 = position;
let _e305 = v_world_position_1;
toCentre = (_e303.xyz - _e305);
let _e307 = toCentre;
let _e308 = halfWidth_1;
let _e310 = halfHeight_1;
corners_1[0i] = ((_e307 - _e308) - _e310);
let _e313 = toCentre;
let _e314 = halfWidth_1;
let _e316 = halfHeight_1;
corners_1[1i] = ((_e313 + _e314) - _e316);
let _e319 = toCentre;
let _e320 = halfWidth_1;
let _e322 = halfHeight_1;
corners_1[2i] = ((_e319 + _e320) + _e322);
let _e325 = toCentre;
let _e326 = halfWidth_1;
let _e328 = halfHeight_1;
corners_1[3i] = ((_e325 - _e326) + _e328);
let _e331 = toCentre;
let _e332 = halfWidth_1;
let _e333 = halfHeight_1;
behind = (dot(_e331, cross(_e332, _e333)) >= 0f);
let _e337 = behind;
if _e337 {
local_18 = 0f;
} else {
let _e338 = corners_1;
param_85 = _e338;
let _e340 = (*s_3).n;
param_86 = _e340;
let _e341 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_85), (¶m_86));
local_18 = _e341;
}
let _e342 = local_18;
formFactor = _e342;
let _e343 = halfWidth_1;
let _e344 = halfHeight_1;
area = (length(cross(_e343, _e344)) * 4f);
let _e348 = area;
if (_e348 > 0.000000001f) {
let _e350 = area;
local_19 = (1f / _e350);
} else {
local_19 = 0f;
}
let _e352 = local_19;
radiance = _e352;
let _e353 = toCentre;
distance_2 = length(_e353);
let _e356 = direction[3u];
if (_e356 > 0f) {
let _e358 = distance_2;
let _e360 = direction[3u];
ratio_1 = (_e358 / _e360);
let _e362 = ratio_1;
let _e363 = ratio_1;
let _e365 = ratio_1;
let _e367 = ratio_1;
window_1 = clamp((1f - (((_e362 * _e363) * _e365) * _e367)), 0f, 1f);
let _e371 = window_1;
let _e372 = window_1;
let _e374 = radiance;
radiance = (_e374 * (_e371 * _e372));
}
let _e377 = (*s_3).v;
let _e380 = (*s_3).n;
mirror_1 = reflect(-(_e377), _e380);
let _e382 = position;
param_87 = _e382.xyz;
let _e384 = halfWidth_1;
param_88 = _e384;
let _e385 = halfHeight_1;
param_89 = _e385;
let _e386 = v_world_position_1;
param_90 = _e386;
let _e387 = mirror_1;
param_91 = _e387;
let _e388 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_87), (¶m_88), (¶m_89), (¶m_90), (¶m_91));
representative = _e388;
let _e389 = representative;
let _e390 = v_world_position_1;
toPoint = (_e389 - _e390);
let _e392 = toPoint;
pointDistance = length(_e392);
let _e394 = pointDistance;
if (_e394 > 0.000001f) {
let _e396 = toPoint;
let _e397 = pointDistance;
local_20 = (_e396 / vec3(_e397));
} else {
let _e401 = (*s_3).n;
local_20 = _e401;
}
let _e402 = local_20;
light_3.l = _e402;
let _e405 = light_3.l;
let _e407 = (*s_3).v;
light_3.h = normalize((_e405 + _e407));
let _e411 = formFactor;
light_3.n_dot_l = _e411;
let _e414 = (*s_3).n;
let _e416 = light_3.h;
light_3.n_dot_h = max(dot(_e414, _e416), 0f);
let _e421 = (*s_3).v;
let _e423 = light_3.h;
light_3.v_dot_h = max(dot(_e421, _e423), 0f);
let _e427 = color_1;
let _e430 = color_1[3u];
let _e432 = radiance;
light_3.radiance = ((_e427.xyz * _e430) * _e432);
let _e435 = light_3;
return _e435;
}
let _e436 = direction;
aim = normalize(_e436.xyz);
attenuation_1 = 1f;
let _e439 = type_39;
if (_e439 < 0.5f) {
let _e441 = aim;
light_3.l = -(_e441);
} else {
let _e444 = position;
let _e446 = v_world_position_1;
toLight_1 = (_e444.xyz - _e446);
let _e448 = toLight_1;
distance_3 = length(_e448);
let _e450 = distance_3;
if (_e450 < 0.000001f) {
let _e453 = (*s_3).n;
light_3.l = _e453;
let _e456 = (*s_3).n;
light_3.h = _e456;
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 _e462 = light_3;
return _e462;
}
let _e463 = toLight_1;
let _e464 = distance_3;
light_3.l = (_e463 / vec3(_e464));
let _e468 = distance_3;
param_92 = _e468;
let _e470 = direction[3u];
param_93 = _e470;
let _e471 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_92), (¶m_93));
attenuation_1 = _e471;
let _e472 = type_39;
if (_e472 > 1.5f) {
let _e474 = aim;
let _e476 = light_3.l;
cosAngle = dot(_e474, -(_e476));
let _e479 = cosAngle;
let _e481 = cone[1u];
let _e484 = cone[0u];
let _e486 = cone[1u];
let _e490 = attenuation_1;
attenuation_1 = (_e490 * clamp(((_e479 - _e481) / (_e484 - _e486)), 0f, 1f));
}
}
let _e493 = light_3.l;
let _e495 = (*s_3).v;
light_3.h = normalize((_e493 + _e495));
let _e500 = (*s_3).n;
let _e502 = light_3.l;
light_3.n_dot_l = max(dot(_e500, _e502), 0f);
let _e507 = (*s_3).n;
let _e509 = light_3.h;
light_3.n_dot_h = max(dot(_e507, _e509), 0f);
let _e514 = (*s_3).v;
let _e516 = light_3.h;
light_3.v_dot_h = max(dot(_e514, _e516), 0f);
let _e520 = color_1;
let _e523 = color_1[3u];
let _e525 = attenuation_1;
light_3.radiance = ((_e520.xyz * _e523) * _e525);
let _e528 = light_3;
return _e528;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_21: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_94: f32;
var param_95: f32;
let _e190 = light_list_info.cluster_view_projection;
let _e191 = (*world_3);
clip_1 = (_e190 * vec4<f32>(_e191.x, _e191.y, _e191.z, 1f));
let _e197 = clip_1;
let _e200 = clip_1[3u];
ndc_1 = (_e197.xy / vec2(max(_e200, 0.000001f)));
let _e205 = light_list_info.cluster_grid;
grid = _e205.xyz;
let _e209 = light_list_info.cluster_depth[0u];
near_1 = _e209;
let _e211 = ndc_1[0u];
let _e215 = grid[0u];
let _e219 = grid[0u];
tx = clamp(floor((((_e211 * 0.5f) + 0.5f) * _e215)), 0f, (_e219 - 1f));
let _e223 = ndc_1[1u];
let _e227 = grid[1u];
let _e231 = grid[1u];
ty = clamp(floor((((_e223 * 0.5f) + 0.5f) * _e227)), 0f, (_e231 - 1f));
let _e235 = clip_1[3u];
let _e236 = near_1;
if (_e235 <= _e236) {
local_21 = 0f;
} else {
let _e239 = clip_1[3u];
let _e240 = near_1;
let _e245 = light_list_info.cluster_depth[1u];
let _e249 = grid[2u];
local_21 = clamp(floor((log((_e239 / _e240)) * _e245)), 0f, (_e249 - 1f));
}
let _e252 = local_21;
tz = _e252;
let _e253 = tx;
let _e254 = ty;
let _e256 = grid[0u];
let _e259 = tz;
let _e261 = grid[0u];
let _e264 = grid[1u];
cell = ((_e253 + (_e254 * _e256)) + ((_e259 * _e261) * _e264));
let _e267 = cell;
row_3 = floor((_e267 / 4f));
let _e270 = cell;
let _e271 = row_3;
let _e276 = light_list_info.cluster_depth[2u];
let _e277 = row_3;
param_94 = (_e270 - (_e271 * 4f));
param_95 = (_e276 + _e277);
let _e279 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
header = _e279;
let _e281 = header[0u];
g_cluster_offset = _e281;
let _e283 = header[1u];
g_cluster_count = _e283;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_96: vec3<f32>;
let _e179 = light_list_info.list[0u];
tail = _e179;
let _e180 = Clustered_u0028_();
if _e180 {
let _e181 = v_world_position_1;
param_96 = _e181;
FindCluster_u0028_vf3_u003b((¶m_96));
let _e182 = g_cluster_count;
tail = _e182;
}
let _e185 = frag_info.frame_params[1u];
let _e189 = tail;
return (clamp(i32((_e185 + 0.5f)), 0i, 8i) + clamp(i32((_e189 + 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_8: i32;
var light_4: LightSample;
var param_97: i32;
var param_98: Surface;
var visibility: f32;
var param_99: i32;
var local_22: f32;
var param_100: Surface;
var param_101: LightSample;
var param_102: i32;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: i32;
var param_106: Surface;
var param_107: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e193 = LightCount_u0028_();
count_1 = _e193;
i_8 = 0i;
loop {
let _e194 = i_8;
if (_e194 < 32i) {
let _e196 = i_8;
let _e197 = count_1;
if (_e196 >= _e197) {
break;
}
let _e199 = i_8;
param_97 = _e199;
let _e200 = (*s_4);
param_98 = _e200;
let _e201 = 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_97), (¶m_98));
light_4 = _e201;
let _e203 = light_4.n_dot_l;
if (_e203 <= 0f) {
continue;
}
let _e205 = i_8;
param_99 = _e205;
let _e206 = LightHasShadow_u0028_i1_u003b((¶m_99));
if _e206 {
let _e207 = (*s_4);
param_100 = _e207;
let _e208 = light_4;
param_101 = _e208;
let _e209 = i_8;
param_102 = _e209;
let _e210 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_100), (¶m_101), (¶m_102));
let _e211 = v_world_position_1;
param_103 = _e211;
let _e213 = (*s_4).n;
param_104 = _e213;
let _e214 = i_8;
param_105 = _e214;
let _e215 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_103), (¶m_104), (¶m_105));
local_22 = (_e210 * _e215);
} else {
local_22 = 1f;
}
let _e217 = local_22;
visibility = _e217;
let _e218 = visibility;
if (_e218 <= 0f) {
continue;
}
let _e220 = (*s_4);
param_106 = _e220;
let _e221 = light_4;
param_107 = _e221;
let _e222 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_106), (¶m_107));
let _e224 = light_4.radiance;
let _e227 = light_4.n_dot_l;
let _e229 = visibility;
let _e231 = total_1;
total_1 = (_e231 + (((_e222 * _e224) * _e227) * _e229));
continue;
} else {
break;
}
continuing {
let _e233 = i_8;
i_8 = (_e233 + 1i);
}
}
let _e235 = total_1;
return _e235;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e176 = v_lightmap_uv_1;
let _e177 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e176);
texel_4 = _e177;
let _e178 = texel_4;
let _e181 = texel_4[3u];
return ((_e178.xyz * _e181) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e177 = frag_info.target_origin[1u];
return _e177;
}
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 _e177 = v_texcoord_1;
let _e178 = MaterialLodBias_u0028_();
let _e179 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e177, _e178);
orm = _e179.xyz;
let _e182 = (*s_5).metallic;
let _e184 = orm[2u];
(*s_5).metallic = clamp((_e182 * _e184), 0f, 1f);
let _e189 = (*s_5).roughness;
let _e191 = orm[1u];
(*s_5).roughness = clamp((_e189 * _e191), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e176 = (*srgb);
let _e179 = (*srgb);
let _e184 = (*srgb);
return mix((_e176 / vec3(12.92f)), pow(((_e179 + 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), _e184));
}
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_108: vec3<f32>;
let _e178 = v_texcoord_1;
let _e179 = MaterialLodBias_u0028_();
let _e180 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e178, _e179);
param_108 = _e180.xyz;
let _e182 = SrgbToLinear_u0028_vf3_u003b((¶m_108));
emissive = _e182;
let _e183 = emissive;
let _e185 = frag_info.emissive;
let _e190 = frag_info.material2_[3u];
(*s_6).emissive = ((_e183 * _e185.xyz) * _e190);
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 _e177 = v_texcoord_1;
let _e178 = MaterialLodBias_u0028_();
let _e179 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e177, _e178);
occlusion = _e179.x;
let _e181 = occlusion;
let _e184 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e181, clamp(_e184, 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_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e180 = v_texcoord_1;
let _e181 = MaterialLodBias_u0028_();
let _e182 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e180, _e181);
sampledTexel = _e182;
let _e183 = v_tangent_1;
t_2 = _e183.xyz;
let _e185 = t_2;
let _e187 = (*s_8).n;
let _e189 = (*s_8).n;
let _e190 = t_2;
t_2 = (_e185 - (_e187 * dot(_e189, _e190)));
let _e194 = t_2;
let _e195 = t_2;
if (dot(_e194, _e195) < 0.000000000001f) {
return;
}
let _e198 = t_2;
t_2 = normalize(_e198);
let _e201 = (*s_8).n;
let _e202 = t_2;
let _e205 = v_tangent_1[3u];
b_3 = (cross(_e201, _e202) * _e205);
let _e207 = gl_FrontFacing_1;
if !(_e207) {
let _e209 = t_2;
t_2 = -(_e209);
}
let _e211 = sampledTexel;
sampled = ((_e211.xyz * 2f) - vec3(1f));
let _e218 = frag_info.emissive[3u];
if (_e218 > 0.5f) {
let _e220 = sampled;
let _e222 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e220.xy, _e222.xy)), 0f));
}
let _e231 = frag_info.material2_[1u];
let _e232 = sampled;
let _e234 = (_e232.xy * _e231);
sampled[0u] = _e234.x;
sampled[1u] = _e234.y;
let _e239 = t_2;
let _e241 = sampled[0u];
let _e243 = b_3;
let _e245 = sampled[1u];
let _e249 = (*s_8).n;
let _e251 = sampled[2u];
(*s_8).n = normalize((((_e239 * _e241) + (_e243 * _e245)) + (_e249 * _e251)));
let _e257 = (*s_8).n;
let _e259 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e257, _e259), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e176 = (*texel_5);
let _e180 = irradiance_info.atlas;
let _e183 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e176 + vec2(0.5f)) * _e180.xy), 0f);
return _e183;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
var at_1: vec2<f32>;
var low: vec2<f32>;
var f: vec2<f32>;
var a_4: vec4<f32>;
var param_109: vec2<f32>;
var b_4: vec4<f32>;
var param_110: vec2<f32>;
var c: vec4<f32>;
var param_111: vec2<f32>;
var d_4: vec4<f32>;
var param_112: vec2<f32>;
let _e189 = (*uv_5);
let _e190 = (*interior);
at_1 = ((vec2(1f) + (_e189 * _e190)) - vec2(0.5f));
let _e196 = at_1;
low = floor(_e196);
let _e198 = at_1;
let _e199 = low;
f = (_e198 - _e199);
let _e201 = (*corner);
let _e202 = low;
param_109 = (_e201 + _e202);
let _e204 = AtlasTexel_u0028_vf2_u003b((¶m_109));
a_4 = _e204;
let _e205 = (*corner);
let _e206 = low;
param_110 = ((_e205 + _e206) + vec2<f32>(1f, 0f));
let _e209 = AtlasTexel_u0028_vf2_u003b((¶m_110));
b_4 = _e209;
let _e210 = (*corner);
let _e211 = low;
param_111 = ((_e210 + _e211) + vec2<f32>(0f, 1f));
let _e214 = AtlasTexel_u0028_vf2_u003b((¶m_111));
c = _e214;
let _e215 = (*corner);
let _e216 = low;
param_112 = ((_e215 + _e216) + vec2<f32>(1f, 1f));
let _e219 = AtlasTexel_u0028_vf2_u003b((¶m_112));
d_4 = _e219;
let _e220 = a_4;
let _e221 = b_4;
let _e223 = f[0u];
let _e226 = c;
let _e227 = d_4;
let _e229 = f[0u];
let _e233 = f[1u];
return mix(mix(_e220, _e221, vec4(_e223)), mix(_e226, _e227, vec4(_e229)), vec4(_e233));
}
fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var sum_1: f32;
var n_5: vec3<f32>;
var xy: vec2<f32>;
let _e180 = (*direction_1)[0u];
let _e183 = (*direction_1)[1u];
let _e187 = (*direction_1)[2u];
sum_1 = ((abs(_e180) + abs(_e183)) + abs(_e187));
let _e190 = sum_1;
if (_e190 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e192 = (*direction_1);
let _e193 = sum_1;
n_5 = (_e192 / vec3(_e193));
let _e196 = n_5;
xy = _e196.xy;
let _e199 = n_5[2u];
if (_e199 < 0f) {
let _e202 = n_5[1u];
let _e206 = n_5[0u];
let _e211 = n_5[0u];
let _e215 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e202)) * select(-1f, 1f, (_e206 >= 0f))), ((1f - abs(_e211)) * select(-1f, 1f, (_e215 >= 0f))));
}
let _e220 = xy;
return ((_e220 * 0.5f) + vec2(0.5f));
}
fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var spacing: vec3<f32>;
var counts: vec3<f32>;
var irradianceTile: f32;
var depthTile: f32;
var columns: f32;
var momentsTop: f32;
var unit: vec3<f32>;
var biased: vec3<f32>;
var grid_1: vec3<f32>;
var base: vec3<f32>;
var f_1: vec3<f32>;
var total_2: vec3<f32>;
var weights: f32;
var corner_1: i32;
var offset_3: vec3<f32>;
var cell_1: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_113: vec2<f32>;
var trilinear: vec3<f32>;
var weight_2: f32;
var probePosition: vec3<f32>;
var toProbe: vec3<f32>;
var distance_4: f32;
var direction_2: vec3<f32>;
var facing: f32;
var probeWeight: f32;
var moments_3: vec2<f32>;
var param_114: vec3<f32>;
var param_115: vec2<f32>;
var param_116: f32;
var param_117: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_118: vec3<f32>;
var param_119: vec2<f32>;
var param_120: f32;
var param_121: vec2<f32>;
var local_23: vec3<f32>;
let _e222 = irradiance_info.origin;
origin_2 = _e222.xyz;
let _e225 = irradiance_info.spacing;
spacing = _e225.xyz;
let _e228 = irradiance_info.counts;
counts = _e228.xyz;
let _e232 = irradiance_info.tiles[0u];
irradianceTile = _e232;
let _e235 = irradiance_info.tiles[1u];
depthTile = _e235;
let _e238 = irradiance_info.tiles[2u];
columns = _e238;
let _e241 = irradiance_info.tiles[3u];
momentsTop = _e241;
let _e242 = (*normal_1);
unit = normalize(_e242);
let _e244 = (*world_4);
let _e245 = unit;
let _e248 = irradiance_info.spacing[3u];
let _e251 = (*view);
let _e254 = irradiance_info.counts[3u];
biased = ((_e244 + (_e245 * _e248)) + (_e251 * _e254));
let _e257 = biased;
let _e258 = origin_2;
let _e260 = spacing;
grid_1 = ((_e257 - _e258) / _e260);
let _e262 = grid_1;
let _e264 = counts;
base = clamp(floor(_e262), vec3<f32>(0f, 0f, 0f), (_e264 - vec3(2f)));
let _e268 = grid_1;
let _e269 = base;
f_1 = clamp((_e268 - _e269), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e272 = corner_1;
if (_e272 < 8i) {
let _e274 = corner_1;
let _e277 = corner_1;
let _e282 = corner_1;
offset_3 = vec3<f32>(f32((_e274 & 1i)), f32(((_e277 >> bitcast<u32>(1i)) & 1i)), f32(((_e282 >> bitcast<u32>(2i)) & 1i)));
let _e288 = base;
let _e289 = offset_3;
cell_1 = (_e288 + _e289);
let _e292 = cell_1[2u];
let _e294 = counts[1u];
let _e297 = cell_1[1u];
let _e300 = counts[0u];
let _e303 = cell_1[0u];
probe = ((((_e292 * _e294) + _e297) * _e300) + _e303);
let _e305 = probe;
let _e306 = columns;
let _e311 = probe;
let _e312 = columns;
tile_4 = vec2<f32>((_e305 - (floor((_e305 / _e306)) * _e306)), floor((_e311 / _e312)));
let _e316 = tile_4;
let _e317 = irradianceTile;
irradianceCorner = (_e316 * (_e317 + 2f));
let _e321 = tile_4[0u];
let _e322 = depthTile;
let _e325 = momentsTop;
let _e327 = tile_4[1u];
let _e328 = depthTile;
momentCorner = vec2<f32>((_e321 * (_e322 + 2f)), (_e325 + (_e327 * (_e328 + 2f))));
let _e333 = irradianceCorner;
param_113 = (_e333 + vec2(1f));
let _e336 = AtlasTexel_u0028_vf2_u003b((¶m_113));
if (_e336.w < 0.5f) {
continue;
}
let _e339 = f_1;
let _e341 = f_1;
let _e342 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e339), _e341, _e342);
let _e345 = trilinear[0u];
let _e347 = trilinear[1u];
let _e350 = trilinear[2u];
weight_2 = max(((_e345 * _e347) * _e350), 0.001f);
let _e353 = origin_2;
let _e354 = spacing;
let _e355 = cell_1;
probePosition = (_e353 + (_e354 * _e355));
let _e358 = probePosition;
let _e359 = biased;
toProbe = (_e358 - _e359);
let _e361 = toProbe;
distance_4 = length(_e361);
let _e363 = distance_4;
if (_e363 > 0.000001f) {
let _e365 = toProbe;
let _e366 = distance_4;
direction_2 = (_e365 / vec3(_e366));
let _e369 = unit;
let _e370 = probePosition;
let _e371 = (*world_4);
facing = ((dot(_e369, normalize((_e370 - _e371))) * 0.5f) + 0.5f);
let _e377 = facing;
let _e378 = facing;
probeWeight = ((_e377 * _e378) + 0.2f);
let _e381 = direction_2;
param_114 = -(_e381);
let _e383 = ProbeOctahedral_u0028_vf3_u003b((¶m_114));
let _e384 = momentCorner;
param_115 = _e384;
let _e385 = depthTile;
param_116 = _e385;
param_117 = _e383;
let _e386 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_115), (¶m_116), (¶m_117));
moments_3 = _e386.xy;
chebyshev = 1f;
let _e388 = distance_4;
let _e390 = moments_3[0u];
if (_e388 > _e390) {
let _e393 = moments_3[1u];
let _e395 = moments_3[0u];
let _e397 = moments_3[0u];
variance_1 = max((_e393 - (_e395 * _e397)), 0.000001f);
let _e401 = distance_4;
let _e403 = moments_3[0u];
difference = (_e401 - _e403);
let _e405 = variance_1;
let _e406 = variance_1;
let _e407 = difference;
let _e408 = difference;
chebyshev = (_e405 / (_e406 + (_e407 * _e408)));
let _e412 = chebyshev;
let _e413 = chebyshev;
let _e415 = chebyshev;
chebyshev = ((_e412 * _e413) * _e415);
}
let _e417 = probeWeight;
let _e418 = chebyshev;
probeWeight = max((_e417 * max(_e418, 0.05f)), 0.000001f);
let _e422 = probeWeight;
if (_e422 < 0.2f) {
let _e424 = probeWeight;
let _e425 = probeWeight;
let _e428 = probeWeight;
probeWeight = (_e428 * ((_e424 * _e425) * 25f));
}
let _e430 = probeWeight;
let _e431 = weight_2;
weight_2 = (_e431 * _e430);
}
let _e433 = unit;
param_118 = _e433;
let _e434 = ProbeOctahedral_u0028_vf3_u003b((¶m_118));
let _e435 = irradianceCorner;
param_119 = _e435;
let _e436 = irradianceTile;
param_120 = _e436;
param_121 = _e434;
let _e437 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_119), (¶m_120), (¶m_121));
let _e439 = weight_2;
let _e441 = total_2;
total_2 = (_e441 + (_e437.xyz * _e439));
let _e443 = weight_2;
let _e444 = weights;
weights = (_e444 + _e443);
continue;
} else {
break;
}
continuing {
let _e446 = corner_1;
corner_1 = (_e446 + 1i);
}
}
let _e448 = weights;
if (_e448 > 0f) {
let _e450 = total_2;
let _e451 = weights;
local_23 = (_e450 / vec3(_e451));
} else {
local_23 = vec3<f32>(0f, 0f, 0f);
}
let _e454 = local_23;
return _e454;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e177 = irradiance_info.origin[3u];
return (_e177 > 0.5f);
}
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_122: vec3<f32>;
var param_123: vec3<f32>;
var param_124: vec3<f32>;
var param_125: Surface;
var param_126: Surface;
var param_127: Surface;
let _e182 = IrradianceEnabled_u0028_();
if _e182 {
let _e183 = v_world_position_1;
param_122 = _e183;
let _e185 = (*s_9).n;
param_123 = _e185;
let _e187 = (*s_9).v;
param_124 = _e187;
let _e188 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_122), (¶m_123), (¶m_124));
let _e191 = frag_info.material[2u];
(*s_9).ambient = (_e188 * _e191);
}
let _e194 = (*s_9);
param_125 = _e194;
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_125));
let _e195 = param_125;
(*s_9) = _e195;
let _e196 = (*s_9);
param_126 = _e196;
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_126));
let _e197 = param_126;
(*s_9) = _e197;
let _e198 = (*s_9);
param_127 = _e198;
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_127));
let _e199 = param_127;
(*s_9) = _e199;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_10: Surface;
var param_128: vec3<f32>;
var param_129: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e182 = v_texcoord_1;
let _e183 = MaterialLodBias_u0028_();
let _e184 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e182, _e183);
texel_6 = _e184;
let _e185 = texel_6;
param_128 = _e185.xyz;
let _e187 = SrgbToLinear_u0028_vf3_u003b((¶m_128));
let _e189 = frag_info.base_color;
param_129 = _e189.xyz;
let _e191 = SrgbToLinear_u0028_vf3_u003b((¶m_129));
let _e193 = v_color_1;
s_10.albedo = ((_e187 * _e191) * _e193.xyz);
let _e198 = texel_6[3u];
let _e201 = frag_info.base_color[3u];
let _e204 = v_color_1[3u];
s_10.alpha = ((_e198 * _e201) * _e204);
let _e208 = s_10.albedo;
g_albedo = _e208;
let _e211 = frag_info.material2_[0u];
cutoff = _e211;
let _e212 = cutoff;
if (_e212 >= 0f) {
let _e215 = s_10.alpha;
let _e216 = cutoff;
if (_e215 < _e216) {
discard;
}
} else {
let _e218 = cutoff;
if (_e218 < -1.5f) {
let _e220 = v_world_position_1;
anchored = floor((_e220 * 16f));
let _e223 = anchored;
noise_1 = fract((sin(dot(_e223, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e229 = s_10.alpha;
let _e230 = noise_1;
if (_e229 < _e230) {
discard;
}
}
}
let _e232 = cutoff;
let _e234 = cutoff;
g_premultiply = ((_e232 < 0f) && (_e234 > -0.75f));
let _e237 = v_normal_1;
s_10.n = normalize(_e237);
let _e240 = gl_FrontFacing_1;
if !(_e240) {
let _e243 = s_10.n;
s_10.n = -(_e243);
}
let _e247 = frag_info.camera_position;
let _e249 = v_world_position_1;
s_10.v = normalize((_e247.xyz - _e249));
let _e254 = s_10.n;
let _e256 = s_10.v;
s_10.n_dot_v = max(dot(_e254, _e256), 0.0001f);
let _e262 = frag_info.material[0u];
s_10.metallic = clamp(_e262, 0f, 1f);
let _e267 = frag_info.material[1u];
s_10.roughness = clamp(_e267, 0.02f, 1f);
let _e271 = frag_info.ambient_ground;
let _e274 = frag_info.ambient_sky;
let _e278 = s_10.n[1u];
let _e285 = frag_info.material[2u];
s_10.ambient = (mix(_e271.xyz, _e274.xyz, vec3(((_e278 * 0.5f) + 0.5f))) * _e285);
let _e290 = frag_info.frame_params[0u];
s_10.exposure = max(_e290, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e295 = s_10;
return _e295;
}
fn main_1() {
var s_11: Surface;
var param_130: Surface;
var param_131: Surface;
var ambient: vec3<f32>;
var param_132: Surface;
var param_133: vec3<f32>;
var param_134: f32;
var param_135: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e183 = ReadSurface_u0028_();
s_11 = _e183;
let _e184 = s_11;
param_130 = _e184;
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_130));
let _e185 = param_130;
s_11 = _e185;
let _e186 = s_11;
param_131 = _e186;
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_131));
let _e187 = param_131;
s_11 = _e187;
let _e189 = s_11.albedo;
let _e191 = s_11.ambient;
let _e192 = SampleLightmap_u0028_();
let _e196 = s_11.occlusion;
ambient = ((_e189 * (_e191 + _e192)) * _e196);
let _e198 = s_11;
param_132 = _e198;
let _e199 = 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_132));
let _e201 = s_11.occlusion;
let _e203 = ambient;
let _e206 = s_11.emissive;
param_133 = (((_e199 * _e201) + _e203) + _e206);
let _e209 = s_11.alpha;
param_134 = _e209;
let _e211 = s_11.roughness;
param_135 = _e211;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_133), (¶m_134), (¶m_135));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: 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;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'IrradianceInfo',
group: 1,
binding: 2,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'spacing',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'counts',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 3,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 4,
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: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'irradiance_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 23,
samplerBinding: 24,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 25,
samplerBinding: 26,
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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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 IrradianceInfo {
origin: vec4<f32>,
spacing: vec4<f32>,
counts: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(13)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(17)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var ltc_texture_smp: sampler;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(27)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(28)
var point_shadow_texture_smp: sampler;
@group(1) @binding(25)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(11)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var irradiance_texture_smp: sampler;
@group(1) @binding(15)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(23)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(21)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(29)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(30)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(10)
var environment_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e194 = v_world_position_1;
let _e196 = fog_info.eye;
let _e200 = fog_info.forward;
return dot((_e194 - _e196.xyz), _e200.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e199 = ViewDepth_u0028_();
z = abs(_e199);
let _e201 = z;
near = (_e201 / 5f);
let _e203 = z;
far = (_e203 / 200f);
let _e205 = far;
let _e206 = far;
let _e208 = far;
far3_ = ((_e205 * _e206) * _e208);
let _e210 = (*alpha);
let _e211 = near;
let _e212 = near;
let _e215 = far3_;
let _e216 = far3_;
return (_e210 * clamp((10f / ((0.00001f + (_e211 * _e212)) + (_e215 * _e216))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e203 = fog_info.forward[3u];
mode = _e203;
let _e204 = mode;
if (_e204 > 0.5f) {
let _e207 = frag_color[3u];
alpha_1 = _e207;
let _e208 = alpha_1;
param = _e208;
let _e209 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e209;
let _e210 = frag_color;
let _e212 = weight;
let _e213 = (_e210.xyz * _e212);
let _e214 = alpha_1;
let _e215 = weight;
accumulate = vec4<f32>(_e213.x, _e213.y, _e213.z, (_e214 * _e215));
let _e221 = mode;
let _e223 = mode;
revealage = ((_e221 > 1.5f) && (_e223 < 2.5f));
let _e226 = revealage;
if _e226 {
let _e227 = alpha_1;
local = vec4(_e227);
} else {
let _e229 = accumulate;
local = _e229;
}
let _e230 = local;
frag_color = _e230;
let _e231 = mode;
if (_e231 > 2.5f) {
let _e233 = alpha_1;
frag_surface = vec4(_e233);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e197 = (*n)[0u];
let _e200 = (*n)[1u];
let _e204 = (*n)[2u];
let _e207 = (*n);
(*n) = (_e207 / vec3(((abs(_e197) + abs(_e200)) + abs(_e204))));
let _e210 = (*n);
e = _e210.xy;
let _e213 = (*n)[2u];
if (_e213 < 0f) {
let _e215 = (*n);
let _e221 = (*n)[0u];
let _e225 = (*n)[1u];
e = ((vec2(1f) - abs(_e215.yx)) * vec2<f32>(select(-1f, 1f, (_e221 >= 0f)), select(-1f, 1f, (_e225 >= 0f))));
}
let _e230 = e;
return ((_e230 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e195 = (*linear);
let _e197 = (*linear);
let _e201 = (*linear);
return mix((_e195 * 12.92f), ((pow(_e197, 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), _e201));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e198 = g_albedo;
param_1 = clamp(_e198, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e200 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e200.x, _e200.y, _e200.z, 1f);
let _e205 = g_debug_surface_on;
if _e205 {
let _e206 = g_debug_surface;
let _e207 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e206.x, _e206.y, _e206.z, _e207);
return;
}
let _e212 = v_normal_1;
geometric = normalize(_e212);
let _e214 = gl_FrontFacing_1;
if !(_e214) {
let _e216 = geometric;
geometric = -(_e216);
}
let _e218 = geometric;
param_2 = _e218;
let _e219 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e220 = (*roughness);
let _e222 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e219.x, _e219.y, clamp(_e220, 0f, 1f), _e222);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e194 = v_world_position_1;
let _e196 = fog_info.eye;
return distance(_e194, _e196.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e199 = fog_info.fog[3u];
density = _e199;
let _e200 = density;
if (_e200 <= 0f) {
let _e202 = (*color);
return _e202;
}
let _e203 = EyeDistance_u0028_();
d = _e203;
let _e205 = fog_info.fog;
let _e207 = (*color);
let _e208 = density;
let _e210 = d;
return mix(_e205.xyz, _e207, vec3(clamp(exp((-(_e208) * _e210)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e200 = g_premultiply;
let _e201 = (*alpha_2);
weight_1 = select(1f, _e201, _e200);
let _e203 = (*linearColor);
param_3 = _e203;
let _e204 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e205 = weight_1;
let _e206 = (_e204 * _e205);
let _e207 = (*alpha_2);
frag_color = vec4<f32>(_e206.x, _e206.y, _e206.z, _e207);
let _e212 = (*roughness_1);
param_4 = _e212;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m: f32;
var g: f32;
let _e198 = (*mu);
m = (1f - _e198);
let _e200 = m;
let _e201 = m;
let _e202 = m;
let _e203 = m;
g = (_e200 * (0.05710853f + (_e201 * (0.49188188f + (_e202 * (-0.33218145f + (_e203 * 0.071443f)))))));
let _e211 = (*r);
let _e212 = g;
let _e215 = (*r);
return ((1f + (_e211 * _e212)) / (1f + (0.2877934f * _e215)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e196 = (*rho);
let _e197 = (*rho);
let _e199 = (*average);
let _e201 = (*rho);
let _e202 = (*average);
return (((_e196 * _e197) * _e199) / (vec3<f32>(1f, 1f, 1f) - (_e201 * (1f - _e202))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e195 = (*r_1);
let _e198 = (*r_1);
return ((1f + (0.07248821f * _e195)) / (1f + (0.2877934f * _e198)));
}
fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
var s: f32;
var s_over_t: f32;
var local_1: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_5: f32;
var multi: vec3<f32>;
var param_6: vec3<f32>;
var param_7: f32;
var param_8: f32;
var param_9: f32;
var param_10: f32;
var param_11: f32;
let _e213 = (*l_dot_v);
let _e214 = (*mu_i);
let _e215 = (*mu_o);
s = (_e213 - (_e214 * _e215));
let _e218 = s;
if (_e218 > 0f) {
let _e220 = s;
let _e221 = (*mu_i);
let _e222 = (*mu_o);
local_1 = (_e220 / max(_e221, _e222));
} else {
let _e225 = s;
local_1 = _e225;
}
let _e226 = local_1;
s_over_t = _e226;
let _e227 = (*r_2);
af = (1f / (1f + (0.2877934f * _e227)));
let _e231 = (*rho_1);
let _e232 = af;
let _e233 = (*r_2);
let _e234 = s_over_t;
single = (_e231 * (_e232 * (1f + (_e233 * _e234))));
let _e239 = (*r_2);
param_5 = _e239;
let _e240 = FonAverage_u0028_f1_u003b((¶m_5));
average_1 = _e240;
let _e241 = (*rho_1);
param_6 = _e241;
let _e242 = average_1;
param_7 = _e242;
let _e243 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_6), (¶m_7));
let _e244 = (*mu_o);
param_8 = _e244;
let _e245 = (*r_2);
param_9 = _e245;
let _e246 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_8), (¶m_9));
let _e249 = (*mu_i);
param_10 = _e249;
let _e250 = (*r_2);
param_11 = _e250;
let _e251 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_10), (¶m_11));
let _e255 = average_1;
multi = (_e243 * ((max((1f - _e246), 0.0000001f) * max((1f - _e251), 0.0000001f)) / max((1f - _e255), 0.0000001f)));
let _e260 = single;
let _e261 = multi;
return ((_e260 + _e261) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e196 = frag_info.ambient_sky[3u];
return (_e196 > 0.5f);
}
fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
var inTable: vec2<f32>;
let _e198 = (*x);
let _e199 = (*y);
inTable = ((vec2<f32>(_e198, _e199) * 0.984375f) + vec2(0.0078125f));
let _e205 = inTable[0u];
let _e207 = inTable[1u];
let _e208 = (*table);
return vec2<f32>(_e205, ((_e207 + _e208) * 0.5f));
}
fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
var dfg: vec2<f32>;
var param_12: f32;
var param_13: f32;
var param_14: f32;
let _e200 = (*roughness_2);
let _e202 = (*n_dot_v);
param_12 = clamp(_e200, 0f, 1f);
param_13 = sqrt(clamp((1f - _e202), 0f, 1f));
param_14 = 1f;
let _e206 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14));
let _e207 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e206, 0f);
dfg = _e207.xy;
let _e210 = dfg[0u];
let _e212 = dfg[1u];
let _e215 = dfg[1u];
return vec2<f32>((_e210 - _e212), _e215);
}
fn MultiscatterScale_u0028_vf3_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(f0_: ptr<function, vec3<f32>>, s_1: ptr<function, Surface>) -> vec3<f32> {
var ab: vec2<f32>;
var param_15: f32;
var param_16: f32;
var ess: f32;
let _e201 = (*s_1).roughness;
param_15 = max(_e201, 0.045f);
let _e204 = (*s_1).n_dot_v;
param_16 = _e204;
let _e205 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_15), (¶m_16));
ab = _e205;
let _e207 = ab[0u];
let _e209 = ab[1u];
ess = max((_e207 + _e209), 0.0001f);
let _e212 = (*f0_);
let _e213 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e212 * ((1f / _e213) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e196 = frag_info.target_origin[2u];
return (_e196 > 0.5f);
}
fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
var f: f32;
let _e197 = (*v_dot_h);
f = pow((1f - _e197), 5f);
let _e200 = (*f0_1);
let _e201 = (*f0_1);
let _e203 = f;
return (_e200 + ((vec3<f32>(1f, 1f, 1f) - _e201) * _e203));
}
fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
var a2_: f32;
var lambda_v: f32;
var lambda_l: f32;
let _e200 = (*alpha_3);
let _e201 = (*alpha_3);
a2_ = (_e200 * _e201);
let _e203 = (*n_dot_l);
let _e204 = (*n_dot_v_1);
let _e205 = (*n_dot_v_1);
let _e207 = a2_;
let _e210 = a2_;
lambda_v = (_e203 * sqrt((((_e204 * _e205) * (1f - _e207)) + _e210)));
let _e214 = (*n_dot_v_1);
let _e215 = (*n_dot_l);
let _e216 = (*n_dot_l);
let _e218 = a2_;
let _e221 = a2_;
lambda_l = (_e214 * sqrt((((_e215 * _e216) * (1f - _e218)) + _e221)));
let _e225 = lambda_v;
let _e226 = lambda_l;
return (0.5f / max((_e225 + _e226), 0.00001f));
}
fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
var a: f32;
var k: f32;
let _e198 = (*n_dot_h);
let _e199 = (*alpha_4);
a = (_e198 * _e199);
let _e201 = (*alpha_4);
let _e202 = (*n_dot_h);
let _e203 = (*n_dot_h);
let _e206 = a;
let _e207 = a;
k = (_e201 / max(((1f - (_e202 * _e203)) + (_e206 * _e207)), 0.0000001f));
let _e212 = k;
let _e213 = k;
return ((_e212 * _e213) * 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_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var lobe: f32;
var alpha_5: f32;
var f0_2: vec3<f32>;
var diffuseColor: vec3<f32>;
var d_1: f32;
var param_17: f32;
var param_18: f32;
var vis: f32;
var param_19: f32;
var param_20: f32;
var param_21: f32;
var f_1: vec3<f32>;
var param_22: vec3<f32>;
var param_23: f32;
var specular: vec3<f32>;
var param_24: vec3<f32>;
var param_25: Surface;
var diffuse: vec3<f32>;
var param_26: vec3<f32>;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
let _e220 = (*s_2).roughness;
lobe = max(_e220, 0.045f);
let _e222 = lobe;
let _e223 = lobe;
alpha_5 = (_e222 * _e223);
let _e226 = (*s_2).albedo;
let _e228 = (*s_2).metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e226, vec3(_e228));
let _e232 = (*s_2).albedo;
let _e234 = (*s_2).metallic;
diffuseColor = (_e232 * (1f - _e234));
let _e238 = (*light).n_dot_h;
param_17 = _e238;
let _e239 = alpha_5;
param_18 = _e239;
let _e240 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_17), (¶m_18));
d_1 = _e240;
let _e242 = (*s_2).n_dot_v;
param_19 = _e242;
let _e244 = (*light).n_dot_l;
param_20 = _e244;
let _e245 = alpha_5;
param_21 = _e245;
let _e246 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21));
vis = _e246;
let _e247 = f0_2;
param_22 = _e247;
let _e249 = (*light).v_dot_h;
param_23 = _e249;
let _e250 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_22), (¶m_23));
f_1 = _e250;
let _e251 = d_1;
let _e252 = vis;
let _e254 = f_1;
let _e258 = frag_info.material[3u];
specular = ((_e254 * (_e251 * _e252)) * _e258);
let _e261 = (*light).integrated;
if (_e261 > 0.5f) {
let _e265 = (*light).ltc[0u];
let _e266 = f0_2;
let _e269 = (*light).ltc[1u];
let _e271 = f0_2;
let _e276 = (*light).ltc[2u];
let _e282 = frag_info.material[3u];
let _e285 = (*light).n_dot_l;
specular = (((((_e266 * _e269) + ((vec3(1f) - _e271) * _e276)) * _e265) * _e282) / vec3(max(_e285, 0.000001f)));
}
let _e289 = EnergyCompensation_u0028_();
if _e289 {
let _e290 = f0_2;
param_24 = _e290;
let _e291 = (*s_2);
param_25 = _e291;
let _e292 = MultiscatterScale_u0028_vf3_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_24), (¶m_25));
let _e293 = specular;
specular = (_e293 * _e292);
}
let _e295 = diffuseColor;
let _e296 = f_1;
diffuse = ((_e295 * (vec3<f32>(1f, 1f, 1f) - _e296)) / vec3(3.1415927f));
let _e301 = EonDiffuse_u0028_();
if _e301 {
let _e303 = (*s_2).n;
let _e305 = (*light).l;
let _e309 = (*light).l;
let _e311 = (*s_2).v;
let _e313 = diffuseColor;
param_26 = _e313;
let _e315 = (*s_2).roughness;
param_27 = _e315;
param_28 = clamp(dot(_e303, _e305), 0.0001f, 1f);
let _e317 = (*s_2).n_dot_v;
param_29 = _e317;
param_30 = dot(_e309, _e311);
let _e318 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30));
let _e319 = f_1;
diffuse = (_e318 * (vec3<f32>(1f, 1f, 1f) - _e319));
}
let _e322 = diffuse;
let _e323 = specular;
return ((_e322 + _e323) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e195 = (*i);
if (_e195 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e197 = (*i);
if (_e197 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e199 = (*i);
if (_e199 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e201 = (*i);
if (_e201 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e203 = (*i);
if (_e203 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e205 = (*i);
if (_e205 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e207 = (*i);
if (_e207 == 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_31: i32;
let _e200 = (*i_1);
param_31 = _e200;
let _e201 = PointShadowDiskTap_u0028_i1_u003b((¶m_31));
p = _e201;
let _e203 = p[0u];
let _e204 = (*ca);
let _e207 = p[1u];
let _e208 = (*sa);
let _e212 = p[0u];
let _e213 = (*sa);
let _e216 = p[1u];
let _e217 = (*ca);
let _e221 = (*radius);
return (vec2<f32>(((_e203 * _e204) - (_e207 * _e208)), ((_e212 * _e213) + (_e216 * _e217))) * _e221);
}
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_2: vec2<f32>;
var atlas: vec2<f32>;
let _e203 = point_shadow.params[0u];
inset = _e203;
let _e204 = (*uv);
let _e205 = (*offset);
let _e207 = inset;
let _e208 = inset;
local_2 = clamp((_e204 + _e205), vec2(_e207), vec2((1f - _e208)));
let _e213 = local_2;
let _e214 = (*tile);
atlas = ((_e213 + _e214) * vec2<f32>(0.16666667f, 0.16666667f));
let _e219 = point_shadow.params3_[0u];
if (_e219 > 0.5f) {
let _e222 = atlas[1u];
atlas[1u] = (1f - _e222);
}
let _e225 = atlas;
let _e226 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e225, 0f);
let _e228 = atlas;
let _e229 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e228, 0f);
let _e232 = (*range);
return (min(_e226.x, _e229.x) * _e232);
}
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_32: vec2<f32>;
var param_33: vec2<f32>;
var param_34: vec2<f32>;
var param_35: f32;
let _e204 = (*uv_1);
param_32 = _e204;
let _e205 = (*offset_1);
param_33 = _e205;
let _e206 = (*tile_1);
param_34 = _e206;
let _e207 = (*range_1);
param_35 = _e207;
let _e208 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35));
stored = _e208;
let _e209 = stored;
let _e210 = (*range_1);
if (_e209 >= (_e210 * 0.999f)) {
return 1f;
}
let _e213 = (*receiver);
let _e214 = stored;
return select(1f, 0f, (_e213 > _e214));
}
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_36: vec2<f32>;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
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 blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e225 = point_shadow.params2_[1u];
lightRadius = _e225;
let _e228 = point_shadow.params2_[0u];
minRadius = _e228;
let _e231 = point_shadow.params2_[2u];
maxRadius = _e231;
let _e232 = lightRadius;
if (_e232 <= 0f) {
let _e234 = (*uv_2);
param_36 = _e234;
param_37 = vec2<f32>(0f, 0f);
let _e235 = (*tile_2);
param_38 = _e235;
let _e236 = (*range_2);
param_39 = _e236;
let _e237 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_36), (¶m_37), (¶m_38), (¶m_39));
(*blockerOut) = _e237;
let _e238 = minRadius;
return _e238;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e239 = i_2;
if (_e239 < 8i) {
let _e241 = i_2;
param_40 = _e241;
let _e242 = (*ca_1);
param_41 = _e242;
let _e243 = (*sa_1);
param_42 = _e243;
let _e244 = maxRadius;
param_43 = _e244;
let _e245 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43));
let _e246 = (*uv_2);
param_44 = _e246;
param_45 = _e245;
let _e247 = (*tile_2);
param_46 = _e247;
let _e248 = (*range_2);
param_47 = _e248;
let _e249 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_44), (¶m_45), (¶m_46), (¶m_47));
stored_1 = _e249;
let _e250 = stored_1;
let _e251 = (*range_2);
if (_e250 >= (_e251 * 0.999f)) {
continue;
}
let _e254 = stored_1;
let _e255 = (*receiver_1);
if (_e254 >= _e255) {
continue;
}
let _e257 = stored_1;
let _e258 = sum;
sum = (_e258 + _e257);
let _e260 = count;
count = (_e260 + 1f);
continue;
} else {
break;
}
continuing {
let _e262 = i_2;
i_2 = (_e262 + 1i);
}
}
let _e264 = count;
if (_e264 < 0.5f) {
return -1f;
}
let _e266 = sum;
let _e267 = count;
blocker = max((_e266 / _e267), 0.0001f);
let _e270 = blocker;
(*blockerOut) = _e270;
let _e271 = lightRadius;
let _e272 = (*receiver_1);
let _e273 = blocker;
let _e277 = blocker;
world = ((_e271 * max((_e272 - _e273), 0f)) / _e277);
let _e279 = world;
let _e280 = (*receiver_1);
let _e282 = (*tanHalf);
let _e285 = minRadius;
let _e286 = maxRadius;
return clamp((_e279 / ((2f * _e280) * _e282)), _e285, _e286);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_3: vec2<f32>;
let _e196 = (*rows);
if (_e196 > 0f) {
let _e199 = gl_FragCoord_1[0u];
let _e200 = (*rows);
let _e202 = gl_FragCoord_1[1u];
local_3 = vec2<f32>(_e199, (_e200 - _e202));
} else {
let _e205 = gl_FragCoord_1;
local_3 = _e205.xy;
}
let _e207 = local_3;
return _e207;
}
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 param_48: 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_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: f32;
var param_52: f32;
var param_53: f32;
var param_54: f32;
var param_55: f32;
var param_56: f32;
var local_4: vec3<f32>;
var lit: f32;
var param_57: vec2<f32>;
var param_58: vec2<f32>;
var param_59: vec2<f32>;
var param_60: f32;
var param_61: f32;
var i_3: i32;
var param_62: i32;
var param_63: f32;
var param_64: f32;
var param_65: f32;
var param_66: vec2<f32>;
var param_67: vec2<f32>;
var param_68: vec2<f32>;
var param_69: f32;
var param_70: f32;
var phi_2490_: bool;
var phi_2551_: bool;
let _e248 = (*lightIndex);
let _e252 = point_shadow.slots[_e248][0u];
slot = i32((_e252 + 0.5f));
let _e255 = (*lightIndex);
let _e259 = point_shadow.slots[_e255][0u];
if (_e259 < 0f) {
return 1f;
}
let _e263 = point_shadow.params[2u];
strength = _e263;
let _e264 = strength;
if (_e264 <= 0f) {
return 1f;
}
let _e266 = slot;
let _e269 = point_shadow.lights[_e266];
let _e271 = (*world_1);
toLight = (_e269.xyz - _e271);
let _e273 = toLight;
toLightLength = max(length(_e273), 0.000001f);
let _e276 = (*normal);
let _e277 = toLight;
let _e278 = toLightLength;
nDotL = max(dot(_e276, (_e277 / vec3(_e278))), 0.15f);
let _e283 = nDotL;
let _e284 = nDotL;
let _e289 = nDotL;
let _e290 = nDotL;
slope = min((sqrt(max((1f - (_e283 * _e284)), 0f)) / (_e289 * _e290)), 8f);
let _e294 = toLightLength;
let _e296 = (*lightIndex);
let _e300 = point_shadow.slots[_e296][2u];
let _e305 = point_shadow.params3_[1u];
texel = (((2f * _e294) * max(_e300, 0.0001f)) * _e305);
let _e307 = (*world_1);
let _e308 = (*normal);
let _e309 = texel;
let _e313 = point_shadow.params[3u];
let _e315 = slope;
origin = (_e307 + (((_e308 * _e309) * _e313) * (1f + _e315)));
let _e319 = origin;
let _e320 = slot;
let _e323 = point_shadow.lights[_e320];
toFragment = (_e319 - _e323.xyz);
let _e326 = toFragment;
distance_ = length(_e326);
let _e328 = slot;
let _e332 = point_shadow.lights[_e328][3u];
range_3 = max(_e332, 0.0001f);
let _e334 = distance_;
let _e335 = range_3;
if (_e334 >= _e335) {
return 1f;
}
face = 0i;
let _e337 = (*lightIndex);
let _e341 = point_shadow.slots[_e337][1u];
if (_e341 < 0.5f) {
let _e343 = toFragment;
a_1 = abs(_e343);
let _e346 = a_1[0u];
let _e348 = a_1[1u];
let _e349 = (_e346 >= _e348);
phi_2490_ = _e349;
if _e349 {
let _e351 = a_1[0u];
let _e353 = a_1[2u];
phi_2490_ = (_e351 >= _e353);
}
let _e356 = phi_2490_;
if _e356 {
let _e358 = toFragment[0u];
face = select(1i, 0i, (_e358 > 0f));
} else {
let _e362 = a_1[1u];
let _e364 = a_1[2u];
if (_e362 >= _e364) {
let _e367 = toFragment[1u];
face = select(3i, 2i, (_e367 > 0f));
} else {
let _e371 = toFragment[2u];
face = select(5i, 4i, (_e371 > 0f));
}
}
}
let _e374 = slot;
let _e376 = face;
let _e380 = point_shadow.faces[((_e374 * 6i) + _e376)];
let _e381 = origin;
clip = (_e380 * vec4<f32>(_e381.x, _e381.y, _e381.z, 1f));
let _e388 = clip[3u];
if (_e388 <= 0f) {
return 1f;
}
let _e390 = clip;
let _e393 = clip[3u];
ndc = (_e390.xy / vec2(_e393));
let _e397 = ndc[0u];
let _e399 = (abs(_e397) > 1f);
phi_2551_ = _e399;
if !(_e399) {
let _e402 = ndc[1u];
phi_2551_ = (abs(_e402) > 1f);
}
let _e406 = phi_2551_;
if _e406 {
return 1f;
}
let _e408 = ndc[0u];
let _e412 = ndc[1u];
uv_3 = vec2<f32>(((_e408 * 0.5f) + 0.5f), (0.5f - (_e412 * 0.5f)));
let _e416 = face;
let _e418 = slot;
tile_3 = vec2<f32>(f32(_e416), f32(_e418));
let _e421 = distance_;
let _e424 = point_shadow.params[1u];
receiver_2 = (_e421 - _e424);
let _e428 = frag_info.target_origin[0u];
param_48 = _e428;
let _e429 = FragCoordFromTop_u0028_f1_u003b((¶m_48));
noise = fract((52.982918f * fract(dot(_e429, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e434 = noise;
angle = (_e434 * 6.2831855f);
let _e436 = angle;
ca_2 = cos(_e436);
let _e438 = angle;
sa_2 = sin(_e438);
let _e440 = (*lightIndex);
let _e444 = point_shadow.slots[_e440][2u];
tanHalf_1 = max(_e444, 0.0001f);
blocker_1 = -1f;
let _e446 = uv_3;
param_49 = _e446;
let _e447 = tile_3;
param_50 = _e447;
let _e448 = range_3;
param_51 = _e448;
let _e449 = receiver_2;
param_52 = _e449;
let _e450 = ca_2;
param_53 = _e450;
let _e451 = sa_2;
param_54 = _e451;
let _e452 = tanHalf_1;
param_55 = _e452;
let _e453 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53), (¶m_54), (¶m_55), (¶m_56));
let _e454 = param_56;
blocker_1 = _e454;
radius_1 = _e453;
let _e457 = point_shadow.params2_[3u];
if (_e457 > 0.5f) {
g_debug_surface_on = true;
let _e459 = radius_1;
if (_e459 < 0f) {
local_4 = vec3<f32>(0f, 0f, 1f);
} else {
let _e461 = radius_1;
let _e464 = point_shadow.params2_[2u];
let _e468 = blocker_1;
let _e469 = range_3;
local_4 = vec3<f32>(clamp((_e461 / max(_e464, 0.000001f)), 0f, 1f), clamp((_e468 / _e469), 0f, 1f), 0f);
}
let _e473 = local_4;
g_debug_surface = _e473;
}
let _e474 = radius_1;
if (_e474 < 0f) {
return 1f;
}
let _e476 = uv_3;
param_57 = _e476;
param_58 = vec2<f32>(0f, 0f);
let _e477 = tile_3;
param_59 = _e477;
let _e478 = range_3;
param_60 = _e478;
let _e479 = receiver_2;
param_61 = _e479;
let _e480 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_57), (¶m_58), (¶m_59), (¶m_60), (¶m_61));
lit = _e480;
let _e481 = radius_1;
if (_e481 > 0f) {
i_3 = 0i;
loop {
let _e483 = i_3;
if (_e483 < 8i) {
let _e485 = i_3;
param_62 = _e485;
let _e486 = ca_2;
param_63 = _e486;
let _e487 = sa_2;
param_64 = _e487;
let _e488 = radius_1;
param_65 = _e488;
let _e489 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_62), (¶m_63), (¶m_64), (¶m_65));
let _e490 = uv_3;
param_66 = _e490;
param_67 = _e489;
let _e491 = tile_3;
param_68 = _e491;
let _e492 = range_3;
param_69 = _e492;
let _e493 = receiver_2;
param_70 = _e493;
let _e494 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70));
let _e495 = lit;
lit = (_e495 + _e494);
continue;
} else {
break;
}
continuing {
let _e497 = i_3;
i_3 = (_e497 + 1i);
}
}
let _e499 = lit;
lit = (_e499 * 0.11111111f);
}
let _e501 = lit;
let _e502 = strength;
return mix(1f, _e501, clamp(_e502, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r_3: f32;
var theta: f32;
let _e199 = (*i_4);
let _e202 = (*n_1);
r_3 = sqrt(((f32(_e199) + 0.5f) / f32(_e202)));
let _e206 = (*i_4);
let _e209 = (*turn);
theta = ((f32(_e206) * 2.3999631f) + _e209);
let _e211 = r_3;
let _e212 = theta;
let _e214 = theta;
return (vec2<f32>(cos(_e212), sin(_e214)) * _e211);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_71: f32;
let _e198 = frag_info.target_origin[0u];
param_71 = _e198;
let _e199 = FragCoordFromTop_u0028_f1_u003b((¶m_71));
let _e202 = frag_info.target_origin[3u];
at = (_e199 + vec2((5.588238f * max(_e202, 0f))));
let _e207 = at;
return fract((52.982918f * fract(dot(_e207, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_2: f32;
var pMax: f32;
var reduced: f32;
let _e203 = (*moments)[1u];
let _e205 = (*moments)[0u];
let _e207 = (*moments)[0u];
let _e210 = (*minVariance);
variance = max((_e203 - (_e205 * _e207)), _e210);
let _e212 = (*t);
let _e214 = (*moments)[0u];
d_2 = (_e212 - _e214);
let _e216 = variance;
let _e217 = variance;
let _e218 = d_2;
let _e219 = d_2;
pMax = (_e216 / (_e217 + (_e218 * _e219)));
let _e223 = pMax;
let _e224 = (*bleed);
let _e226 = (*bleed);
reduced = clamp(((_e223 - _e224) / max((1f - _e226), 0.0001f)), 0f, 1f);
let _e231 = (*t);
let _e233 = (*moments)[0u];
let _e235 = reduced;
return select(_e235, 1f, (_e231 <= _e233));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_3: f32;
let _e196 = (*depth);
d_3 = ((2f * clamp(_e196, 0f, 1f)) - 1f);
let _e200 = d_3;
let _e203 = d_3;
return vec2<f32>(exp((40f * _e200)), -(exp((-5f * _e203))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_72: f32;
var scale: vec2<f32>;
var positive: f32;
var param_73: vec2<f32>;
var param_74: f32;
var param_75: f32;
var param_76: f32;
var negative: f32;
var param_77: vec2<f32>;
var param_78: f32;
var param_79: f32;
var param_80: f32;
let _e210 = (*depth_1);
param_72 = _e210;
let _e211 = EvsmWarp_u0028_f1_u003b((¶m_72));
warped = _e211;
let _e212 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e212);
let _e215 = scale[0u];
let _e217 = scale[0u];
let _e219 = (*moments_1);
param_73 = _e219.xy;
let _e222 = warped[0u];
param_74 = _e222;
param_75 = (_e215 * _e217);
let _e223 = (*bleed_1);
param_76 = _e223;
let _e224 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_73), (¶m_74), (¶m_75), (¶m_76));
positive = _e224;
let _e226 = scale[1u];
let _e228 = scale[1u];
let _e230 = (*moments_1);
param_77 = _e230.zw;
let _e233 = warped[1u];
param_78 = _e233;
param_79 = (_e226 * _e228);
let _e234 = (*bleed_1);
param_80 = _e234;
let _e235 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_77), (¶m_78), (¶m_79), (¶m_80));
negative = _e235;
let _e236 = positive;
let _e237 = negative;
return min(_e236, _e237);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_5: mat4x4<f32>;
var local_6: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_7: f32;
var local_8: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_81: vec4<f32>;
var param_82: f32;
var param_83: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var occluder_1: f32;
var param_84: i32;
var param_85: i32;
var param_86: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var occluder_2: f32;
var param_87: i32;
var param_88: i32;
var param_89: f32;
var phi_3608_: bool;
var phi_3619_: bool;
var phi_3775_: bool;
var phi_3782_: bool;
var phi_3789_: bool;
let _e255 = frag_info.shadow_params[3u];
strength_1 = _e255;
let _e256 = strength_1;
if (_e256 <= 0f) {
return 1f;
}
let _e258 = (*lightIndex_1);
let _e261 = frag_info.frame_params[2u];
if (_e258 != i32((_e261 + 0.5f))) {
return 1f;
}
let _e267 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e267 + 0.5f));
let _e270 = v_world_position_1;
let _e272 = frag_info.camera_position;
viewDistance = length((_e270 - _e272.xyz));
cascade = 0i;
let _e276 = cascadeCount;
let _e277 = (_e276 > 1i);
phi_3608_ = _e277;
if _e277 {
let _e278 = viewDistance;
let _e281 = frag_info.shadow_cascades[0u];
phi_3608_ = (_e278 > _e281);
}
let _e284 = phi_3608_;
if _e284 {
cascade = 1i;
}
let _e285 = cascadeCount;
let _e286 = (_e285 > 2i);
phi_3619_ = _e286;
if _e286 {
let _e287 = viewDistance;
let _e290 = frag_info.shadow_cascades[1u];
phi_3619_ = (_e287 > _e290);
}
let _e293 = phi_3619_;
if _e293 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e294 = attempt;
if (_e294 < 3i) {
let _e296 = cascade;
let _e297 = attempt;
which = (_e296 + _e297);
let _e299 = which;
let _e300 = cascadeCount;
if (_e299 >= _e300) {
break;
}
let _e302 = which;
if (_e302 == 0i) {
let _e305 = frag_info.shadow_matrix;
local_5 = _e305;
} else {
let _e306 = which;
if (_e306 == 1i) {
let _e309 = frag_info.shadow_matrix_far;
local_6 = _e309;
} else {
let _e311 = frag_info.shadow_matrix_farthest;
local_6 = _e311;
}
let _e312 = local_6;
local_5 = _e312;
}
let _e313 = local_5;
matrix = _e313;
let _e316 = matrix[0][0u];
let _e319 = matrix[1][0u];
let _e322 = matrix[2][0u];
axisX = vec3<f32>(_e316, _e319, _e322);
let _e326 = matrix[0][1u];
let _e329 = matrix[1][1u];
let _e332 = matrix[2][1u];
axisY = vec3<f32>(_e326, _e329, _e332);
let _e334 = axisX;
rowX = max(length(_e334), 0.000001f);
let _e337 = axisY;
rowY = max(length(_e337), 0.000001f);
let _e342 = frag_info.shadow_cascades[3u];
let _e344 = rowX;
texelMetres = ((2f * _e342) / _e344);
let _e348 = frag_info.shadow_cascades[3u];
let _e351 = (*s_3).n;
let _e352 = axisX;
let _e355 = rowX;
let _e356 = rowX;
let _e360 = (*s_3).n;
let _e361 = axisY;
let _e364 = rowY;
let _e365 = rowY;
reach = ((3f * _e348) * ((abs(dot(_e351, _e352)) / (_e355 * _e356)) + (abs(dot(_e360, _e361)) / (_e364 * _e365))));
let _e370 = v_world_position_1;
let _e372 = (*s_3).n;
let _e375 = frag_info.shadow_params[2u];
let _e376 = reach;
origin_1 = (_e370 + (_e372 * (_e375 + _e376)));
let _e380 = matrix;
let _e381 = origin_1;
lightSpace = (_e380 * vec4<f32>(_e381.x, _e381.y, _e381.z, 1f));
let _e388 = lightSpace[3u];
if (_e388 <= 0f) {
continue;
}
let _e390 = lightSpace;
let _e393 = lightSpace[3u];
candidate = (_e390.xyz / vec3(_e393));
let _e397 = candidate[0u];
let _e401 = candidate[1u];
inTile = vec2<f32>(((_e397 * 0.5f) + 0.5f), (0.5f - (_e401 * 0.5f)));
let _e406 = inTile[0u];
let _e407 = (_e406 < 0f);
phi_3775_ = _e407;
if !(_e407) {
let _e410 = inTile[0u];
phi_3775_ = (_e410 > 1f);
}
let _e413 = phi_3775_;
phi_3782_ = _e413;
if !(_e413) {
let _e416 = inTile[1u];
phi_3782_ = (_e416 < 0f);
}
let _e419 = phi_3782_;
phi_3789_ = _e419;
if !(_e419) {
let _e422 = inTile[1u];
phi_3789_ = (_e422 > 1f);
}
let _e425 = phi_3789_;
if _e425 {
continue;
}
let _e427 = candidate[2u];
if (_e427 > 1f) {
let _e429 = which;
let _e430 = cascadeCount;
if (_e429 < (_e430 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e435 = inTile[0u];
let _e436 = which;
let _e439 = cascadeCount;
let _e443 = inTile[1u];
uv_4 = vec2<f32>(((_e435 + f32(_e436)) / f32(_e439)), _e443);
let _e445 = candidate;
projected = _e445;
let _e446 = which;
cascade = _e446;
let _e447 = texelMetres;
cascadeTexel = _e447;
let _e450 = matrix[0][2u];
let _e453 = matrix[1][2u];
let _e456 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e450, _e453, _e456)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e461 = attempt;
attempt = (_e461 + 1i);
}
}
let _e463 = found;
if !(_e463) {
return 1f;
}
let _e465 = cascade;
if (_e465 == 0i) {
let _e469 = frag_info.shadow_bias[0u];
local_7 = _e469;
} else {
let _e470 = cascade;
if (_e470 == 1i) {
let _e474 = frag_info.shadow_bias[1u];
local_8 = _e474;
} else {
let _e477 = frag_info.shadow_bias[2u];
local_8 = _e477;
}
let _e478 = local_8;
local_7 = _e478;
}
let _e479 = local_7;
bias = _e479;
let _e482 = frag_info.shadow_params[0u];
let _e485 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e482, _e485);
let _e487 = cascade;
let _e489 = cascadeCount;
let _e493 = texel_1;
tileLo = (vec2<f32>((f32(_e487) / f32(_e489)), 0f) + (_e493 * 0.5f));
let _e496 = cascade;
let _e499 = cascadeCount;
let _e503 = texel_1;
tileHi = (vec2<f32>((f32((_e496 + 1i)) / f32(_e499)), 1f) - (_e503 * 0.5f));
let _e508 = frag_info.ambient_ground[3u];
softness = _e508;
lit_1 = 0f;
let _e509 = softness;
if (_e509 < 0f) {
let _e511 = uv_4;
let _e512 = tileLo;
let _e513 = tileHi;
let _e515 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e511, _e512, _e513), 0f);
moments_2 = _e515;
let _e517 = projected[2u];
let _e518 = bias;
let _e520 = softness;
let _e524 = moments_2;
param_81 = _e524;
param_82 = (_e517 - _e518);
param_83 = clamp((-(_e520) - 1f), 0f, 0.95f);
let _e525 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_81), (¶m_82), (¶m_83));
lit_1 = _e525;
} else {
let _e526 = softness;
if (_e526 <= 0f) {
y_1 = -1i;
loop {
let _e528 = y_1;
if (_e528 <= 1i) {
x_1 = -1i;
loop {
let _e530 = x_1;
if (_e530 <= 1i) {
let _e532 = uv_4;
let _e533 = x_1;
let _e535 = y_1;
let _e538 = texel_1;
let _e541 = tileLo;
let _e542 = tileHi;
let _e544 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e532 + (vec2<f32>(f32(_e533), f32(_e535)) * _e538)), _e541, _e542), 0f);
occluder = _e544.x;
let _e547 = projected[2u];
let _e548 = bias;
let _e550 = occluder;
let _e553 = lit_1;
lit_1 = (_e553 + select(1f, 0f, ((_e547 - _e548) > _e550)));
continue;
} else {
break;
}
continuing {
let _e555 = x_1;
x_1 = (_e555 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e557 = y_1;
y_1 = (_e557 + 1i);
}
}
let _e559 = lit_1;
lit_1 = (_e559 * 0.11111111f);
} else {
let _e561 = softness;
spread = tan(min(_e561, 0.5f));
let _e564 = ShadowNoise_u0028_();
turn_1 = (_e564 * 6.2831855f);
let _e566 = spread;
let _e568 = projected[2u];
let _e570 = cascadeDepth;
let _e572 = cascadeTexel;
searchRadius = clamp((((_e566 * _e568) * _e570) / _e572), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e575 = i_5;
if (_e575 < 16i) {
let _e577 = uv_4;
let _e578 = i_5;
param_84 = _e578;
param_85 = 16i;
let _e579 = turn_1;
param_86 = _e579;
let _e580 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_84), (¶m_85), (¶m_86));
let _e581 = texel_1;
let _e583 = searchRadius;
let _e586 = tileLo;
let _e587 = tileHi;
let _e589 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e577 + ((_e580 * _e581) * _e583)), _e586, _e587), 0f);
occluder_1 = _e589.x;
let _e592 = projected[2u];
let _e593 = bias;
let _e595 = occluder_1;
if ((_e592 - _e593) > _e595) {
let _e597 = occluder_1;
let _e598 = blockerSum;
blockerSum = (_e598 + _e597);
let _e600 = blockerCount;
blockerCount = (_e600 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e602 = i_5;
i_5 = (_e602 + 1i);
}
}
let _e604 = blockerCount;
if (_e604 <= 0f) {
return 1f;
}
let _e607 = projected[2u];
let _e608 = blockerSum;
let _e609 = blockerCount;
let _e613 = cascadeDepth;
gap = (max((_e607 - (_e608 / _e609)), 0f) * _e613);
let _e615 = spread;
let _e616 = gap;
let _e618 = cascadeTexel;
radius_2 = clamp(((_e615 * _e616) / _e618), 1f, 16f);
i_6 = 0i;
loop {
let _e621 = i_6;
if (_e621 < 16i) {
let _e623 = uv_4;
let _e624 = turn_1;
let _e626 = i_6;
param_87 = _e626;
param_88 = 16i;
param_89 = (_e624 + 1f);
let _e627 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_87), (¶m_88), (¶m_89));
let _e628 = texel_1;
let _e630 = radius_2;
let _e633 = tileLo;
let _e634 = tileHi;
let _e636 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e623 + ((_e627 * _e628) * _e630)), _e633, _e634), 0f);
occluder_2 = _e636.x;
let _e639 = projected[2u];
let _e640 = bias;
let _e642 = occluder_2;
let _e645 = lit_1;
lit_1 = (_e645 + select(1f, 0f, ((_e639 - _e640) > _e642)));
continue;
} else {
break;
}
continuing {
let _e647 = i_6;
i_6 = (_e647 + 1i);
}
}
let _e649 = lit_1;
lit_1 = (_e649 * 0.0625f);
}
}
let _e651 = lit_1;
let _e652 = strength_1;
return mix(1f, _e651, clamp(_e652, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_90: Surface;
var param_91: LightSample;
var param_92: i32;
let _e200 = (*s_4);
param_90 = _e200;
let _e201 = (*light_2);
param_91 = _e201;
let _e202 = (*index);
param_92 = _e202;
let _e203 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_90), (¶m_91), (¶m_92));
return _e203;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e195 = (*index_1);
return (_e195 < 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 _e199 = (*distance_1);
let _e200 = (*distance_1);
attenuation = (1f / max((_e199 * _e200), 0.0001f));
let _e204 = (*range_4);
if (_e204 > 0f) {
let _e206 = (*distance_1);
let _e207 = (*range_4);
ratio = (_e206 / _e207);
let _e209 = ratio;
let _e210 = ratio;
let _e212 = ratio;
let _e214 = ratio;
window = clamp((1f - (((_e209 * _e210) * _e212) * _e214)), 0f, 1f);
let _e218 = window;
let _e219 = window;
let _e221 = attenuation;
attenuation = (_e221 * (_e218 * _e219));
}
let _e223 = attenuation;
return _e223;
}
fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
var axis: vec3<f32>;
var len: f32;
var angle_1: f32;
var local_9: vec3<f32>;
let _e200 = (*a_2);
let _e201 = (*b);
axis = cross(_e200, _e201);
let _e203 = axis;
len = length(_e203);
let _e205 = (*a_2);
let _e206 = (*b);
angle_1 = acos(clamp(dot(_e205, _e206), -1f, 1f));
let _e210 = len;
if (_e210 > 0.000001f) {
let _e212 = axis;
let _e213 = angle_1;
let _e214 = len;
local_9 = (_e212 * (_e213 / (_e214 * 6.2831855f)));
} else {
local_9 = vec3<f32>(0f, 0f, 0f);
}
let _e218 = local_9;
return _e218;
}
fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
var uv_5: vec2<f32>;
var inverse: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: f32;
var fit: vec4<f32>;
var param_96: f32;
var param_97: f32;
var param_98: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_10: vec3<f32>;
var t2_: vec3<f32>;
var minv: mat3x3<f32>;
var i_7: i32;
var p_1: vec3<f32>;
var l: array<vec3<f32>, 4>;
var f_2: vec3<f32>;
var param_99: vec3<f32>;
var param_100: vec3<f32>;
var param_101: vec3<f32>;
var param_102: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_11: f32;
var sphere: f32;
var param_107: f32;
var param_108: f32;
var param_109: f32;
let _e232 = (*roughness_3);
let _e234 = (*n_2);
let _e235 = (*v);
uv_5 = vec2<f32>(clamp(_e232, 0f, 1f), sqrt(clamp((1f - dot(_e234, _e235)), 0f, 1f)));
let _e242 = uv_5[0u];
param_93 = _e242;
let _e244 = uv_5[1u];
param_94 = _e244;
param_95 = 0f;
let _e245 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_93), (¶m_94), (¶m_95));
let _e246 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e245, 0f);
inverse = _e246;
let _e248 = uv_5[0u];
param_96 = _e248;
let _e250 = uv_5[1u];
param_97 = _e250;
param_98 = 1f;
let _e251 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_96), (¶m_97), (¶m_98));
let _e252 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e251, 0f);
fit = _e252;
let _e253 = (*v);
let _e254 = (*n_2);
let _e255 = (*v);
let _e256 = (*n_2);
along = (_e253 - (_e254 * dot(_e255, _e256)));
let _e260 = along;
alongLength = length(_e260);
let _e262 = alongLength;
if (_e262 > 0.00001f) {
let _e264 = along;
let _e265 = alongLength;
local_10 = (_e264 / vec3(_e265));
} else {
let _e268 = (*n_2);
let _e270 = (*n_2)[2u];
local_10 = normalize(cross(_e268, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e270) < 0.999f)))));
}
let _e277 = local_10;
t1_ = _e277;
let _e278 = (*n_2);
let _e279 = t1_;
t2_ = cross(_e278, _e279);
let _e282 = inverse[0u];
let _e284 = inverse[1u];
let _e285 = vec3<f32>(_e282, 0f, _e284);
let _e287 = inverse[2u];
let _e289 = inverse[3u];
let _e290 = vec3<f32>(_e287, 0f, _e289);
minv = mat3x3<f32>(vec3<f32>(_e285.x, _e285.y, _e285.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e290.x, _e290.y, _e290.z));
i_7 = 0i;
loop {
let _e304 = i_7;
if (_e304 < 4i) {
let _e306 = i_7;
let _e308 = (*corners)[_e306];
p_1 = _e308;
let _e309 = i_7;
let _e310 = minv;
let _e311 = p_1;
let _e312 = t1_;
let _e314 = p_1;
let _e315 = t2_;
let _e317 = p_1;
let _e318 = (*n_2);
l[_e309] = normalize((_e310 * vec3<f32>(dot(_e311, _e312), dot(_e314, _e315), dot(_e317, _e318))));
continue;
} else {
break;
}
continuing {
let _e324 = i_7;
i_7 = (_e324 + 1i);
}
}
let _e327 = l[0i];
param_99 = _e327;
let _e329 = l[1i];
param_100 = _e329;
let _e330 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_99), (¶m_100));
let _e332 = l[1i];
param_101 = _e332;
let _e334 = l[2i];
param_102 = _e334;
let _e335 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_101), (¶m_102));
let _e338 = l[2i];
param_103 = _e338;
let _e340 = l[3i];
param_104 = _e340;
let _e341 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_103), (¶m_104));
let _e344 = l[3i];
param_105 = _e344;
let _e346 = l[0i];
param_106 = _e346;
let _e347 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_105), (¶m_106));
f_2 = -((((_e330 + _e335) + _e341) + _e347));
let _e350 = f_2;
len_1 = length(_e350);
let _e352 = len_1;
if (_e352 > 0.000000001f) {
let _e355 = f_2[2u];
let _e356 = len_1;
local_11 = (_e355 / _e356);
} else {
local_11 = 0f;
}
let _e358 = local_11;
z_1 = _e358;
let _e359 = z_1;
let _e362 = len_1;
param_107 = ((_e359 * 0.5f) + 0.5f);
param_108 = clamp(_e362, 0f, 1f);
param_109 = 1f;
let _e364 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_107), (¶m_108), (¶m_109));
let _e365 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e364, 0f);
sphere = _e365.w;
let _e367 = len_1;
let _e368 = sphere;
let _e372 = fit[0u];
let _e374 = fit[1u];
return vec3<f32>(max((_e367 * _e368), 0f), _e372, _e374);
}
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_3: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_12: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e211 = (*halfWidth);
let _e212 = (*halfHeight);
n_3 = cross(_e211, _e212);
let _e214 = n_3;
nLen = length(_e214);
let _e216 = nLen;
if (_e216 < 0.000000000001f) {
let _e218 = (*centre);
return _e218;
}
let _e219 = nLen;
let _e220 = n_3;
n_3 = (_e220 / vec3(_e219));
let _e223 = (*centre);
let _e224 = (*world_2);
toPlane = (_e223 - _e224);
let _e226 = (*mirror);
let _e227 = n_3;
denom = dot(_e226, _e227);
let _e229 = denom;
if (abs(_e229) < 0.00001f) {
let _e232 = toPlane;
let _e233 = n_3;
let _e234 = toPlane;
let _e235 = n_3;
onPlane = (_e232 - (_e233 * dot(_e234, _e235)));
} else {
let _e239 = toPlane;
let _e240 = n_3;
let _e242 = denom;
t_1 = (dot(_e239, _e240) / _e242);
let _e244 = t_1;
if (_e244 > 0f) {
let _e246 = (*mirror);
let _e247 = t_1;
local_12 = (_e246 * _e247);
} else {
let _e249 = toPlane;
let _e250 = n_3;
let _e251 = toPlane;
let _e252 = n_3;
local_12 = (_e249 - (_e250 * dot(_e251, _e252)));
}
let _e256 = local_12;
onPlane = _e256;
}
let _e257 = onPlane;
let _e258 = toPlane;
offset_2 = (_e257 - _e258);
let _e260 = (*halfWidth);
let _e261 = (*halfWidth);
wLen2_ = max(dot(_e260, _e261), 0.000000000001f);
let _e264 = (*halfHeight);
let _e265 = (*halfHeight);
hLen2_ = max(dot(_e264, _e265), 0.000000000001f);
let _e268 = offset_2;
let _e269 = (*halfWidth);
let _e271 = wLen2_;
u = clamp((dot(_e268, _e269) / _e271), -1f, 1f);
let _e274 = offset_2;
let _e275 = (*halfHeight);
let _e277 = hLen2_;
v_1 = clamp((dot(_e274, _e275) / _e277), -1f, 1f);
let _e280 = (*centre);
let _e281 = (*halfWidth);
let _e282 = u;
let _e285 = (*halfHeight);
let _e286 = v_1;
return ((_e280 + (_e281 * _e282)) + (_e285 * _e286));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_2: f32;
var axis_1: vec3<f32>;
var len_2: f32;
var local_13: f32;
let _e203 = (*a_3);
let _e204 = (*a_3);
ua = (_e203 / vec3(max(length(_e204), 0.000000000001f)));
let _e209 = (*b_1);
let _e210 = (*b_1);
ub = (_e209 / vec3(max(length(_e210), 0.000000000001f)));
let _e215 = ua;
let _e216 = ub;
angle_2 = acos(clamp(dot(_e215, _e216), -1f, 1f));
let _e220 = ua;
let _e221 = ub;
axis_1 = cross(_e220, _e221);
let _e223 = axis_1;
len_2 = length(_e223);
let _e225 = len_2;
if (_e225 > 0.000001f) {
let _e227 = angle_2;
let _e228 = axis_1;
let _e229 = (*n_4);
let _e232 = len_2;
local_13 = ((_e227 * dot(_e228, _e229)) / _e232);
} else {
local_13 = 0f;
}
let _e234 = local_13;
return _e234;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_8: i32;
var a_4: vec3<f32>;
var b_2: vec3<f32>;
var local_14: i32;
var ha: f32;
var hb: f32;
var d_4: f32;
var q: vec3<f32>;
var local_15: f32;
var aAbove: bool;
var bAbove: bool;
var local_16: f32;
var param_110: vec3<f32>;
var param_111: vec3<f32>;
var param_112: vec3<f32>;
var param_113: vec3<f32>;
var param_114: vec3<f32>;
var param_115: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e217 = i_8;
if (_e217 < 4i) {
let _e219 = i_8;
let _e221 = (*corners_1)[_e219];
a_4 = _e221;
let _e222 = i_8;
if (_e222 == 3i) {
local_14 = 0i;
} else {
let _e224 = i_8;
local_14 = (_e224 + 1i);
}
let _e226 = local_14;
let _e228 = (*corners_1)[_e226];
b_2 = _e228;
let _e229 = a_4;
let _e230 = (*n_5);
ha = dot(_e229, _e230);
let _e232 = b_2;
let _e233 = (*n_5);
hb = dot(_e232, _e233);
let _e235 = ha;
let _e236 = hb;
d_4 = (_e235 - _e236);
let _e238 = a_4;
let _e239 = b_2;
let _e240 = a_4;
let _e242 = d_4;
if (abs(_e242) > 0.000000000001f) {
let _e245 = ha;
let _e246 = d_4;
local_15 = (_e245 / _e246);
} else {
local_15 = 0f;
}
let _e248 = local_15;
q = (_e238 + ((_e239 - _e240) * _e248));
let _e251 = ha;
aAbove = (_e251 > 0f);
let _e253 = hb;
bAbove = (_e253 > 0f);
let _e255 = aAbove;
let _e256 = bAbove;
if (_e255 || _e256) {
let _e258 = aAbove;
let _e259 = a_4;
let _e260 = q;
let _e263 = bAbove;
let _e264 = b_2;
let _e265 = q;
param_110 = select(_e260, _e259, vec3(_e258));
param_111 = select(_e265, _e264, vec3(_e263));
let _e268 = (*n_5);
param_112 = _e268;
let _e269 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_110), (¶m_111), (¶m_112));
local_16 = _e269;
} else {
local_16 = 0f;
}
let _e270 = local_16;
let _e271 = total;
total = (_e271 + _e270);
let _e273 = aAbove;
let _e274 = bAbove;
let _e277 = q;
let _e278 = exit;
exit = select(_e278, _e277, vec3((_e273 && !(_e274))));
let _e281 = aAbove;
let _e283 = bAbove;
let _e285 = q;
let _e286 = entry;
entry = select(_e286, _e285, vec3((!(_e281) && _e283)));
continue;
} else {
break;
}
continuing {
let _e289 = i_8;
i_8 = (_e289 + 1i);
}
}
let _e291 = exit;
param_113 = _e291;
let _e292 = entry;
param_114 = _e292;
let _e293 = (*n_5);
param_115 = _e293;
let _e294 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_113), (¶m_114), (¶m_115));
let _e295 = total;
total = (_e295 + _e294);
let _e297 = total;
return max((-(_e297) * 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_17: f32;
var local_18: f32;
var local_19: f32;
let _e200 = (*slot_1);
let _e201 = (*slot_1);
lane = (_e200 - ((_e201 / 4i) * 4i));
let _e205 = lane;
if (_e205 == 0i) {
let _e208 = (*four)[0u];
local_17 = _e208;
} else {
let _e209 = lane;
if (_e209 == 1i) {
let _e212 = (*four)[1u];
local_18 = _e212;
} else {
let _e213 = lane;
if (_e213 == 2i) {
let _e216 = (*four)[2u];
local_19 = _e216;
} else {
let _e218 = (*four)[3u];
local_19 = _e218;
}
let _e219 = local_19;
local_18 = _e219;
}
let _e220 = local_18;
local_17 = _e220;
}
let _e221 = local_17;
return _e221;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_116: vec4<f32>;
var param_117: i32;
let _e197 = (*slot_2);
let _e201 = light_list_info.scales[(_e197 / 4i)];
param_116 = _e201;
let _e202 = (*slot_2);
param_117 = _e202;
let _e203 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_116), (¶m_117));
return _e203;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e199 = light_list_info.slot_rows[0i];
let _e200 = (*row);
a_5 = abs((_e199 - vec4(_e200)));
let _e206 = light_list_info.slot_rows[1i];
let _e207 = (*row);
b_3 = abs((_e206 - vec4(_e207)));
let _e212 = a_5[0u];
let _e214 = a_5[1u];
let _e217 = a_5[2u];
let _e219 = a_5[3u];
let _e223 = b_3[0u];
let _e225 = b_3[1u];
let _e228 = b_3[2u];
let _e230 = b_3[3u];
return (min(min(min(_e212, _e214), min(_e217, _e219)), min(min(_e223, _e225), min(_e228, _e230))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_118: vec4<f32>;
var param_119: i32;
let _e197 = (*slot_3);
let _e201 = light_list_info.indices[(_e197 / 4i)];
param_118 = _e201;
let _e202 = (*slot_3);
param_119 = _e202;
let _e203 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_118), (¶m_119));
return _e203;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e196 = (*texel_2);
let _e200 = light_list_info.list[1u];
let _e202 = (*row_1);
let _e206 = light_list_info.list[2u];
let _e209 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e196 + 0.5f) * _e200), ((_e202 + 0.5f) * _e206)), 0f);
return _e209;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_120: f32;
var param_121: f32;
var param_122: vec4<f32>;
var param_123: i32;
let _e204 = g_cluster_offset;
let _e205 = (*slot_4);
entry_1 = (_e204 + f32(_e205));
let _e208 = entry_1;
row_2 = floor((_e208 / 16f));
let _e211 = entry_1;
let _e212 = row_2;
within = (_e211 - (_e212 * 16f));
let _e215 = within;
texel_3 = floor((_e215 / 4f));
let _e220 = light_list_info.cluster_depth[3u];
let _e221 = row_2;
let _e223 = texel_3;
param_120 = _e223;
param_121 = (_e220 + _e221);
let _e224 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_120), (¶m_121));
four_1 = _e224;
let _e225 = within;
let _e226 = texel_3;
let _e231 = four_1;
param_122 = _e231;
param_123 = i32(((_e225 - (_e226 * 4f)) + 0.5f));
let _e232 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_122), (¶m_123));
return _e232;
}
fn Clustered_u0028_() -> bool {
let _e196 = light_list_info.cluster_grid[3u];
return (_e196 > 0.5f);
}
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_5: ptr<function, Surface>) -> LightSample {
var light_3: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_20: f32;
var param_124: i32;
var param_125: i32;
var v_2: f32;
var u_1: f32;
var local_21: f32;
var param_126: f32;
var param_127: i32;
var type_42: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_2: array<vec3<f32>, 4>;
var behind: bool;
var formFactor: f32;
var local_22: f32;
var param_128: array<vec3<f32>, 4>;
var param_129: vec3<f32>;
var area: f32;
var radiance: f32;
var local_23: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_130: vec3<f32>;
var param_131: vec3<f32>;
var param_132: vec3<f32>;
var param_133: vec3<f32>;
var param_134: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_24: vec3<f32>;
var param_135: vec3<f32>;
var param_136: vec3<f32>;
var param_137: f32;
var param_138: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_139: f32;
var param_140: f32;
var cosAngle: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e251 = (*index_2);
if (_e251 < 8i) {
let _e253 = (*index_2);
let _e256 = frag_info.light_position[_e253];
position = _e256;
let _e257 = (*index_2);
let _e260 = frag_info.light_color[_e257];
color_1 = _e260;
let _e261 = (*index_2);
let _e264 = frag_info.light_direction[_e261];
direction = _e264;
let _e265 = (*index_2);
let _e268 = frag_info.light_cone[_e265];
cone = _e268;
} else {
let _e269 = (*index_2);
slot_5 = (_e269 - 8i);
let _e271 = Clustered_u0028_();
clustered = _e271;
let _e272 = clustered;
if _e272 {
let _e273 = slot_5;
param_124 = _e273;
let _e274 = ClusterRow_u0028_i1_u003b((¶m_124));
local_20 = _e274;
} else {
let _e275 = slot_5;
param_125 = _e275;
let _e276 = LightListRow_u0028_i1_u003b((¶m_125));
local_20 = _e276;
}
let _e277 = local_20;
listRow = _e277;
let _e278 = listRow;
let _e282 = light_list_info.list[2u];
v_2 = ((_e278 + 0.5f) * _e282);
let _e286 = light_list_info.list[1u];
u_1 = _e286;
let _e287 = u_1;
let _e289 = v_2;
let _e291 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e287), _e289), 0f);
position = _e291;
let _e292 = u_1;
let _e294 = v_2;
let _e296 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e292), _e294), 0f);
color_1 = _e296;
let _e297 = u_1;
let _e299 = v_2;
let _e301 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e297), _e299), 0f);
direction = _e301;
let _e302 = u_1;
let _e304 = v_2;
let _e306 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e302), _e304), 0f);
cone = _e306;
let _e307 = clustered;
if _e307 {
let _e308 = listRow;
param_126 = _e308;
let _e309 = InSlots_u0028_f1_u003b((¶m_126));
local_21 = select(1f, 0f, _e309);
} else {
let _e311 = slot_5;
param_127 = _e311;
let _e312 = LightListScale_u0028_i1_u003b((¶m_127));
local_21 = _e312;
}
let _e313 = local_21;
let _e315 = color_1[3u];
color_1[3u] = (_e315 * _e313);
}
let _e319 = position[3u];
type_42 = _e319;
let _e320 = type_42;
if (_e320 > 2.5f) {
let _e322 = direction;
halfWidth_1 = _e322.xyz;
let _e324 = cone;
halfHeight_1 = _e324.xyz;
let _e326 = position;
let _e328 = v_world_position_1;
toCentre = (_e326.xyz - _e328);
let _e330 = toCentre;
let _e331 = halfWidth_1;
let _e333 = halfHeight_1;
corners_2[0i] = ((_e330 - _e331) - _e333);
let _e336 = toCentre;
let _e337 = halfWidth_1;
let _e339 = halfHeight_1;
corners_2[1i] = ((_e336 + _e337) - _e339);
let _e342 = toCentre;
let _e343 = halfWidth_1;
let _e345 = halfHeight_1;
corners_2[2i] = ((_e342 + _e343) + _e345);
let _e348 = toCentre;
let _e349 = halfWidth_1;
let _e351 = halfHeight_1;
corners_2[3i] = ((_e348 - _e349) + _e351);
let _e354 = toCentre;
let _e355 = halfWidth_1;
let _e356 = halfHeight_1;
behind = (dot(_e354, cross(_e355, _e356)) >= 0f);
let _e360 = behind;
if _e360 {
local_22 = 0f;
} else {
let _e361 = corners_2;
param_128 = _e361;
let _e363 = (*s_5).n;
param_129 = _e363;
let _e364 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_128), (¶m_129));
local_22 = _e364;
}
let _e365 = local_22;
formFactor = _e365;
let _e366 = halfWidth_1;
let _e367 = halfHeight_1;
area = (length(cross(_e366, _e367)) * 4f);
let _e371 = area;
if (_e371 > 0.000000001f) {
let _e373 = area;
local_23 = (1f / _e373);
} else {
local_23 = 0f;
}
let _e375 = local_23;
radiance = _e375;
let _e376 = toCentre;
distance_2 = length(_e376);
let _e379 = direction[3u];
if (_e379 > 0f) {
let _e381 = distance_2;
let _e383 = direction[3u];
ratio_1 = (_e381 / _e383);
let _e385 = ratio_1;
let _e386 = ratio_1;
let _e388 = ratio_1;
let _e390 = ratio_1;
window_1 = clamp((1f - (((_e385 * _e386) * _e388) * _e390)), 0f, 1f);
let _e394 = window_1;
let _e395 = window_1;
let _e397 = radiance;
radiance = (_e397 * (_e394 * _e395));
}
let _e400 = (*s_5).v;
let _e403 = (*s_5).n;
mirror_1 = reflect(-(_e400), _e403);
let _e405 = position;
param_130 = _e405.xyz;
let _e407 = halfWidth_1;
param_131 = _e407;
let _e408 = halfHeight_1;
param_132 = _e408;
let _e409 = v_world_position_1;
param_133 = _e409;
let _e410 = mirror_1;
param_134 = _e410;
let _e411 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_130), (¶m_131), (¶m_132), (¶m_133), (¶m_134));
representative = _e411;
let _e412 = representative;
let _e413 = v_world_position_1;
toPoint = (_e412 - _e413);
let _e415 = toPoint;
pointDistance = length(_e415);
let _e417 = pointDistance;
if (_e417 > 0.000001f) {
let _e419 = toPoint;
let _e420 = pointDistance;
local_24 = (_e419 / vec3(_e420));
} else {
let _e424 = (*s_5).n;
local_24 = _e424;
}
let _e425 = local_24;
light_3.l = _e425;
let _e428 = light_3.l;
let _e430 = (*s_5).v;
light_3.h = normalize((_e428 + _e430));
let _e434 = formFactor;
light_3.n_dot_l = _e434;
let _e437 = (*s_5).n;
let _e439 = light_3.h;
light_3.n_dot_h = max(dot(_e437, _e439), 0f);
let _e444 = (*s_5).v;
let _e446 = light_3.h;
light_3.v_dot_h = max(dot(_e444, _e446), 0f);
let _e450 = color_1;
let _e453 = color_1[3u];
let _e455 = radiance;
light_3.radiance = ((_e450.xyz * _e453) * _e455);
light_3.integrated = 1f;
let _e460 = (*s_5).n;
param_135 = _e460;
let _e462 = (*s_5).v;
param_136 = _e462;
let _e464 = (*s_5).roughness;
param_137 = _e464;
let _e465 = corners_2;
param_138 = _e465;
let _e466 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_135), (¶m_136), (¶m_137), (¶m_138));
light_3.ltc = _e466;
let _e468 = light_3;
return _e468;
}
let _e469 = direction;
aim = normalize(_e469.xyz);
attenuation_1 = 1f;
let _e472 = type_42;
if (_e472 < 0.5f) {
let _e474 = aim;
light_3.l = -(_e474);
} else {
let _e477 = position;
let _e479 = v_world_position_1;
toLight_1 = (_e477.xyz - _e479);
let _e481 = toLight_1;
distance_3 = length(_e481);
let _e483 = distance_3;
if (_e483 < 0.000001f) {
let _e486 = (*s_5).n;
light_3.l = _e486;
let _e489 = (*s_5).n;
light_3.h = _e489;
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 _e495 = light_3;
return _e495;
}
let _e496 = toLight_1;
let _e497 = distance_3;
light_3.l = (_e496 / vec3(_e497));
let _e501 = distance_3;
param_139 = _e501;
let _e503 = direction[3u];
param_140 = _e503;
let _e504 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_139), (¶m_140));
attenuation_1 = _e504;
let _e505 = type_42;
if (_e505 > 1.5f) {
let _e507 = aim;
let _e509 = light_3.l;
cosAngle = dot(_e507, -(_e509));
let _e512 = cosAngle;
let _e514 = cone[1u];
let _e517 = cone[0u];
let _e519 = cone[1u];
let _e523 = attenuation_1;
attenuation_1 = (_e523 * clamp(((_e512 - _e514) / (_e517 - _e519)), 0f, 1f));
}
}
let _e526 = light_3.l;
let _e528 = (*s_5).v;
light_3.h = normalize((_e526 + _e528));
let _e533 = (*s_5).n;
let _e535 = light_3.l;
light_3.n_dot_l = max(dot(_e533, _e535), 0f);
let _e540 = (*s_5).n;
let _e542 = light_3.h;
light_3.n_dot_h = max(dot(_e540, _e542), 0f);
let _e547 = (*s_5).v;
let _e549 = light_3.h;
light_3.v_dot_h = max(dot(_e547, _e549), 0f);
let _e553 = color_1;
let _e556 = color_1[3u];
let _e558 = attenuation_1;
light_3.radiance = ((_e553.xyz * _e556) * _e558);
let _e561 = light_3;
return _e561;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_25: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_141: f32;
var param_142: f32;
let _e209 = light_list_info.cluster_view_projection;
let _e210 = (*world_3);
clip_1 = (_e209 * vec4<f32>(_e210.x, _e210.y, _e210.z, 1f));
let _e216 = clip_1;
let _e219 = clip_1[3u];
ndc_1 = (_e216.xy / vec2(max(_e219, 0.000001f)));
let _e224 = light_list_info.cluster_grid;
grid = _e224.xyz;
let _e228 = light_list_info.cluster_depth[0u];
near_1 = _e228;
let _e230 = ndc_1[0u];
let _e234 = grid[0u];
let _e238 = grid[0u];
tx = clamp(floor((((_e230 * 0.5f) + 0.5f) * _e234)), 0f, (_e238 - 1f));
let _e242 = ndc_1[1u];
let _e246 = grid[1u];
let _e250 = grid[1u];
ty = clamp(floor((((_e242 * 0.5f) + 0.5f) * _e246)), 0f, (_e250 - 1f));
let _e254 = clip_1[3u];
let _e255 = near_1;
if (_e254 <= _e255) {
local_25 = 0f;
} else {
let _e258 = clip_1[3u];
let _e259 = near_1;
let _e264 = light_list_info.cluster_depth[1u];
let _e268 = grid[2u];
local_25 = clamp(floor((log((_e258 / _e259)) * _e264)), 0f, (_e268 - 1f));
}
let _e271 = local_25;
tz = _e271;
let _e272 = tx;
let _e273 = ty;
let _e275 = grid[0u];
let _e278 = tz;
let _e280 = grid[0u];
let _e283 = grid[1u];
cell = ((_e272 + (_e273 * _e275)) + ((_e278 * _e280) * _e283));
let _e286 = cell;
row_3 = floor((_e286 / 4f));
let _e289 = cell;
let _e290 = row_3;
let _e295 = light_list_info.cluster_depth[2u];
let _e296 = row_3;
param_141 = (_e289 - (_e290 * 4f));
param_142 = (_e295 + _e296);
let _e298 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_141), (¶m_142));
header = _e298;
let _e300 = header[0u];
g_cluster_offset = _e300;
let _e302 = header[1u];
g_cluster_count = _e302;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_143: vec3<f32>;
let _e198 = light_list_info.list[0u];
tail = _e198;
let _e199 = Clustered_u0028_();
if _e199 {
let _e200 = v_world_position_1;
param_143 = _e200;
FindCluster_u0028_vf3_u003b((¶m_143));
let _e201 = g_cluster_count;
tail = _e201;
}
let _e204 = frag_info.frame_params[1u];
let _e208 = tail;
return (clamp(i32((_e204 + 0.5f)), 0i, 8i) + clamp(i32((_e208 + 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_6: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_9: i32;
var light_4: LightSample;
var param_144: i32;
var param_145: Surface;
var visibility: f32;
var param_146: i32;
var local_26: f32;
var param_147: Surface;
var param_148: LightSample;
var param_149: i32;
var param_150: vec3<f32>;
var param_151: vec3<f32>;
var param_152: i32;
var param_153: Surface;
var param_154: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e212 = LightCount_u0028_();
count_1 = _e212;
i_9 = 0i;
loop {
let _e213 = i_9;
if (_e213 < 32i) {
let _e215 = i_9;
let _e216 = count_1;
if (_e215 >= _e216) {
break;
}
let _e218 = i_9;
param_144 = _e218;
let _e219 = (*s_6);
param_145 = _e219;
let _e220 = 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_144), (¶m_145));
light_4 = _e220;
let _e222 = light_4.n_dot_l;
if (_e222 <= 0f) {
continue;
}
let _e224 = i_9;
param_146 = _e224;
let _e225 = LightHasShadow_u0028_i1_u003b((¶m_146));
if _e225 {
let _e226 = (*s_6);
param_147 = _e226;
let _e227 = light_4;
param_148 = _e227;
let _e228 = i_9;
param_149 = _e228;
let _e229 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_147), (¶m_148), (¶m_149));
let _e230 = v_world_position_1;
param_150 = _e230;
let _e232 = (*s_6).n;
param_151 = _e232;
let _e233 = i_9;
param_152 = _e233;
let _e234 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_150), (¶m_151), (¶m_152));
local_26 = (_e229 * _e234);
} else {
local_26 = 1f;
}
let _e236 = local_26;
visibility = _e236;
let _e237 = visibility;
if (_e237 <= 0f) {
continue;
}
let _e239 = (*s_6);
param_153 = _e239;
let _e240 = light_4;
param_154 = _e240;
let _e241 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_153), (¶m_154));
let _e243 = light_4.radiance;
let _e246 = light_4.n_dot_l;
let _e248 = visibility;
let _e250 = total_1;
total_1 = (_e250 + (((_e241 * _e243) * _e246) * _e248));
continue;
} else {
break;
}
continuing {
let _e252 = i_9;
i_9 = (_e252 + 1i);
}
}
let _e254 = total_1;
return _e254;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e195 = v_lightmap_uv_1;
let _e196 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e195);
texel_4 = _e196;
let _e197 = texel_4;
let _e200 = texel_4[3u];
return ((_e197.xyz * _e200) * 8f);
}
fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
var e_1: f32;
var param_155: f32;
var param_156: f32;
var param_157: f32;
var param_158: vec3<f32>;
var param_159: f32;
let _e203 = (*mu_1);
param_155 = _e203;
let _e204 = (*r_4);
param_156 = _e204;
let _e205 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_155), (¶m_156));
e_1 = _e205;
let _e206 = (*rho_2);
let _e207 = e_1;
let _e209 = (*r_4);
param_157 = _e209;
let _e210 = FonAverage_u0028_f1_u003b((¶m_157));
let _e211 = (*rho_2);
param_158 = _e211;
param_159 = _e210;
let _e212 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_158), (¶m_159));
let _e213 = e_1;
return ((_e206 * _e207) + (_e212 * (1f - _e213)));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e196 = frag_info.target_origin[1u];
return _e196;
}
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_7: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e196 = v_texcoord_1;
let _e197 = MaterialLodBias_u0028_();
let _e198 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e196, _e197);
orm = _e198.xyz;
let _e201 = (*s_7).metallic;
let _e203 = orm[2u];
(*s_7).metallic = clamp((_e201 * _e203), 0f, 1f);
let _e208 = (*s_7).roughness;
let _e210 = orm[1u];
(*s_7).roughness = clamp((_e208 * _e210), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e195 = (*srgb);
let _e198 = (*srgb);
let _e203 = (*srgb);
return mix((_e195 / vec3(12.92f)), pow(((_e198 + 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), _e203));
}
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_8: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_160: vec3<f32>;
let _e197 = v_texcoord_1;
let _e198 = MaterialLodBias_u0028_();
let _e199 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e197, _e198);
param_160 = _e199.xyz;
let _e201 = SrgbToLinear_u0028_vf3_u003b((¶m_160));
emissive = _e201;
let _e202 = emissive;
let _e204 = frag_info.emissive;
let _e209 = frag_info.material2_[3u];
(*s_8).emissive = ((_e202 * _e204.xyz) * _e209);
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_9: ptr<function, Surface>) {
var occlusion: f32;
let _e196 = v_texcoord_1;
let _e197 = MaterialLodBias_u0028_();
let _e198 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e196, _e197);
occlusion = _e198.x;
let _e200 = occlusion;
let _e203 = frag_info.material2_[2u];
(*s_9).occlusion = mix(1f, _e200, clamp(_e203, 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_10: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_4: vec3<f32>;
var sampled: vec3<f32>;
let _e199 = v_texcoord_1;
let _e200 = MaterialLodBias_u0028_();
let _e201 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e199, _e200);
sampledTexel = _e201;
let _e202 = v_tangent_1;
t_2 = _e202.xyz;
let _e204 = t_2;
let _e206 = (*s_10).n;
let _e208 = (*s_10).n;
let _e209 = t_2;
t_2 = (_e204 - (_e206 * dot(_e208, _e209)));
let _e213 = t_2;
let _e214 = t_2;
if (dot(_e213, _e214) < 0.000000000001f) {
return;
}
let _e217 = t_2;
t_2 = normalize(_e217);
let _e220 = (*s_10).n;
let _e221 = t_2;
let _e224 = v_tangent_1[3u];
b_4 = (cross(_e220, _e221) * _e224);
let _e226 = gl_FrontFacing_1;
if !(_e226) {
let _e228 = t_2;
t_2 = -(_e228);
}
let _e230 = sampledTexel;
sampled = ((_e230.xyz * 2f) - vec3(1f));
let _e237 = frag_info.emissive[3u];
if (_e237 > 0.5f) {
let _e239 = sampled;
let _e241 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e239.xy, _e241.xy)), 0f));
}
let _e250 = frag_info.material2_[1u];
let _e251 = sampled;
let _e253 = (_e251.xy * _e250);
sampled[0u] = _e253.x;
sampled[1u] = _e253.y;
let _e258 = t_2;
let _e260 = sampled[0u];
let _e262 = b_4;
let _e264 = sampled[1u];
let _e268 = (*s_10).n;
let _e270 = sampled[2u];
(*s_10).n = normalize((((_e258 * _e260) + (_e262 * _e264)) + (_e268 * _e270)));
let _e276 = (*s_10).n;
let _e278 = (*s_10).v;
(*s_10).n_dot_v = max(dot(_e276, _e278), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e195 = (*texel_5);
let _e199 = irradiance_info.atlas;
let _e202 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e195 + vec2(0.5f)) * _e199.xy), 0f);
return _e202;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
var at_1: vec2<f32>;
var low: vec2<f32>;
var f_3: vec2<f32>;
var a_6: vec4<f32>;
var param_161: vec2<f32>;
var b_5: vec4<f32>;
var param_162: vec2<f32>;
var c: vec4<f32>;
var param_163: vec2<f32>;
var d_5: vec4<f32>;
var param_164: vec2<f32>;
let _e208 = (*uv_6);
let _e209 = (*interior);
at_1 = ((vec2(1f) + (_e208 * _e209)) - vec2(0.5f));
let _e215 = at_1;
low = floor(_e215);
let _e217 = at_1;
let _e218 = low;
f_3 = (_e217 - _e218);
let _e220 = (*corner);
let _e221 = low;
param_161 = (_e220 + _e221);
let _e223 = AtlasTexel_u0028_vf2_u003b((¶m_161));
a_6 = _e223;
let _e224 = (*corner);
let _e225 = low;
param_162 = ((_e224 + _e225) + vec2<f32>(1f, 0f));
let _e228 = AtlasTexel_u0028_vf2_u003b((¶m_162));
b_5 = _e228;
let _e229 = (*corner);
let _e230 = low;
param_163 = ((_e229 + _e230) + vec2<f32>(0f, 1f));
let _e233 = AtlasTexel_u0028_vf2_u003b((¶m_163));
c = _e233;
let _e234 = (*corner);
let _e235 = low;
param_164 = ((_e234 + _e235) + vec2<f32>(1f, 1f));
let _e238 = AtlasTexel_u0028_vf2_u003b((¶m_164));
d_5 = _e238;
let _e239 = a_6;
let _e240 = b_5;
let _e242 = f_3[0u];
let _e245 = c;
let _e246 = d_5;
let _e248 = f_3[0u];
let _e252 = f_3[1u];
return mix(mix(_e239, _e240, vec4(_e242)), mix(_e245, _e246, vec4(_e248)), vec4(_e252));
}
fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var sum_1: f32;
var n_6: vec3<f32>;
var xy: vec2<f32>;
let _e199 = (*direction_1)[0u];
let _e202 = (*direction_1)[1u];
let _e206 = (*direction_1)[2u];
sum_1 = ((abs(_e199) + abs(_e202)) + abs(_e206));
let _e209 = sum_1;
if (_e209 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e211 = (*direction_1);
let _e212 = sum_1;
n_6 = (_e211 / vec3(_e212));
let _e215 = n_6;
xy = _e215.xy;
let _e218 = n_6[2u];
if (_e218 < 0f) {
let _e221 = n_6[1u];
let _e225 = n_6[0u];
let _e230 = n_6[0u];
let _e234 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e221)) * select(-1f, 1f, (_e225 >= 0f))), ((1f - abs(_e230)) * select(-1f, 1f, (_e234 >= 0f))));
}
let _e239 = xy;
return ((_e239 * 0.5f) + vec2(0.5f));
}
fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var spacing: vec3<f32>;
var counts: vec3<f32>;
var irradianceTile: f32;
var depthTile: f32;
var columns: f32;
var momentsTop: f32;
var unit: vec3<f32>;
var biased: vec3<f32>;
var grid_1: vec3<f32>;
var base: vec3<f32>;
var f_4: vec3<f32>;
var total_2: vec3<f32>;
var weights: f32;
var corner_1: i32;
var offset_3: vec3<f32>;
var cell_1: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_165: vec2<f32>;
var trilinear: vec3<f32>;
var weight_2: f32;
var probePosition: vec3<f32>;
var toProbe: vec3<f32>;
var distance_4: f32;
var direction_2: vec3<f32>;
var facing: f32;
var probeWeight: f32;
var moments_3: vec2<f32>;
var param_166: vec3<f32>;
var param_167: vec2<f32>;
var param_168: f32;
var param_169: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_170: vec3<f32>;
var param_171: vec2<f32>;
var param_172: f32;
var param_173: vec2<f32>;
var local_27: vec3<f32>;
let _e241 = irradiance_info.origin;
origin_2 = _e241.xyz;
let _e244 = irradiance_info.spacing;
spacing = _e244.xyz;
let _e247 = irradiance_info.counts;
counts = _e247.xyz;
let _e251 = irradiance_info.tiles[0u];
irradianceTile = _e251;
let _e254 = irradiance_info.tiles[1u];
depthTile = _e254;
let _e257 = irradiance_info.tiles[2u];
columns = _e257;
let _e260 = irradiance_info.tiles[3u];
momentsTop = _e260;
let _e261 = (*normal_1);
unit = normalize(_e261);
let _e263 = (*world_4);
let _e264 = unit;
let _e267 = irradiance_info.spacing[3u];
let _e270 = (*view);
let _e273 = irradiance_info.counts[3u];
biased = ((_e263 + (_e264 * _e267)) + (_e270 * _e273));
let _e276 = biased;
let _e277 = origin_2;
let _e279 = spacing;
grid_1 = ((_e276 - _e277) / _e279);
let _e281 = grid_1;
let _e283 = counts;
base = clamp(floor(_e281), vec3<f32>(0f, 0f, 0f), (_e283 - vec3(2f)));
let _e287 = grid_1;
let _e288 = base;
f_4 = clamp((_e287 - _e288), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e291 = corner_1;
if (_e291 < 8i) {
let _e293 = corner_1;
let _e296 = corner_1;
let _e301 = corner_1;
offset_3 = vec3<f32>(f32((_e293 & 1i)), f32(((_e296 >> bitcast<u32>(1i)) & 1i)), f32(((_e301 >> bitcast<u32>(2i)) & 1i)));
let _e307 = base;
let _e308 = offset_3;
cell_1 = (_e307 + _e308);
let _e311 = cell_1[2u];
let _e313 = counts[1u];
let _e316 = cell_1[1u];
let _e319 = counts[0u];
let _e322 = cell_1[0u];
probe = ((((_e311 * _e313) + _e316) * _e319) + _e322);
let _e324 = probe;
let _e325 = columns;
let _e330 = probe;
let _e331 = columns;
tile_4 = vec2<f32>((_e324 - (floor((_e324 / _e325)) * _e325)), floor((_e330 / _e331)));
let _e335 = tile_4;
let _e336 = irradianceTile;
irradianceCorner = (_e335 * (_e336 + 2f));
let _e340 = tile_4[0u];
let _e341 = depthTile;
let _e344 = momentsTop;
let _e346 = tile_4[1u];
let _e347 = depthTile;
momentCorner = vec2<f32>((_e340 * (_e341 + 2f)), (_e344 + (_e346 * (_e347 + 2f))));
let _e352 = irradianceCorner;
param_165 = (_e352 + vec2(1f));
let _e355 = AtlasTexel_u0028_vf2_u003b((¶m_165));
if (_e355.w < 0.5f) {
continue;
}
let _e358 = f_4;
let _e360 = f_4;
let _e361 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e358), _e360, _e361);
let _e364 = trilinear[0u];
let _e366 = trilinear[1u];
let _e369 = trilinear[2u];
weight_2 = max(((_e364 * _e366) * _e369), 0.001f);
let _e372 = origin_2;
let _e373 = spacing;
let _e374 = cell_1;
probePosition = (_e372 + (_e373 * _e374));
let _e377 = probePosition;
let _e378 = biased;
toProbe = (_e377 - _e378);
let _e380 = toProbe;
distance_4 = length(_e380);
let _e382 = distance_4;
if (_e382 > 0.000001f) {
let _e384 = toProbe;
let _e385 = distance_4;
direction_2 = (_e384 / vec3(_e385));
let _e388 = unit;
let _e389 = probePosition;
let _e390 = (*world_4);
facing = ((dot(_e388, normalize((_e389 - _e390))) * 0.5f) + 0.5f);
let _e396 = facing;
let _e397 = facing;
probeWeight = ((_e396 * _e397) + 0.2f);
let _e400 = direction_2;
param_166 = -(_e400);
let _e402 = ProbeOctahedral_u0028_vf3_u003b((¶m_166));
let _e403 = momentCorner;
param_167 = _e403;
let _e404 = depthTile;
param_168 = _e404;
param_169 = _e402;
let _e405 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_167), (¶m_168), (¶m_169));
moments_3 = _e405.xy;
chebyshev = 1f;
let _e407 = distance_4;
let _e409 = moments_3[0u];
if (_e407 > _e409) {
let _e412 = moments_3[1u];
let _e414 = moments_3[0u];
let _e416 = moments_3[0u];
variance_1 = max((_e412 - (_e414 * _e416)), 0.000001f);
let _e420 = distance_4;
let _e422 = moments_3[0u];
difference = (_e420 - _e422);
let _e424 = variance_1;
let _e425 = variance_1;
let _e426 = difference;
let _e427 = difference;
chebyshev = (_e424 / (_e425 + (_e426 * _e427)));
let _e431 = chebyshev;
let _e432 = chebyshev;
let _e434 = chebyshev;
chebyshev = ((_e431 * _e432) * _e434);
}
let _e436 = probeWeight;
let _e437 = chebyshev;
probeWeight = max((_e436 * max(_e437, 0.05f)), 0.000001f);
let _e441 = probeWeight;
if (_e441 < 0.2f) {
let _e443 = probeWeight;
let _e444 = probeWeight;
let _e447 = probeWeight;
probeWeight = (_e447 * ((_e443 * _e444) * 25f));
}
let _e449 = probeWeight;
let _e450 = weight_2;
weight_2 = (_e450 * _e449);
}
let _e452 = unit;
param_170 = _e452;
let _e453 = ProbeOctahedral_u0028_vf3_u003b((¶m_170));
let _e454 = irradianceCorner;
param_171 = _e454;
let _e455 = irradianceTile;
param_172 = _e455;
param_173 = _e453;
let _e456 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_171), (¶m_172), (¶m_173));
let _e458 = weight_2;
let _e460 = total_2;
total_2 = (_e460 + (_e456.xyz * _e458));
let _e462 = weight_2;
let _e463 = weights;
weights = (_e463 + _e462);
continue;
} else {
break;
}
continuing {
let _e465 = corner_1;
corner_1 = (_e465 + 1i);
}
}
let _e467 = weights;
if (_e467 > 0f) {
let _e469 = total_2;
let _e470 = weights;
local_27 = (_e469 / vec3(_e470));
} else {
local_27 = vec3<f32>(0f, 0f, 0f);
}
let _e473 = local_27;
return _e473;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e196 = irradiance_info.origin[3u];
return (_e196 > 0.5f);
}
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_11: ptr<function, Surface>) {
var param_174: vec3<f32>;
var param_175: vec3<f32>;
var param_176: vec3<f32>;
var param_177: Surface;
var param_178: Surface;
var param_179: Surface;
let _e201 = IrradianceEnabled_u0028_();
if _e201 {
let _e202 = v_world_position_1;
param_174 = _e202;
let _e204 = (*s_11).n;
param_175 = _e204;
let _e206 = (*s_11).v;
param_176 = _e206;
let _e207 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_174), (¶m_175), (¶m_176));
let _e210 = frag_info.material[2u];
(*s_11).ambient = (_e207 * _e210);
}
let _e213 = (*s_11);
param_177 = _e213;
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_177));
let _e214 = param_177;
(*s_11) = _e214;
let _e215 = (*s_11);
param_178 = _e215;
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_178));
let _e216 = param_178;
(*s_11) = _e216;
let _e217 = (*s_11);
param_179 = _e217;
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_179));
let _e218 = param_179;
(*s_11) = _e218;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_12: Surface;
var param_180: vec3<f32>;
var param_181: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e201 = v_texcoord_1;
let _e202 = MaterialLodBias_u0028_();
let _e203 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e201, _e202);
texel_6 = _e203;
let _e204 = texel_6;
param_180 = _e204.xyz;
let _e206 = SrgbToLinear_u0028_vf3_u003b((¶m_180));
let _e208 = frag_info.base_color;
param_181 = _e208.xyz;
let _e210 = SrgbToLinear_u0028_vf3_u003b((¶m_181));
let _e212 = v_color_1;
s_12.albedo = ((_e206 * _e210) * _e212.xyz);
let _e217 = texel_6[3u];
let _e220 = frag_info.base_color[3u];
let _e223 = v_color_1[3u];
s_12.alpha = ((_e217 * _e220) * _e223);
let _e227 = s_12.albedo;
g_albedo = _e227;
let _e230 = frag_info.material2_[0u];
cutoff = _e230;
let _e231 = cutoff;
if (_e231 >= 0f) {
let _e234 = s_12.alpha;
let _e235 = cutoff;
if (_e234 < _e235) {
discard;
}
} else {
let _e237 = cutoff;
if (_e237 < -1.5f) {
let _e239 = v_world_position_1;
anchored = floor((_e239 * 16f));
let _e242 = anchored;
noise_1 = fract((sin(dot(_e242, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e248 = s_12.alpha;
let _e249 = noise_1;
if (_e248 < _e249) {
discard;
}
}
}
let _e251 = cutoff;
let _e253 = cutoff;
g_premultiply = ((_e251 < 0f) && (_e253 > -0.75f));
let _e256 = v_normal_1;
s_12.n = normalize(_e256);
let _e259 = gl_FrontFacing_1;
if !(_e259) {
let _e262 = s_12.n;
s_12.n = -(_e262);
}
let _e266 = frag_info.camera_position;
let _e268 = v_world_position_1;
s_12.v = normalize((_e266.xyz - _e268));
let _e273 = s_12.n;
let _e275 = s_12.v;
s_12.n_dot_v = max(dot(_e273, _e275), 0.0001f);
let _e281 = frag_info.material[0u];
s_12.metallic = clamp(_e281, 0f, 1f);
let _e286 = frag_info.material[1u];
s_12.roughness = clamp(_e286, 0.02f, 1f);
let _e290 = frag_info.ambient_ground;
let _e293 = frag_info.ambient_sky;
let _e297 = s_12.n[1u];
let _e304 = frag_info.material[2u];
s_12.ambient = (mix(_e290.xyz, _e293.xyz, vec3(((_e297 * 0.5f) + 0.5f))) * _e304);
let _e309 = frag_info.frame_params[0u];
s_12.exposure = max(_e309, 0f);
s_12.occlusion = 1f;
s_12.emissive = vec3<f32>(0f, 0f, 0f);
let _e314 = s_12;
return _e314;
}
fn main_1() {
var s_13: Surface;
var param_182: Surface;
var param_183: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_184: vec3<f32>;
var param_185: f32;
var param_186: f32;
var ambient: vec3<f32>;
var levels: f32;
var f0_3: vec3<f32>;
var reflected: vec3<f32>;
var irradiance: vec3<f32>;
var prefiltered: vec3<f32>;
var ab_1: vec2<f32>;
var param_187: f32;
var param_188: f32;
var single_1: vec3<f32>;
var specular_1: vec3<f32>;
var missed: f32;
var average_2: vec3<f32>;
var multiple: vec3<f32>;
var param_189: Surface;
var param_190: vec3<f32>;
var param_191: f32;
var param_192: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e220 = ReadSurface_u0028_();
s_13 = _e220;
let _e221 = s_13;
param_182 = _e221;
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_182));
let _e222 = param_182;
s_13 = _e222;
let _e223 = s_13;
param_183 = _e223;
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_183));
let _e224 = param_183;
s_13 = _e224;
let _e226 = s_13.metallic;
metallic = clamp(_e226, 0f, 1f);
let _e229 = s_13.albedo;
let _e230 = metallic;
diffuseColor_1 = (_e229 * (1f - _e230));
let _e233 = EonDiffuse_u0028_();
if _e233 {
let _e234 = diffuseColor_1;
param_184 = _e234;
let _e236 = s_13.roughness;
param_185 = _e236;
let _e238 = s_13.n_dot_v;
param_186 = _e238;
let _e239 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_184), (¶m_185), (¶m_186));
diffuseColor_1 = _e239;
}
let _e240 = diffuseColor_1;
let _e242 = s_13.ambient;
let _e245 = s_13.occlusion;
ambient = ((_e240 * _e242) * _e245);
let _e249 = frag_info.frame_params[3u];
levels = _e249;
let _e250 = levels;
if (_e250 > 0f) {
let _e253 = s_13.albedo;
let _e254 = metallic;
f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e253, vec3(_e254));
let _e258 = s_13.v;
let _e261 = s_13.n;
reflected = reflect(-(_e258), _e261);
let _e264 = s_13.n;
let _e265 = levels;
let _e266 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e264, _e265);
irradiance = _e266.xyz;
let _e268 = reflected;
let _e270 = s_13.roughness;
let _e271 = levels;
let _e273 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e268, (_e270 * _e271));
prefiltered = _e273.xyz;
let _e276 = s_13.roughness;
param_187 = _e276;
let _e278 = s_13.n_dot_v;
param_188 = _e278;
let _e279 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_187), (¶m_188));
ab_1 = _e279;
let _e280 = f0_3;
let _e282 = ab_1[0u];
let _e285 = ab_1[1u];
single_1 = ((_e280 * _e282) + vec3(_e285));
let _e288 = prefiltered;
let _e289 = single_1;
specular_1 = (_e288 * _e289);
let _e291 = EnergyCompensation_u0028_();
if _e291 {
let _e293 = ab_1[0u];
let _e295 = ab_1[1u];
missed = (1f - (_e293 + _e295));
let _e298 = f0_3;
let _e299 = f0_3;
average_2 = (_e298 + ((vec3<f32>(1f, 1f, 1f) - _e299) / vec3(21f)));
let _e304 = single_1;
let _e305 = average_2;
let _e307 = missed;
let _e308 = average_2;
multiple = ((_e304 * _e305) / (vec3<f32>(1f, 1f, 1f) - (_e308 * _e307)));
let _e312 = multiple;
let _e313 = missed;
let _e315 = irradiance;
let _e317 = specular_1;
specular_1 = (_e317 + ((_e312 * _e313) * _e315));
}
let _e319 = diffuseColor_1;
let _e320 = irradiance;
let _e322 = specular_1;
let _e326 = frag_info.material[2u];
let _e329 = s_13.occlusion;
ambient = ((((_e319 * _e320) + _e322) * _e326) * _e329);
}
let _e331 = diffuseColor_1;
let _e332 = SampleLightmap_u0028_();
let _e335 = s_13.occlusion;
let _e337 = ambient;
ambient = (_e337 + ((_e331 * _e332) * _e335));
let _e339 = s_13;
param_189 = _e339;
let _e340 = 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_189));
let _e342 = s_13.occlusion;
let _e344 = ambient;
let _e347 = s_13.emissive;
param_190 = (((_e340 * _e342) + _e344) + _e347);
let _e350 = s_13.alpha;
param_191 = _e350;
let _e352 = s_13.roughness;
param_192 = _e352;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_190), (¶m_191), (¶m_192));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: 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;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'IrradianceInfo',
group: 1,
binding: 2,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'spacing',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'counts',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 3,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 4,
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: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'irradiance_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'ltc_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 23,
samplerBinding: 24,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 25,
samplerBinding: 26,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 27,
samplerBinding: 28,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 29,
samplerBinding: 30,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'PbrLayered': 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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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 IrradianceInfo {
origin: vec4<f32>,
spacing: vec4<f32>,
counts: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
struct LayerInfo {
specular: vec4<f32>,
coat: vec4<f32>,
sheen: vec4<f32>,
anisotropy: vec4<f32>,
transmission: vec4<f32>,
attenuation: vec4<f32>,
iridescence: vec4<f32>,
uv_transform: array<vec4<f32>, 10>,
scene_colour: vec4<f32>,
scene_viewport: vec4<f32>,
scene_levels: array<vec4<f32>, 6>,
scene_view_projection: mat4x4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> g_f0_dielectric: vec3<f32>;
var<private> g_f90_: f32;
var<private> g_coat: f32;
var<private> g_coat_roughness: f32;
var<private> g_coat_n: vec3<f32>;
var<private> g_coat_n_dot_v: f32;
var<private> g_coat_through: f32;
var<private> g_sheen: vec3<f32>;
var<private> g_sheen_roughness: f32;
var<private> g_sheen_albedo: f32;
var<private> g_sheen_scale: f32;
var<private> g_aniso: f32;
var<private> g_aniso_t: vec3<f32>;
var<private> g_aniso_b: vec3<f32>;
var<private> g_transmission: f32;
var<private> g_thickness: f32;
var<private> g_transmittance: vec3<f32>;
var<private> g_iridescence: f32;
var<private> g_irid_fresnel: vec3<f32>;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(16)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(6)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var base_color_texture_smp: sampler;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(20)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var ltc_texture_smp: sampler;
var<private> g_rect_corners: array<vec3<f32>, 4>;
@group(1) @binding(5)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(30)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(31)
var point_shadow_texture_smp: sampler;
@group(1) @binding(28)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(29)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(14)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var irradiance_texture_smp: sampler;
@group(1) @binding(18)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(22)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(26)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(27)
var occlusion_texture_smp: sampler;
@group(1) @binding(10)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var emissive_texture_smp: sampler;
@group(1) @binding(24)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(34)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(35)
var shadow_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(3)
var<uniform> layer_info: LayerInfo;
@group(1) @binding(8)
var coat_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var coat_texture_smp: sampler;
@group(1) @binding(36)
var sheen_texture_tex: texture_2d<f32>;
@group(1) @binding(37)
var sheen_texture_smp: sampler;
@group(1) @binding(12)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(13)
var environment_texture_smp: sampler;
@group(1) @binding(32)
var scene_colour_texture_tex: texture_2d<f32>;
@group(1) @binding(33)
var scene_colour_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e260 = v_world_position_1;
let _e262 = fog_info.eye;
let _e266 = fog_info.forward;
return dot((_e260 - _e262.xyz), _e266.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e265 = ViewDepth_u0028_();
z = abs(_e265);
let _e267 = z;
near = (_e267 / 5f);
let _e269 = z;
far = (_e269 / 200f);
let _e271 = far;
let _e272 = far;
let _e274 = far;
far3_ = ((_e271 * _e272) * _e274);
let _e276 = (*alpha);
let _e277 = near;
let _e278 = near;
let _e281 = far3_;
let _e282 = far3_;
return (_e276 * clamp((10f / ((0.00001f + (_e277 * _e278)) + (_e281 * _e282))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e269 = fog_info.forward[3u];
mode = _e269;
let _e270 = mode;
if (_e270 > 0.5f) {
let _e273 = frag_color[3u];
alpha_1 = _e273;
let _e274 = alpha_1;
param = _e274;
let _e275 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e275;
let _e276 = frag_color;
let _e278 = weight;
let _e279 = (_e276.xyz * _e278);
let _e280 = alpha_1;
let _e281 = weight;
accumulate = vec4<f32>(_e279.x, _e279.y, _e279.z, (_e280 * _e281));
let _e287 = mode;
let _e289 = mode;
revealage = ((_e287 > 1.5f) && (_e289 < 2.5f));
let _e292 = revealage;
if _e292 {
let _e293 = alpha_1;
local = vec4(_e293);
} else {
let _e295 = accumulate;
local = _e295;
}
let _e296 = local;
frag_color = _e296;
let _e297 = mode;
if (_e297 > 2.5f) {
let _e299 = alpha_1;
frag_surface = vec4(_e299);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e263 = (*n)[0u];
let _e266 = (*n)[1u];
let _e270 = (*n)[2u];
let _e273 = (*n);
(*n) = (_e273 / vec3(((abs(_e263) + abs(_e266)) + abs(_e270))));
let _e276 = (*n);
e = _e276.xy;
let _e279 = (*n)[2u];
if (_e279 < 0f) {
let _e281 = (*n);
let _e287 = (*n)[0u];
let _e291 = (*n)[1u];
e = ((vec2(1f) - abs(_e281.yx)) * vec2<f32>(select(-1f, 1f, (_e287 >= 0f)), select(-1f, 1f, (_e291 >= 0f))));
}
let _e296 = e;
return ((_e296 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e261 = (*linear);
let _e263 = (*linear);
let _e267 = (*linear);
return mix((_e261 * 12.92f), ((pow(_e263, 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), _e267));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e264 = g_albedo;
param_1 = clamp(_e264, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e266 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e266.x, _e266.y, _e266.z, 1f);
let _e271 = g_debug_surface_on;
if _e271 {
let _e272 = g_debug_surface;
let _e273 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e272.x, _e272.y, _e272.z, _e273);
return;
}
let _e278 = v_normal_1;
geometric = normalize(_e278);
let _e280 = gl_FrontFacing_1;
if !(_e280) {
let _e282 = geometric;
geometric = -(_e282);
}
let _e284 = geometric;
param_2 = _e284;
let _e285 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e286 = (*roughness);
let _e288 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e285.x, _e285.y, clamp(_e286, 0f, 1f), _e288);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e260 = v_world_position_1;
let _e262 = fog_info.eye;
return distance(_e260, _e262.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e265 = fog_info.fog[3u];
density = _e265;
let _e266 = density;
if (_e266 <= 0f) {
let _e268 = (*color);
return _e268;
}
let _e269 = EyeDistance_u0028_();
d = _e269;
let _e271 = fog_info.fog;
let _e273 = (*color);
let _e274 = density;
let _e276 = d;
return mix(_e271.xyz, _e273, vec3(clamp(exp((-(_e274) * _e276)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e266 = g_premultiply;
let _e267 = (*alpha_2);
weight_1 = select(1f, _e267, _e266);
let _e269 = (*linearColor);
param_3 = _e269;
let _e270 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e271 = weight_1;
let _e272 = (_e270 * _e271);
let _e273 = (*alpha_2);
frag_color = vec4<f32>(_e272.x, _e272.y, _e272.z, _e273);
let _e278 = (*roughness_1);
param_4 = _e278;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
var a2_: f32;
var lambda_v: f32;
var lambda_l: f32;
let _e266 = (*alpha_3);
let _e267 = (*alpha_3);
a2_ = (_e266 * _e267);
let _e269 = (*n_dot_l);
let _e270 = (*n_dot_v);
let _e271 = (*n_dot_v);
let _e273 = a2_;
let _e276 = a2_;
lambda_v = (_e269 * sqrt((((_e270 * _e271) * (1f - _e273)) + _e276)));
let _e280 = (*n_dot_v);
let _e281 = (*n_dot_l);
let _e282 = (*n_dot_l);
let _e284 = a2_;
let _e287 = a2_;
lambda_l = (_e280 * sqrt((((_e281 * _e282) * (1f - _e284)) + _e287)));
let _e291 = lambda_v;
let _e292 = lambda_l;
return (0.5f / max((_e291 + _e292), 0.00001f));
}
fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
var a: f32;
var k: f32;
let _e264 = (*n_dot_h);
let _e265 = (*alpha_4);
a = (_e264 * _e265);
let _e267 = (*alpha_4);
let _e268 = (*n_dot_h);
let _e269 = (*n_dot_h);
let _e272 = a;
let _e273 = a;
k = (_e267 / max(((1f - (_e268 * _e269)) + (_e272 * _e273)), 0.0000001f));
let _e278 = k;
let _e279 = k;
return ((_e278 * _e279) * 0.31830987f);
}
fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
var axis: vec3<f32>;
var len: f32;
var angle: f32;
var local_1: vec3<f32>;
let _e266 = (*a_1);
let _e267 = (*b);
axis = cross(_e266, _e267);
let _e269 = axis;
len = length(_e269);
let _e271 = (*a_1);
let _e272 = (*b);
angle = acos(clamp(dot(_e271, _e272), -1f, 1f));
let _e276 = len;
if (_e276 > 0.000001f) {
let _e278 = axis;
let _e279 = angle;
let _e280 = len;
local_1 = (_e278 * (_e279 / (_e280 * 6.2831855f)));
} else {
local_1 = vec3<f32>(0f, 0f, 0f);
}
let _e284 = local_1;
return _e284;
}
fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
var inTable: vec2<f32>;
let _e264 = (*x);
let _e265 = (*y);
inTable = ((vec2<f32>(_e264, _e265) * 0.984375f) + vec2(0.0078125f));
let _e271 = inTable[0u];
let _e273 = inTable[1u];
let _e274 = (*table);
return vec2<f32>(_e271, ((_e273 + _e274) * 0.5f));
}
fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
var uv: vec2<f32>;
var inverse: vec4<f32>;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var fit: vec4<f32>;
var param_8: f32;
var param_9: f32;
var param_10: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_2: vec3<f32>;
var t2_: vec3<f32>;
var minv: mat3x3<f32>;
var i: i32;
var p: vec3<f32>;
var l: array<vec3<f32>, 4>;
var f: 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>;
var param_16: vec3<f32>;
var param_17: vec3<f32>;
var param_18: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_3: f32;
var sphere: f32;
var param_19: f32;
var param_20: f32;
var param_21: f32;
let _e298 = (*roughness_2);
let _e300 = (*n_1);
let _e301 = (*v);
uv = vec2<f32>(clamp(_e298, 0f, 1f), sqrt(clamp((1f - dot(_e300, _e301)), 0f, 1f)));
let _e308 = uv[0u];
param_5 = _e308;
let _e310 = uv[1u];
param_6 = _e310;
param_7 = 0f;
let _e311 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
let _e312 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e311, 0f);
inverse = _e312;
let _e314 = uv[0u];
param_8 = _e314;
let _e316 = uv[1u];
param_9 = _e316;
param_10 = 1f;
let _e317 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10));
let _e318 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e317, 0f);
fit = _e318;
let _e319 = (*v);
let _e320 = (*n_1);
let _e321 = (*v);
let _e322 = (*n_1);
along = (_e319 - (_e320 * dot(_e321, _e322)));
let _e326 = along;
alongLength = length(_e326);
let _e328 = alongLength;
if (_e328 > 0.00001f) {
let _e330 = along;
let _e331 = alongLength;
local_2 = (_e330 / vec3(_e331));
} else {
let _e334 = (*n_1);
let _e336 = (*n_1)[2u];
local_2 = normalize(cross(_e334, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e336) < 0.999f)))));
}
let _e343 = local_2;
t1_ = _e343;
let _e344 = (*n_1);
let _e345 = t1_;
t2_ = cross(_e344, _e345);
let _e348 = inverse[0u];
let _e350 = inverse[1u];
let _e351 = vec3<f32>(_e348, 0f, _e350);
let _e353 = inverse[2u];
let _e355 = inverse[3u];
let _e356 = vec3<f32>(_e353, 0f, _e355);
minv = mat3x3<f32>(vec3<f32>(_e351.x, _e351.y, _e351.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e356.x, _e356.y, _e356.z));
i = 0i;
loop {
let _e370 = i;
if (_e370 < 4i) {
let _e372 = i;
let _e374 = (*corners)[_e372];
p = _e374;
let _e375 = i;
let _e376 = minv;
let _e377 = p;
let _e378 = t1_;
let _e380 = p;
let _e381 = t2_;
let _e383 = p;
let _e384 = (*n_1);
l[_e375] = normalize((_e376 * vec3<f32>(dot(_e377, _e378), dot(_e380, _e381), dot(_e383, _e384))));
continue;
} else {
break;
}
continuing {
let _e390 = i;
i = (_e390 + 1i);
}
}
let _e393 = l[0i];
param_11 = _e393;
let _e395 = l[1i];
param_12 = _e395;
let _e396 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_11), (¶m_12));
let _e398 = l[1i];
param_13 = _e398;
let _e400 = l[2i];
param_14 = _e400;
let _e401 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_13), (¶m_14));
let _e404 = l[2i];
param_15 = _e404;
let _e406 = l[3i];
param_16 = _e406;
let _e407 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_15), (¶m_16));
let _e410 = l[3i];
param_17 = _e410;
let _e412 = l[0i];
param_18 = _e412;
let _e413 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_17), (¶m_18));
f = -((((_e396 + _e401) + _e407) + _e413));
let _e416 = f;
len_1 = length(_e416);
let _e418 = len_1;
if (_e418 > 0.000000001f) {
let _e421 = f[2u];
let _e422 = len_1;
local_3 = (_e421 / _e422);
} else {
local_3 = 0f;
}
let _e424 = local_3;
z_1 = _e424;
let _e425 = z_1;
let _e428 = len_1;
param_19 = ((_e425 * 0.5f) + 0.5f);
param_20 = clamp(_e428, 0f, 1f);
param_21 = 1f;
let _e430 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21));
let _e431 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e430, 0f);
sphere = _e431.w;
let _e433 = len_1;
let _e434 = sphere;
let _e438 = fit[0u];
let _e440 = fit[1u];
return vec3<f32>(max((_e433 * _e434), 0f), _e438, _e440);
}
fn CoatLobe_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_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
var ltc: vec3<f32>;
var param_22: vec3<f32>;
var param_23: vec3<f32>;
var param_24: f32;
var param_25: array<vec3<f32>, 4>;
var lobe: f32;
var alpha_5: f32;
var n_dot_l_1: f32;
var n_dot_h_1: f32;
var d_1: f32;
var param_26: f32;
var param_27: f32;
var vis: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var f_1: f32;
let _e280 = (*light).integrated;
if (_e280 > 0.5f) {
let _e282 = g_coat_n;
param_22 = _e282;
let _e284 = (*s).v;
param_23 = _e284;
let _e285 = g_coat_roughness;
param_24 = _e285;
let _e286 = g_rect_corners;
param_25 = _e286;
let _e287 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_22), (¶m_23), (¶m_24), (¶m_25));
ltc = _e287;
let _e289 = ltc[0u];
let _e291 = ltc[1u];
let _e294 = ltc[2u];
let _e300 = frag_info.material[3u];
let _e303 = (*light).n_dot_l;
return (((_e289 * ((0.04f * _e291) + (0.96f * _e294))) * _e300) / max(_e303, 0.000001f));
}
let _e306 = g_coat_roughness;
lobe = max(_e306, 0.045f);
let _e308 = lobe;
let _e309 = lobe;
alpha_5 = (_e308 * _e309);
let _e311 = g_coat_n;
let _e313 = (*light).l;
n_dot_l_1 = max(dot(_e311, _e313), 0f);
let _e316 = g_coat_n;
let _e318 = (*light).h;
n_dot_h_1 = max(dot(_e316, _e318), 0f);
let _e321 = n_dot_h_1;
param_26 = _e321;
let _e322 = alpha_5;
param_27 = _e322;
let _e323 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_26), (¶m_27));
d_1 = _e323;
let _e324 = g_coat_n_dot_v;
param_28 = _e324;
let _e325 = n_dot_l_1;
param_29 = _e325;
let _e326 = alpha_5;
param_30 = _e326;
let _e327 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30));
vis = _e327;
let _e329 = (*light).v_dot_h;
f_1 = (0.04f + (0.96f * pow((1f - _e329), 5f)));
let _e334 = d_1;
let _e335 = vis;
let _e337 = f_1;
let _e341 = frag_info.material[3u];
let _e343 = n_dot_l_1;
let _e346 = (*light).n_dot_l;
return (((((_e334 * _e335) * _e337) * _e341) * _e343) / max(_e346, 0.000001f));
}
fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
let _e262 = (*n_dot_l_2);
let _e263 = (*n_dot_v_1);
let _e265 = (*n_dot_l_2);
let _e266 = (*n_dot_v_1);
return (1f / (4f * ((_e262 + _e263) - (_e265 * _e266))));
}
fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
var inv_alpha: f32;
var sin2h: f32;
let _e264 = (*roughness_3);
let _e265 = (*roughness_3);
inv_alpha = (1f / (_e264 * _e265));
let _e268 = (*n_dot_h_2);
let _e269 = (*n_dot_h_2);
sin2h = max((1f - (_e268 * _e269)), 0.0078125f);
let _e273 = inv_alpha;
let _e275 = sin2h;
let _e276 = inv_alpha;
return (((2f + _e273) * pow(_e275, (_e276 * 0.5f))) / 6.2831855f);
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m: f32;
var g: f32;
let _e264 = (*mu);
m = (1f - _e264);
let _e266 = m;
let _e267 = m;
let _e268 = m;
let _e269 = m;
g = (_e266 * (0.05710853f + (_e267 * (0.49188188f + (_e268 * (-0.33218145f + (_e269 * 0.071443f)))))));
let _e277 = (*r);
let _e278 = g;
let _e281 = (*r);
return ((1f + (_e277 * _e278)) / (1f + (0.2877934f * _e281)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e262 = (*rho);
let _e263 = (*rho);
let _e265 = (*average);
let _e267 = (*rho);
let _e268 = (*average);
return (((_e262 * _e263) * _e265) / (vec3<f32>(1f, 1f, 1f) - (_e267 * (1f - _e268))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e261 = (*r_1);
let _e264 = (*r_1);
return ((1f + (0.07248821f * _e261)) / (1f + (0.2877934f * _e264)));
}
fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
var s_1: f32;
var s_over_t: f32;
var local_4: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_31: f32;
var multi: vec3<f32>;
var param_32: vec3<f32>;
var param_33: f32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: f32;
let _e279 = (*l_dot_v);
let _e280 = (*mu_i);
let _e281 = (*mu_o);
s_1 = (_e279 - (_e280 * _e281));
let _e284 = s_1;
if (_e284 > 0f) {
let _e286 = s_1;
let _e287 = (*mu_i);
let _e288 = (*mu_o);
local_4 = (_e286 / max(_e287, _e288));
} else {
let _e291 = s_1;
local_4 = _e291;
}
let _e292 = local_4;
s_over_t = _e292;
let _e293 = (*r_2);
af = (1f / (1f + (0.2877934f * _e293)));
let _e297 = (*rho_1);
let _e298 = af;
let _e299 = (*r_2);
let _e300 = s_over_t;
single = (_e297 * (_e298 * (1f + (_e299 * _e300))));
let _e305 = (*r_2);
param_31 = _e305;
let _e306 = FonAverage_u0028_f1_u003b((¶m_31));
average_1 = _e306;
let _e307 = (*rho_1);
param_32 = _e307;
let _e308 = average_1;
param_33 = _e308;
let _e309 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_32), (¶m_33));
let _e310 = (*mu_o);
param_34 = _e310;
let _e311 = (*r_2);
param_35 = _e311;
let _e312 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_34), (¶m_35));
let _e315 = (*mu_i);
param_36 = _e315;
let _e316 = (*r_2);
param_37 = _e316;
let _e317 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_36), (¶m_37));
let _e321 = average_1;
multi = (_e309 * ((max((1f - _e312), 0.0000001f) * max((1f - _e317), 0.0000001f)) / max((1f - _e321), 0.0000001f)));
let _e326 = single;
let _e327 = multi;
return ((_e326 + _e327) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e262 = frag_info.ambient_sky[3u];
return (_e262 > 0.5f);
}
fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
var dfg: vec2<f32>;
var param_38: f32;
var param_39: f32;
var param_40: f32;
let _e266 = (*roughness_4);
let _e268 = (*n_dot_v_2);
param_38 = clamp(_e266, 0f, 1f);
param_39 = sqrt(clamp((1f - _e268), 0f, 1f));
param_40 = 1f;
let _e272 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_38), (¶m_39), (¶m_40));
let _e273 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e272, 0f);
dfg = _e273.xy;
let _e276 = dfg[0u];
let _e278 = dfg[1u];
let _e281 = dfg[1u];
return vec2<f32>((_e276 - _e278), _e281);
}
fn MultiscatterScale_u0028_vf3_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(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
var ab: vec2<f32>;
var param_41: f32;
var param_42: f32;
var ess: f32;
let _e267 = (*s_2).roughness;
param_41 = max(_e267, 0.045f);
let _e270 = (*s_2).n_dot_v;
param_42 = _e270;
let _e271 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_41), (¶m_42));
ab = _e271;
let _e273 = ab[0u];
let _e275 = ab[1u];
ess = max((_e273 + _e275), 0.0001f);
let _e278 = (*f0_);
let _e279 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e278 * ((1f / _e279) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e262 = frag_info.target_origin[2u];
return (_e262 > 0.5f);
}
fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
var f_2: f32;
let _e264 = (*v_dot_h);
f_2 = pow((1f - _e264), 5f);
let _e267 = (*f0_1);
let _e268 = (*f90_);
let _e269 = (*f0_1);
let _e271 = f_2;
return (_e267 + ((_e268 - _e269) * _e271));
}
fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
var ggx_v: f32;
var ggx_l: f32;
let _e270 = (*n_dot_l_3);
let _e271 = (*at);
let _e272 = (*t_dot_v);
let _e274 = (*ab_1);
let _e275 = (*b_dot_v);
let _e277 = (*n_dot_v_3);
ggx_v = (_e270 * length(vec3<f32>((_e271 * _e272), (_e274 * _e275), _e277)));
let _e281 = (*n_dot_v_3);
let _e282 = (*at);
let _e283 = (*t_dot_l);
let _e285 = (*ab_1);
let _e286 = (*b_dot_l);
let _e288 = (*n_dot_l_3);
ggx_l = (_e281 * length(vec3<f32>((_e282 * _e283), (_e285 * _e286), _e288)));
let _e292 = ggx_v;
let _e293 = ggx_l;
return clamp((0.5f / max((_e292 + _e293), 0.00001f)), 0f, 1f);
}
fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
var a2_1: f32;
var f_3: vec3<f32>;
var w2_: f32;
let _e268 = (*at_1);
let _e269 = (*ab_2);
a2_1 = (_e268 * _e269);
let _e271 = (*ab_2);
let _e272 = (*t_dot_h);
let _e274 = (*at_1);
let _e275 = (*b_dot_h);
let _e277 = a2_1;
let _e278 = (*n_dot_h_3);
f_3 = vec3<f32>((_e271 * _e272), (_e274 * _e275), (_e277 * _e278));
let _e281 = a2_1;
let _e282 = f_3;
let _e283 = f_3;
w2_ = (_e281 / max(dot(_e282, _e283), 0.000000000001f));
let _e287 = a2_1;
let _e288 = w2_;
let _e290 = w2_;
return (((_e287 * _e288) * _e290) / 3.1415927f);
}
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_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
var lobe_1: f32;
var alpha_6: f32;
var f0_2: vec3<f32>;
var f90_1: vec3<f32>;
var diffuseColor: vec3<f32>;
var d_2: f32;
var param_43: f32;
var param_44: f32;
var vis_1: f32;
var param_45: f32;
var param_46: f32;
var param_47: f32;
var at_2: f32;
var ab_3: f32;
var param_48: f32;
var param_49: f32;
var param_50: f32;
var param_51: f32;
var param_52: f32;
var param_53: f32;
var param_54: f32;
var param_55: f32;
var param_56: f32;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var param_60: f32;
var f_4: vec3<f32>;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var param_63: f32;
var specular: vec3<f32>;
var param_64: vec3<f32>;
var param_65: Surface;
var diffuse: vec3<f32>;
var param_66: vec3<f32>;
var param_67: f32;
var param_68: f32;
var param_69: f32;
var param_70: f32;
var sheen: vec3<f32>;
var param_71: f32;
var param_72: f32;
var param_73: f32;
var param_74: f32;
var param_75: Surface;
var param_76: LightSample;
let _e310 = (*s_3).roughness;
lobe_1 = max(_e310, 0.045f);
let _e312 = lobe_1;
let _e313 = lobe_1;
alpha_6 = (_e312 * _e313);
let _e315 = g_f0_dielectric;
let _e317 = (*s_3).albedo;
let _e319 = (*s_3).metallic;
f0_2 = mix(_e315, _e317, vec3(_e319));
let _e322 = g_f90_;
let _e324 = (*s_3).metallic;
f90_1 = vec3(mix(_e322, 1f, _e324));
let _e328 = (*s_3).albedo;
let _e330 = (*s_3).metallic;
diffuseColor = (_e328 * (1f - _e330));
let _e334 = (*light_1).n_dot_h;
param_43 = _e334;
let _e335 = alpha_6;
param_44 = _e335;
let _e336 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_43), (¶m_44));
d_2 = _e336;
let _e338 = (*s_3).n_dot_v;
param_45 = _e338;
let _e340 = (*light_1).n_dot_l;
param_46 = _e340;
let _e341 = alpha_6;
param_47 = _e341;
let _e342 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47));
vis_1 = _e342;
let _e343 = g_aniso;
if (_e343 > 0f) {
let _e345 = alpha_6;
let _e346 = g_aniso;
let _e347 = g_aniso;
at_2 = mix(_e345, 1f, (_e346 * _e347));
let _e350 = alpha_6;
ab_3 = max(_e350, 0.001f);
let _e352 = g_aniso_t;
let _e354 = (*light_1).h;
let _e356 = g_aniso_b;
let _e358 = (*light_1).h;
let _e361 = (*light_1).n_dot_h;
param_48 = _e361;
param_49 = dot(_e352, _e354);
param_50 = dot(_e356, _e358);
let _e362 = at_2;
param_51 = _e362;
let _e363 = ab_3;
param_52 = _e363;
let _e364 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_48), (¶m_49), (¶m_50), (¶m_51), (¶m_52));
d_2 = _e364;
let _e365 = g_aniso_b;
let _e367 = (*s_3).v;
let _e369 = g_aniso_t;
let _e371 = (*s_3).v;
let _e373 = g_aniso_t;
let _e375 = (*light_1).l;
let _e377 = g_aniso_b;
let _e379 = (*light_1).l;
let _e382 = (*light_1).n_dot_l;
param_53 = _e382;
let _e384 = (*s_3).n_dot_v;
param_54 = _e384;
param_55 = dot(_e365, _e367);
param_56 = dot(_e369, _e371);
param_57 = dot(_e373, _e375);
param_58 = dot(_e377, _e379);
let _e385 = at_2;
param_59 = _e385;
let _e386 = ab_3;
param_60 = _e386;
let _e387 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57), (¶m_58), (¶m_59), (¶m_60));
vis_1 = _e387;
}
let _e388 = f0_2;
param_61 = _e388;
let _e389 = f90_1;
param_62 = _e389;
let _e391 = (*light_1).v_dot_h;
param_63 = _e391;
let _e392 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_61), (¶m_62), (¶m_63));
f_4 = _e392;
let _e393 = f_4;
let _e394 = g_irid_fresnel;
let _e395 = g_iridescence;
f_4 = mix(_e393, _e394, vec3(_e395));
let _e398 = d_2;
let _e399 = vis_1;
let _e401 = f_4;
let _e405 = frag_info.material[3u];
specular = ((_e401 * (_e398 * _e399)) * _e405);
let _e408 = (*light_1).integrated;
if (_e408 > 0.5f) {
let _e412 = (*light_1).ltc[0u];
let _e413 = f0_2;
let _e416 = (*light_1).ltc[1u];
let _e418 = f90_1;
let _e419 = f0_2;
let _e423 = (*light_1).ltc[2u];
let _e429 = frag_info.material[3u];
let _e432 = (*light_1).n_dot_l;
specular = (((((_e413 * _e416) + ((_e418 - _e419) * _e423)) * _e412) * _e429) / vec3(max(_e432, 0.000001f)));
}
let _e436 = EnergyCompensation_u0028_();
if _e436 {
let _e437 = f0_2;
param_64 = _e437;
let _e438 = (*s_3);
param_65 = _e438;
let _e439 = MultiscatterScale_u0028_vf3_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_64), (¶m_65));
let _e440 = specular;
specular = (_e440 * _e439);
}
let _e442 = diffuseColor;
let _e443 = f_4;
diffuse = ((_e442 * (vec3<f32>(1f, 1f, 1f) - _e443)) / vec3(3.1415927f));
let _e448 = EonDiffuse_u0028_();
if _e448 {
let _e450 = (*s_3).n;
let _e452 = (*light_1).l;
let _e456 = (*light_1).l;
let _e458 = (*s_3).v;
let _e460 = diffuseColor;
param_66 = _e460;
let _e462 = (*s_3).roughness;
param_67 = _e462;
param_68 = clamp(dot(_e450, _e452), 0.0001f, 1f);
let _e464 = (*s_3).n_dot_v;
param_69 = _e464;
param_70 = dot(_e456, _e458);
let _e465 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70));
let _e466 = f_4;
diffuse = (_e465 * (vec3<f32>(1f, 1f, 1f) - _e466));
}
let _e469 = g_transmission;
let _e471 = diffuse;
diffuse = (_e471 * (1f - _e469));
let _e473 = g_sheen;
let _e474 = g_sheen_roughness;
param_71 = _e474;
let _e476 = (*light_1).n_dot_h;
param_72 = _e476;
let _e477 = D_Charlie_u0028_f1_u003b_f1_u003b((¶m_71), (¶m_72));
let _e480 = (*s_3).n;
let _e482 = (*light_1).l;
let _e486 = (*s_3).n_dot_v;
param_73 = _e486;
param_74 = clamp(dot(_e480, _e482), 0f, 1f);
let _e487 = V_Neubelt_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
sheen = ((_e473 * _e477) * _e487);
let _e489 = diffuse;
let _e490 = specular;
let _e492 = g_sheen_scale;
let _e494 = sheen;
let _e496 = g_coat_through;
let _e498 = g_coat;
let _e499 = (*s_3);
param_75 = _e499;
let _e500 = (*light_1);
param_76 = _e500;
let _e501 = CoatLobe_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_f1_u002d_f1_u002d_vf31_u003b((¶m_75), (¶m_76));
return ((((((_e489 + _e490) * _e492) + _e494) * _e496) + vec3((_e498 * _e501))) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
let _e261 = (*i_1);
if (_e261 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e263 = (*i_1);
if (_e263 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e265 = (*i_1);
if (_e265 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e267 = (*i_1);
if (_e267 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e269 = (*i_1);
if (_e269 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e271 = (*i_1);
if (_e271 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e273 = (*i_1);
if (_e273 == 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_2: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p_1: vec2<f32>;
var param_77: i32;
let _e266 = (*i_2);
param_77 = _e266;
let _e267 = PointShadowDiskTap_u0028_i1_u003b((¶m_77));
p_1 = _e267;
let _e269 = p_1[0u];
let _e270 = (*ca);
let _e273 = p_1[1u];
let _e274 = (*sa);
let _e278 = p_1[0u];
let _e279 = (*sa);
let _e282 = p_1[1u];
let _e283 = (*ca);
let _e287 = (*radius);
return (vec2<f32>(((_e269 * _e270) - (_e273 * _e274)), ((_e278 * _e279) + (_e282 * _e283))) * _e287);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local_5: vec2<f32>;
var atlas: vec2<f32>;
let _e269 = point_shadow.params[0u];
inset = _e269;
let _e270 = (*uv_1);
let _e271 = (*offset);
let _e273 = inset;
let _e274 = inset;
local_5 = clamp((_e270 + _e271), vec2(_e273), vec2((1f - _e274)));
let _e279 = local_5;
let _e280 = (*tile);
atlas = ((_e279 + _e280) * vec2<f32>(0.16666667f, 0.16666667f));
let _e285 = point_shadow.params3_[0u];
if (_e285 > 0.5f) {
let _e288 = atlas[1u];
atlas[1u] = (1f - _e288);
}
let _e291 = atlas;
let _e292 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e291, 0f);
let _e294 = atlas;
let _e295 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e294, 0f);
let _e298 = (*range);
return (min(_e292.x, _e295.x) * _e298);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: 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_78: vec2<f32>;
var param_79: vec2<f32>;
var param_80: vec2<f32>;
var param_81: f32;
let _e270 = (*uv_2);
param_78 = _e270;
let _e271 = (*offset_1);
param_79 = _e271;
let _e272 = (*tile_1);
param_80 = _e272;
let _e273 = (*range_1);
param_81 = _e273;
let _e274 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_78), (¶m_79), (¶m_80), (¶m_81));
stored = _e274;
let _e275 = stored;
let _e276 = (*range_1);
if (_e275 >= (_e276 * 0.999f)) {
return 1f;
}
let _e279 = (*receiver);
let _e280 = stored;
return select(1f, 0f, (_e279 > _e280));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: 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_82: vec2<f32>;
var param_83: vec2<f32>;
var param_84: vec2<f32>;
var param_85: f32;
var sum: f32;
var count: f32;
var i_3: i32;
var stored_1: f32;
var param_86: i32;
var param_87: f32;
var param_88: f32;
var param_89: f32;
var param_90: vec2<f32>;
var param_91: vec2<f32>;
var param_92: vec2<f32>;
var param_93: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e291 = point_shadow.params2_[1u];
lightRadius = _e291;
let _e294 = point_shadow.params2_[0u];
minRadius = _e294;
let _e297 = point_shadow.params2_[2u];
maxRadius = _e297;
let _e298 = lightRadius;
if (_e298 <= 0f) {
let _e300 = (*uv_3);
param_82 = _e300;
param_83 = vec2<f32>(0f, 0f);
let _e301 = (*tile_2);
param_84 = _e301;
let _e302 = (*range_2);
param_85 = _e302;
let _e303 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_82), (¶m_83), (¶m_84), (¶m_85));
(*blockerOut) = _e303;
let _e304 = minRadius;
return _e304;
}
sum = 0f;
count = 0f;
i_3 = 0i;
loop {
let _e305 = i_3;
if (_e305 < 8i) {
let _e307 = i_3;
param_86 = _e307;
let _e308 = (*ca_1);
param_87 = _e308;
let _e309 = (*sa_1);
param_88 = _e309;
let _e310 = maxRadius;
param_89 = _e310;
let _e311 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_86), (¶m_87), (¶m_88), (¶m_89));
let _e312 = (*uv_3);
param_90 = _e312;
param_91 = _e311;
let _e313 = (*tile_2);
param_92 = _e313;
let _e314 = (*range_2);
param_93 = _e314;
let _e315 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_90), (¶m_91), (¶m_92), (¶m_93));
stored_1 = _e315;
let _e316 = stored_1;
let _e317 = (*range_2);
if (_e316 >= (_e317 * 0.999f)) {
continue;
}
let _e320 = stored_1;
let _e321 = (*receiver_1);
if (_e320 >= _e321) {
continue;
}
let _e323 = stored_1;
let _e324 = sum;
sum = (_e324 + _e323);
let _e326 = count;
count = (_e326 + 1f);
continue;
} else {
break;
}
continuing {
let _e328 = i_3;
i_3 = (_e328 + 1i);
}
}
let _e330 = count;
if (_e330 < 0.5f) {
return -1f;
}
let _e332 = sum;
let _e333 = count;
blocker = max((_e332 / _e333), 0.0001f);
let _e336 = blocker;
(*blockerOut) = _e336;
let _e337 = lightRadius;
let _e338 = (*receiver_1);
let _e339 = blocker;
let _e343 = blocker;
world = ((_e337 * max((_e338 - _e339), 0f)) / _e343);
let _e345 = world;
let _e346 = (*receiver_1);
let _e348 = (*tanHalf);
let _e351 = minRadius;
let _e352 = maxRadius;
return clamp((_e345 / ((2f * _e346) * _e348)), _e351, _e352);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_6: vec2<f32>;
let _e262 = (*rows);
if (_e262 > 0f) {
let _e265 = gl_FragCoord_1[0u];
let _e266 = (*rows);
let _e268 = gl_FragCoord_1[1u];
local_6 = vec2<f32>(_e265, (_e266 - _e268));
} else {
let _e271 = gl_FragCoord_1;
local_6 = _e271.xy;
}
let _e273 = local_6;
return _e273;
}
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_2: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_94: f32;
var angle_1: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_95: vec2<f32>;
var param_96: vec2<f32>;
var param_97: f32;
var param_98: f32;
var param_99: f32;
var param_100: f32;
var param_101: f32;
var param_102: f32;
var local_7: vec3<f32>;
var lit: f32;
var param_103: vec2<f32>;
var param_104: vec2<f32>;
var param_105: vec2<f32>;
var param_106: f32;
var param_107: f32;
var i_4: i32;
var param_108: i32;
var param_109: f32;
var param_110: f32;
var param_111: f32;
var param_112: vec2<f32>;
var param_113: vec2<f32>;
var param_114: vec2<f32>;
var param_115: f32;
var param_116: f32;
var phi_2602_: bool;
var phi_2663_: bool;
let _e314 = (*lightIndex);
let _e318 = point_shadow.slots[_e314][0u];
slot = i32((_e318 + 0.5f));
let _e321 = (*lightIndex);
let _e325 = point_shadow.slots[_e321][0u];
if (_e325 < 0f) {
return 1f;
}
let _e329 = point_shadow.params[2u];
strength = _e329;
let _e330 = strength;
if (_e330 <= 0f) {
return 1f;
}
let _e332 = slot;
let _e335 = point_shadow.lights[_e332];
let _e337 = (*world_1);
toLight = (_e335.xyz - _e337);
let _e339 = toLight;
toLightLength = max(length(_e339), 0.000001f);
let _e342 = (*normal);
let _e343 = toLight;
let _e344 = toLightLength;
nDotL = max(dot(_e342, (_e343 / vec3(_e344))), 0.15f);
let _e349 = nDotL;
let _e350 = nDotL;
let _e355 = nDotL;
let _e356 = nDotL;
slope = min((sqrt(max((1f - (_e349 * _e350)), 0f)) / (_e355 * _e356)), 8f);
let _e360 = toLightLength;
let _e362 = (*lightIndex);
let _e366 = point_shadow.slots[_e362][2u];
let _e371 = point_shadow.params3_[1u];
texel = (((2f * _e360) * max(_e366, 0.0001f)) * _e371);
let _e373 = (*world_1);
let _e374 = (*normal);
let _e375 = texel;
let _e379 = point_shadow.params[3u];
let _e381 = slope;
origin = (_e373 + (((_e374 * _e375) * _e379) * (1f + _e381)));
let _e385 = origin;
let _e386 = slot;
let _e389 = point_shadow.lights[_e386];
toFragment = (_e385 - _e389.xyz);
let _e392 = toFragment;
distance_ = length(_e392);
let _e394 = slot;
let _e398 = point_shadow.lights[_e394][3u];
range_3 = max(_e398, 0.0001f);
let _e400 = distance_;
let _e401 = range_3;
if (_e400 >= _e401) {
return 1f;
}
face = 0i;
let _e403 = (*lightIndex);
let _e407 = point_shadow.slots[_e403][1u];
if (_e407 < 0.5f) {
let _e409 = toFragment;
a_2 = abs(_e409);
let _e412 = a_2[0u];
let _e414 = a_2[1u];
let _e415 = (_e412 >= _e414);
phi_2602_ = _e415;
if _e415 {
let _e417 = a_2[0u];
let _e419 = a_2[2u];
phi_2602_ = (_e417 >= _e419);
}
let _e422 = phi_2602_;
if _e422 {
let _e424 = toFragment[0u];
face = select(1i, 0i, (_e424 > 0f));
} else {
let _e428 = a_2[1u];
let _e430 = a_2[2u];
if (_e428 >= _e430) {
let _e433 = toFragment[1u];
face = select(3i, 2i, (_e433 > 0f));
} else {
let _e437 = toFragment[2u];
face = select(5i, 4i, (_e437 > 0f));
}
}
}
let _e440 = slot;
let _e442 = face;
let _e446 = point_shadow.faces[((_e440 * 6i) + _e442)];
let _e447 = origin;
clip = (_e446 * vec4<f32>(_e447.x, _e447.y, _e447.z, 1f));
let _e454 = clip[3u];
if (_e454 <= 0f) {
return 1f;
}
let _e456 = clip;
let _e459 = clip[3u];
ndc = (_e456.xy / vec2(_e459));
let _e463 = ndc[0u];
let _e465 = (abs(_e463) > 1f);
phi_2663_ = _e465;
if !(_e465) {
let _e468 = ndc[1u];
phi_2663_ = (abs(_e468) > 1f);
}
let _e472 = phi_2663_;
if _e472 {
return 1f;
}
let _e474 = ndc[0u];
let _e478 = ndc[1u];
uv_4 = vec2<f32>(((_e474 * 0.5f) + 0.5f), (0.5f - (_e478 * 0.5f)));
let _e482 = face;
let _e484 = slot;
tile_3 = vec2<f32>(f32(_e482), f32(_e484));
let _e487 = distance_;
let _e490 = point_shadow.params[1u];
receiver_2 = (_e487 - _e490);
let _e494 = frag_info.target_origin[0u];
param_94 = _e494;
let _e495 = FragCoordFromTop_u0028_f1_u003b((¶m_94));
noise = fract((52.982918f * fract(dot(_e495, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e500 = noise;
angle_1 = (_e500 * 6.2831855f);
let _e502 = angle_1;
ca_2 = cos(_e502);
let _e504 = angle_1;
sa_2 = sin(_e504);
let _e506 = (*lightIndex);
let _e510 = point_shadow.slots[_e506][2u];
tanHalf_1 = max(_e510, 0.0001f);
blocker_1 = -1f;
let _e512 = uv_4;
param_95 = _e512;
let _e513 = tile_3;
param_96 = _e513;
let _e514 = range_3;
param_97 = _e514;
let _e515 = receiver_2;
param_98 = _e515;
let _e516 = ca_2;
param_99 = _e516;
let _e517 = sa_2;
param_100 = _e517;
let _e518 = tanHalf_1;
param_101 = _e518;
let _e519 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_95), (¶m_96), (¶m_97), (¶m_98), (¶m_99), (¶m_100), (¶m_101), (¶m_102));
let _e520 = param_102;
blocker_1 = _e520;
radius_1 = _e519;
let _e523 = point_shadow.params2_[3u];
if (_e523 > 0.5f) {
g_debug_surface_on = true;
let _e525 = radius_1;
if (_e525 < 0f) {
local_7 = vec3<f32>(0f, 0f, 1f);
} else {
let _e527 = radius_1;
let _e530 = point_shadow.params2_[2u];
let _e534 = blocker_1;
let _e535 = range_3;
local_7 = vec3<f32>(clamp((_e527 / max(_e530, 0.000001f)), 0f, 1f), clamp((_e534 / _e535), 0f, 1f), 0f);
}
let _e539 = local_7;
g_debug_surface = _e539;
}
let _e540 = radius_1;
if (_e540 < 0f) {
return 1f;
}
let _e542 = uv_4;
param_103 = _e542;
param_104 = vec2<f32>(0f, 0f);
let _e543 = tile_3;
param_105 = _e543;
let _e544 = range_3;
param_106 = _e544;
let _e545 = receiver_2;
param_107 = _e545;
let _e546 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
lit = _e546;
let _e547 = radius_1;
if (_e547 > 0f) {
i_4 = 0i;
loop {
let _e549 = i_4;
if (_e549 < 8i) {
let _e551 = i_4;
param_108 = _e551;
let _e552 = ca_2;
param_109 = _e552;
let _e553 = sa_2;
param_110 = _e553;
let _e554 = radius_1;
param_111 = _e554;
let _e555 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_108), (¶m_109), (¶m_110), (¶m_111));
let _e556 = uv_4;
param_112 = _e556;
param_113 = _e555;
let _e557 = tile_3;
param_114 = _e557;
let _e558 = range_3;
param_115 = _e558;
let _e559 = receiver_2;
param_116 = _e559;
let _e560 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_112), (¶m_113), (¶m_114), (¶m_115), (¶m_116));
let _e561 = lit;
lit = (_e561 + _e560);
continue;
} else {
break;
}
continuing {
let _e563 = i_4;
i_4 = (_e563 + 1i);
}
}
let _e565 = lit;
lit = (_e565 * 0.11111111f);
}
let _e567 = lit;
let _e568 = strength;
return mix(1f, _e567, clamp(_e568, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r_3: f32;
var theta: f32;
let _e265 = (*i_5);
let _e268 = (*n_2);
r_3 = sqrt(((f32(_e265) + 0.5f) / f32(_e268)));
let _e272 = (*i_5);
let _e275 = (*turn);
theta = ((f32(_e272) * 2.3999631f) + _e275);
let _e277 = r_3;
let _e278 = theta;
let _e280 = theta;
return (vec2<f32>(cos(_e278), sin(_e280)) * _e277);
}
fn ShadowNoise_u0028_() -> f32 {
var at_3: vec2<f32>;
var param_117: f32;
let _e264 = frag_info.target_origin[0u];
param_117 = _e264;
let _e265 = FragCoordFromTop_u0028_f1_u003b((¶m_117));
let _e268 = frag_info.target_origin[3u];
at_3 = (_e265 + vec2((5.588238f * max(_e268, 0f))));
let _e273 = at_3;
return fract((52.982918f * fract(dot(_e273, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_3: f32;
var pMax: f32;
var reduced: f32;
let _e269 = (*moments)[1u];
let _e271 = (*moments)[0u];
let _e273 = (*moments)[0u];
let _e276 = (*minVariance);
variance = max((_e269 - (_e271 * _e273)), _e276);
let _e278 = (*t);
let _e280 = (*moments)[0u];
d_3 = (_e278 - _e280);
let _e282 = variance;
let _e283 = variance;
let _e284 = d_3;
let _e285 = d_3;
pMax = (_e282 / (_e283 + (_e284 * _e285)));
let _e289 = pMax;
let _e290 = (*bleed);
let _e292 = (*bleed);
reduced = clamp(((_e289 - _e290) / max((1f - _e292), 0.0001f)), 0f, 1f);
let _e297 = (*t);
let _e299 = (*moments)[0u];
let _e301 = reduced;
return select(_e301, 1f, (_e297 <= _e299));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_4: f32;
let _e262 = (*depth);
d_4 = ((2f * clamp(_e262, 0f, 1f)) - 1f);
let _e266 = d_4;
let _e269 = d_4;
return vec2<f32>(exp((40f * _e266)), -(exp((-5f * _e269))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_118: f32;
var scale: vec2<f32>;
var positive: f32;
var param_119: vec2<f32>;
var param_120: f32;
var param_121: f32;
var param_122: f32;
var negative: f32;
var param_123: vec2<f32>;
var param_124: f32;
var param_125: f32;
var param_126: f32;
let _e276 = (*depth_1);
param_118 = _e276;
let _e277 = EvsmWarp_u0028_f1_u003b((¶m_118));
warped = _e277;
let _e278 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e278);
let _e281 = scale[0u];
let _e283 = scale[0u];
let _e285 = (*moments_1);
param_119 = _e285.xy;
let _e288 = warped[0u];
param_120 = _e288;
param_121 = (_e281 * _e283);
let _e289 = (*bleed_1);
param_122 = _e289;
let _e290 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_119), (¶m_120), (¶m_121), (¶m_122));
positive = _e290;
let _e292 = scale[1u];
let _e294 = scale[1u];
let _e296 = (*moments_1);
param_123 = _e296.zw;
let _e299 = warped[1u];
param_124 = _e299;
param_125 = (_e292 * _e294);
let _e300 = (*bleed_1);
param_126 = _e300;
let _e301 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125), (¶m_126));
negative = _e301;
let _e302 = positive;
let _e303 = negative;
return min(_e302, _e303);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_8: mat4x4<f32>;
var local_9: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_10: f32;
var local_11: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_127: vec4<f32>;
var param_128: f32;
var param_129: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_6: i32;
var occluder_1: f32;
var param_130: i32;
var param_131: i32;
var param_132: f32;
var gap: f32;
var radius_2: f32;
var i_7: i32;
var occluder_2: f32;
var param_133: i32;
var param_134: i32;
var param_135: f32;
var phi_3823_: bool;
var phi_3834_: bool;
var phi_3990_: bool;
var phi_3997_: bool;
var phi_4004_: bool;
let _e321 = frag_info.shadow_params[3u];
strength_1 = _e321;
let _e322 = strength_1;
if (_e322 <= 0f) {
return 1f;
}
let _e324 = (*lightIndex_1);
let _e327 = frag_info.frame_params[2u];
if (_e324 != i32((_e327 + 0.5f))) {
return 1f;
}
let _e333 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e333 + 0.5f));
let _e336 = v_world_position_1;
let _e338 = frag_info.camera_position;
viewDistance = length((_e336 - _e338.xyz));
cascade = 0i;
let _e342 = cascadeCount;
let _e343 = (_e342 > 1i);
phi_3823_ = _e343;
if _e343 {
let _e344 = viewDistance;
let _e347 = frag_info.shadow_cascades[0u];
phi_3823_ = (_e344 > _e347);
}
let _e350 = phi_3823_;
if _e350 {
cascade = 1i;
}
let _e351 = cascadeCount;
let _e352 = (_e351 > 2i);
phi_3834_ = _e352;
if _e352 {
let _e353 = viewDistance;
let _e356 = frag_info.shadow_cascades[1u];
phi_3834_ = (_e353 > _e356);
}
let _e359 = phi_3834_;
if _e359 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e360 = attempt;
if (_e360 < 3i) {
let _e362 = cascade;
let _e363 = attempt;
which = (_e362 + _e363);
let _e365 = which;
let _e366 = cascadeCount;
if (_e365 >= _e366) {
break;
}
let _e368 = which;
if (_e368 == 0i) {
let _e371 = frag_info.shadow_matrix;
local_8 = _e371;
} else {
let _e372 = which;
if (_e372 == 1i) {
let _e375 = frag_info.shadow_matrix_far;
local_9 = _e375;
} else {
let _e377 = frag_info.shadow_matrix_farthest;
local_9 = _e377;
}
let _e378 = local_9;
local_8 = _e378;
}
let _e379 = local_8;
matrix = _e379;
let _e382 = matrix[0][0u];
let _e385 = matrix[1][0u];
let _e388 = matrix[2][0u];
axisX = vec3<f32>(_e382, _e385, _e388);
let _e392 = matrix[0][1u];
let _e395 = matrix[1][1u];
let _e398 = matrix[2][1u];
axisY = vec3<f32>(_e392, _e395, _e398);
let _e400 = axisX;
rowX = max(length(_e400), 0.000001f);
let _e403 = axisY;
rowY = max(length(_e403), 0.000001f);
let _e408 = frag_info.shadow_cascades[3u];
let _e410 = rowX;
texelMetres = ((2f * _e408) / _e410);
let _e414 = frag_info.shadow_cascades[3u];
let _e417 = (*s_4).n;
let _e418 = axisX;
let _e421 = rowX;
let _e422 = rowX;
let _e426 = (*s_4).n;
let _e427 = axisY;
let _e430 = rowY;
let _e431 = rowY;
reach = ((3f * _e414) * ((abs(dot(_e417, _e418)) / (_e421 * _e422)) + (abs(dot(_e426, _e427)) / (_e430 * _e431))));
let _e436 = v_world_position_1;
let _e438 = (*s_4).n;
let _e441 = frag_info.shadow_params[2u];
let _e442 = reach;
origin_1 = (_e436 + (_e438 * (_e441 + _e442)));
let _e446 = matrix;
let _e447 = origin_1;
lightSpace = (_e446 * vec4<f32>(_e447.x, _e447.y, _e447.z, 1f));
let _e454 = lightSpace[3u];
if (_e454 <= 0f) {
continue;
}
let _e456 = lightSpace;
let _e459 = lightSpace[3u];
candidate = (_e456.xyz / vec3(_e459));
let _e463 = candidate[0u];
let _e467 = candidate[1u];
inTile = vec2<f32>(((_e463 * 0.5f) + 0.5f), (0.5f - (_e467 * 0.5f)));
let _e472 = inTile[0u];
let _e473 = (_e472 < 0f);
phi_3990_ = _e473;
if !(_e473) {
let _e476 = inTile[0u];
phi_3990_ = (_e476 > 1f);
}
let _e479 = phi_3990_;
phi_3997_ = _e479;
if !(_e479) {
let _e482 = inTile[1u];
phi_3997_ = (_e482 < 0f);
}
let _e485 = phi_3997_;
phi_4004_ = _e485;
if !(_e485) {
let _e488 = inTile[1u];
phi_4004_ = (_e488 > 1f);
}
let _e491 = phi_4004_;
if _e491 {
continue;
}
let _e493 = candidate[2u];
if (_e493 > 1f) {
let _e495 = which;
let _e496 = cascadeCount;
if (_e495 < (_e496 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e501 = inTile[0u];
let _e502 = which;
let _e505 = cascadeCount;
let _e509 = inTile[1u];
uv_5 = vec2<f32>(((_e501 + f32(_e502)) / f32(_e505)), _e509);
let _e511 = candidate;
projected = _e511;
let _e512 = which;
cascade = _e512;
let _e513 = texelMetres;
cascadeTexel = _e513;
let _e516 = matrix[0][2u];
let _e519 = matrix[1][2u];
let _e522 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e516, _e519, _e522)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e527 = attempt;
attempt = (_e527 + 1i);
}
}
let _e529 = found;
if !(_e529) {
return 1f;
}
let _e531 = cascade;
if (_e531 == 0i) {
let _e535 = frag_info.shadow_bias[0u];
local_10 = _e535;
} else {
let _e536 = cascade;
if (_e536 == 1i) {
let _e540 = frag_info.shadow_bias[1u];
local_11 = _e540;
} else {
let _e543 = frag_info.shadow_bias[2u];
local_11 = _e543;
}
let _e544 = local_11;
local_10 = _e544;
}
let _e545 = local_10;
bias = _e545;
let _e548 = frag_info.shadow_params[0u];
let _e551 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e548, _e551);
let _e553 = cascade;
let _e555 = cascadeCount;
let _e559 = texel_1;
tileLo = (vec2<f32>((f32(_e553) / f32(_e555)), 0f) + (_e559 * 0.5f));
let _e562 = cascade;
let _e565 = cascadeCount;
let _e569 = texel_1;
tileHi = (vec2<f32>((f32((_e562 + 1i)) / f32(_e565)), 1f) - (_e569 * 0.5f));
let _e574 = frag_info.ambient_ground[3u];
softness = _e574;
lit_1 = 0f;
let _e575 = softness;
if (_e575 < 0f) {
let _e577 = uv_5;
let _e578 = tileLo;
let _e579 = tileHi;
let _e581 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e577, _e578, _e579), 0f);
moments_2 = _e581;
let _e583 = projected[2u];
let _e584 = bias;
let _e586 = softness;
let _e590 = moments_2;
param_127 = _e590;
param_128 = (_e583 - _e584);
param_129 = clamp((-(_e586) - 1f), 0f, 0.95f);
let _e591 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_127), (¶m_128), (¶m_129));
lit_1 = _e591;
} else {
let _e592 = softness;
if (_e592 <= 0f) {
y_1 = -1i;
loop {
let _e594 = y_1;
if (_e594 <= 1i) {
x_1 = -1i;
loop {
let _e596 = x_1;
if (_e596 <= 1i) {
let _e598 = uv_5;
let _e599 = x_1;
let _e601 = y_1;
let _e604 = texel_1;
let _e607 = tileLo;
let _e608 = tileHi;
let _e610 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e598 + (vec2<f32>(f32(_e599), f32(_e601)) * _e604)), _e607, _e608), 0f);
occluder = _e610.x;
let _e613 = projected[2u];
let _e614 = bias;
let _e616 = occluder;
let _e619 = lit_1;
lit_1 = (_e619 + select(1f, 0f, ((_e613 - _e614) > _e616)));
continue;
} else {
break;
}
continuing {
let _e621 = x_1;
x_1 = (_e621 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e623 = y_1;
y_1 = (_e623 + 1i);
}
}
let _e625 = lit_1;
lit_1 = (_e625 * 0.11111111f);
} else {
let _e627 = softness;
spread = tan(min(_e627, 0.5f));
let _e630 = ShadowNoise_u0028_();
turn_1 = (_e630 * 6.2831855f);
let _e632 = spread;
let _e634 = projected[2u];
let _e636 = cascadeDepth;
let _e638 = cascadeTexel;
searchRadius = clamp((((_e632 * _e634) * _e636) / _e638), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_6 = 0i;
loop {
let _e641 = i_6;
if (_e641 < 16i) {
let _e643 = uv_5;
let _e644 = i_6;
param_130 = _e644;
param_131 = 16i;
let _e645 = turn_1;
param_132 = _e645;
let _e646 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_130), (¶m_131), (¶m_132));
let _e647 = texel_1;
let _e649 = searchRadius;
let _e652 = tileLo;
let _e653 = tileHi;
let _e655 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e643 + ((_e646 * _e647) * _e649)), _e652, _e653), 0f);
occluder_1 = _e655.x;
let _e658 = projected[2u];
let _e659 = bias;
let _e661 = occluder_1;
if ((_e658 - _e659) > _e661) {
let _e663 = occluder_1;
let _e664 = blockerSum;
blockerSum = (_e664 + _e663);
let _e666 = blockerCount;
blockerCount = (_e666 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e668 = i_6;
i_6 = (_e668 + 1i);
}
}
let _e670 = blockerCount;
if (_e670 <= 0f) {
return 1f;
}
let _e673 = projected[2u];
let _e674 = blockerSum;
let _e675 = blockerCount;
let _e679 = cascadeDepth;
gap = (max((_e673 - (_e674 / _e675)), 0f) * _e679);
let _e681 = spread;
let _e682 = gap;
let _e684 = cascadeTexel;
radius_2 = clamp(((_e681 * _e682) / _e684), 1f, 16f);
i_7 = 0i;
loop {
let _e687 = i_7;
if (_e687 < 16i) {
let _e689 = uv_5;
let _e690 = turn_1;
let _e692 = i_7;
param_133 = _e692;
param_134 = 16i;
param_135 = (_e690 + 1f);
let _e693 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_133), (¶m_134), (¶m_135));
let _e694 = texel_1;
let _e696 = radius_2;
let _e699 = tileLo;
let _e700 = tileHi;
let _e702 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e689 + ((_e693 * _e694) * _e696)), _e699, _e700), 0f);
occluder_2 = _e702.x;
let _e705 = projected[2u];
let _e706 = bias;
let _e708 = occluder_2;
let _e711 = lit_1;
lit_1 = (_e711 + select(1f, 0f, ((_e705 - _e706) > _e708)));
continue;
} else {
break;
}
continuing {
let _e713 = i_7;
i_7 = (_e713 + 1i);
}
}
let _e715 = lit_1;
lit_1 = (_e715 * 0.0625f);
}
}
let _e717 = lit_1;
let _e718 = strength_1;
return mix(1f, _e717, clamp(_e718, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_136: Surface;
var param_137: LightSample;
var param_138: i32;
let _e266 = (*s_5);
param_136 = _e266;
let _e267 = (*light_3);
param_137 = _e267;
let _e268 = (*index);
param_138 = _e268;
let _e269 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_136), (¶m_137), (¶m_138));
return _e269;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e261 = (*index_1);
return (_e261 < 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 _e265 = (*distance_1);
let _e266 = (*distance_1);
attenuation = (1f / max((_e265 * _e266), 0.0001f));
let _e270 = (*range_4);
if (_e270 > 0f) {
let _e272 = (*distance_1);
let _e273 = (*range_4);
ratio = (_e272 / _e273);
let _e275 = ratio;
let _e276 = ratio;
let _e278 = ratio;
let _e280 = ratio;
window = clamp((1f - (((_e275 * _e276) * _e278) * _e280)), 0f, 1f);
let _e284 = window;
let _e285 = window;
let _e287 = attenuation;
attenuation = (_e287 * (_e284 * _e285));
}
let _e289 = attenuation;
return _e289;
}
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_3: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_12: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e277 = (*halfWidth);
let _e278 = (*halfHeight);
n_3 = cross(_e277, _e278);
let _e280 = n_3;
nLen = length(_e280);
let _e282 = nLen;
if (_e282 < 0.000000000001f) {
let _e284 = (*centre);
return _e284;
}
let _e285 = nLen;
let _e286 = n_3;
n_3 = (_e286 / vec3(_e285));
let _e289 = (*centre);
let _e290 = (*world_2);
toPlane = (_e289 - _e290);
let _e292 = (*mirror);
let _e293 = n_3;
denom = dot(_e292, _e293);
let _e295 = denom;
if (abs(_e295) < 0.00001f) {
let _e298 = toPlane;
let _e299 = n_3;
let _e300 = toPlane;
let _e301 = n_3;
onPlane = (_e298 - (_e299 * dot(_e300, _e301)));
} else {
let _e305 = toPlane;
let _e306 = n_3;
let _e308 = denom;
t_1 = (dot(_e305, _e306) / _e308);
let _e310 = t_1;
if (_e310 > 0f) {
let _e312 = (*mirror);
let _e313 = t_1;
local_12 = (_e312 * _e313);
} else {
let _e315 = toPlane;
let _e316 = n_3;
let _e317 = toPlane;
let _e318 = n_3;
local_12 = (_e315 - (_e316 * dot(_e317, _e318)));
}
let _e322 = local_12;
onPlane = _e322;
}
let _e323 = onPlane;
let _e324 = toPlane;
offset_2 = (_e323 - _e324);
let _e326 = (*halfWidth);
let _e327 = (*halfWidth);
wLen2_ = max(dot(_e326, _e327), 0.000000000001f);
let _e330 = (*halfHeight);
let _e331 = (*halfHeight);
hLen2_ = max(dot(_e330, _e331), 0.000000000001f);
let _e334 = offset_2;
let _e335 = (*halfWidth);
let _e337 = wLen2_;
u = clamp((dot(_e334, _e335) / _e337), -1f, 1f);
let _e340 = offset_2;
let _e341 = (*halfHeight);
let _e343 = hLen2_;
v_1 = clamp((dot(_e340, _e341) / _e343), -1f, 1f);
let _e346 = (*centre);
let _e347 = (*halfWidth);
let _e348 = u;
let _e351 = (*halfHeight);
let _e352 = v_1;
return ((_e346 + (_e347 * _e348)) + (_e351 * _e352));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_2: f32;
var axis_1: vec3<f32>;
var len_2: f32;
var local_13: f32;
let _e269 = (*a_3);
let _e270 = (*a_3);
ua = (_e269 / vec3(max(length(_e270), 0.000000000001f)));
let _e275 = (*b_1);
let _e276 = (*b_1);
ub = (_e275 / vec3(max(length(_e276), 0.000000000001f)));
let _e281 = ua;
let _e282 = ub;
angle_2 = acos(clamp(dot(_e281, _e282), -1f, 1f));
let _e286 = ua;
let _e287 = ub;
axis_1 = cross(_e286, _e287);
let _e289 = axis_1;
len_2 = length(_e289);
let _e291 = len_2;
if (_e291 > 0.000001f) {
let _e293 = angle_2;
let _e294 = axis_1;
let _e295 = (*n_4);
let _e298 = len_2;
local_13 = ((_e293 * dot(_e294, _e295)) / _e298);
} else {
local_13 = 0f;
}
let _e300 = local_13;
return _e300;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_8: i32;
var a_4: vec3<f32>;
var b_2: vec3<f32>;
var local_14: i32;
var ha: f32;
var hb: f32;
var d_5: f32;
var q: vec3<f32>;
var local_15: f32;
var aAbove: bool;
var bAbove: bool;
var local_16: f32;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: vec3<f32>;
var param_142: vec3<f32>;
var param_143: vec3<f32>;
var param_144: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e283 = i_8;
if (_e283 < 4i) {
let _e285 = i_8;
let _e287 = (*corners_1)[_e285];
a_4 = _e287;
let _e288 = i_8;
if (_e288 == 3i) {
local_14 = 0i;
} else {
let _e290 = i_8;
local_14 = (_e290 + 1i);
}
let _e292 = local_14;
let _e294 = (*corners_1)[_e292];
b_2 = _e294;
let _e295 = a_4;
let _e296 = (*n_5);
ha = dot(_e295, _e296);
let _e298 = b_2;
let _e299 = (*n_5);
hb = dot(_e298, _e299);
let _e301 = ha;
let _e302 = hb;
d_5 = (_e301 - _e302);
let _e304 = a_4;
let _e305 = b_2;
let _e306 = a_4;
let _e308 = d_5;
if (abs(_e308) > 0.000000000001f) {
let _e311 = ha;
let _e312 = d_5;
local_15 = (_e311 / _e312);
} else {
local_15 = 0f;
}
let _e314 = local_15;
q = (_e304 + ((_e305 - _e306) * _e314));
let _e317 = ha;
aAbove = (_e317 > 0f);
let _e319 = hb;
bAbove = (_e319 > 0f);
let _e321 = aAbove;
let _e322 = bAbove;
if (_e321 || _e322) {
let _e324 = aAbove;
let _e325 = a_4;
let _e326 = q;
let _e329 = bAbove;
let _e330 = b_2;
let _e331 = q;
param_139 = select(_e326, _e325, vec3(_e324));
param_140 = select(_e331, _e330, vec3(_e329));
let _e334 = (*n_5);
param_141 = _e334;
let _e335 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_139), (¶m_140), (¶m_141));
local_16 = _e335;
} else {
local_16 = 0f;
}
let _e336 = local_16;
let _e337 = total;
total = (_e337 + _e336);
let _e339 = aAbove;
let _e340 = bAbove;
let _e343 = q;
let _e344 = exit;
exit = select(_e344, _e343, vec3((_e339 && !(_e340))));
let _e347 = aAbove;
let _e349 = bAbove;
let _e351 = q;
let _e352 = entry;
entry = select(_e352, _e351, vec3((!(_e347) && _e349)));
continue;
} else {
break;
}
continuing {
let _e355 = i_8;
i_8 = (_e355 + 1i);
}
}
let _e357 = exit;
param_142 = _e357;
let _e358 = entry;
param_143 = _e358;
let _e359 = (*n_5);
param_144 = _e359;
let _e360 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_142), (¶m_143), (¶m_144));
let _e361 = total;
total = (_e361 + _e360);
let _e363 = total;
return max((-(_e363) * 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_17: f32;
var local_18: f32;
var local_19: f32;
let _e266 = (*slot_1);
let _e267 = (*slot_1);
lane = (_e266 - ((_e267 / 4i) * 4i));
let _e271 = lane;
if (_e271 == 0i) {
let _e274 = (*four)[0u];
local_17 = _e274;
} else {
let _e275 = lane;
if (_e275 == 1i) {
let _e278 = (*four)[1u];
local_18 = _e278;
} else {
let _e279 = lane;
if (_e279 == 2i) {
let _e282 = (*four)[2u];
local_19 = _e282;
} else {
let _e284 = (*four)[3u];
local_19 = _e284;
}
let _e285 = local_19;
local_18 = _e285;
}
let _e286 = local_18;
local_17 = _e286;
}
let _e287 = local_17;
return _e287;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_145: vec4<f32>;
var param_146: i32;
let _e263 = (*slot_2);
let _e267 = light_list_info.scales[(_e263 / 4i)];
param_145 = _e267;
let _e268 = (*slot_2);
param_146 = _e268;
let _e269 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_145), (¶m_146));
return _e269;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e265 = light_list_info.slot_rows[0i];
let _e266 = (*row);
a_5 = abs((_e265 - vec4(_e266)));
let _e272 = light_list_info.slot_rows[1i];
let _e273 = (*row);
b_3 = abs((_e272 - vec4(_e273)));
let _e278 = a_5[0u];
let _e280 = a_5[1u];
let _e283 = a_5[2u];
let _e285 = a_5[3u];
let _e289 = b_3[0u];
let _e291 = b_3[1u];
let _e294 = b_3[2u];
let _e296 = b_3[3u];
return (min(min(min(_e278, _e280), min(_e283, _e285)), min(min(_e289, _e291), min(_e294, _e296))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_147: vec4<f32>;
var param_148: i32;
let _e263 = (*slot_3);
let _e267 = light_list_info.indices[(_e263 / 4i)];
param_147 = _e267;
let _e268 = (*slot_3);
param_148 = _e268;
let _e269 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_147), (¶m_148));
return _e269;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e262 = (*texel_2);
let _e266 = light_list_info.list[1u];
let _e268 = (*row_1);
let _e272 = light_list_info.list[2u];
let _e275 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e262 + 0.5f) * _e266), ((_e268 + 0.5f) * _e272)), 0f);
return _e275;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_149: f32;
var param_150: f32;
var param_151: vec4<f32>;
var param_152: i32;
let _e270 = g_cluster_offset;
let _e271 = (*slot_4);
entry_1 = (_e270 + f32(_e271));
let _e274 = entry_1;
row_2 = floor((_e274 / 16f));
let _e277 = entry_1;
let _e278 = row_2;
within = (_e277 - (_e278 * 16f));
let _e281 = within;
texel_3 = floor((_e281 / 4f));
let _e286 = light_list_info.cluster_depth[3u];
let _e287 = row_2;
let _e289 = texel_3;
param_149 = _e289;
param_150 = (_e286 + _e287);
let _e290 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_149), (¶m_150));
four_1 = _e290;
let _e291 = within;
let _e292 = texel_3;
let _e297 = four_1;
param_151 = _e297;
param_152 = i32(((_e291 - (_e292 * 4f)) + 0.5f));
let _e298 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_151), (¶m_152));
return _e298;
}
fn Clustered_u0028_() -> bool {
let _e262 = light_list_info.cluster_grid[3u];
return (_e262 > 0.5f);
}
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_6: ptr<function, Surface>) -> LightSample {
var light_4: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_20: f32;
var param_153: i32;
var param_154: i32;
var v_2: f32;
var u_1: f32;
var local_21: f32;
var param_155: f32;
var param_156: i32;
var type_45: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_2: array<vec3<f32>, 4>;
var behind: bool;
var formFactor: f32;
var local_22: f32;
var param_157: array<vec3<f32>, 4>;
var param_158: vec3<f32>;
var area: f32;
var radiance: f32;
var local_23: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_159: vec3<f32>;
var param_160: vec3<f32>;
var param_161: vec3<f32>;
var param_162: vec3<f32>;
var param_163: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_24: vec3<f32>;
var param_164: vec3<f32>;
var param_165: vec3<f32>;
var param_166: f32;
var param_167: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_168: f32;
var param_169: f32;
var cosAngle: f32;
light_4.integrated = 0f;
light_4.ltc = vec3<f32>(0f, 0f, 0f);
let _e317 = (*index_2);
if (_e317 < 8i) {
let _e319 = (*index_2);
let _e322 = frag_info.light_position[_e319];
position = _e322;
let _e323 = (*index_2);
let _e326 = frag_info.light_color[_e323];
color_1 = _e326;
let _e327 = (*index_2);
let _e330 = frag_info.light_direction[_e327];
direction = _e330;
let _e331 = (*index_2);
let _e334 = frag_info.light_cone[_e331];
cone = _e334;
} else {
let _e335 = (*index_2);
slot_5 = (_e335 - 8i);
let _e337 = Clustered_u0028_();
clustered = _e337;
let _e338 = clustered;
if _e338 {
let _e339 = slot_5;
param_153 = _e339;
let _e340 = ClusterRow_u0028_i1_u003b((¶m_153));
local_20 = _e340;
} else {
let _e341 = slot_5;
param_154 = _e341;
let _e342 = LightListRow_u0028_i1_u003b((¶m_154));
local_20 = _e342;
}
let _e343 = local_20;
listRow = _e343;
let _e344 = listRow;
let _e348 = light_list_info.list[2u];
v_2 = ((_e344 + 0.5f) * _e348);
let _e352 = light_list_info.list[1u];
u_1 = _e352;
let _e353 = u_1;
let _e355 = v_2;
let _e357 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e353), _e355), 0f);
position = _e357;
let _e358 = u_1;
let _e360 = v_2;
let _e362 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e358), _e360), 0f);
color_1 = _e362;
let _e363 = u_1;
let _e365 = v_2;
let _e367 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e363), _e365), 0f);
direction = _e367;
let _e368 = u_1;
let _e370 = v_2;
let _e372 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e368), _e370), 0f);
cone = _e372;
let _e373 = clustered;
if _e373 {
let _e374 = listRow;
param_155 = _e374;
let _e375 = InSlots_u0028_f1_u003b((¶m_155));
local_21 = select(1f, 0f, _e375);
} else {
let _e377 = slot_5;
param_156 = _e377;
let _e378 = LightListScale_u0028_i1_u003b((¶m_156));
local_21 = _e378;
}
let _e379 = local_21;
let _e381 = color_1[3u];
color_1[3u] = (_e381 * _e379);
}
let _e385 = position[3u];
type_45 = _e385;
let _e386 = type_45;
if (_e386 > 2.5f) {
let _e388 = direction;
halfWidth_1 = _e388.xyz;
let _e390 = cone;
halfHeight_1 = _e390.xyz;
let _e392 = position;
let _e394 = v_world_position_1;
toCentre = (_e392.xyz - _e394);
let _e396 = toCentre;
let _e397 = halfWidth_1;
let _e399 = halfHeight_1;
corners_2[0i] = ((_e396 - _e397) - _e399);
let _e402 = toCentre;
let _e403 = halfWidth_1;
let _e405 = halfHeight_1;
corners_2[1i] = ((_e402 + _e403) - _e405);
let _e408 = toCentre;
let _e409 = halfWidth_1;
let _e411 = halfHeight_1;
corners_2[2i] = ((_e408 + _e409) + _e411);
let _e414 = toCentre;
let _e415 = halfWidth_1;
let _e417 = halfHeight_1;
corners_2[3i] = ((_e414 - _e415) + _e417);
let _e420 = toCentre;
let _e421 = halfWidth_1;
let _e422 = halfHeight_1;
behind = (dot(_e420, cross(_e421, _e422)) >= 0f);
let _e426 = behind;
if _e426 {
local_22 = 0f;
} else {
let _e427 = corners_2;
param_157 = _e427;
let _e429 = (*s_6).n;
param_158 = _e429;
let _e430 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_157), (¶m_158));
local_22 = _e430;
}
let _e431 = local_22;
formFactor = _e431;
let _e432 = halfWidth_1;
let _e433 = halfHeight_1;
area = (length(cross(_e432, _e433)) * 4f);
let _e437 = area;
if (_e437 > 0.000000001f) {
let _e439 = area;
local_23 = (1f / _e439);
} else {
local_23 = 0f;
}
let _e441 = local_23;
radiance = _e441;
let _e442 = toCentre;
distance_2 = length(_e442);
let _e445 = direction[3u];
if (_e445 > 0f) {
let _e447 = distance_2;
let _e449 = direction[3u];
ratio_1 = (_e447 / _e449);
let _e451 = ratio_1;
let _e452 = ratio_1;
let _e454 = ratio_1;
let _e456 = ratio_1;
window_1 = clamp((1f - (((_e451 * _e452) * _e454) * _e456)), 0f, 1f);
let _e460 = window_1;
let _e461 = window_1;
let _e463 = radiance;
radiance = (_e463 * (_e460 * _e461));
}
let _e466 = (*s_6).v;
let _e469 = (*s_6).n;
mirror_1 = reflect(-(_e466), _e469);
let _e471 = position;
param_159 = _e471.xyz;
let _e473 = halfWidth_1;
param_160 = _e473;
let _e474 = halfHeight_1;
param_161 = _e474;
let _e475 = v_world_position_1;
param_162 = _e475;
let _e476 = mirror_1;
param_163 = _e476;
let _e477 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_159), (¶m_160), (¶m_161), (¶m_162), (¶m_163));
representative = _e477;
let _e478 = representative;
let _e479 = v_world_position_1;
toPoint = (_e478 - _e479);
let _e481 = toPoint;
pointDistance = length(_e481);
let _e483 = pointDistance;
if (_e483 > 0.000001f) {
let _e485 = toPoint;
let _e486 = pointDistance;
local_24 = (_e485 / vec3(_e486));
} else {
let _e490 = (*s_6).n;
local_24 = _e490;
}
let _e491 = local_24;
light_4.l = _e491;
let _e494 = light_4.l;
let _e496 = (*s_6).v;
light_4.h = normalize((_e494 + _e496));
let _e500 = formFactor;
light_4.n_dot_l = _e500;
let _e503 = (*s_6).n;
let _e505 = light_4.h;
light_4.n_dot_h = max(dot(_e503, _e505), 0f);
let _e510 = (*s_6).v;
let _e512 = light_4.h;
light_4.v_dot_h = max(dot(_e510, _e512), 0f);
let _e516 = color_1;
let _e519 = color_1[3u];
let _e521 = radiance;
light_4.radiance = ((_e516.xyz * _e519) * _e521);
light_4.integrated = 1f;
let _e526 = (*s_6).n;
param_164 = _e526;
let _e528 = (*s_6).v;
param_165 = _e528;
let _e530 = (*s_6).roughness;
param_166 = _e530;
let _e531 = corners_2;
param_167 = _e531;
let _e532 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_164), (¶m_165), (¶m_166), (¶m_167));
light_4.ltc = _e532;
let _e534 = corners_2;
g_rect_corners = _e534;
let _e535 = light_4;
return _e535;
}
let _e536 = direction;
aim = normalize(_e536.xyz);
attenuation_1 = 1f;
let _e539 = type_45;
if (_e539 < 0.5f) {
let _e541 = aim;
light_4.l = -(_e541);
} else {
let _e544 = position;
let _e546 = v_world_position_1;
toLight_1 = (_e544.xyz - _e546);
let _e548 = toLight_1;
distance_3 = length(_e548);
let _e550 = distance_3;
if (_e550 < 0.000001f) {
let _e553 = (*s_6).n;
light_4.l = _e553;
let _e556 = (*s_6).n;
light_4.h = _e556;
light_4.radiance = vec3<f32>(0f, 0f, 0f);
light_4.n_dot_l = 0f;
light_4.n_dot_h = 0f;
light_4.v_dot_h = 0f;
let _e562 = light_4;
return _e562;
}
let _e563 = toLight_1;
let _e564 = distance_3;
light_4.l = (_e563 / vec3(_e564));
let _e568 = distance_3;
param_168 = _e568;
let _e570 = direction[3u];
param_169 = _e570;
let _e571 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_168), (¶m_169));
attenuation_1 = _e571;
let _e572 = type_45;
if (_e572 > 1.5f) {
let _e574 = aim;
let _e576 = light_4.l;
cosAngle = dot(_e574, -(_e576));
let _e579 = cosAngle;
let _e581 = cone[1u];
let _e584 = cone[0u];
let _e586 = cone[1u];
let _e590 = attenuation_1;
attenuation_1 = (_e590 * clamp(((_e579 - _e581) / (_e584 - _e586)), 0f, 1f));
}
}
let _e593 = light_4.l;
let _e595 = (*s_6).v;
light_4.h = normalize((_e593 + _e595));
let _e600 = (*s_6).n;
let _e602 = light_4.l;
light_4.n_dot_l = max(dot(_e600, _e602), 0f);
let _e607 = (*s_6).n;
let _e609 = light_4.h;
light_4.n_dot_h = max(dot(_e607, _e609), 0f);
let _e614 = (*s_6).v;
let _e616 = light_4.h;
light_4.v_dot_h = max(dot(_e614, _e616), 0f);
let _e620 = color_1;
let _e623 = color_1[3u];
let _e625 = attenuation_1;
light_4.radiance = ((_e620.xyz * _e623) * _e625);
let _e628 = light_4;
return _e628;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_25: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_170: f32;
var param_171: f32;
let _e275 = light_list_info.cluster_view_projection;
let _e276 = (*world_3);
clip_1 = (_e275 * vec4<f32>(_e276.x, _e276.y, _e276.z, 1f));
let _e282 = clip_1;
let _e285 = clip_1[3u];
ndc_1 = (_e282.xy / vec2(max(_e285, 0.000001f)));
let _e290 = light_list_info.cluster_grid;
grid = _e290.xyz;
let _e294 = light_list_info.cluster_depth[0u];
near_1 = _e294;
let _e296 = ndc_1[0u];
let _e300 = grid[0u];
let _e304 = grid[0u];
tx = clamp(floor((((_e296 * 0.5f) + 0.5f) * _e300)), 0f, (_e304 - 1f));
let _e308 = ndc_1[1u];
let _e312 = grid[1u];
let _e316 = grid[1u];
ty = clamp(floor((((_e308 * 0.5f) + 0.5f) * _e312)), 0f, (_e316 - 1f));
let _e320 = clip_1[3u];
let _e321 = near_1;
if (_e320 <= _e321) {
local_25 = 0f;
} else {
let _e324 = clip_1[3u];
let _e325 = near_1;
let _e330 = light_list_info.cluster_depth[1u];
let _e334 = grid[2u];
local_25 = clamp(floor((log((_e324 / _e325)) * _e330)), 0f, (_e334 - 1f));
}
let _e337 = local_25;
tz = _e337;
let _e338 = tx;
let _e339 = ty;
let _e341 = grid[0u];
let _e344 = tz;
let _e346 = grid[0u];
let _e349 = grid[1u];
cell = ((_e338 + (_e339 * _e341)) + ((_e344 * _e346) * _e349));
let _e352 = cell;
row_3 = floor((_e352 / 4f));
let _e355 = cell;
let _e356 = row_3;
let _e361 = light_list_info.cluster_depth[2u];
let _e362 = row_3;
param_170 = (_e355 - (_e356 * 4f));
param_171 = (_e361 + _e362);
let _e364 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_170), (¶m_171));
header = _e364;
let _e366 = header[0u];
g_cluster_offset = _e366;
let _e368 = header[1u];
g_cluster_count = _e368;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_172: vec3<f32>;
let _e264 = light_list_info.list[0u];
tail = _e264;
let _e265 = Clustered_u0028_();
if _e265 {
let _e266 = v_world_position_1;
param_172 = _e266;
FindCluster_u0028_vf3_u003b((¶m_172));
let _e267 = g_cluster_count;
tail = _e267;
}
let _e270 = frag_info.frame_params[1u];
let _e274 = tail;
return (clamp(i32((_e270 + 0.5f)), 0i, 8i) + clamp(i32((_e274 + 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_7: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_9: i32;
var light_5: LightSample;
var param_173: i32;
var param_174: Surface;
var visibility: f32;
var param_175: i32;
var local_26: f32;
var param_176: Surface;
var param_177: LightSample;
var param_178: i32;
var param_179: vec3<f32>;
var param_180: vec3<f32>;
var param_181: i32;
var param_182: Surface;
var param_183: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e278 = LightCount_u0028_();
count_1 = _e278;
i_9 = 0i;
loop {
let _e279 = i_9;
if (_e279 < 32i) {
let _e281 = i_9;
let _e282 = count_1;
if (_e281 >= _e282) {
break;
}
let _e284 = i_9;
param_173 = _e284;
let _e285 = (*s_7);
param_174 = _e285;
let _e286 = 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_173), (¶m_174));
light_5 = _e286;
let _e288 = light_5.n_dot_l;
if (_e288 <= 0f) {
continue;
}
let _e290 = i_9;
param_175 = _e290;
let _e291 = LightHasShadow_u0028_i1_u003b((¶m_175));
if _e291 {
let _e292 = (*s_7);
param_176 = _e292;
let _e293 = light_5;
param_177 = _e293;
let _e294 = i_9;
param_178 = _e294;
let _e295 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_176), (¶m_177), (¶m_178));
let _e296 = v_world_position_1;
param_179 = _e296;
let _e298 = (*s_7).n;
param_180 = _e298;
let _e299 = i_9;
param_181 = _e299;
let _e300 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_179), (¶m_180), (¶m_181));
local_26 = (_e295 * _e300);
} else {
local_26 = 1f;
}
let _e302 = local_26;
visibility = _e302;
let _e303 = visibility;
if (_e303 <= 0f) {
continue;
}
let _e305 = (*s_7);
param_182 = _e305;
let _e306 = light_5;
param_183 = _e306;
let _e307 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_182), (¶m_183));
let _e309 = light_5.radiance;
let _e312 = light_5.n_dot_l;
let _e314 = visibility;
let _e316 = total_1;
total_1 = (_e316 + (((_e307 * _e309) * _e312) * _e314));
continue;
} else {
break;
}
continuing {
let _e318 = i_9;
i_9 = (_e318 + 1i);
}
}
let _e320 = total_1;
return _e320;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e261 = v_lightmap_uv_1;
let _e262 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e261);
texel_4 = _e262;
let _e263 = texel_4;
let _e266 = texel_4[3u];
return ((_e263.xyz * _e266) * 8f);
}
fn SceneColourLevel_u0028_vf2_u003b_i1_u003b(uv_6: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
var rect: vec4<f32>;
var inset_1: vec2<f32>;
var at_4: vec2<f32>;
let _e265 = (*level);
let _e268 = layer_info.scene_levels[_e265];
rect = _e268;
let _e270 = layer_info.scene_colour;
inset_1 = (_e270.yz * 0.5f);
let _e273 = rect;
let _e275 = (*uv_6);
let _e276 = rect;
let _e279 = inset_1;
let _e280 = rect;
let _e282 = inset_1;
let _e284 = inset_1;
at_4 = (_e273.xy + clamp((_e275 * _e276.zw), _e279, max((_e280.zw - _e282), _e284)));
let _e288 = at_4;
let _e289 = textureSampleLevel(scene_colour_texture_tex, scene_colour_texture_smp, _e288, 0f);
return _e289.xyz;
}
fn SceneColourAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
var clip_2: vec4<f32>;
var ndc_2: vec2<f32>;
var view: vec2<f32>;
var uv_7: vec2<f32>;
var top: f32;
var level_1: f32;
var lower: f32;
var near_2: vec3<f32>;
var param_184: vec2<f32>;
var param_185: i32;
var far_1: vec3<f32>;
var param_186: vec2<f32>;
var param_187: i32;
let _e276 = layer_info.scene_view_projection;
let _e277 = (*world_4);
clip_2 = (_e276 * vec4<f32>(_e277.x, _e277.y, _e277.z, 1f));
let _e283 = clip_2;
let _e286 = clip_2[3u];
ndc_2 = (_e283.xy / vec2(max(_e286, 0.000001f)));
let _e291 = ndc_2[0u];
let _e295 = ndc_2[1u];
view = clamp(vec2<f32>(((_e291 * 0.5f) + 0.5f), (0.5f - (_e295 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
let _e301 = layer_info.scene_viewport;
let _e303 = view;
let _e305 = layer_info.scene_viewport;
uv_7 = (_e301.xy + (_e303 * _e305.zw));
let _e311 = layer_info.scene_colour[0u];
top = (_e311 - 1f);
let _e313 = (*lod);
let _e314 = top;
level_1 = clamp(_e313, 0f, _e314);
let _e316 = level_1;
lower = floor(_e316);
let _e318 = lower;
let _e320 = uv_7;
param_184 = _e320;
param_185 = i32(_e318);
let _e321 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_184), (¶m_185));
near_2 = _e321;
let _e322 = lower;
let _e324 = top;
let _e327 = uv_7;
param_186 = _e327;
param_187 = i32(min((_e322 + 1f), _e324));
let _e328 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_186), (¶m_187));
far_1 = _e328;
let _e329 = near_2;
let _e330 = far_1;
let _e331 = level_1;
let _e332 = lower;
return mix(_e329, _e330, vec3((_e331 - _e332)));
}
fn IorInfinite_u0028_() -> bool {
let _e262 = layer_info.coat[2u];
return (_e262 == 0f);
}
fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
var local_27: f32;
let _e262 = IorInfinite_u0028_();
if _e262 {
local_27 = 0f;
} else {
let _e263 = (*ior);
let _e268 = layer_info.transmission[3u];
local_27 = (((_e263 - 1f) * 0.025f) * _e268);
}
let _e270 = local_27;
return _e270;
}
fn RefractionIor_u0028_() -> f32 {
var local_28: f32;
let _e261 = IorInfinite_u0028_();
if _e261 {
local_28 = 10000f;
} else {
let _e264 = layer_info.coat[2u];
local_28 = max(_e264, 1f);
}
let _e266 = local_28;
return _e266;
}
fn SceneBehind_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>) -> vec3<f32> {
var ior_1: f32;
var spread_1: f32;
var param_188: f32;
var width: f32;
var lod_1: f32;
var thin: bool;
var red: vec3<f32>;
var local_29: vec3<f32>;
var green: vec3<f32>;
var local_30: vec3<f32>;
var blue: vec3<f32>;
var local_31: vec3<f32>;
var param_189: vec3<f32>;
var param_190: f32;
var param_191: vec3<f32>;
var param_192: f32;
var param_193: vec3<f32>;
var param_194: f32;
let _e279 = RefractionIor_u0028_();
ior_1 = _e279;
let _e280 = ior_1;
param_188 = _e280;
let _e281 = DispersionSpread_u0028_f1_u003b((¶m_188));
spread_1 = _e281;
let _e285 = layer_info.scene_levels[0i][2u];
let _e288 = layer_info.scene_colour[1u];
width = (_e285 / max(_e288, 0.000000001f));
let _e291 = width;
let _e295 = (*s_8).roughness;
let _e297 = ior_1;
lod_1 = ((log2(max(_e291, 1f)) * _e295) * clamp(((_e297 * 2f) - 2f), 0f, 1f));
let _e302 = g_thickness;
thin = (_e302 <= 0f);
let _e304 = thin;
if _e304 {
let _e306 = (*s_8).v;
local_29 = -(_e306);
} else {
let _e309 = (*s_8).v;
let _e312 = (*s_8).n;
let _e313 = ior_1;
let _e314 = spread_1;
local_29 = refract(-(_e309), _e312, (1f / max((_e313 - _e314), 1f)));
}
let _e319 = local_29;
red = _e319;
let _e320 = thin;
if _e320 {
let _e322 = (*s_8).v;
local_30 = -(_e322);
} else {
let _e325 = (*s_8).v;
let _e328 = (*s_8).n;
let _e329 = ior_1;
local_30 = refract(-(_e325), _e328, (1f / _e329));
}
let _e332 = local_30;
green = _e332;
let _e333 = thin;
if _e333 {
let _e335 = (*s_8).v;
local_31 = -(_e335);
} else {
let _e338 = (*s_8).v;
let _e341 = (*s_8).n;
let _e342 = ior_1;
let _e343 = spread_1;
local_31 = refract(-(_e338), _e341, (1f / (_e342 + _e343)));
}
let _e347 = local_31;
blue = _e347;
let _e348 = v_world_position_1;
let _e349 = red;
let _e350 = g_thickness;
param_189 = (_e348 + (_e349 * _e350));
let _e353 = lod_1;
param_190 = _e353;
let _e354 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_189), (¶m_190));
let _e356 = v_world_position_1;
let _e357 = green;
let _e358 = g_thickness;
param_191 = (_e356 + (_e357 * _e358));
let _e361 = lod_1;
param_192 = _e361;
let _e362 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_191), (¶m_192));
let _e364 = v_world_position_1;
let _e365 = blue;
let _e366 = g_thickness;
param_193 = (_e364 + (_e365 * _e366));
let _e369 = lod_1;
param_194 = _e369;
let _e370 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_193), (¶m_194));
return vec3<f32>(_e354.x, _e362.y, _e370.z);
}
fn TransmittedRadiance_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_f1_u003b(s_9: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
var ior_2: f32;
var spread_2: f32;
var param_195: f32;
var lod_2: f32;
var thin_1: bool;
var red_1: vec3<f32>;
var local_32: vec3<f32>;
var green_1: vec3<f32>;
var local_33: vec3<f32>;
var blue_1: vec3<f32>;
var local_34: vec3<f32>;
let _e273 = RefractionIor_u0028_();
ior_2 = _e273;
let _e274 = ior_2;
param_195 = _e274;
let _e275 = DispersionSpread_u0028_f1_u003b((¶m_195));
spread_2 = _e275;
let _e277 = (*s_9).roughness;
let _e278 = ior_2;
let _e283 = (*levels);
lod_2 = ((_e277 * clamp(((_e278 * 2f) - 2f), 0f, 1f)) * _e283);
let _e285 = g_thickness;
thin_1 = (_e285 <= 0f);
let _e287 = thin_1;
if _e287 {
let _e289 = (*s_9).v;
local_32 = -(_e289);
} else {
let _e292 = (*s_9).v;
let _e295 = (*s_9).n;
let _e296 = ior_2;
let _e297 = spread_2;
local_32 = refract(-(_e292), _e295, (1f / max((_e296 - _e297), 1f)));
}
let _e302 = local_32;
red_1 = _e302;
let _e303 = thin_1;
if _e303 {
let _e305 = (*s_9).v;
local_33 = -(_e305);
} else {
let _e308 = (*s_9).v;
let _e311 = (*s_9).n;
let _e312 = ior_2;
local_33 = refract(-(_e308), _e311, (1f / _e312));
}
let _e315 = local_33;
green_1 = _e315;
let _e316 = thin_1;
if _e316 {
let _e318 = (*s_9).v;
local_34 = -(_e318);
} else {
let _e321 = (*s_9).v;
let _e324 = (*s_9).n;
let _e325 = ior_2;
let _e326 = spread_2;
local_34 = refract(-(_e321), _e324, (1f / (_e325 + _e326)));
}
let _e330 = local_34;
blue_1 = _e330;
let _e331 = red_1;
let _e332 = lod_2;
let _e333 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e331, _e332);
let _e335 = green_1;
let _e336 = lod_2;
let _e337 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e335, _e336);
let _e339 = blue_1;
let _e340 = lod_2;
let _e341 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e339, _e340);
return vec3<f32>(_e333.x, _e337.y, _e341.z);
}
fn SceneColourBound_u0028_() -> bool {
let _e262 = layer_info.scene_colour[0u];
return (_e262 > 0f);
}
fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
var e_1: f32;
var param_196: f32;
var param_197: f32;
var param_198: f32;
var param_199: vec3<f32>;
var param_200: f32;
let _e269 = (*mu_1);
param_196 = _e269;
let _e270 = (*r_4);
param_197 = _e270;
let _e271 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_196), (¶m_197));
e_1 = _e271;
let _e272 = (*rho_2);
let _e273 = e_1;
let _e275 = (*r_4);
param_198 = _e275;
let _e276 = FonAverage_u0028_f1_u003b((¶m_198));
let _e277 = (*rho_2);
param_199 = _e277;
param_200 = _e276;
let _e278 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_199), (¶m_200));
let _e279 = e_1;
return ((_e272 * _e273) + (_e278 * (1f - _e279)));
}
fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
var phase: f32;
var val: vec3<f32>;
var pos: vec3<f32>;
var variance_1: vec3<f32>;
var xyz: vec3<f32>;
let _e267 = (*opd);
phase = ((6.2831855f * _e267) * 0.000000001f);
val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
pos = vec3<f32>(1681000f, 1795300f, 2208400f);
variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
let _e270 = val;
let _e271 = variance_1;
let _e275 = pos;
let _e276 = phase;
let _e278 = (*shift);
let _e282 = phase;
let _e283 = phase;
let _e286 = variance_1;
xyz = (((_e270 * sqrt((_e271 * 6.2831855f))) * cos(((_e275 * _e276) + _e278))) * exp((_e286 * -((_e282 * _e283)))));
let _e290 = phase;
let _e293 = (*shift)[0u];
let _e297 = phase;
let _e299 = phase;
let _e304 = xyz[0u];
xyz[0u] = (_e304 + ((0.00000001644083f * cos(((2239900f * _e290) + _e293))) * exp(((-4528200000f * _e297) * _e299))));
let _e307 = xyz;
xyz = (_e307 / vec3(0.00000010685f));
let _e310 = xyz;
return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e310);
}
fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
var eta2_: f32;
var sin2Sq: f32;
var cos2Sq: f32;
var cos2_: f32;
var r0_: f32;
var r12_: f32;
var t121_: f32;
var phi12_: f32;
var phi21_: f32;
var sqrtBase: vec3<f32>;
var baseIor: vec3<f32>;
var r1_: vec3<f32>;
var r23_: vec3<f32>;
var phi23_: vec3<f32>;
var opd_1: f32;
var phi: vec3<f32>;
var r123_: vec3<f32>;
var rootR123_: vec3<f32>;
var rs: vec3<f32>;
var total_2: vec3<f32>;
var cm: vec3<f32>;
var m_1: i32;
var param_201: f32;
var param_202: vec3<f32>;
var local_35: vec3<f32>;
let _e289 = (*film);
let _e290 = (*thickness);
eta2_ = mix(1f, _e289, smoothstep(0f, 0.03f, _e290));
let _e293 = (*cos1_);
let _e294 = (*cos1_);
let _e297 = eta2_;
let _e298 = eta2_;
sin2Sq = ((1f - (_e293 * _e294)) / (_e297 * _e298));
let _e301 = sin2Sq;
cos2Sq = (1f - _e301);
let _e303 = cos2Sq;
cos2_ = sqrt(max(_e303, 0f));
let _e306 = eta2_;
let _e308 = eta2_;
r0_ = ((_e306 - 1f) / (_e308 + 1f));
let _e311 = r0_;
let _e312 = r0_;
let _e314 = r0_;
let _e315 = r0_;
let _e318 = (*cos1_);
r12_ = ((_e311 * _e312) + ((1f - (_e314 * _e315)) * pow((1f - _e318), 5f)));
let _e323 = r12_;
t121_ = (1f - _e323);
let _e325 = eta2_;
phi12_ = select(0f, 3.1415927f, (_e325 < 1f));
let _e328 = phi12_;
phi21_ = (3.1415927f - _e328);
let _e330 = (*base);
sqrtBase = sqrt(clamp(_e330, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
let _e333 = sqrtBase;
let _e335 = sqrtBase;
baseIor = ((vec3<f32>(1f, 1f, 1f) + _e333) / (vec3<f32>(1f, 1f, 1f) - _e335));
let _e338 = baseIor;
let _e339 = eta2_;
let _e342 = baseIor;
let _e343 = eta2_;
r1_ = ((_e338 - vec3(_e339)) / (_e342 + vec3(_e343)));
let _e347 = r1_;
let _e348 = r1_;
r1_ = (_e348 * _e347);
let _e350 = r1_;
let _e351 = r1_;
let _e353 = cos2_;
r23_ = (_e350 + ((vec3<f32>(1f, 1f, 1f) - _e351) * pow((1f - _e353), 5f)));
let _e359 = baseIor[0u];
let _e360 = eta2_;
let _e364 = baseIor[1u];
let _e365 = eta2_;
let _e369 = baseIor[2u];
let _e370 = eta2_;
phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e359 < _e360)), select(0f, 3.1415927f, (_e364 < _e365)), select(0f, 3.1415927f, (_e369 < _e370)));
let _e374 = eta2_;
let _e376 = (*thickness);
let _e378 = cos2_;
opd_1 = (((2f * _e374) * _e376) * _e378);
let _e380 = phi21_;
let _e382 = phi23_;
phi = (vec3(_e380) + _e382);
let _e384 = r12_;
let _e385 = r23_;
r123_ = clamp((_e385 * _e384), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
let _e388 = r123_;
rootR123_ = sqrt(_e388);
let _e390 = t121_;
let _e391 = t121_;
let _e393 = r23_;
let _e395 = r123_;
rs = ((_e393 * (_e390 * _e391)) / (vec3<f32>(1f, 1f, 1f) - _e395));
let _e398 = r12_;
let _e400 = rs;
total_2 = (vec3(_e398) + _e400);
let _e402 = rs;
let _e403 = t121_;
cm = (_e402 - vec3(_e403));
m_1 = 1i;
loop {
let _e406 = m_1;
if (_e406 <= 2i) {
let _e408 = rootR123_;
let _e409 = cm;
cm = (_e409 * _e408);
let _e411 = cm;
let _e413 = m_1;
let _e415 = opd_1;
let _e417 = m_1;
let _e419 = phi;
param_201 = (f32(_e413) * _e415);
param_202 = (_e419 * f32(_e417));
let _e421 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((¶m_201), (¶m_202));
let _e423 = total_2;
total_2 = (_e423 + ((_e411 * 2f) * _e421));
continue;
} else {
break;
}
continuing {
let _e425 = m_1;
m_1 = (_e425 + 1i);
}
}
let _e427 = cos2Sq;
if (_e427 < 0f) {
local_35 = vec3<f32>(1f, 1f, 1f);
} else {
let _e429 = total_2;
local_35 = max(_e429, vec3<f32>(0f, 0f, 0f));
}
let _e431 = local_35;
return _e431;
}
fn ReadIridescence_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_10: ptr<function, Surface>) {
var f0_3: vec3<f32>;
var param_203: f32;
var param_204: f32;
var param_205: f32;
var param_206: vec3<f32>;
let _e266 = g_f0_dielectric;
let _e268 = (*s_10).albedo;
let _e270 = (*s_10).metallic;
f0_3 = mix(_e266, _e268, vec3(clamp(_e270, 0f, 1f)));
let _e276 = layer_info.iridescence[1u];
param_203 = _e276;
let _e278 = (*s_10).n_dot_v;
param_204 = _e278;
let _e281 = layer_info.iridescence[2u];
param_205 = _e281;
let _e282 = f0_3;
param_206 = _e282;
let _e283 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((¶m_203), (¶m_204), (¶m_205), (¶m_206));
g_irid_fresnel = _e283;
return;
}
fn ReadLayersOnMaps_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_11: ptr<function, Surface>) {
var param_207: f32;
var param_208: f32;
var param_209: f32;
var t_2: vec3<f32>;
var usable: bool;
var local_36: vec3<f32>;
var b_4: vec3<f32>;
var turn_2: vec2<f32>;
var along_1: vec3<f32>;
var local_37: f32;
var local_38: vec3<f32>;
var phi_4624_: bool;
let _e273 = (*s_11).n_dot_v;
let _e277 = g_sheen_roughness;
param_207 = _e277;
param_208 = sqrt(clamp((1f - _e273), 0f, 1f));
param_209 = 1f;
let _e278 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_207), (¶m_208), (¶m_209));
let _e279 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e278, 0f);
g_sheen_albedo = _e279.z;
let _e282 = g_sheen[0u];
let _e284 = g_sheen[1u];
let _e287 = g_sheen[2u];
let _e289 = g_sheen_albedo;
g_sheen_scale = (1f - (max(max(_e282, _e284), _e287) * _e289));
let _e292 = v_tangent_1;
let _e295 = (*s_11).n;
let _e297 = (*s_11).n;
let _e298 = v_tangent_1;
t_2 = (_e292.xyz - (_e295 * dot(_e297, _e298.xyz)));
let _e303 = t_2;
let _e304 = t_2;
usable = (dot(_e303, _e304) > 0.000000000001f);
let _e307 = usable;
if _e307 {
let _e308 = t_2;
local_36 = normalize(_e308);
} else {
local_36 = vec3<f32>(1f, 0f, 0f);
}
let _e310 = local_36;
t_2 = _e310;
let _e312 = (*s_11).n;
let _e313 = t_2;
let _e316 = v_tangent_1[3u];
b_4 = (cross(_e312, _e313) * _e316);
let _e318 = gl_FrontFacing_1;
if !(_e318) {
let _e320 = t_2;
t_2 = -(_e320);
}
let _e323 = layer_info.anisotropy;
turn_2 = _e323.yz;
let _e325 = t_2;
let _e327 = turn_2[0u];
let _e329 = b_4;
let _e331 = turn_2[1u];
along_1 = ((_e325 * _e327) + (_e329 * _e331));
let _e334 = usable;
phi_4624_ = _e334;
if _e334 {
let _e335 = along_1;
let _e336 = along_1;
phi_4624_ = (dot(_e335, _e336) > 0.000000000001f);
}
let _e340 = phi_4624_;
if _e340 {
let _e343 = layer_info.anisotropy[0u];
local_37 = clamp(_e343, 0f, 1f);
} else {
local_37 = 0f;
}
let _e345 = local_37;
g_aniso = _e345;
let _e346 = g_aniso;
if (_e346 > 0f) {
let _e348 = along_1;
local_38 = normalize(_e348);
} else {
let _e350 = t_2;
local_38 = _e350;
}
let _e351 = local_38;
g_aniso_t = _e351;
let _e353 = (*s_11).n;
let _e354 = g_aniso_t;
g_aniso_b = cross(_e353, _e354);
return;
}
fn MaterialLodBias_u0028_() -> f32 {
let _e262 = frag_info.target_origin[1u];
return _e262;
}
fn MapUv_u0028_i1_u003b(slot_6: ptr<function, i32>) -> vec2<f32> {
var uvw: vec3<f32>;
let _e262 = v_texcoord_1;
uvw = vec3<f32>(_e262.x, _e262.y, 1f);
let _e266 = (*slot_6);
let _e270 = layer_info.uv_transform[(_e266 * 2i)];
let _e272 = uvw;
let _e274 = (*slot_6);
let _e279 = layer_info.uv_transform[((_e274 * 2i) + 1i)];
let _e281 = uvw;
return vec2<f32>(dot(_e270.xyz, _e272), dot(_e279.xyz, _e281));
}
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_12: ptr<function, Surface>) {
var orm: vec3<f32>;
var param_210: i32;
param_210 = 1i;
let _e263 = MapUv_u0028_i1_u003b((¶m_210));
let _e264 = MaterialLodBias_u0028_();
let _e265 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e263, _e264);
orm = _e265.xyz;
let _e268 = (*s_12).metallic;
let _e270 = orm[2u];
(*s_12).metallic = clamp((_e268 * _e270), 0f, 1f);
let _e275 = (*s_12).roughness;
let _e277 = orm[1u];
(*s_12).roughness = clamp((_e275 * _e277), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e261 = (*srgb);
let _e264 = (*srgb);
let _e269 = (*srgb);
return mix((_e261 / vec3(12.92f)), pow(((_e264 + 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), _e269));
}
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_13: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_211: i32;
var param_212: vec3<f32>;
param_211 = 4i;
let _e264 = MapUv_u0028_i1_u003b((¶m_211));
let _e265 = MaterialLodBias_u0028_();
let _e266 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e264, _e265);
param_212 = _e266.xyz;
let _e268 = SrgbToLinear_u0028_vf3_u003b((¶m_212));
emissive = _e268;
let _e269 = emissive;
let _e271 = frag_info.emissive;
let _e276 = frag_info.material2_[3u];
(*s_13).emissive = ((_e269 * _e271.xyz) * _e276);
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_14: ptr<function, Surface>) {
var occlusion: f32;
var param_213: i32;
param_213 = 3i;
let _e263 = MapUv_u0028_i1_u003b((¶m_213));
let _e264 = MaterialLodBias_u0028_();
let _e265 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e263, _e264);
occlusion = _e265.x;
let _e267 = occlusion;
let _e270 = frag_info.material2_[2u];
(*s_14).occlusion = mix(1f, _e267, clamp(_e270, 0f, 1f));
return;
}
fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
var u_2: vec4<f32>;
var v_3: vec4<f32>;
let _e263 = (*slot_7);
let _e267 = layer_info.uv_transform[(_e263 * 2i)];
u_2 = _e267;
let _e268 = (*slot_7);
let _e273 = layer_info.uv_transform[((_e268 * 2i) + 1i)];
v_3 = _e273;
let _e275 = u_2[0u];
let _e277 = u_2[1u];
let _e279 = v_3[0u];
let _e281 = v_3[1u];
return vec4<f32>(_e275, _e277, _e279, _e281);
}
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_15: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var param_214: i32;
var t_3: vec3<f32>;
var b_5: vec3<f32>;
var m_2: vec4<f32>;
var param_215: i32;
var det: f32;
var flip: f32;
var front: vec3<f32>;
var local_39: vec3<f32>;
var turned: vec3<f32>;
var turns: bool;
var local_40: vec3<f32>;
var local_41: vec3<f32>;
var sampled: vec3<f32>;
var phi_3502_: bool;
var phi_3509_: bool;
var phi_3516_: bool;
var phi_3523_: bool;
param_214 = 2i;
let _e276 = MapUv_u0028_i1_u003b((¶m_214));
let _e277 = MaterialLodBias_u0028_();
let _e278 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e276, _e277);
sampledTexel = _e278;
let _e279 = v_tangent_1;
t_3 = _e279.xyz;
let _e281 = t_3;
let _e283 = (*s_15).n;
let _e285 = (*s_15).n;
let _e286 = t_3;
t_3 = (_e281 - (_e283 * dot(_e285, _e286)));
let _e290 = t_3;
let _e291 = t_3;
if (dot(_e290, _e291) < 0.000000000001f) {
return;
}
let _e294 = t_3;
t_3 = normalize(_e294);
let _e297 = (*s_15).n;
let _e298 = t_3;
let _e301 = v_tangent_1[3u];
b_5 = (cross(_e297, _e298) * _e301);
param_215 = 2i;
let _e303 = MapMatrix_u0028_i1_u003b((¶m_215));
m_2 = _e303;
let _e305 = m_2[0u];
let _e307 = m_2[3u];
let _e310 = m_2[1u];
let _e312 = m_2[2u];
det = ((_e305 * _e307) - (_e310 * _e312));
let _e315 = det;
flip = select(1f, -1f, (_e315 < 0f));
let _e318 = gl_FrontFacing_1;
if _e318 {
let _e319 = b_5;
local_39 = _e319;
} else {
let _e320 = b_5;
local_39 = -(_e320);
}
let _e322 = local_39;
front = _e322;
let _e323 = t_3;
let _e325 = m_2[3u];
let _e327 = front;
let _e329 = m_2[2u];
let _e332 = flip;
turned = (((_e323 * _e325) + (_e327 * _e329)) * _e332);
let _e335 = m_2[1u];
let _e336 = (_e335 != 0f);
phi_3502_ = _e336;
if !(_e336) {
let _e339 = m_2[2u];
phi_3502_ = (_e339 != 0f);
}
let _e342 = phi_3502_;
phi_3509_ = _e342;
if !(_e342) {
let _e345 = m_2[0u];
phi_3509_ = (_e345 < 0f);
}
let _e348 = phi_3509_;
phi_3516_ = _e348;
if !(_e348) {
let _e351 = m_2[3u];
phi_3516_ = (_e351 < 0f);
}
let _e354 = phi_3516_;
phi_3523_ = _e354;
if _e354 {
let _e355 = turned;
let _e356 = turned;
phi_3523_ = (dot(_e355, _e356) > 0.000000000001f);
}
let _e360 = phi_3523_;
turns = _e360;
let _e361 = turns;
if _e361 {
let _e362 = turned;
local_40 = normalize(_e362);
} else {
let _e364 = t_3;
local_40 = _e364;
}
let _e365 = local_40;
t_3 = _e365;
let _e366 = turns;
if _e366 {
let _e368 = (*s_15).n;
let _e369 = t_3;
let _e372 = v_tangent_1[3u];
let _e374 = flip;
local_41 = ((cross(_e368, _e369) * _e372) * _e374);
} else {
let _e376 = b_5;
local_41 = _e376;
}
let _e377 = local_41;
b_5 = _e377;
let _e378 = gl_FrontFacing_1;
if !(_e378) {
let _e380 = t_3;
t_3 = -(_e380);
}
let _e382 = sampledTexel;
sampled = ((_e382.xyz * 2f) - vec3(1f));
let _e389 = frag_info.emissive[3u];
if (_e389 > 0.5f) {
let _e391 = sampled;
let _e393 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e391.xy, _e393.xy)), 0f));
}
let _e402 = frag_info.material2_[1u];
let _e403 = sampled;
let _e405 = (_e403.xy * _e402);
sampled[0u] = _e405.x;
sampled[1u] = _e405.y;
let _e410 = t_3;
let _e412 = sampled[0u];
let _e414 = b_5;
let _e416 = sampled[1u];
let _e420 = (*s_15).n;
let _e422 = sampled[2u];
(*s_15).n = normalize((((_e410 * _e412) + (_e414 * _e416)) + (_e420 * _e422)));
let _e428 = (*s_15).n;
let _e430 = (*s_15).v;
(*s_15).n_dot_v = max(dot(_e428, _e430), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e261 = (*texel_5);
let _e265 = irradiance_info.atlas;
let _e268 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e261 + vec2(0.5f)) * _e265.xy), 0f);
return _e268;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_8: ptr<function, vec2<f32>>) -> vec4<f32> {
var at_5: vec2<f32>;
var low: vec2<f32>;
var f_5: vec2<f32>;
var a_6: vec4<f32>;
var param_216: vec2<f32>;
var b_6: vec4<f32>;
var param_217: vec2<f32>;
var c: vec4<f32>;
var param_218: vec2<f32>;
var d_6: vec4<f32>;
var param_219: vec2<f32>;
let _e274 = (*uv_8);
let _e275 = (*interior);
at_5 = ((vec2(1f) + (_e274 * _e275)) - vec2(0.5f));
let _e281 = at_5;
low = floor(_e281);
let _e283 = at_5;
let _e284 = low;
f_5 = (_e283 - _e284);
let _e286 = (*corner);
let _e287 = low;
param_216 = (_e286 + _e287);
let _e289 = AtlasTexel_u0028_vf2_u003b((¶m_216));
a_6 = _e289;
let _e290 = (*corner);
let _e291 = low;
param_217 = ((_e290 + _e291) + vec2<f32>(1f, 0f));
let _e294 = AtlasTexel_u0028_vf2_u003b((¶m_217));
b_6 = _e294;
let _e295 = (*corner);
let _e296 = low;
param_218 = ((_e295 + _e296) + vec2<f32>(0f, 1f));
let _e299 = AtlasTexel_u0028_vf2_u003b((¶m_218));
c = _e299;
let _e300 = (*corner);
let _e301 = low;
param_219 = ((_e300 + _e301) + vec2<f32>(1f, 1f));
let _e304 = AtlasTexel_u0028_vf2_u003b((¶m_219));
d_6 = _e304;
let _e305 = a_6;
let _e306 = b_6;
let _e308 = f_5[0u];
let _e311 = c;
let _e312 = d_6;
let _e314 = f_5[0u];
let _e318 = f_5[1u];
return mix(mix(_e305, _e306, vec4(_e308)), mix(_e311, _e312, vec4(_e314)), vec4(_e318));
}
fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var sum_1: f32;
var n_6: vec3<f32>;
var xy: vec2<f32>;
let _e265 = (*direction_1)[0u];
let _e268 = (*direction_1)[1u];
let _e272 = (*direction_1)[2u];
sum_1 = ((abs(_e265) + abs(_e268)) + abs(_e272));
let _e275 = sum_1;
if (_e275 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e277 = (*direction_1);
let _e278 = sum_1;
n_6 = (_e277 / vec3(_e278));
let _e281 = n_6;
xy = _e281.xy;
let _e284 = n_6[2u];
if (_e284 < 0f) {
let _e287 = n_6[1u];
let _e291 = n_6[0u];
let _e296 = n_6[0u];
let _e300 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e287)) * select(-1f, 1f, (_e291 >= 0f))), ((1f - abs(_e296)) * select(-1f, 1f, (_e300 >= 0f))));
}
let _e305 = xy;
return ((_e305 * 0.5f) + vec2(0.5f));
}
fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var spacing: vec3<f32>;
var counts: vec3<f32>;
var irradianceTile: f32;
var depthTile: f32;
var columns: f32;
var momentsTop: f32;
var unit: vec3<f32>;
var biased: vec3<f32>;
var grid_1: vec3<f32>;
var base_1: vec3<f32>;
var f_6: vec3<f32>;
var total_3: vec3<f32>;
var weights: f32;
var corner_1: i32;
var offset_3: vec3<f32>;
var cell_1: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_220: vec2<f32>;
var trilinear: vec3<f32>;
var weight_2: f32;
var probePosition: vec3<f32>;
var toProbe: vec3<f32>;
var distance_4: f32;
var direction_2: vec3<f32>;
var facing: f32;
var probeWeight: f32;
var moments_3: vec2<f32>;
var param_221: vec3<f32>;
var param_222: vec2<f32>;
var param_223: f32;
var param_224: vec2<f32>;
var chebyshev: f32;
var variance_2: f32;
var difference: f32;
var param_225: vec3<f32>;
var param_226: vec2<f32>;
var param_227: f32;
var param_228: vec2<f32>;
var local_42: vec3<f32>;
let _e307 = irradiance_info.origin;
origin_2 = _e307.xyz;
let _e310 = irradiance_info.spacing;
spacing = _e310.xyz;
let _e313 = irradiance_info.counts;
counts = _e313.xyz;
let _e317 = irradiance_info.tiles[0u];
irradianceTile = _e317;
let _e320 = irradiance_info.tiles[1u];
depthTile = _e320;
let _e323 = irradiance_info.tiles[2u];
columns = _e323;
let _e326 = irradiance_info.tiles[3u];
momentsTop = _e326;
let _e327 = (*normal_1);
unit = normalize(_e327);
let _e329 = (*world_5);
let _e330 = unit;
let _e333 = irradiance_info.spacing[3u];
let _e336 = (*view_1);
let _e339 = irradiance_info.counts[3u];
biased = ((_e329 + (_e330 * _e333)) + (_e336 * _e339));
let _e342 = biased;
let _e343 = origin_2;
let _e345 = spacing;
grid_1 = ((_e342 - _e343) / _e345);
let _e347 = grid_1;
let _e349 = counts;
base_1 = clamp(floor(_e347), vec3<f32>(0f, 0f, 0f), (_e349 - vec3(2f)));
let _e353 = grid_1;
let _e354 = base_1;
f_6 = clamp((_e353 - _e354), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_3 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e357 = corner_1;
if (_e357 < 8i) {
let _e359 = corner_1;
let _e362 = corner_1;
let _e367 = corner_1;
offset_3 = vec3<f32>(f32((_e359 & 1i)), f32(((_e362 >> bitcast<u32>(1i)) & 1i)), f32(((_e367 >> bitcast<u32>(2i)) & 1i)));
let _e373 = base_1;
let _e374 = offset_3;
cell_1 = (_e373 + _e374);
let _e377 = cell_1[2u];
let _e379 = counts[1u];
let _e382 = cell_1[1u];
let _e385 = counts[0u];
let _e388 = cell_1[0u];
probe = ((((_e377 * _e379) + _e382) * _e385) + _e388);
let _e390 = probe;
let _e391 = columns;
let _e396 = probe;
let _e397 = columns;
tile_4 = vec2<f32>((_e390 - (floor((_e390 / _e391)) * _e391)), floor((_e396 / _e397)));
let _e401 = tile_4;
let _e402 = irradianceTile;
irradianceCorner = (_e401 * (_e402 + 2f));
let _e406 = tile_4[0u];
let _e407 = depthTile;
let _e410 = momentsTop;
let _e412 = tile_4[1u];
let _e413 = depthTile;
momentCorner = vec2<f32>((_e406 * (_e407 + 2f)), (_e410 + (_e412 * (_e413 + 2f))));
let _e418 = irradianceCorner;
param_220 = (_e418 + vec2(1f));
let _e421 = AtlasTexel_u0028_vf2_u003b((¶m_220));
if (_e421.w < 0.5f) {
continue;
}
let _e424 = f_6;
let _e426 = f_6;
let _e427 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e424), _e426, _e427);
let _e430 = trilinear[0u];
let _e432 = trilinear[1u];
let _e435 = trilinear[2u];
weight_2 = max(((_e430 * _e432) * _e435), 0.001f);
let _e438 = origin_2;
let _e439 = spacing;
let _e440 = cell_1;
probePosition = (_e438 + (_e439 * _e440));
let _e443 = probePosition;
let _e444 = biased;
toProbe = (_e443 - _e444);
let _e446 = toProbe;
distance_4 = length(_e446);
let _e448 = distance_4;
if (_e448 > 0.000001f) {
let _e450 = toProbe;
let _e451 = distance_4;
direction_2 = (_e450 / vec3(_e451));
let _e454 = unit;
let _e455 = probePosition;
let _e456 = (*world_5);
facing = ((dot(_e454, normalize((_e455 - _e456))) * 0.5f) + 0.5f);
let _e462 = facing;
let _e463 = facing;
probeWeight = ((_e462 * _e463) + 0.2f);
let _e466 = direction_2;
param_221 = -(_e466);
let _e468 = ProbeOctahedral_u0028_vf3_u003b((¶m_221));
let _e469 = momentCorner;
param_222 = _e469;
let _e470 = depthTile;
param_223 = _e470;
param_224 = _e468;
let _e471 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_222), (¶m_223), (¶m_224));
moments_3 = _e471.xy;
chebyshev = 1f;
let _e473 = distance_4;
let _e475 = moments_3[0u];
if (_e473 > _e475) {
let _e478 = moments_3[1u];
let _e480 = moments_3[0u];
let _e482 = moments_3[0u];
variance_2 = max((_e478 - (_e480 * _e482)), 0.000001f);
let _e486 = distance_4;
let _e488 = moments_3[0u];
difference = (_e486 - _e488);
let _e490 = variance_2;
let _e491 = variance_2;
let _e492 = difference;
let _e493 = difference;
chebyshev = (_e490 / (_e491 + (_e492 * _e493)));
let _e497 = chebyshev;
let _e498 = chebyshev;
let _e500 = chebyshev;
chebyshev = ((_e497 * _e498) * _e500);
}
let _e502 = probeWeight;
let _e503 = chebyshev;
probeWeight = max((_e502 * max(_e503, 0.05f)), 0.000001f);
let _e507 = probeWeight;
if (_e507 < 0.2f) {
let _e509 = probeWeight;
let _e510 = probeWeight;
let _e513 = probeWeight;
probeWeight = (_e513 * ((_e509 * _e510) * 25f));
}
let _e515 = probeWeight;
let _e516 = weight_2;
weight_2 = (_e516 * _e515);
}
let _e518 = unit;
param_225 = _e518;
let _e519 = ProbeOctahedral_u0028_vf3_u003b((¶m_225));
let _e520 = irradianceCorner;
param_226 = _e520;
let _e521 = irradianceTile;
param_227 = _e521;
param_228 = _e519;
let _e522 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_226), (¶m_227), (¶m_228));
let _e524 = weight_2;
let _e526 = total_3;
total_3 = (_e526 + (_e522.xyz * _e524));
let _e528 = weight_2;
let _e529 = weights;
weights = (_e529 + _e528);
continue;
} else {
break;
}
continuing {
let _e531 = corner_1;
corner_1 = (_e531 + 1i);
}
}
let _e533 = weights;
if (_e533 > 0f) {
let _e535 = total_3;
let _e536 = weights;
local_42 = (_e535 / vec3(_e536));
} else {
local_42 = vec3<f32>(0f, 0f, 0f);
}
let _e539 = local_42;
return _e539;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e262 = irradiance_info.origin[3u];
return (_e262 > 0.5f);
}
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_16: ptr<function, Surface>) {
var param_229: vec3<f32>;
var param_230: vec3<f32>;
var param_231: vec3<f32>;
var param_232: Surface;
var param_233: Surface;
var param_234: Surface;
let _e267 = IrradianceEnabled_u0028_();
if _e267 {
let _e268 = v_world_position_1;
param_229 = _e268;
let _e270 = (*s_16).n;
param_230 = _e270;
let _e272 = (*s_16).v;
param_231 = _e272;
let _e273 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_229), (¶m_230), (¶m_231));
let _e276 = frag_info.material[2u];
(*s_16).ambient = (_e273 * _e276);
}
let _e279 = (*s_16);
param_232 = _e279;
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_232));
let _e280 = param_232;
(*s_16) = _e280;
let _e281 = (*s_16);
param_233 = _e281;
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_233));
let _e282 = param_233;
(*s_16) = _e282;
let _e283 = (*s_16);
param_234 = _e283;
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_234));
let _e284 = param_234;
(*s_16) = _e284;
return;
}
fn ReadLayers_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_17: ptr<function, Surface>) {
var coatTexel: vec4<f32>;
var sheenTexel: vec4<f32>;
var param_235: vec3<f32>;
var ior_3: f32;
var r_5: f32;
var local_43: f32;
var distance_5: f32;
var local_44: vec3<f32>;
var fc: f32;
let _e270 = v_texcoord_1;
let _e271 = MaterialLodBias_u0028_();
let _e272 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e270, _e271);
coatTexel = _e272;
let _e273 = v_texcoord_1;
let _e274 = MaterialLodBias_u0028_();
let _e275 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e273, _e274);
sheenTexel = _e275;
let _e277 = layer_info.sheen;
let _e279 = sheenTexel;
param_235 = _e279.xyz;
let _e281 = SrgbToLinear_u0028_vf3_u003b((¶m_235));
g_sheen = (_e277.xyz * _e281);
let _e285 = layer_info.sheen[3u];
let _e287 = sheenTexel[3u];
g_sheen_roughness = clamp((_e285 * _e287), 0.07f, 1f);
let _e292 = layer_info.coat[2u];
ior_3 = max(_e292, 1f);
let _e294 = IorInfinite_u0028_();
if _e294 {
local_43 = 1f;
} else {
let _e295 = ior_3;
let _e297 = ior_3;
local_43 = ((_e295 - 1f) / (_e297 + 1f));
}
let _e300 = local_43;
r_5 = _e300;
let _e301 = r_5;
let _e302 = r_5;
let _e306 = layer_info.specular;
let _e312 = layer_info.specular[3u];
g_f0_dielectric = (min((vec3((_e301 * _e302)) * _e306.xyz), vec3<f32>(1f, 1f, 1f)) * _e312);
let _e316 = layer_info.specular[3u];
g_f90_ = _e316;
let _e319 = layer_info.coat[0u];
let _e321 = coatTexel[0u];
g_coat = clamp((_e319 * _e321), 0f, 1f);
let _e326 = layer_info.coat[1u];
let _e328 = coatTexel[1u];
g_coat_roughness = clamp((_e326 * _e328), 0.02f, 1f);
let _e333 = layer_info.transmission[0u];
let _e335 = coatTexel[2u];
g_transmission = clamp((_e333 * _e335), 0f, 1f);
let _e340 = layer_info.transmission[1u];
let _e342 = coatTexel[3u];
g_thickness = max((_e340 * _e342), 0f);
let _e347 = layer_info.transmission[2u];
distance_5 = _e347;
let _e348 = distance_5;
if (_e348 > 0f) {
let _e351 = layer_info.attenuation;
let _e354 = g_thickness;
let _e355 = distance_5;
local_44 = pow(max(_e351.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e354 / _e355)));
} else {
local_44 = vec3<f32>(1f, 1f, 1f);
}
let _e359 = local_44;
g_transmittance = _e359;
let _e362 = layer_info.iridescence[0u];
g_iridescence = clamp(_e362, 0f, 1f);
let _e365 = (*s_17).n;
g_coat_n = _e365;
let _e367 = (*s_17).n;
let _e369 = (*s_17).v;
g_coat_n_dot_v = max(dot(_e367, _e369), 0.0001f);
let _e372 = g_coat_n_dot_v;
fc = (0.04f + (0.96f * pow((1f - _e372), 5f)));
let _e377 = g_coat;
let _e378 = fc;
g_coat_through = (1f - (_e377 * _e378));
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var param_236: i32;
var s_18: Surface;
var param_237: vec3<f32>;
var param_238: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
param_236 = 0i;
let _e268 = MapUv_u0028_i1_u003b((¶m_236));
let _e269 = MaterialLodBias_u0028_();
let _e270 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e268, _e269);
texel_6 = _e270;
let _e271 = texel_6;
param_237 = _e271.xyz;
let _e273 = SrgbToLinear_u0028_vf3_u003b((¶m_237));
let _e275 = frag_info.base_color;
param_238 = _e275.xyz;
let _e277 = SrgbToLinear_u0028_vf3_u003b((¶m_238));
let _e279 = v_color_1;
s_18.albedo = ((_e273 * _e277) * _e279.xyz);
let _e284 = texel_6[3u];
let _e287 = frag_info.base_color[3u];
let _e290 = v_color_1[3u];
s_18.alpha = ((_e284 * _e287) * _e290);
let _e294 = s_18.albedo;
g_albedo = _e294;
let _e297 = frag_info.material2_[0u];
cutoff = _e297;
let _e298 = cutoff;
if (_e298 >= 0f) {
let _e301 = s_18.alpha;
let _e302 = cutoff;
if (_e301 < _e302) {
discard;
}
} else {
let _e304 = cutoff;
if (_e304 < -1.5f) {
let _e306 = v_world_position_1;
anchored = floor((_e306 * 16f));
let _e309 = anchored;
noise_1 = fract((sin(dot(_e309, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e315 = s_18.alpha;
let _e316 = noise_1;
if (_e315 < _e316) {
discard;
}
}
}
let _e318 = cutoff;
let _e320 = cutoff;
g_premultiply = ((_e318 < 0f) && (_e320 > -0.75f));
let _e323 = v_normal_1;
s_18.n = normalize(_e323);
let _e326 = gl_FrontFacing_1;
if !(_e326) {
let _e329 = s_18.n;
s_18.n = -(_e329);
}
let _e333 = frag_info.camera_position;
let _e335 = v_world_position_1;
s_18.v = normalize((_e333.xyz - _e335));
let _e340 = s_18.n;
let _e342 = s_18.v;
s_18.n_dot_v = max(dot(_e340, _e342), 0.0001f);
let _e348 = frag_info.material[0u];
s_18.metallic = clamp(_e348, 0f, 1f);
let _e353 = frag_info.material[1u];
s_18.roughness = clamp(_e353, 0.02f, 1f);
let _e357 = frag_info.ambient_ground;
let _e360 = frag_info.ambient_sky;
let _e364 = s_18.n[1u];
let _e371 = frag_info.material[2u];
s_18.ambient = (mix(_e357.xyz, _e360.xyz, vec3(((_e364 * 0.5f) + 0.5f))) * _e371);
let _e376 = frag_info.frame_params[0u];
s_18.exposure = max(_e376, 0f);
s_18.occlusion = 1f;
s_18.emissive = vec3<f32>(0f, 0f, 0f);
let _e381 = s_18;
return _e381;
}
fn main_1() {
var s_19: Surface;
var param_239: Surface;
var param_240: Surface;
var param_241: Surface;
var param_242: Surface;
var param_243: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_244: vec3<f32>;
var param_245: f32;
var param_246: f32;
var ambient: vec3<f32>;
var levels_1: f32;
var coatAmbient: vec3<f32>;
var sheenIncoming: vec3<f32>;
var f0_4: vec3<f32>;
var f90_2: f32;
var bent: vec3<f32>;
var across: vec3<f32>;
var anisoN: vec3<f32>;
var bend: f32;
var bend4_: f32;
var reflected: vec3<f32>;
var irradiance: vec3<f32>;
var prefiltered: vec3<f32>;
var ab_4: vec2<f32>;
var param_247: f32;
var param_248: f32;
var single_1: vec3<f32>;
var specular_1: vec3<f32>;
var missed: f32;
var average_2: vec3<f32>;
var multiple: vec3<f32>;
var reflects: vec3<f32>;
var through: vec3<f32>;
var local_45: vec3<f32>;
var param_249: Surface;
var param_250: f32;
var coatPrefiltered: vec3<f32>;
var coatAb: vec2<f32>;
var param_251: f32;
var param_252: f32;
var sceneAb: vec2<f32>;
var param_253: f32;
var param_254: f32;
var sceneReflects: vec3<f32>;
var param_255: Surface;
var sheenAmbient: vec3<f32>;
var param_256: Surface;
var param_257: vec3<f32>;
var param_258: f32;
var param_259: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
g_f0_dielectric = vec3<f32>(0.04f, 0.04f, 0.04f);
g_f90_ = 1f;
g_coat = 0f;
g_coat_roughness = 0.02f;
g_coat_n = vec3<f32>(0f, 0f, 1f);
g_coat_n_dot_v = 1f;
g_coat_through = 1f;
g_sheen = vec3<f32>(0f, 0f, 0f);
g_sheen_roughness = 0.07f;
g_sheen_albedo = 0f;
g_sheen_scale = 1f;
g_aniso = 0f;
g_aniso_t = vec3<f32>(1f, 0f, 0f);
g_aniso_b = vec3<f32>(0f, 1f, 0f);
g_transmission = 0f;
g_thickness = 0f;
g_transmittance = vec3<f32>(1f, 1f, 1f);
g_iridescence = 0f;
g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
let _e312 = ReadSurface_u0028_();
s_19 = _e312;
let _e313 = s_19;
param_239 = _e313;
ReadLayers_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_239));
let _e314 = s_19;
param_240 = _e314;
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_240));
let _e315 = param_240;
s_19 = _e315;
let _e316 = s_19;
param_241 = _e316;
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_241));
let _e317 = param_241;
s_19 = _e317;
let _e318 = s_19;
param_242 = _e318;
ReadLayersOnMaps_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_242));
let _e319 = s_19;
param_243 = _e319;
ReadIridescence_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_243));
let _e321 = s_19.metallic;
metallic = clamp(_e321, 0f, 1f);
let _e324 = s_19.albedo;
let _e325 = metallic;
diffuseColor_1 = (_e324 * (1f - _e325));
let _e328 = EonDiffuse_u0028_();
if _e328 {
let _e329 = diffuseColor_1;
param_244 = _e329;
let _e331 = s_19.roughness;
param_245 = _e331;
let _e333 = s_19.n_dot_v;
param_246 = _e333;
let _e334 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_244), (¶m_245), (¶m_246));
diffuseColor_1 = _e334;
}
let _e335 = diffuseColor_1;
let _e337 = s_19.ambient;
let _e340 = s_19.occlusion;
ambient = ((_e335 * _e337) * _e340);
let _e342 = SceneColourBound_u0028_();
let _e343 = g_transmittance;
let _e346 = g_transmission;
let _e349 = ambient;
ambient = (_e349 * mix(vec3<f32>(1f, 1f, 1f), select(_e343, vec3<f32>(0f, 0f, 0f), vec3(_e342)), vec3(_e346)));
let _e353 = frag_info.frame_params[3u];
levels_1 = _e353;
coatAmbient = vec3<f32>(0f, 0f, 0f);
let _e355 = s_19.ambient;
sheenIncoming = _e355;
let _e356 = levels_1;
if (_e356 > 0f) {
let _e358 = g_f0_dielectric;
let _e360 = s_19.albedo;
let _e361 = metallic;
f0_4 = mix(_e358, _e360, vec3(_e361));
let _e364 = g_f90_;
let _e365 = metallic;
f90_2 = mix(_e364, 1f, _e365);
let _e368 = s_19.n;
bent = _e368;
let _e369 = g_aniso;
if (_e369 > 0f) {
let _e371 = g_aniso_t;
let _e373 = s_19.v;
across = cross(_e371, _e373);
let _e375 = across;
let _e376 = g_aniso_t;
anisoN = cross(_e375, _e376);
let _e378 = g_aniso;
let _e380 = s_19.roughness;
bend = (1f - (_e378 * (1f - _e380)));
let _e384 = bend;
let _e385 = bend;
let _e387 = bend;
let _e389 = bend;
bend4_ = (((_e384 * _e385) * _e387) * _e389);
let _e391 = anisoN;
let _e393 = s_19.n;
let _e394 = bend4_;
bent = normalize(mix(_e391, _e393, vec3(_e394)));
}
let _e399 = s_19.v;
let _e401 = bent;
reflected = reflect(-(_e399), _e401);
let _e404 = s_19.n;
let _e405 = levels_1;
let _e406 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e404, _e405);
irradiance = _e406.xyz;
let _e408 = reflected;
let _e410 = s_19.roughness;
let _e411 = levels_1;
let _e413 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e408, (_e410 * _e411));
prefiltered = _e413.xyz;
let _e416 = s_19.roughness;
param_247 = _e416;
let _e418 = s_19.n_dot_v;
param_248 = _e418;
let _e419 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_247), (¶m_248));
ab_4 = _e419;
let _e420 = f0_4;
let _e421 = g_irid_fresnel;
let _e422 = g_iridescence;
let _e426 = ab_4[0u];
let _e428 = f90_2;
let _e430 = ab_4[1u];
single_1 = ((mix(_e420, _e421, vec3(_e422)) * _e426) + vec3((_e428 * _e430)));
let _e434 = prefiltered;
let _e435 = single_1;
specular_1 = (_e434 * _e435);
let _e437 = EnergyCompensation_u0028_();
if _e437 {
let _e439 = ab_4[0u];
let _e441 = ab_4[1u];
missed = (1f - (_e439 + _e441));
let _e444 = f0_4;
let _e445 = f0_4;
average_2 = (_e444 + ((vec3<f32>(1f, 1f, 1f) - _e445) / vec3(21f)));
let _e450 = single_1;
let _e451 = average_2;
let _e453 = missed;
let _e454 = average_2;
multiple = ((_e450 * _e451) / (vec3<f32>(1f, 1f, 1f) - (_e454 * _e453)));
let _e458 = multiple;
let _e459 = missed;
let _e461 = irradiance;
let _e463 = specular_1;
specular_1 = (_e463 + ((_e458 * _e459) * _e461));
}
let _e465 = diffuseColor_1;
let _e466 = irradiance;
let _e468 = specular_1;
let _e472 = frag_info.material[2u];
let _e475 = s_19.occlusion;
ambient = ((((_e465 * _e466) + _e468) * _e472) * _e475);
let _e477 = g_f0_dielectric;
let _e478 = g_irid_fresnel;
let _e479 = g_iridescence;
let _e483 = ab_4[0u];
let _e485 = g_f90_;
let _e487 = ab_4[1u];
reflects = ((mix(_e477, _e478, vec3(_e479)) * _e483) + vec3((_e485 * _e487)));
let _e491 = SceneColourBound_u0028_();
if _e491 {
local_45 = vec3<f32>(0f, 0f, 0f);
} else {
let _e492 = s_19;
param_249 = _e492;
let _e493 = levels_1;
param_250 = _e493;
let _e494 = TransmittedRadiance_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_f1_u003b((¶m_249), (¶m_250));
let _e495 = g_transmittance;
let _e497 = reflects;
local_45 = ((_e494 * _e495) * (vec3<f32>(1f, 1f, 1f) - min(_e497, vec3<f32>(1f, 1f, 1f))));
}
let _e501 = local_45;
through = _e501;
let _e502 = diffuseColor_1;
let _e503 = through;
let _e504 = irradiance;
let _e507 = g_transmission;
let _e511 = frag_info.material[2u];
let _e514 = s_19.occlusion;
let _e516 = ambient;
ambient = (_e516 + ((((_e502 * (_e503 - _e504)) * _e507) * _e511) * _e514));
let _e519 = s_19.v;
let _e521 = g_coat_n;
let _e523 = g_coat_roughness;
let _e524 = levels_1;
let _e526 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e519), _e521), (_e523 * _e524));
coatPrefiltered = _e526.xyz;
let _e528 = g_coat_roughness;
param_251 = _e528;
let _e529 = g_coat_n_dot_v;
param_252 = _e529;
let _e530 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_251), (¶m_252));
coatAb = _e530;
let _e531 = coatPrefiltered;
let _e533 = coatAb[0u];
let _e536 = coatAb[1u];
let _e539 = g_coat;
let _e543 = frag_info.material[2u];
let _e546 = s_19.occlusion;
coatAmbient = ((((_e531 * ((0.04f * _e533) + _e536)) * _e539) * _e543) * _e546);
let _e549 = s_19.n;
let _e550 = g_sheen_roughness;
let _e551 = levels_1;
let _e553 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e549, (_e550 * _e551));
let _e557 = frag_info.material[2u];
sheenIncoming = (_e553.xyz * _e557);
}
let _e559 = SceneColourBound_u0028_();
if _e559 {
let _e561 = s_19.roughness;
param_253 = _e561;
let _e563 = s_19.n_dot_v;
param_254 = _e563;
let _e564 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_253), (¶m_254));
sceneAb = _e564;
let _e565 = g_f0_dielectric;
let _e566 = g_irid_fresnel;
let _e567 = g_iridescence;
let _e571 = sceneAb[0u];
let _e573 = g_f90_;
let _e575 = sceneAb[1u];
sceneReflects = ((mix(_e565, _e566, vec3(_e567)) * _e571) + vec3((_e573 * _e575)));
let _e579 = diffuseColor_1;
let _e580 = s_19;
param_255 = _e580;
let _e581 = SceneBehind_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_255));
let _e583 = g_transmittance;
let _e585 = sceneReflects;
let _e589 = g_transmission;
let _e591 = ambient;
ambient = (_e591 + ((((_e579 * _e581) * _e583) * (vec3<f32>(1f, 1f, 1f) - min(_e585, vec3<f32>(1f, 1f, 1f)))) * _e589));
}
let _e593 = diffuseColor_1;
let _e594 = SampleLightmap_u0028_();
let _e597 = s_19.occlusion;
let _e599 = ambient;
ambient = (_e599 + ((_e593 * _e594) * _e597));
let _e601 = g_sheen;
let _e602 = g_sheen_albedo;
let _e604 = sheenIncoming;
let _e607 = s_19.occlusion;
sheenAmbient = (((_e601 * _e602) * _e604) * _e607);
let _e609 = s_19;
param_256 = _e609;
let _e610 = 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_256));
let _e612 = s_19.occlusion;
let _e614 = ambient;
let _e615 = g_sheen_scale;
let _e617 = sheenAmbient;
let _e620 = s_19.emissive;
let _e622 = g_coat_through;
let _e625 = coatAmbient;
param_257 = (((_e610 * _e612) + ((((_e614 * _e615) + _e617) + _e620) * _e622)) + _e625);
let _e628 = s_19.alpha;
param_258 = _e628;
let _e630 = s_19.roughness;
param_259 = _e630;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_257), (¶m_258), (¶m_259));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(4) v_texcoord: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
v_texcoord_1 = v_texcoord;
main_1();
let _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'IrradianceInfo',
group: 1,
binding: 2,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'spacing',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'counts',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LayerInfo',
group: 1,
binding: 3,
sizeInBytes: 464,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'specular',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'coat', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'sheen',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'anisotropy',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'transmission',
offsetInBytes: 64,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'attenuation',
offsetInBytes: 80,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'iridescence',
offsetInBytes: 96,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'uv_transform',
offsetInBytes: 112,
sizeInBytes: 160,
),
WebGpuBlockMember(
name: 'scene_colour',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'scene_viewport',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'scene_levels',
offsetInBytes: 304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scene_view_projection',
offsetInBytes: 400,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 4,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 5,
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: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'coat_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'irradiance_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'ltc_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 24,
samplerBinding: 25,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 26,
samplerBinding: 27,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 28,
samplerBinding: 29,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 30,
samplerBinding: 31,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_colour_texture',
group: 1,
textureBinding: 32,
samplerBinding: 33,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 34,
samplerBinding: 35,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'sheen_texture',
group: 1,
textureBinding: 36,
samplerBinding: 37,
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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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 IrradianceInfo {
origin: vec4<f32>,
spacing: vec4<f32>,
counts: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e176 = v_world_position_1;
let _e178 = fog_info.eye;
let _e182 = fog_info.forward;
return dot((_e176 - _e178.xyz), _e182.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e181 = ViewDepth_u0028_();
z = abs(_e181);
let _e183 = z;
near = (_e183 / 5f);
let _e185 = z;
far = (_e185 / 200f);
let _e187 = far;
let _e188 = far;
let _e190 = far;
far3_ = ((_e187 * _e188) * _e190);
let _e192 = (*alpha);
let _e193 = near;
let _e194 = near;
let _e197 = far3_;
let _e198 = far3_;
return (_e192 * clamp((10f / ((0.00001f + (_e193 * _e194)) + (_e197 * _e198))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e185 = fog_info.forward[3u];
mode = _e185;
let _e186 = mode;
if (_e186 > 0.5f) {
let _e189 = frag_color[3u];
alpha_1 = _e189;
let _e190 = alpha_1;
param = _e190;
let _e191 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e191;
let _e192 = frag_color;
let _e194 = weight;
let _e195 = (_e192.xyz * _e194);
let _e196 = alpha_1;
let _e197 = weight;
accumulate = vec4<f32>(_e195.x, _e195.y, _e195.z, (_e196 * _e197));
let _e203 = mode;
let _e205 = mode;
revealage = ((_e203 > 1.5f) && (_e205 < 2.5f));
let _e208 = revealage;
if _e208 {
let _e209 = alpha_1;
local = vec4(_e209);
} else {
let _e211 = accumulate;
local = _e211;
}
let _e212 = local;
frag_color = _e212;
let _e213 = mode;
if (_e213 > 2.5f) {
let _e215 = alpha_1;
frag_surface = vec4(_e215);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e179 = (*n)[0u];
let _e182 = (*n)[1u];
let _e186 = (*n)[2u];
let _e189 = (*n);
(*n) = (_e189 / vec3(((abs(_e179) + abs(_e182)) + abs(_e186))));
let _e192 = (*n);
e = _e192.xy;
let _e195 = (*n)[2u];
if (_e195 < 0f) {
let _e197 = (*n);
let _e203 = (*n)[0u];
let _e207 = (*n)[1u];
e = ((vec2(1f) - abs(_e197.yx)) * vec2<f32>(select(-1f, 1f, (_e203 >= 0f)), select(-1f, 1f, (_e207 >= 0f))));
}
let _e212 = e;
return ((_e212 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e177 = (*linear);
let _e179 = (*linear);
let _e183 = (*linear);
return mix((_e177 * 12.92f), ((pow(_e179, 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), _e183));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e180 = g_albedo;
param_1 = clamp(_e180, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e182 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
let _e187 = g_debug_surface_on;
if _e187 {
let _e188 = g_debug_surface;
let _e189 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e188.x, _e188.y, _e188.z, _e189);
return;
}
let _e194 = v_normal_1;
geometric = normalize(_e194);
let _e196 = gl_FrontFacing_1;
if !(_e196) {
let _e198 = geometric;
geometric = -(_e198);
}
let _e200 = geometric;
param_2 = _e200;
let _e201 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e202 = (*roughness);
let _e204 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e201.x, _e201.y, clamp(_e202, 0f, 1f), _e204);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e176 = v_world_position_1;
let _e178 = fog_info.eye;
return distance(_e176, _e178.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e181 = fog_info.fog[3u];
density = _e181;
let _e182 = density;
if (_e182 <= 0f) {
let _e184 = (*color);
return _e184;
}
let _e185 = EyeDistance_u0028_();
d = _e185;
let _e187 = fog_info.fog;
let _e189 = (*color);
let _e190 = density;
let _e192 = d;
return mix(_e187.xyz, _e189, vec3(clamp(exp((-(_e190) * _e192)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e182 = g_premultiply;
let _e183 = (*alpha_2);
weight_1 = select(1f, _e183, _e182);
let _e185 = (*linearColor);
param_3 = _e185;
let _e186 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e187 = weight_1;
let _e188 = (_e186 * _e187);
let _e189 = (*alpha_2);
frag_color = vec4<f32>(_e188.x, _e188.y, _e188.z, _e189);
let _e194 = (*roughness_1);
param_4 = _e194;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
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_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var bands: f32;
var quantized: f32;
var fraction: f32;
var ramp: f32;
let _e183 = (*s).roughness;
bands = mix(5f, 2f, _e183);
let _e186 = (*light).n_dot_l;
let _e187 = bands;
let _e190 = bands;
quantized = (floor((_e186 * _e187)) / _e190);
let _e193 = (*light).n_dot_l;
let _e194 = bands;
fraction = fract((_e193 * _e194));
let _e197 = fraction;
let _e199 = bands;
let _e201 = quantized;
quantized = (_e201 + (smoothstep(0.85f, 1f, _e197) / _e199));
let _e203 = quantized;
let _e205 = (*light).n_dot_l;
ramp = (_e203 / max(_e205, 0.001f));
let _e209 = (*s).albedo;
let _e210 = ramp;
return (_e209 * _e210);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e177 = (*i);
if (_e177 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e179 = (*i);
if (_e179 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e181 = (*i);
if (_e181 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e183 = (*i);
if (_e183 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e185 = (*i);
if (_e185 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e187 = (*i);
if (_e187 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e189 = (*i);
if (_e189 == 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_5: i32;
let _e182 = (*i_1);
param_5 = _e182;
let _e183 = PointShadowDiskTap_u0028_i1_u003b((¶m_5));
p = _e183;
let _e185 = p[0u];
let _e186 = (*ca);
let _e189 = p[1u];
let _e190 = (*sa);
let _e194 = p[0u];
let _e195 = (*sa);
let _e198 = p[1u];
let _e199 = (*ca);
let _e203 = (*radius);
return (vec2<f32>(((_e185 * _e186) - (_e189 * _e190)), ((_e194 * _e195) + (_e198 * _e199))) * _e203);
}
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_1: vec2<f32>;
var atlas: vec2<f32>;
let _e185 = point_shadow.params[0u];
inset = _e185;
let _e186 = (*uv);
let _e187 = (*offset);
let _e189 = inset;
let _e190 = inset;
local_1 = clamp((_e186 + _e187), vec2(_e189), vec2((1f - _e190)));
let _e195 = local_1;
let _e196 = (*tile);
atlas = ((_e195 + _e196) * vec2<f32>(0.16666667f, 0.16666667f));
let _e201 = point_shadow.params3_[0u];
if (_e201 > 0.5f) {
let _e204 = atlas[1u];
atlas[1u] = (1f - _e204);
}
let _e207 = atlas;
let _e208 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e207, 0f);
let _e210 = atlas;
let _e211 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e210, 0f);
let _e214 = (*range);
return (min(_e208.x, _e211.x) * _e214);
}
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_6: vec2<f32>;
var param_7: vec2<f32>;
var param_8: vec2<f32>;
var param_9: f32;
let _e186 = (*uv_1);
param_6 = _e186;
let _e187 = (*offset_1);
param_7 = _e187;
let _e188 = (*tile_1);
param_8 = _e188;
let _e189 = (*range_1);
param_9 = _e189;
let _e190 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9));
stored = _e190;
let _e191 = stored;
let _e192 = (*range_1);
if (_e191 >= (_e192 * 0.999f)) {
return 1f;
}
let _e195 = (*receiver);
let _e196 = stored;
return select(1f, 0f, (_e195 > _e196));
}
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_10: vec2<f32>;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_14: i32;
var param_15: f32;
var param_16: f32;
var param_17: f32;
var param_18: vec2<f32>;
var param_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e207 = point_shadow.params2_[1u];
lightRadius = _e207;
let _e210 = point_shadow.params2_[0u];
minRadius = _e210;
let _e213 = point_shadow.params2_[2u];
maxRadius = _e213;
let _e214 = lightRadius;
if (_e214 <= 0f) {
let _e216 = (*uv_2);
param_10 = _e216;
param_11 = vec2<f32>(0f, 0f);
let _e217 = (*tile_2);
param_12 = _e217;
let _e218 = (*range_2);
param_13 = _e218;
let _e219 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13));
(*blockerOut) = _e219;
let _e220 = minRadius;
return _e220;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e221 = i_2;
if (_e221 < 8i) {
let _e223 = i_2;
param_14 = _e223;
let _e224 = (*ca_1);
param_15 = _e224;
let _e225 = (*sa_1);
param_16 = _e225;
let _e226 = maxRadius;
param_17 = _e226;
let _e227 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_14), (¶m_15), (¶m_16), (¶m_17));
let _e228 = (*uv_2);
param_18 = _e228;
param_19 = _e227;
let _e229 = (*tile_2);
param_20 = _e229;
let _e230 = (*range_2);
param_21 = _e230;
let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_18), (¶m_19), (¶m_20), (¶m_21));
stored_1 = _e231;
let _e232 = stored_1;
let _e233 = (*range_2);
if (_e232 >= (_e233 * 0.999f)) {
continue;
}
let _e236 = stored_1;
let _e237 = (*receiver_1);
if (_e236 >= _e237) {
continue;
}
let _e239 = stored_1;
let _e240 = sum;
sum = (_e240 + _e239);
let _e242 = count;
count = (_e242 + 1f);
continue;
} else {
break;
}
continuing {
let _e244 = i_2;
i_2 = (_e244 + 1i);
}
}
let _e246 = count;
if (_e246 < 0.5f) {
return -1f;
}
let _e248 = sum;
let _e249 = count;
blocker = max((_e248 / _e249), 0.0001f);
let _e252 = blocker;
(*blockerOut) = _e252;
let _e253 = lightRadius;
let _e254 = (*receiver_1);
let _e255 = blocker;
let _e259 = blocker;
world = ((_e253 * max((_e254 - _e255), 0f)) / _e259);
let _e261 = world;
let _e262 = (*receiver_1);
let _e264 = (*tanHalf);
let _e267 = minRadius;
let _e268 = maxRadius;
return clamp((_e261 / ((2f * _e262) * _e264)), _e267, _e268);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_2: vec2<f32>;
let _e178 = (*rows);
if (_e178 > 0f) {
let _e181 = gl_FragCoord_1[0u];
let _e182 = (*rows);
let _e184 = gl_FragCoord_1[1u];
local_2 = vec2<f32>(_e181, (_e182 - _e184));
} else {
let _e187 = gl_FragCoord_1;
local_2 = _e187.xy;
}
let _e189 = local_2;
return _e189;
}
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 param_22: 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_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var local_3: vec3<f32>;
var lit: f32;
var param_31: vec2<f32>;
var param_32: vec2<f32>;
var param_33: vec2<f32>;
var param_34: f32;
var param_35: f32;
var i_3: i32;
var param_36: i32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
var param_40: vec2<f32>;
var param_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: f32;
var param_44: f32;
var phi_2149_: bool;
var phi_2210_: bool;
let _e230 = (*lightIndex);
let _e234 = point_shadow.slots[_e230][0u];
slot = i32((_e234 + 0.5f));
let _e237 = (*lightIndex);
let _e241 = point_shadow.slots[_e237][0u];
if (_e241 < 0f) {
return 1f;
}
let _e245 = point_shadow.params[2u];
strength = _e245;
let _e246 = strength;
if (_e246 <= 0f) {
return 1f;
}
let _e248 = slot;
let _e251 = point_shadow.lights[_e248];
let _e253 = (*world_1);
toLight = (_e251.xyz - _e253);
let _e255 = toLight;
toLightLength = max(length(_e255), 0.000001f);
let _e258 = (*normal);
let _e259 = toLight;
let _e260 = toLightLength;
nDotL = max(dot(_e258, (_e259 / vec3(_e260))), 0.15f);
let _e265 = nDotL;
let _e266 = nDotL;
let _e271 = nDotL;
let _e272 = nDotL;
slope = min((sqrt(max((1f - (_e265 * _e266)), 0f)) / (_e271 * _e272)), 8f);
let _e276 = toLightLength;
let _e278 = (*lightIndex);
let _e282 = point_shadow.slots[_e278][2u];
let _e287 = point_shadow.params3_[1u];
texel = (((2f * _e276) * max(_e282, 0.0001f)) * _e287);
let _e289 = (*world_1);
let _e290 = (*normal);
let _e291 = texel;
let _e295 = point_shadow.params[3u];
let _e297 = slope;
origin = (_e289 + (((_e290 * _e291) * _e295) * (1f + _e297)));
let _e301 = origin;
let _e302 = slot;
let _e305 = point_shadow.lights[_e302];
toFragment = (_e301 - _e305.xyz);
let _e308 = toFragment;
distance_ = length(_e308);
let _e310 = slot;
let _e314 = point_shadow.lights[_e310][3u];
range_3 = max(_e314, 0.0001f);
let _e316 = distance_;
let _e317 = range_3;
if (_e316 >= _e317) {
return 1f;
}
face = 0i;
let _e319 = (*lightIndex);
let _e323 = point_shadow.slots[_e319][1u];
if (_e323 < 0.5f) {
let _e325 = toFragment;
a = abs(_e325);
let _e328 = a[0u];
let _e330 = a[1u];
let _e331 = (_e328 >= _e330);
phi_2149_ = _e331;
if _e331 {
let _e333 = a[0u];
let _e335 = a[2u];
phi_2149_ = (_e333 >= _e335);
}
let _e338 = phi_2149_;
if _e338 {
let _e340 = toFragment[0u];
face = select(1i, 0i, (_e340 > 0f));
} else {
let _e344 = a[1u];
let _e346 = a[2u];
if (_e344 >= _e346) {
let _e349 = toFragment[1u];
face = select(3i, 2i, (_e349 > 0f));
} else {
let _e353 = toFragment[2u];
face = select(5i, 4i, (_e353 > 0f));
}
}
}
let _e356 = slot;
let _e358 = face;
let _e362 = point_shadow.faces[((_e356 * 6i) + _e358)];
let _e363 = origin;
clip = (_e362 * vec4<f32>(_e363.x, _e363.y, _e363.z, 1f));
let _e370 = clip[3u];
if (_e370 <= 0f) {
return 1f;
}
let _e372 = clip;
let _e375 = clip[3u];
ndc = (_e372.xy / vec2(_e375));
let _e379 = ndc[0u];
let _e381 = (abs(_e379) > 1f);
phi_2210_ = _e381;
if !(_e381) {
let _e384 = ndc[1u];
phi_2210_ = (abs(_e384) > 1f);
}
let _e388 = phi_2210_;
if _e388 {
return 1f;
}
let _e390 = ndc[0u];
let _e394 = ndc[1u];
uv_3 = vec2<f32>(((_e390 * 0.5f) + 0.5f), (0.5f - (_e394 * 0.5f)));
let _e398 = face;
let _e400 = slot;
tile_3 = vec2<f32>(f32(_e398), f32(_e400));
let _e403 = distance_;
let _e406 = point_shadow.params[1u];
receiver_2 = (_e403 - _e406);
let _e410 = frag_info.target_origin[0u];
param_22 = _e410;
let _e411 = FragCoordFromTop_u0028_f1_u003b((¶m_22));
noise = fract((52.982918f * fract(dot(_e411, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e416 = noise;
angle = (_e416 * 6.2831855f);
let _e418 = angle;
ca_2 = cos(_e418);
let _e420 = angle;
sa_2 = sin(_e420);
let _e422 = (*lightIndex);
let _e426 = point_shadow.slots[_e422][2u];
tanHalf_1 = max(_e426, 0.0001f);
blocker_1 = -1f;
let _e428 = uv_3;
param_23 = _e428;
let _e429 = tile_3;
param_24 = _e429;
let _e430 = range_3;
param_25 = _e430;
let _e431 = receiver_2;
param_26 = _e431;
let _e432 = ca_2;
param_27 = _e432;
let _e433 = sa_2;
param_28 = _e433;
let _e434 = tanHalf_1;
param_29 = _e434;
let _e435 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30));
let _e436 = param_30;
blocker_1 = _e436;
radius_1 = _e435;
let _e439 = point_shadow.params2_[3u];
if (_e439 > 0.5f) {
g_debug_surface_on = true;
let _e441 = radius_1;
if (_e441 < 0f) {
local_3 = vec3<f32>(0f, 0f, 1f);
} else {
let _e443 = radius_1;
let _e446 = point_shadow.params2_[2u];
let _e450 = blocker_1;
let _e451 = range_3;
local_3 = vec3<f32>(clamp((_e443 / max(_e446, 0.000001f)), 0f, 1f), clamp((_e450 / _e451), 0f, 1f), 0f);
}
let _e455 = local_3;
g_debug_surface = _e455;
}
let _e456 = radius_1;
if (_e456 < 0f) {
return 1f;
}
let _e458 = uv_3;
param_31 = _e458;
param_32 = vec2<f32>(0f, 0f);
let _e459 = tile_3;
param_33 = _e459;
let _e460 = range_3;
param_34 = _e460;
let _e461 = receiver_2;
param_35 = _e461;
let _e462 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_31), (¶m_32), (¶m_33), (¶m_34), (¶m_35));
lit = _e462;
let _e463 = radius_1;
if (_e463 > 0f) {
i_3 = 0i;
loop {
let _e465 = i_3;
if (_e465 < 8i) {
let _e467 = i_3;
param_36 = _e467;
let _e468 = ca_2;
param_37 = _e468;
let _e469 = sa_2;
param_38 = _e469;
let _e470 = radius_1;
param_39 = _e470;
let _e471 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e472 = uv_3;
param_40 = _e472;
param_41 = _e471;
let _e473 = tile_3;
param_42 = _e473;
let _e474 = range_3;
param_43 = _e474;
let _e475 = receiver_2;
param_44 = _e475;
let _e476 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
let _e477 = lit;
lit = (_e477 + _e476);
continue;
} else {
break;
}
continuing {
let _e479 = i_3;
i_3 = (_e479 + 1i);
}
}
let _e481 = lit;
lit = (_e481 * 0.11111111f);
}
let _e483 = lit;
let _e484 = strength;
return mix(1f, _e483, clamp(_e484, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r: f32;
var theta: f32;
let _e181 = (*i_4);
let _e184 = (*n_1);
r = sqrt(((f32(_e181) + 0.5f) / f32(_e184)));
let _e188 = (*i_4);
let _e191 = (*turn);
theta = ((f32(_e188) * 2.3999631f) + _e191);
let _e193 = r;
let _e194 = theta;
let _e196 = theta;
return (vec2<f32>(cos(_e194), sin(_e196)) * _e193);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_45: f32;
let _e180 = frag_info.target_origin[0u];
param_45 = _e180;
let _e181 = FragCoordFromTop_u0028_f1_u003b((¶m_45));
let _e184 = frag_info.target_origin[3u];
at = (_e181 + vec2((5.588238f * max(_e184, 0f))));
let _e189 = at;
return fract((52.982918f * fract(dot(_e189, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_1: f32;
var pMax: f32;
var reduced: f32;
let _e185 = (*moments)[1u];
let _e187 = (*moments)[0u];
let _e189 = (*moments)[0u];
let _e192 = (*minVariance);
variance = max((_e185 - (_e187 * _e189)), _e192);
let _e194 = (*t);
let _e196 = (*moments)[0u];
d_1 = (_e194 - _e196);
let _e198 = variance;
let _e199 = variance;
let _e200 = d_1;
let _e201 = d_1;
pMax = (_e198 / (_e199 + (_e200 * _e201)));
let _e205 = pMax;
let _e206 = (*bleed);
let _e208 = (*bleed);
reduced = clamp(((_e205 - _e206) / max((1f - _e208), 0.0001f)), 0f, 1f);
let _e213 = (*t);
let _e215 = (*moments)[0u];
let _e217 = reduced;
return select(_e217, 1f, (_e213 <= _e215));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e178 = (*depth);
d_2 = ((2f * clamp(_e178, 0f, 1f)) - 1f);
let _e182 = d_2;
let _e185 = d_2;
return vec2<f32>(exp((40f * _e182)), -(exp((-5f * _e185))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_46: f32;
var scale: vec2<f32>;
var positive: f32;
var param_47: vec2<f32>;
var param_48: f32;
var param_49: f32;
var param_50: f32;
var negative: f32;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var param_54: f32;
let _e192 = (*depth_1);
param_46 = _e192;
let _e193 = EvsmWarp_u0028_f1_u003b((¶m_46));
warped = _e193;
let _e194 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e194);
let _e197 = scale[0u];
let _e199 = scale[0u];
let _e201 = (*moments_1);
param_47 = _e201.xy;
let _e204 = warped[0u];
param_48 = _e204;
param_49 = (_e197 * _e199);
let _e205 = (*bleed_1);
param_50 = _e205;
let _e206 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_47), (¶m_48), (¶m_49), (¶m_50));
positive = _e206;
let _e208 = scale[1u];
let _e210 = scale[1u];
let _e212 = (*moments_1);
param_51 = _e212.zw;
let _e215 = warped[1u];
param_52 = _e215;
param_53 = (_e208 * _e210);
let _e216 = (*bleed_1);
param_54 = _e216;
let _e217 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_51), (¶m_52), (¶m_53), (¶m_54));
negative = _e217;
let _e218 = positive;
let _e219 = negative;
return min(_e218, _e219);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_4: mat4x4<f32>;
var local_5: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_6: f32;
var local_7: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_55: vec4<f32>;
var param_56: f32;
var param_57: f32;
var y: i32;
var x: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var occluder_1: f32;
var param_58: i32;
var param_59: i32;
var param_60: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var occluder_2: f32;
var param_61: i32;
var param_62: i32;
var param_63: f32;
var phi_3269_: bool;
var phi_3280_: bool;
var phi_3436_: bool;
var phi_3443_: bool;
var phi_3450_: bool;
let _e237 = frag_info.shadow_params[3u];
strength_1 = _e237;
let _e238 = strength_1;
if (_e238 <= 0f) {
return 1f;
}
let _e240 = (*lightIndex_1);
let _e243 = frag_info.frame_params[2u];
if (_e240 != i32((_e243 + 0.5f))) {
return 1f;
}
let _e249 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e249 + 0.5f));
let _e252 = v_world_position_1;
let _e254 = frag_info.camera_position;
viewDistance = length((_e252 - _e254.xyz));
cascade = 0i;
let _e258 = cascadeCount;
let _e259 = (_e258 > 1i);
phi_3269_ = _e259;
if _e259 {
let _e260 = viewDistance;
let _e263 = frag_info.shadow_cascades[0u];
phi_3269_ = (_e260 > _e263);
}
let _e266 = phi_3269_;
if _e266 {
cascade = 1i;
}
let _e267 = cascadeCount;
let _e268 = (_e267 > 2i);
phi_3280_ = _e268;
if _e268 {
let _e269 = viewDistance;
let _e272 = frag_info.shadow_cascades[1u];
phi_3280_ = (_e269 > _e272);
}
let _e275 = phi_3280_;
if _e275 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e276 = attempt;
if (_e276 < 3i) {
let _e278 = cascade;
let _e279 = attempt;
which = (_e278 + _e279);
let _e281 = which;
let _e282 = cascadeCount;
if (_e281 >= _e282) {
break;
}
let _e284 = which;
if (_e284 == 0i) {
let _e287 = frag_info.shadow_matrix;
local_4 = _e287;
} else {
let _e288 = which;
if (_e288 == 1i) {
let _e291 = frag_info.shadow_matrix_far;
local_5 = _e291;
} else {
let _e293 = frag_info.shadow_matrix_farthest;
local_5 = _e293;
}
let _e294 = local_5;
local_4 = _e294;
}
let _e295 = local_4;
matrix = _e295;
let _e298 = matrix[0][0u];
let _e301 = matrix[1][0u];
let _e304 = matrix[2][0u];
axisX = vec3<f32>(_e298, _e301, _e304);
let _e308 = matrix[0][1u];
let _e311 = matrix[1][1u];
let _e314 = matrix[2][1u];
axisY = vec3<f32>(_e308, _e311, _e314);
let _e316 = axisX;
rowX = max(length(_e316), 0.000001f);
let _e319 = axisY;
rowY = max(length(_e319), 0.000001f);
let _e324 = frag_info.shadow_cascades[3u];
let _e326 = rowX;
texelMetres = ((2f * _e324) / _e326);
let _e330 = frag_info.shadow_cascades[3u];
let _e333 = (*s_1).n;
let _e334 = axisX;
let _e337 = rowX;
let _e338 = rowX;
let _e342 = (*s_1).n;
let _e343 = axisY;
let _e346 = rowY;
let _e347 = rowY;
reach = ((3f * _e330) * ((abs(dot(_e333, _e334)) / (_e337 * _e338)) + (abs(dot(_e342, _e343)) / (_e346 * _e347))));
let _e352 = v_world_position_1;
let _e354 = (*s_1).n;
let _e357 = frag_info.shadow_params[2u];
let _e358 = reach;
origin_1 = (_e352 + (_e354 * (_e357 + _e358)));
let _e362 = matrix;
let _e363 = origin_1;
lightSpace = (_e362 * vec4<f32>(_e363.x, _e363.y, _e363.z, 1f));
let _e370 = lightSpace[3u];
if (_e370 <= 0f) {
continue;
}
let _e372 = lightSpace;
let _e375 = lightSpace[3u];
candidate = (_e372.xyz / vec3(_e375));
let _e379 = candidate[0u];
let _e383 = candidate[1u];
inTile = vec2<f32>(((_e379 * 0.5f) + 0.5f), (0.5f - (_e383 * 0.5f)));
let _e388 = inTile[0u];
let _e389 = (_e388 < 0f);
phi_3436_ = _e389;
if !(_e389) {
let _e392 = inTile[0u];
phi_3436_ = (_e392 > 1f);
}
let _e395 = phi_3436_;
phi_3443_ = _e395;
if !(_e395) {
let _e398 = inTile[1u];
phi_3443_ = (_e398 < 0f);
}
let _e401 = phi_3443_;
phi_3450_ = _e401;
if !(_e401) {
let _e404 = inTile[1u];
phi_3450_ = (_e404 > 1f);
}
let _e407 = phi_3450_;
if _e407 {
continue;
}
let _e409 = candidate[2u];
if (_e409 > 1f) {
let _e411 = which;
let _e412 = cascadeCount;
if (_e411 < (_e412 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e417 = inTile[0u];
let _e418 = which;
let _e421 = cascadeCount;
let _e425 = inTile[1u];
uv_4 = vec2<f32>(((_e417 + f32(_e418)) / f32(_e421)), _e425);
let _e427 = candidate;
projected = _e427;
let _e428 = which;
cascade = _e428;
let _e429 = texelMetres;
cascadeTexel = _e429;
let _e432 = matrix[0][2u];
let _e435 = matrix[1][2u];
let _e438 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e432, _e435, _e438)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e443 = attempt;
attempt = (_e443 + 1i);
}
}
let _e445 = found;
if !(_e445) {
return 1f;
}
let _e447 = cascade;
if (_e447 == 0i) {
let _e451 = frag_info.shadow_bias[0u];
local_6 = _e451;
} else {
let _e452 = cascade;
if (_e452 == 1i) {
let _e456 = frag_info.shadow_bias[1u];
local_7 = _e456;
} else {
let _e459 = frag_info.shadow_bias[2u];
local_7 = _e459;
}
let _e460 = local_7;
local_6 = _e460;
}
let _e461 = local_6;
bias = _e461;
let _e464 = frag_info.shadow_params[0u];
let _e467 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e464, _e467);
let _e469 = cascade;
let _e471 = cascadeCount;
let _e475 = texel_1;
tileLo = (vec2<f32>((f32(_e469) / f32(_e471)), 0f) + (_e475 * 0.5f));
let _e478 = cascade;
let _e481 = cascadeCount;
let _e485 = texel_1;
tileHi = (vec2<f32>((f32((_e478 + 1i)) / f32(_e481)), 1f) - (_e485 * 0.5f));
let _e490 = frag_info.ambient_ground[3u];
softness = _e490;
lit_1 = 0f;
let _e491 = softness;
if (_e491 < 0f) {
let _e493 = uv_4;
let _e494 = tileLo;
let _e495 = tileHi;
let _e497 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e493, _e494, _e495), 0f);
moments_2 = _e497;
let _e499 = projected[2u];
let _e500 = bias;
let _e502 = softness;
let _e506 = moments_2;
param_55 = _e506;
param_56 = (_e499 - _e500);
param_57 = clamp((-(_e502) - 1f), 0f, 0.95f);
let _e507 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_55), (¶m_56), (¶m_57));
lit_1 = _e507;
} else {
let _e508 = softness;
if (_e508 <= 0f) {
y = -1i;
loop {
let _e510 = y;
if (_e510 <= 1i) {
x = -1i;
loop {
let _e512 = x;
if (_e512 <= 1i) {
let _e514 = uv_4;
let _e515 = x;
let _e517 = y;
let _e520 = texel_1;
let _e523 = tileLo;
let _e524 = tileHi;
let _e526 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e514 + (vec2<f32>(f32(_e515), f32(_e517)) * _e520)), _e523, _e524), 0f);
occluder = _e526.x;
let _e529 = projected[2u];
let _e530 = bias;
let _e532 = occluder;
let _e535 = lit_1;
lit_1 = (_e535 + select(1f, 0f, ((_e529 - _e530) > _e532)));
continue;
} else {
break;
}
continuing {
let _e537 = x;
x = (_e537 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e539 = y;
y = (_e539 + 1i);
}
}
let _e541 = lit_1;
lit_1 = (_e541 * 0.11111111f);
} else {
let _e543 = softness;
spread = tan(min(_e543, 0.5f));
let _e546 = ShadowNoise_u0028_();
turn_1 = (_e546 * 6.2831855f);
let _e548 = spread;
let _e550 = projected[2u];
let _e552 = cascadeDepth;
let _e554 = cascadeTexel;
searchRadius = clamp((((_e548 * _e550) * _e552) / _e554), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e557 = i_5;
if (_e557 < 16i) {
let _e559 = uv_4;
let _e560 = i_5;
param_58 = _e560;
param_59 = 16i;
let _e561 = turn_1;
param_60 = _e561;
let _e562 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60));
let _e563 = texel_1;
let _e565 = searchRadius;
let _e568 = tileLo;
let _e569 = tileHi;
let _e571 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e559 + ((_e562 * _e563) * _e565)), _e568, _e569), 0f);
occluder_1 = _e571.x;
let _e574 = projected[2u];
let _e575 = bias;
let _e577 = occluder_1;
if ((_e574 - _e575) > _e577) {
let _e579 = occluder_1;
let _e580 = blockerSum;
blockerSum = (_e580 + _e579);
let _e582 = blockerCount;
blockerCount = (_e582 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e584 = i_5;
i_5 = (_e584 + 1i);
}
}
let _e586 = blockerCount;
if (_e586 <= 0f) {
return 1f;
}
let _e589 = projected[2u];
let _e590 = blockerSum;
let _e591 = blockerCount;
let _e595 = cascadeDepth;
gap = (max((_e589 - (_e590 / _e591)), 0f) * _e595);
let _e597 = spread;
let _e598 = gap;
let _e600 = cascadeTexel;
radius_2 = clamp(((_e597 * _e598) / _e600), 1f, 16f);
i_6 = 0i;
loop {
let _e603 = i_6;
if (_e603 < 16i) {
let _e605 = uv_4;
let _e606 = turn_1;
let _e608 = i_6;
param_61 = _e608;
param_62 = 16i;
param_63 = (_e606 + 1f);
let _e609 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_61), (¶m_62), (¶m_63));
let _e610 = texel_1;
let _e612 = radius_2;
let _e615 = tileLo;
let _e616 = tileHi;
let _e618 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e605 + ((_e609 * _e610) * _e612)), _e615, _e616), 0f);
occluder_2 = _e618.x;
let _e621 = projected[2u];
let _e622 = bias;
let _e624 = occluder_2;
let _e627 = lit_1;
lit_1 = (_e627 + select(1f, 0f, ((_e621 - _e622) > _e624)));
continue;
} else {
break;
}
continuing {
let _e629 = i_6;
i_6 = (_e629 + 1i);
}
}
let _e631 = lit_1;
lit_1 = (_e631 * 0.0625f);
}
}
let _e633 = lit_1;
let _e634 = strength_1;
return mix(1f, _e633, clamp(_e634, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_64: Surface;
var param_65: LightSample;
var param_66: i32;
let _e182 = (*s_2);
param_64 = _e182;
let _e183 = (*light_2);
param_65 = _e183;
let _e184 = (*index);
param_66 = _e184;
let _e185 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_64), (¶m_65), (¶m_66));
return _e185;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e177 = (*index_1);
return (_e177 < 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 _e181 = (*distance_1);
let _e182 = (*distance_1);
attenuation = (1f / max((_e181 * _e182), 0.0001f));
let _e186 = (*range_4);
if (_e186 > 0f) {
let _e188 = (*distance_1);
let _e189 = (*range_4);
ratio = (_e188 / _e189);
let _e191 = ratio;
let _e192 = ratio;
let _e194 = ratio;
let _e196 = ratio;
window = clamp((1f - (((_e191 * _e192) * _e194) * _e196)), 0f, 1f);
let _e200 = window;
let _e201 = window;
let _e203 = attenuation;
attenuation = (_e203 * (_e200 * _e201));
}
let _e205 = attenuation;
return _e205;
}
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_2: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_8: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e193 = (*halfWidth);
let _e194 = (*halfHeight);
n_2 = cross(_e193, _e194);
let _e196 = n_2;
nLen = length(_e196);
let _e198 = nLen;
if (_e198 < 0.000000000001f) {
let _e200 = (*centre);
return _e200;
}
let _e201 = nLen;
let _e202 = n_2;
n_2 = (_e202 / vec3(_e201));
let _e205 = (*centre);
let _e206 = (*world_2);
toPlane = (_e205 - _e206);
let _e208 = (*mirror);
let _e209 = n_2;
denom = dot(_e208, _e209);
let _e211 = denom;
if (abs(_e211) < 0.00001f) {
let _e214 = toPlane;
let _e215 = n_2;
let _e216 = toPlane;
let _e217 = n_2;
onPlane = (_e214 - (_e215 * dot(_e216, _e217)));
} else {
let _e221 = toPlane;
let _e222 = n_2;
let _e224 = denom;
t_1 = (dot(_e221, _e222) / _e224);
let _e226 = t_1;
if (_e226 > 0f) {
let _e228 = (*mirror);
let _e229 = t_1;
local_8 = (_e228 * _e229);
} else {
let _e231 = toPlane;
let _e232 = n_2;
let _e233 = toPlane;
let _e234 = n_2;
local_8 = (_e231 - (_e232 * dot(_e233, _e234)));
}
let _e238 = local_8;
onPlane = _e238;
}
let _e239 = onPlane;
let _e240 = toPlane;
offset_2 = (_e239 - _e240);
let _e242 = (*halfWidth);
let _e243 = (*halfWidth);
wLen2_ = max(dot(_e242, _e243), 0.000000000001f);
let _e246 = (*halfHeight);
let _e247 = (*halfHeight);
hLen2_ = max(dot(_e246, _e247), 0.000000000001f);
let _e250 = offset_2;
let _e251 = (*halfWidth);
let _e253 = wLen2_;
u = clamp((dot(_e250, _e251) / _e253), -1f, 1f);
let _e256 = offset_2;
let _e257 = (*halfHeight);
let _e259 = hLen2_;
v = clamp((dot(_e256, _e257) / _e259), -1f, 1f);
let _e262 = (*centre);
let _e263 = (*halfWidth);
let _e264 = u;
let _e267 = (*halfHeight);
let _e268 = v;
return ((_e262 + (_e263 * _e264)) + (_e267 * _e268));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
var local_9: f32;
let _e185 = (*a_1);
let _e186 = (*a_1);
ua = (_e185 / vec3(max(length(_e186), 0.000000000001f)));
let _e191 = (*b);
let _e192 = (*b);
ub = (_e191 / vec3(max(length(_e192), 0.000000000001f)));
let _e197 = ua;
let _e198 = ub;
angle_1 = acos(clamp(dot(_e197, _e198), -1f, 1f));
let _e202 = ua;
let _e203 = ub;
axis = cross(_e202, _e203);
let _e205 = axis;
len = length(_e205);
let _e207 = len;
if (_e207 > 0.000001f) {
let _e209 = angle_1;
let _e210 = axis;
let _e211 = (*n_3);
let _e214 = len;
local_9 = ((_e209 * dot(_e210, _e211)) / _e214);
} else {
local_9 = 0f;
}
let _e216 = local_9;
return _e216;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_7: i32;
var a_2: vec3<f32>;
var b_1: vec3<f32>;
var local_10: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_11: f32;
var aAbove: bool;
var bAbove: bool;
var local_12: f32;
var param_67: vec3<f32>;
var param_68: vec3<f32>;
var param_69: vec3<f32>;
var param_70: vec3<f32>;
var param_71: vec3<f32>;
var param_72: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e199 = i_7;
if (_e199 < 4i) {
let _e201 = i_7;
let _e203 = (*corners)[_e201];
a_2 = _e203;
let _e204 = i_7;
if (_e204 == 3i) {
local_10 = 0i;
} else {
let _e206 = i_7;
local_10 = (_e206 + 1i);
}
let _e208 = local_10;
let _e210 = (*corners)[_e208];
b_1 = _e210;
let _e211 = a_2;
let _e212 = (*n_4);
ha = dot(_e211, _e212);
let _e214 = b_1;
let _e215 = (*n_4);
hb = dot(_e214, _e215);
let _e217 = ha;
let _e218 = hb;
d_3 = (_e217 - _e218);
let _e220 = a_2;
let _e221 = b_1;
let _e222 = a_2;
let _e224 = d_3;
if (abs(_e224) > 0.000000000001f) {
let _e227 = ha;
let _e228 = d_3;
local_11 = (_e227 / _e228);
} else {
local_11 = 0f;
}
let _e230 = local_11;
q = (_e220 + ((_e221 - _e222) * _e230));
let _e233 = ha;
aAbove = (_e233 > 0f);
let _e235 = hb;
bAbove = (_e235 > 0f);
let _e237 = aAbove;
let _e238 = bAbove;
if (_e237 || _e238) {
let _e240 = aAbove;
let _e241 = a_2;
let _e242 = q;
let _e245 = bAbove;
let _e246 = b_1;
let _e247 = q;
param_67 = select(_e242, _e241, vec3(_e240));
param_68 = select(_e247, _e246, vec3(_e245));
let _e250 = (*n_4);
param_69 = _e250;
let _e251 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_67), (¶m_68), (¶m_69));
local_12 = _e251;
} else {
local_12 = 0f;
}
let _e252 = local_12;
let _e253 = total;
total = (_e253 + _e252);
let _e255 = aAbove;
let _e256 = bAbove;
let _e259 = q;
let _e260 = exit;
exit = select(_e260, _e259, vec3((_e255 && !(_e256))));
let _e263 = aAbove;
let _e265 = bAbove;
let _e267 = q;
let _e268 = entry;
entry = select(_e268, _e267, vec3((!(_e263) && _e265)));
continue;
} else {
break;
}
continuing {
let _e271 = i_7;
i_7 = (_e271 + 1i);
}
}
let _e273 = exit;
param_70 = _e273;
let _e274 = entry;
param_71 = _e274;
let _e275 = (*n_4);
param_72 = _e275;
let _e276 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_70), (¶m_71), (¶m_72));
let _e277 = total;
total = (_e277 + _e276);
let _e279 = total;
return max((-(_e279) * 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_13: f32;
var local_14: f32;
var local_15: f32;
let _e182 = (*slot_1);
let _e183 = (*slot_1);
lane = (_e182 - ((_e183 / 4i) * 4i));
let _e187 = lane;
if (_e187 == 0i) {
let _e190 = (*four)[0u];
local_13 = _e190;
} else {
let _e191 = lane;
if (_e191 == 1i) {
let _e194 = (*four)[1u];
local_14 = _e194;
} else {
let _e195 = lane;
if (_e195 == 2i) {
let _e198 = (*four)[2u];
local_15 = _e198;
} else {
let _e200 = (*four)[3u];
local_15 = _e200;
}
let _e201 = local_15;
local_14 = _e201;
}
let _e202 = local_14;
local_13 = _e202;
}
let _e203 = local_13;
return _e203;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_73: vec4<f32>;
var param_74: i32;
let _e179 = (*slot_2);
let _e183 = light_list_info.scales[(_e179 / 4i)];
param_73 = _e183;
let _e184 = (*slot_2);
param_74 = _e184;
let _e185 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_73), (¶m_74));
return _e185;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e181 = light_list_info.slot_rows[0i];
let _e182 = (*row);
a_3 = abs((_e181 - vec4(_e182)));
let _e188 = light_list_info.slot_rows[1i];
let _e189 = (*row);
b_2 = abs((_e188 - vec4(_e189)));
let _e194 = a_3[0u];
let _e196 = a_3[1u];
let _e199 = a_3[2u];
let _e201 = a_3[3u];
let _e205 = b_2[0u];
let _e207 = b_2[1u];
let _e210 = b_2[2u];
let _e212 = b_2[3u];
return (min(min(min(_e194, _e196), min(_e199, _e201)), min(min(_e205, _e207), min(_e210, _e212))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_75: vec4<f32>;
var param_76: i32;
let _e179 = (*slot_3);
let _e183 = light_list_info.indices[(_e179 / 4i)];
param_75 = _e183;
let _e184 = (*slot_3);
param_76 = _e184;
let _e185 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_75), (¶m_76));
return _e185;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e178 = (*texel_2);
let _e182 = light_list_info.list[1u];
let _e184 = (*row_1);
let _e188 = light_list_info.list[2u];
let _e191 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e178 + 0.5f) * _e182), ((_e184 + 0.5f) * _e188)), 0f);
return _e191;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_77: f32;
var param_78: f32;
var param_79: vec4<f32>;
var param_80: i32;
let _e186 = g_cluster_offset;
let _e187 = (*slot_4);
entry_1 = (_e186 + f32(_e187));
let _e190 = entry_1;
row_2 = floor((_e190 / 16f));
let _e193 = entry_1;
let _e194 = row_2;
within = (_e193 - (_e194 * 16f));
let _e197 = within;
texel_3 = floor((_e197 / 4f));
let _e202 = light_list_info.cluster_depth[3u];
let _e203 = row_2;
let _e205 = texel_3;
param_77 = _e205;
param_78 = (_e202 + _e203);
let _e206 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_77), (¶m_78));
four_1 = _e206;
let _e207 = within;
let _e208 = texel_3;
let _e213 = four_1;
param_79 = _e213;
param_80 = i32(((_e207 - (_e208 * 4f)) + 0.5f));
let _e214 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_79), (¶m_80));
return _e214;
}
fn Clustered_u0028_() -> bool {
let _e178 = light_list_info.cluster_grid[3u];
return (_e178 > 0.5f);
}
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 light_3: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_16: f32;
var param_81: i32;
var param_82: i32;
var v_1: f32;
var u_1: f32;
var local_17: f32;
var param_83: f32;
var param_84: 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 behind: bool;
var formFactor: f32;
var local_18: f32;
var param_85: array<vec3<f32>, 4>;
var param_86: vec3<f32>;
var area: f32;
var radiance: f32;
var local_19: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
var param_89: vec3<f32>;
var param_90: vec3<f32>;
var param_91: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_20: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_92: f32;
var param_93: f32;
var cosAngle: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e229 = (*index_2);
if (_e229 < 8i) {
let _e231 = (*index_2);
let _e234 = frag_info.light_position[_e231];
position = _e234;
let _e235 = (*index_2);
let _e238 = frag_info.light_color[_e235];
color_1 = _e238;
let _e239 = (*index_2);
let _e242 = frag_info.light_direction[_e239];
direction = _e242;
let _e243 = (*index_2);
let _e246 = frag_info.light_cone[_e243];
cone = _e246;
} else {
let _e247 = (*index_2);
slot_5 = (_e247 - 8i);
let _e249 = Clustered_u0028_();
clustered = _e249;
let _e250 = clustered;
if _e250 {
let _e251 = slot_5;
param_81 = _e251;
let _e252 = ClusterRow_u0028_i1_u003b((¶m_81));
local_16 = _e252;
} else {
let _e253 = slot_5;
param_82 = _e253;
let _e254 = LightListRow_u0028_i1_u003b((¶m_82));
local_16 = _e254;
}
let _e255 = local_16;
listRow = _e255;
let _e256 = listRow;
let _e260 = light_list_info.list[2u];
v_1 = ((_e256 + 0.5f) * _e260);
let _e264 = light_list_info.list[1u];
u_1 = _e264;
let _e265 = u_1;
let _e267 = v_1;
let _e269 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e265), _e267), 0f);
position = _e269;
let _e270 = u_1;
let _e272 = v_1;
let _e274 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e270), _e272), 0f);
color_1 = _e274;
let _e275 = u_1;
let _e277 = v_1;
let _e279 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e275), _e277), 0f);
direction = _e279;
let _e280 = u_1;
let _e282 = v_1;
let _e284 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e280), _e282), 0f);
cone = _e284;
let _e285 = clustered;
if _e285 {
let _e286 = listRow;
param_83 = _e286;
let _e287 = InSlots_u0028_f1_u003b((¶m_83));
local_17 = select(1f, 0f, _e287);
} else {
let _e289 = slot_5;
param_84 = _e289;
let _e290 = LightListScale_u0028_i1_u003b((¶m_84));
local_17 = _e290;
}
let _e291 = local_17;
let _e293 = color_1[3u];
color_1[3u] = (_e293 * _e291);
}
let _e297 = position[3u];
type_39 = _e297;
let _e298 = type_39;
if (_e298 > 2.5f) {
let _e300 = direction;
halfWidth_1 = _e300.xyz;
let _e302 = cone;
halfHeight_1 = _e302.xyz;
let _e304 = position;
let _e306 = v_world_position_1;
toCentre = (_e304.xyz - _e306);
let _e308 = toCentre;
let _e309 = halfWidth_1;
let _e311 = halfHeight_1;
corners_1[0i] = ((_e308 - _e309) - _e311);
let _e314 = toCentre;
let _e315 = halfWidth_1;
let _e317 = halfHeight_1;
corners_1[1i] = ((_e314 + _e315) - _e317);
let _e320 = toCentre;
let _e321 = halfWidth_1;
let _e323 = halfHeight_1;
corners_1[2i] = ((_e320 + _e321) + _e323);
let _e326 = toCentre;
let _e327 = halfWidth_1;
let _e329 = halfHeight_1;
corners_1[3i] = ((_e326 - _e327) + _e329);
let _e332 = toCentre;
let _e333 = halfWidth_1;
let _e334 = halfHeight_1;
behind = (dot(_e332, cross(_e333, _e334)) >= 0f);
let _e338 = behind;
if _e338 {
local_18 = 0f;
} else {
let _e339 = corners_1;
param_85 = _e339;
let _e341 = (*s_3).n;
param_86 = _e341;
let _e342 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_85), (¶m_86));
local_18 = _e342;
}
let _e343 = local_18;
formFactor = _e343;
let _e344 = halfWidth_1;
let _e345 = halfHeight_1;
area = (length(cross(_e344, _e345)) * 4f);
let _e349 = area;
if (_e349 > 0.000000001f) {
let _e351 = area;
local_19 = (1f / _e351);
} else {
local_19 = 0f;
}
let _e353 = local_19;
radiance = _e353;
let _e354 = toCentre;
distance_2 = length(_e354);
let _e357 = direction[3u];
if (_e357 > 0f) {
let _e359 = distance_2;
let _e361 = direction[3u];
ratio_1 = (_e359 / _e361);
let _e363 = ratio_1;
let _e364 = ratio_1;
let _e366 = ratio_1;
let _e368 = ratio_1;
window_1 = clamp((1f - (((_e363 * _e364) * _e366) * _e368)), 0f, 1f);
let _e372 = window_1;
let _e373 = window_1;
let _e375 = radiance;
radiance = (_e375 * (_e372 * _e373));
}
let _e378 = (*s_3).v;
let _e381 = (*s_3).n;
mirror_1 = reflect(-(_e378), _e381);
let _e383 = position;
param_87 = _e383.xyz;
let _e385 = halfWidth_1;
param_88 = _e385;
let _e386 = halfHeight_1;
param_89 = _e386;
let _e387 = v_world_position_1;
param_90 = _e387;
let _e388 = mirror_1;
param_91 = _e388;
let _e389 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_87), (¶m_88), (¶m_89), (¶m_90), (¶m_91));
representative = _e389;
let _e390 = representative;
let _e391 = v_world_position_1;
toPoint = (_e390 - _e391);
let _e393 = toPoint;
pointDistance = length(_e393);
let _e395 = pointDistance;
if (_e395 > 0.000001f) {
let _e397 = toPoint;
let _e398 = pointDistance;
local_20 = (_e397 / vec3(_e398));
} else {
let _e402 = (*s_3).n;
local_20 = _e402;
}
let _e403 = local_20;
light_3.l = _e403;
let _e406 = light_3.l;
let _e408 = (*s_3).v;
light_3.h = normalize((_e406 + _e408));
let _e412 = formFactor;
light_3.n_dot_l = _e412;
let _e415 = (*s_3).n;
let _e417 = light_3.h;
light_3.n_dot_h = max(dot(_e415, _e417), 0f);
let _e422 = (*s_3).v;
let _e424 = light_3.h;
light_3.v_dot_h = max(dot(_e422, _e424), 0f);
let _e428 = color_1;
let _e431 = color_1[3u];
let _e433 = radiance;
light_3.radiance = ((_e428.xyz * _e431) * _e433);
let _e436 = light_3;
return _e436;
}
let _e437 = direction;
aim = normalize(_e437.xyz);
attenuation_1 = 1f;
let _e440 = type_39;
if (_e440 < 0.5f) {
let _e442 = aim;
light_3.l = -(_e442);
} else {
let _e445 = position;
let _e447 = v_world_position_1;
toLight_1 = (_e445.xyz - _e447);
let _e449 = toLight_1;
distance_3 = length(_e449);
let _e451 = distance_3;
if (_e451 < 0.000001f) {
let _e454 = (*s_3).n;
light_3.l = _e454;
let _e457 = (*s_3).n;
light_3.h = _e457;
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 _e463 = light_3;
return _e463;
}
let _e464 = toLight_1;
let _e465 = distance_3;
light_3.l = (_e464 / vec3(_e465));
let _e469 = distance_3;
param_92 = _e469;
let _e471 = direction[3u];
param_93 = _e471;
let _e472 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_92), (¶m_93));
attenuation_1 = _e472;
let _e473 = type_39;
if (_e473 > 1.5f) {
let _e475 = aim;
let _e477 = light_3.l;
cosAngle = dot(_e475, -(_e477));
let _e480 = cosAngle;
let _e482 = cone[1u];
let _e485 = cone[0u];
let _e487 = cone[1u];
let _e491 = attenuation_1;
attenuation_1 = (_e491 * clamp(((_e480 - _e482) / (_e485 - _e487)), 0f, 1f));
}
}
let _e494 = light_3.l;
let _e496 = (*s_3).v;
light_3.h = normalize((_e494 + _e496));
let _e501 = (*s_3).n;
let _e503 = light_3.l;
light_3.n_dot_l = max(dot(_e501, _e503), 0f);
let _e508 = (*s_3).n;
let _e510 = light_3.h;
light_3.n_dot_h = max(dot(_e508, _e510), 0f);
let _e515 = (*s_3).v;
let _e517 = light_3.h;
light_3.v_dot_h = max(dot(_e515, _e517), 0f);
let _e521 = color_1;
let _e524 = color_1[3u];
let _e526 = attenuation_1;
light_3.radiance = ((_e521.xyz * _e524) * _e526);
let _e529 = light_3;
return _e529;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_21: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_94: f32;
var param_95: f32;
let _e191 = light_list_info.cluster_view_projection;
let _e192 = (*world_3);
clip_1 = (_e191 * vec4<f32>(_e192.x, _e192.y, _e192.z, 1f));
let _e198 = clip_1;
let _e201 = clip_1[3u];
ndc_1 = (_e198.xy / vec2(max(_e201, 0.000001f)));
let _e206 = light_list_info.cluster_grid;
grid = _e206.xyz;
let _e210 = light_list_info.cluster_depth[0u];
near_1 = _e210;
let _e212 = ndc_1[0u];
let _e216 = grid[0u];
let _e220 = grid[0u];
tx = clamp(floor((((_e212 * 0.5f) + 0.5f) * _e216)), 0f, (_e220 - 1f));
let _e224 = ndc_1[1u];
let _e228 = grid[1u];
let _e232 = grid[1u];
ty = clamp(floor((((_e224 * 0.5f) + 0.5f) * _e228)), 0f, (_e232 - 1f));
let _e236 = clip_1[3u];
let _e237 = near_1;
if (_e236 <= _e237) {
local_21 = 0f;
} else {
let _e240 = clip_1[3u];
let _e241 = near_1;
let _e246 = light_list_info.cluster_depth[1u];
let _e250 = grid[2u];
local_21 = clamp(floor((log((_e240 / _e241)) * _e246)), 0f, (_e250 - 1f));
}
let _e253 = local_21;
tz = _e253;
let _e254 = tx;
let _e255 = ty;
let _e257 = grid[0u];
let _e260 = tz;
let _e262 = grid[0u];
let _e265 = grid[1u];
cell = ((_e254 + (_e255 * _e257)) + ((_e260 * _e262) * _e265));
let _e268 = cell;
row_3 = floor((_e268 / 4f));
let _e271 = cell;
let _e272 = row_3;
let _e277 = light_list_info.cluster_depth[2u];
let _e278 = row_3;
param_94 = (_e271 - (_e272 * 4f));
param_95 = (_e277 + _e278);
let _e280 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
header = _e280;
let _e282 = header[0u];
g_cluster_offset = _e282;
let _e284 = header[1u];
g_cluster_count = _e284;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_96: vec3<f32>;
let _e180 = light_list_info.list[0u];
tail = _e180;
let _e181 = Clustered_u0028_();
if _e181 {
let _e182 = v_world_position_1;
param_96 = _e182;
FindCluster_u0028_vf3_u003b((¶m_96));
let _e183 = g_cluster_count;
tail = _e183;
}
let _e186 = frag_info.frame_params[1u];
let _e190 = tail;
return (clamp(i32((_e186 + 0.5f)), 0i, 8i) + clamp(i32((_e190 + 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_8: i32;
var light_4: LightSample;
var param_97: i32;
var param_98: Surface;
var visibility: f32;
var param_99: i32;
var local_22: f32;
var param_100: Surface;
var param_101: LightSample;
var param_102: i32;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: i32;
var param_106: Surface;
var param_107: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e194 = LightCount_u0028_();
count_1 = _e194;
i_8 = 0i;
loop {
let _e195 = i_8;
if (_e195 < 32i) {
let _e197 = i_8;
let _e198 = count_1;
if (_e197 >= _e198) {
break;
}
let _e200 = i_8;
param_97 = _e200;
let _e201 = (*s_4);
param_98 = _e201;
let _e202 = 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_97), (¶m_98));
light_4 = _e202;
let _e204 = light_4.n_dot_l;
if (_e204 <= 0f) {
continue;
}
let _e206 = i_8;
param_99 = _e206;
let _e207 = LightHasShadow_u0028_i1_u003b((¶m_99));
if _e207 {
let _e208 = (*s_4);
param_100 = _e208;
let _e209 = light_4;
param_101 = _e209;
let _e210 = i_8;
param_102 = _e210;
let _e211 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_100), (¶m_101), (¶m_102));
let _e212 = v_world_position_1;
param_103 = _e212;
let _e214 = (*s_4).n;
param_104 = _e214;
let _e215 = i_8;
param_105 = _e215;
let _e216 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_103), (¶m_104), (¶m_105));
local_22 = (_e211 * _e216);
} else {
local_22 = 1f;
}
let _e218 = local_22;
visibility = _e218;
let _e219 = visibility;
if (_e219 <= 0f) {
continue;
}
let _e221 = (*s_4);
param_106 = _e221;
let _e222 = light_4;
param_107 = _e222;
let _e223 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_106), (¶m_107));
let _e225 = light_4.radiance;
let _e228 = light_4.n_dot_l;
let _e230 = visibility;
let _e232 = total_1;
total_1 = (_e232 + (((_e223 * _e225) * _e228) * _e230));
continue;
} else {
break;
}
continuing {
let _e234 = i_8;
i_8 = (_e234 + 1i);
}
}
let _e236 = total_1;
return _e236;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e177 = v_lightmap_uv_1;
let _e178 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e177);
texel_4 = _e178;
let _e179 = texel_4;
let _e182 = texel_4[3u];
return ((_e179.xyz * _e182) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e178 = frag_info.target_origin[1u];
return _e178;
}
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 _e178 = v_texcoord_1;
let _e179 = MaterialLodBias_u0028_();
let _e180 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e178, _e179);
orm = _e180.xyz;
let _e183 = (*s_5).metallic;
let _e185 = orm[2u];
(*s_5).metallic = clamp((_e183 * _e185), 0f, 1f);
let _e190 = (*s_5).roughness;
let _e192 = orm[1u];
(*s_5).roughness = clamp((_e190 * _e192), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e177 = (*srgb);
let _e180 = (*srgb);
let _e185 = (*srgb);
return mix((_e177 / vec3(12.92f)), pow(((_e180 + 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), _e185));
}
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_108: vec3<f32>;
let _e179 = v_texcoord_1;
let _e180 = MaterialLodBias_u0028_();
let _e181 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e179, _e180);
param_108 = _e181.xyz;
let _e183 = SrgbToLinear_u0028_vf3_u003b((¶m_108));
emissive = _e183;
let _e184 = emissive;
let _e186 = frag_info.emissive;
let _e191 = frag_info.material2_[3u];
(*s_6).emissive = ((_e184 * _e186.xyz) * _e191);
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 _e178 = v_texcoord_1;
let _e179 = MaterialLodBias_u0028_();
let _e180 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e178, _e179);
occlusion = _e180.x;
let _e182 = occlusion;
let _e185 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e182, clamp(_e185, 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_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e181 = v_texcoord_1;
let _e182 = MaterialLodBias_u0028_();
let _e183 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e181, _e182);
sampledTexel = _e183;
let _e184 = v_tangent_1;
t_2 = _e184.xyz;
let _e186 = t_2;
let _e188 = (*s_8).n;
let _e190 = (*s_8).n;
let _e191 = t_2;
t_2 = (_e186 - (_e188 * dot(_e190, _e191)));
let _e195 = t_2;
let _e196 = t_2;
if (dot(_e195, _e196) < 0.000000000001f) {
return;
}
let _e199 = t_2;
t_2 = normalize(_e199);
let _e202 = (*s_8).n;
let _e203 = t_2;
let _e206 = v_tangent_1[3u];
b_3 = (cross(_e202, _e203) * _e206);
let _e208 = gl_FrontFacing_1;
if !(_e208) {
let _e210 = t_2;
t_2 = -(_e210);
}
let _e212 = sampledTexel;
sampled = ((_e212.xyz * 2f) - vec3(1f));
let _e219 = frag_info.emissive[3u];
if (_e219 > 0.5f) {
let _e221 = sampled;
let _e223 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e221.xy, _e223.xy)), 0f));
}
let _e232 = frag_info.material2_[1u];
let _e233 = sampled;
let _e235 = (_e233.xy * _e232);
sampled[0u] = _e235.x;
sampled[1u] = _e235.y;
let _e240 = t_2;
let _e242 = sampled[0u];
let _e244 = b_3;
let _e246 = sampled[1u];
let _e250 = (*s_8).n;
let _e252 = sampled[2u];
(*s_8).n = normalize((((_e240 * _e242) + (_e244 * _e246)) + (_e250 * _e252)));
let _e258 = (*s_8).n;
let _e260 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e258, _e260), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e177 = (*texel_5);
let _e181 = irradiance_info.atlas;
let _e184 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e177 + vec2(0.5f)) * _e181.xy), 0f);
return _e184;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
var at_1: vec2<f32>;
var low: vec2<f32>;
var f: vec2<f32>;
var a_4: vec4<f32>;
var param_109: vec2<f32>;
var b_4: vec4<f32>;
var param_110: vec2<f32>;
var c: vec4<f32>;
var param_111: vec2<f32>;
var d_4: vec4<f32>;
var param_112: vec2<f32>;
let _e190 = (*uv_5);
let _e191 = (*interior);
at_1 = ((vec2(1f) + (_e190 * _e191)) - vec2(0.5f));
let _e197 = at_1;
low = floor(_e197);
let _e199 = at_1;
let _e200 = low;
f = (_e199 - _e200);
let _e202 = (*corner);
let _e203 = low;
param_109 = (_e202 + _e203);
let _e205 = AtlasTexel_u0028_vf2_u003b((¶m_109));
a_4 = _e205;
let _e206 = (*corner);
let _e207 = low;
param_110 = ((_e206 + _e207) + vec2<f32>(1f, 0f));
let _e210 = AtlasTexel_u0028_vf2_u003b((¶m_110));
b_4 = _e210;
let _e211 = (*corner);
let _e212 = low;
param_111 = ((_e211 + _e212) + vec2<f32>(0f, 1f));
let _e215 = AtlasTexel_u0028_vf2_u003b((¶m_111));
c = _e215;
let _e216 = (*corner);
let _e217 = low;
param_112 = ((_e216 + _e217) + vec2<f32>(1f, 1f));
let _e220 = AtlasTexel_u0028_vf2_u003b((¶m_112));
d_4 = _e220;
let _e221 = a_4;
let _e222 = b_4;
let _e224 = f[0u];
let _e227 = c;
let _e228 = d_4;
let _e230 = f[0u];
let _e234 = f[1u];
return mix(mix(_e221, _e222, vec4(_e224)), mix(_e227, _e228, vec4(_e230)), vec4(_e234));
}
fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var sum_1: f32;
var n_5: vec3<f32>;
var xy: vec2<f32>;
let _e181 = (*direction_1)[0u];
let _e184 = (*direction_1)[1u];
let _e188 = (*direction_1)[2u];
sum_1 = ((abs(_e181) + abs(_e184)) + abs(_e188));
let _e191 = sum_1;
if (_e191 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e193 = (*direction_1);
let _e194 = sum_1;
n_5 = (_e193 / vec3(_e194));
let _e197 = n_5;
xy = _e197.xy;
let _e200 = n_5[2u];
if (_e200 < 0f) {
let _e203 = n_5[1u];
let _e207 = n_5[0u];
let _e212 = n_5[0u];
let _e216 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e203)) * select(-1f, 1f, (_e207 >= 0f))), ((1f - abs(_e212)) * select(-1f, 1f, (_e216 >= 0f))));
}
let _e221 = xy;
return ((_e221 * 0.5f) + vec2(0.5f));
}
fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var spacing: vec3<f32>;
var counts: vec3<f32>;
var irradianceTile: f32;
var depthTile: f32;
var columns: f32;
var momentsTop: f32;
var unit: vec3<f32>;
var biased: vec3<f32>;
var grid_1: vec3<f32>;
var base: vec3<f32>;
var f_1: vec3<f32>;
var total_2: vec3<f32>;
var weights: f32;
var corner_1: i32;
var offset_3: vec3<f32>;
var cell_1: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_113: vec2<f32>;
var trilinear: vec3<f32>;
var weight_2: f32;
var probePosition: vec3<f32>;
var toProbe: vec3<f32>;
var distance_4: f32;
var direction_2: vec3<f32>;
var facing: f32;
var probeWeight: f32;
var moments_3: vec2<f32>;
var param_114: vec3<f32>;
var param_115: vec2<f32>;
var param_116: f32;
var param_117: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_118: vec3<f32>;
var param_119: vec2<f32>;
var param_120: f32;
var param_121: vec2<f32>;
var local_23: vec3<f32>;
let _e223 = irradiance_info.origin;
origin_2 = _e223.xyz;
let _e226 = irradiance_info.spacing;
spacing = _e226.xyz;
let _e229 = irradiance_info.counts;
counts = _e229.xyz;
let _e233 = irradiance_info.tiles[0u];
irradianceTile = _e233;
let _e236 = irradiance_info.tiles[1u];
depthTile = _e236;
let _e239 = irradiance_info.tiles[2u];
columns = _e239;
let _e242 = irradiance_info.tiles[3u];
momentsTop = _e242;
let _e243 = (*normal_1);
unit = normalize(_e243);
let _e245 = (*world_4);
let _e246 = unit;
let _e249 = irradiance_info.spacing[3u];
let _e252 = (*view);
let _e255 = irradiance_info.counts[3u];
biased = ((_e245 + (_e246 * _e249)) + (_e252 * _e255));
let _e258 = biased;
let _e259 = origin_2;
let _e261 = spacing;
grid_1 = ((_e258 - _e259) / _e261);
let _e263 = grid_1;
let _e265 = counts;
base = clamp(floor(_e263), vec3<f32>(0f, 0f, 0f), (_e265 - vec3(2f)));
let _e269 = grid_1;
let _e270 = base;
f_1 = clamp((_e269 - _e270), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e273 = corner_1;
if (_e273 < 8i) {
let _e275 = corner_1;
let _e278 = corner_1;
let _e283 = corner_1;
offset_3 = vec3<f32>(f32((_e275 & 1i)), f32(((_e278 >> bitcast<u32>(1i)) & 1i)), f32(((_e283 >> bitcast<u32>(2i)) & 1i)));
let _e289 = base;
let _e290 = offset_3;
cell_1 = (_e289 + _e290);
let _e293 = cell_1[2u];
let _e295 = counts[1u];
let _e298 = cell_1[1u];
let _e301 = counts[0u];
let _e304 = cell_1[0u];
probe = ((((_e293 * _e295) + _e298) * _e301) + _e304);
let _e306 = probe;
let _e307 = columns;
let _e312 = probe;
let _e313 = columns;
tile_4 = vec2<f32>((_e306 - (floor((_e306 / _e307)) * _e307)), floor((_e312 / _e313)));
let _e317 = tile_4;
let _e318 = irradianceTile;
irradianceCorner = (_e317 * (_e318 + 2f));
let _e322 = tile_4[0u];
let _e323 = depthTile;
let _e326 = momentsTop;
let _e328 = tile_4[1u];
let _e329 = depthTile;
momentCorner = vec2<f32>((_e322 * (_e323 + 2f)), (_e326 + (_e328 * (_e329 + 2f))));
let _e334 = irradianceCorner;
param_113 = (_e334 + vec2(1f));
let _e337 = AtlasTexel_u0028_vf2_u003b((¶m_113));
if (_e337.w < 0.5f) {
continue;
}
let _e340 = f_1;
let _e342 = f_1;
let _e343 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e340), _e342, _e343);
let _e346 = trilinear[0u];
let _e348 = trilinear[1u];
let _e351 = trilinear[2u];
weight_2 = max(((_e346 * _e348) * _e351), 0.001f);
let _e354 = origin_2;
let _e355 = spacing;
let _e356 = cell_1;
probePosition = (_e354 + (_e355 * _e356));
let _e359 = probePosition;
let _e360 = biased;
toProbe = (_e359 - _e360);
let _e362 = toProbe;
distance_4 = length(_e362);
let _e364 = distance_4;
if (_e364 > 0.000001f) {
let _e366 = toProbe;
let _e367 = distance_4;
direction_2 = (_e366 / vec3(_e367));
let _e370 = unit;
let _e371 = probePosition;
let _e372 = (*world_4);
facing = ((dot(_e370, normalize((_e371 - _e372))) * 0.5f) + 0.5f);
let _e378 = facing;
let _e379 = facing;
probeWeight = ((_e378 * _e379) + 0.2f);
let _e382 = direction_2;
param_114 = -(_e382);
let _e384 = ProbeOctahedral_u0028_vf3_u003b((¶m_114));
let _e385 = momentCorner;
param_115 = _e385;
let _e386 = depthTile;
param_116 = _e386;
param_117 = _e384;
let _e387 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_115), (¶m_116), (¶m_117));
moments_3 = _e387.xy;
chebyshev = 1f;
let _e389 = distance_4;
let _e391 = moments_3[0u];
if (_e389 > _e391) {
let _e394 = moments_3[1u];
let _e396 = moments_3[0u];
let _e398 = moments_3[0u];
variance_1 = max((_e394 - (_e396 * _e398)), 0.000001f);
let _e402 = distance_4;
let _e404 = moments_3[0u];
difference = (_e402 - _e404);
let _e406 = variance_1;
let _e407 = variance_1;
let _e408 = difference;
let _e409 = difference;
chebyshev = (_e406 / (_e407 + (_e408 * _e409)));
let _e413 = chebyshev;
let _e414 = chebyshev;
let _e416 = chebyshev;
chebyshev = ((_e413 * _e414) * _e416);
}
let _e418 = probeWeight;
let _e419 = chebyshev;
probeWeight = max((_e418 * max(_e419, 0.05f)), 0.000001f);
let _e423 = probeWeight;
if (_e423 < 0.2f) {
let _e425 = probeWeight;
let _e426 = probeWeight;
let _e429 = probeWeight;
probeWeight = (_e429 * ((_e425 * _e426) * 25f));
}
let _e431 = probeWeight;
let _e432 = weight_2;
weight_2 = (_e432 * _e431);
}
let _e434 = unit;
param_118 = _e434;
let _e435 = ProbeOctahedral_u0028_vf3_u003b((¶m_118));
let _e436 = irradianceCorner;
param_119 = _e436;
let _e437 = irradianceTile;
param_120 = _e437;
param_121 = _e435;
let _e438 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_119), (¶m_120), (¶m_121));
let _e440 = weight_2;
let _e442 = total_2;
total_2 = (_e442 + (_e438.xyz * _e440));
let _e444 = weight_2;
let _e445 = weights;
weights = (_e445 + _e444);
continue;
} else {
break;
}
continuing {
let _e447 = corner_1;
corner_1 = (_e447 + 1i);
}
}
let _e449 = weights;
if (_e449 > 0f) {
let _e451 = total_2;
let _e452 = weights;
local_23 = (_e451 / vec3(_e452));
} else {
local_23 = vec3<f32>(0f, 0f, 0f);
}
let _e455 = local_23;
return _e455;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e178 = irradiance_info.origin[3u];
return (_e178 > 0.5f);
}
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_122: vec3<f32>;
var param_123: vec3<f32>;
var param_124: vec3<f32>;
var param_125: Surface;
var param_126: Surface;
var param_127: Surface;
let _e183 = IrradianceEnabled_u0028_();
if _e183 {
let _e184 = v_world_position_1;
param_122 = _e184;
let _e186 = (*s_9).n;
param_123 = _e186;
let _e188 = (*s_9).v;
param_124 = _e188;
let _e189 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_122), (¶m_123), (¶m_124));
let _e192 = frag_info.material[2u];
(*s_9).ambient = (_e189 * _e192);
}
let _e195 = (*s_9);
param_125 = _e195;
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_125));
let _e196 = param_125;
(*s_9) = _e196;
let _e197 = (*s_9);
param_126 = _e197;
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_126));
let _e198 = param_126;
(*s_9) = _e198;
let _e199 = (*s_9);
param_127 = _e199;
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_127));
let _e200 = param_127;
(*s_9) = _e200;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_10: Surface;
var param_128: vec3<f32>;
var param_129: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e183 = v_texcoord_1;
let _e184 = MaterialLodBias_u0028_();
let _e185 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e183, _e184);
texel_6 = _e185;
let _e186 = texel_6;
param_128 = _e186.xyz;
let _e188 = SrgbToLinear_u0028_vf3_u003b((¶m_128));
let _e190 = frag_info.base_color;
param_129 = _e190.xyz;
let _e192 = SrgbToLinear_u0028_vf3_u003b((¶m_129));
let _e194 = v_color_1;
s_10.albedo = ((_e188 * _e192) * _e194.xyz);
let _e199 = texel_6[3u];
let _e202 = frag_info.base_color[3u];
let _e205 = v_color_1[3u];
s_10.alpha = ((_e199 * _e202) * _e205);
let _e209 = s_10.albedo;
g_albedo = _e209;
let _e212 = frag_info.material2_[0u];
cutoff = _e212;
let _e213 = cutoff;
if (_e213 >= 0f) {
let _e216 = s_10.alpha;
let _e217 = cutoff;
if (_e216 < _e217) {
discard;
}
} else {
let _e219 = cutoff;
if (_e219 < -1.5f) {
let _e221 = v_world_position_1;
anchored = floor((_e221 * 16f));
let _e224 = anchored;
noise_1 = fract((sin(dot(_e224, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e230 = s_10.alpha;
let _e231 = noise_1;
if (_e230 < _e231) {
discard;
}
}
}
let _e233 = cutoff;
let _e235 = cutoff;
g_premultiply = ((_e233 < 0f) && (_e235 > -0.75f));
let _e238 = v_normal_1;
s_10.n = normalize(_e238);
let _e241 = gl_FrontFacing_1;
if !(_e241) {
let _e244 = s_10.n;
s_10.n = -(_e244);
}
let _e248 = frag_info.camera_position;
let _e250 = v_world_position_1;
s_10.v = normalize((_e248.xyz - _e250));
let _e255 = s_10.n;
let _e257 = s_10.v;
s_10.n_dot_v = max(dot(_e255, _e257), 0.0001f);
let _e263 = frag_info.material[0u];
s_10.metallic = clamp(_e263, 0f, 1f);
let _e268 = frag_info.material[1u];
s_10.roughness = clamp(_e268, 0.02f, 1f);
let _e272 = frag_info.ambient_ground;
let _e275 = frag_info.ambient_sky;
let _e279 = s_10.n[1u];
let _e286 = frag_info.material[2u];
s_10.ambient = (mix(_e272.xyz, _e275.xyz, vec3(((_e279 * 0.5f) + 0.5f))) * _e286);
let _e291 = frag_info.frame_params[0u];
s_10.exposure = max(_e291, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e296 = s_10;
return _e296;
}
fn main_1() {
var s_11: Surface;
var param_130: Surface;
var param_131: Surface;
var rim: f32;
var ambient: vec3<f32>;
var param_132: Surface;
var param_133: vec3<f32>;
var param_134: f32;
var param_135: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e185 = ReadSurface_u0028_();
s_11 = _e185;
let _e186 = s_11;
param_130 = _e186;
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_130));
let _e187 = param_130;
s_11 = _e187;
let _e188 = s_11;
param_131 = _e188;
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_131));
let _e189 = param_131;
s_11 = _e189;
let _e191 = s_11.n_dot_v;
let _e196 = frag_info.material[3u];
rim = (pow((1f - _e191), 3f) * _e196);
let _e199 = s_11.albedo;
let _e201 = s_11.ambient;
let _e202 = SampleLightmap_u0028_();
let _e206 = s_11.occlusion;
ambient = ((_e199 * (_e201 + _e202)) * _e206);
let _e208 = s_11;
param_132 = _e208;
let _e209 = 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_132));
let _e211 = s_11.occlusion;
let _e213 = ambient;
let _e215 = rim;
let _e220 = s_11.emissive;
param_133 = ((((_e209 * _e211) + _e213) + vec3((_e215 * 0.35f))) + _e220);
let _e223 = s_11.alpha;
param_134 = _e223;
let _e225 = s_11.roughness;
param_135 = _e225;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_133), (¶m_134), (¶m_135));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: 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;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'IrradianceInfo',
group: 1,
binding: 2,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'spacing',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'counts',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 3,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 4,
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: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'irradiance_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 23,
samplerBinding: 24,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 25,
samplerBinding: 26,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Normals': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragmentOutput {
@location(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
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 _e44 = (*n)[0u];
let _e47 = (*n)[1u];
let _e51 = (*n)[2u];
let _e54 = (*n);
(*n) = (_e54 / vec3(((abs(_e44) + abs(_e47)) + abs(_e51))));
let _e57 = (*n);
e = _e57.xy;
let _e60 = (*n)[2u];
if (_e60 < 0f) {
let _e62 = (*n);
let _e68 = (*n)[0u];
let _e72 = (*n)[1u];
e = ((vec2(1f) - abs(_e62.yx)) * vec2<f32>(select(-1f, 1f, (_e68 >= 0f)), select(-1f, 1f, (_e72 >= 0f))));
}
let _e77 = e;
return ((_e77 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e41 = v_world_position_1;
let _e43 = fog_info.eye;
let _e47 = fog_info.forward;
return dot((_e41 - _e43.xyz), _e47.xyz);
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e42 = (*linear);
let _e44 = (*linear);
let _e48 = (*linear);
return mix((_e42 * 12.92f), ((pow(_e44, 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), _e48));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
var geometric: vec3<f32>;
var param_1: vec3<f32>;
let _e45 = g_albedo;
param = clamp(_e45, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e47 = LinearToSrgb_u0028_vf3_u003b((¶m));
frag_albedo = vec4<f32>(_e47.x, _e47.y, _e47.z, 1f);
let _e52 = g_debug_surface_on;
if _e52 {
let _e53 = g_debug_surface;
let _e54 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e53.x, _e53.y, _e53.z, _e54);
return;
}
let _e59 = v_normal_1;
geometric = normalize(_e59);
let _e61 = gl_FrontFacing_1;
if !(_e61) {
let _e63 = geometric;
geometric = -(_e63);
}
let _e65 = geometric;
param_1 = _e65;
let _e66 = EncodeOctahedral_u0028_vf3_u003b((¶m_1));
let _e67 = (*roughness);
let _e69 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e66.x, _e66.y, clamp(_e67, 0f, 1f), _e69);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e42 = (*srgb);
let _e45 = (*srgb);
let _e50 = (*srgb);
return mix((_e42 / vec3(12.92f)), pow(((_e45 + 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), _e50));
}
fn WriteDisplayColor_u0028_vf3_u003b_f1_u003b(displayColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>) {
var param_2: vec3<f32>;
var param_3: f32;
let _e45 = (*displayColor);
param_2 = _e45;
let _e46 = SrgbToLinear_u0028_vf3_u003b((¶m_2));
let _e47 = (*alpha);
frag_color = vec4<f32>(_e46.x, _e46.y, _e46.z, _e47);
param_3 = 1f;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_3));
return;
}
fn main_1() {
var n_1: vec3<f32>;
var param_4: vec3<f32>;
var param_5: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e44 = v_normal_1;
n_1 = normalize(_e44);
let _e46 = n_1;
param_4 = ((_e46 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
param_5 = 1f;
WriteDisplayColor_u0028_vf3_u003b_f1_u003b((¶m_4), (¶m_5));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @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;
gl_FrontFacing_1 = gl_FrontFacing;
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 _e17 = frag_albedo;
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e17, _e18, _e19);
}
''',
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 _e24 = (*color);
return dot(_e24, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var texel: vec2<f32>;
var s0_: vec3<f32>;
var s1_: vec3<f32>;
var s2_: vec3<f32>;
var s3_: vec3<f32>;
var w0_: f32;
var param: vec3<f32>;
var w1_: f32;
var param_1: vec3<f32>;
var w2_: f32;
var param_2: vec3<f32>;
var w3_: f32;
var param_3: vec3<f32>;
var color_1: vec3<f32>;
var threshold: f32;
var knee: f32;
var brightness: f32;
var param_4: vec3<f32>;
var soft: f32;
var contribution: f32;
let _e44 = bloom_info.params;
texel = _e44.xy;
let _e46 = v_uv_1;
let _e47 = texel;
let _e50 = textureSample(source_texture_tex, source_texture_smp, (_e46 + (_e47 * vec2<f32>(-0.5f, -0.5f))));
s0_ = _e50.xyz;
let _e52 = v_uv_1;
let _e53 = texel;
let _e56 = textureSample(source_texture_tex, source_texture_smp, (_e52 + (_e53 * vec2<f32>(0.5f, -0.5f))));
s1_ = _e56.xyz;
let _e58 = v_uv_1;
let _e59 = texel;
let _e62 = textureSample(source_texture_tex, source_texture_smp, (_e58 + (_e59 * vec2<f32>(-0.5f, 0.5f))));
s2_ = _e62.xyz;
let _e64 = v_uv_1;
let _e65 = texel;
let _e68 = textureSample(source_texture_tex, source_texture_smp, (_e64 + (_e65 * vec2<f32>(0.5f, 0.5f))));
s3_ = _e68.xyz;
let _e70 = s0_;
param = _e70;
let _e71 = Luminance_u0028_vf3_u003b((¶m));
w0_ = (1f / (1f + _e71));
let _e74 = s1_;
param_1 = _e74;
let _e75 = Luminance_u0028_vf3_u003b((¶m_1));
w1_ = (1f / (1f + _e75));
let _e78 = s2_;
param_2 = _e78;
let _e79 = Luminance_u0028_vf3_u003b((¶m_2));
w2_ = (1f / (1f + _e79));
let _e82 = s3_;
param_3 = _e82;
let _e83 = Luminance_u0028_vf3_u003b((¶m_3));
w3_ = (1f / (1f + _e83));
let _e86 = s0_;
let _e87 = w0_;
let _e89 = s1_;
let _e90 = w1_;
let _e93 = s2_;
let _e94 = w2_;
let _e97 = s3_;
let _e98 = w3_;
let _e101 = w0_;
let _e102 = w1_;
let _e104 = w2_;
let _e106 = w3_;
color_1 = (((((_e86 * _e87) + (_e89 * _e90)) + (_e93 * _e94)) + (_e97 * _e98)) / vec3((((_e101 + _e102) + _e104) + _e106)));
let _e112 = bloom_info.params[2u];
threshold = _e112;
let _e115 = bloom_info.params[3u];
knee = max(_e115, 0.0001f);
let _e117 = color_1;
param_4 = _e117;
let _e118 = Luminance_u0028_vf3_u003b((¶m_4));
brightness = _e118;
let _e119 = brightness;
let _e120 = threshold;
let _e122 = knee;
let _e124 = knee;
soft = clamp(((_e119 - _e120) + _e122), 0f, (2f * _e124));
let _e127 = soft;
let _e128 = soft;
let _e130 = knee;
soft = ((_e127 * _e128) / (4f * _e130));
let _e133 = soft;
let _e134 = brightness;
let _e135 = threshold;
let _e138 = brightness;
contribution = (max(_e133, (_e134 - _e135)) / max(_e138, 0.0001f));
let _e141 = color_1;
let _e142 = contribution;
let _e143 = (_e141 * _e142);
frag_color = vec4<f32>(_e143.x, _e143.y, _e143.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>,
tint: 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>;
let _e34 = bloom_info.params;
let _e38 = bloom_info.params[2u];
t = (_e34.xy * max(_e38, 0f));
let _e41 = v_uv_1;
let _e42 = t;
let _e45 = textureSample(source_texture_tex, source_texture_smp, (_e41 + (vec2<f32>(-1f, 1f) * _e42)));
a = _e45.xyz;
let _e47 = v_uv_1;
let _e48 = t;
let _e51 = textureSample(source_texture_tex, source_texture_smp, (_e47 + (vec2<f32>(0f, 1f) * _e48)));
b = _e51.xyz;
let _e53 = v_uv_1;
let _e54 = t;
let _e57 = textureSample(source_texture_tex, source_texture_smp, (_e53 + (vec2<f32>(1f, 1f) * _e54)));
c = _e57.xyz;
let _e59 = v_uv_1;
let _e60 = t;
let _e63 = textureSample(source_texture_tex, source_texture_smp, (_e59 + (vec2<f32>(-1f, 0f) * _e60)));
d = _e63.xyz;
let _e65 = v_uv_1;
let _e66 = textureSample(source_texture_tex, source_texture_smp, _e65);
e = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = t;
let _e72 = textureSample(source_texture_tex, source_texture_smp, (_e68 + (vec2<f32>(1f, 0f) * _e69)));
f = _e72.xyz;
let _e74 = v_uv_1;
let _e75 = t;
let _e78 = textureSample(source_texture_tex, source_texture_smp, (_e74 + (vec2<f32>(-1f, -1f) * _e75)));
g = _e78.xyz;
let _e80 = v_uv_1;
let _e81 = t;
let _e84 = textureSample(source_texture_tex, source_texture_smp, (_e80 + (vec2<f32>(0f, -1f) * _e81)));
h = _e84.xyz;
let _e86 = v_uv_1;
let _e87 = t;
let _e90 = textureSample(source_texture_tex, source_texture_smp, (_e86 + (vec2<f32>(1f, -1f) * _e87)));
i = _e90.xyz;
let _e92 = e;
let _e94 = b;
let _e95 = d;
let _e97 = f;
let _e99 = h;
let _e103 = a;
let _e104 = c;
let _e106 = g;
let _e108 = i;
result = (((_e92 * 4f) + ((((_e94 + _e95) + _e97) + _e99) * 2f)) + (((_e103 + _e104) + _e106) + _e108));
let _e111 = result;
result = (_e111 * 0.0625f);
let _e114 = bloom_info.tint;
let _e116 = result;
result = (_e116 * _e114.xyz);
let _e118 = result;
frag_color = vec4<f32>(_e118.x, _e118.y, _e118.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: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'tint', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Composite': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
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>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(12)
var lut_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var lut_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> composite_info: CompositeInfo;
@group(1) @binding(8)
var display_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var display_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(14)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var scene_texture_smp: sampler;
@group(1) @binding(4)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var bloom_texture_smp: sampler;
@group(1) @binding(2)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var ao_texture_smp: sampler;
@group(1) @binding(6)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var contact_shadow_texture_smp: sampler;
@group(1) @binding(10)
var local_exposure_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var local_exposure_texture_smp: sampler;
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 _e149 = (*at)[0u];
x = i32((_e149 - (floor((_e149 / 4f)) * 4f)));
let _e156 = (*at)[1u];
y = i32((_e156 - (floor((_e156 / 4f)) * 4f)));
let _e162 = y;
let _e164 = x;
index = ((_e162 * 4i) + _e164);
value = 0f;
let _e166 = index;
if (_e166 == 0i) {
value = 0f;
} else {
let _e168 = index;
if (_e168 == 1i) {
value = 8f;
} else {
let _e170 = index;
if (_e170 == 2i) {
value = 2f;
} else {
let _e172 = index;
if (_e172 == 3i) {
value = 10f;
} else {
let _e174 = index;
if (_e174 == 4i) {
value = 12f;
} else {
let _e176 = index;
if (_e176 == 5i) {
value = 4f;
} else {
let _e178 = index;
if (_e178 == 6i) {
value = 14f;
} else {
let _e180 = index;
if (_e180 == 7i) {
value = 6f;
} else {
let _e182 = index;
if (_e182 == 8i) {
value = 3f;
} else {
let _e184 = index;
if (_e184 == 9i) {
value = 11f;
} else {
let _e186 = index;
if (_e186 == 10i) {
value = 1f;
} else {
let _e188 = index;
if (_e188 == 11i) {
value = 9f;
} else {
let _e190 = index;
if (_e190 == 12i) {
value = 15f;
} else {
let _e192 = index;
if (_e192 == 13i) {
value = 7f;
} else {
let _e194 = index;
if (_e194 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e196 = value;
return ((_e196 / 16f) - 0.5f);
}
fn Hash_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
let _e144 = (*at_1);
return fract((sin(dot(_e144, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e145 = (*rows);
if (_e145 > 0f) {
let _e148 = gl_FragCoord_1[0u];
let _e149 = (*rows);
let _e151 = gl_FragCoord_1[1u];
local = vec2<f32>(_e148, (_e149 - _e151));
} else {
let _e154 = gl_FragCoord_1;
local = _e154.xy;
}
let _e156 = local;
return _e156;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param: f32;
let _e146 = frag_coord_info.origin[0u];
param = _e146;
let _e147 = FragCoordFromTop_u0028_f1_u003b((¶m));
return _e147;
}
fn SrgbToLinear_u0028_vf3_u003b(encoded: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e144 = (*encoded);
let _e147 = (*encoded);
let _e153 = (*encoded);
return mix((_e144 / vec3(12.92f)), pow(((max(_e147, vec3<f32>(0f, 0f, 0f)) + 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 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 _e156 = (*color);
c = clamp(_e156, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e158 = (*size);
sliceWidth = (1f / _e158);
let _e160 = (*size);
let _e161 = (*size);
texel = (1f / (_e160 * _e161));
let _e164 = texel;
let _e165 = (*size);
innerWidth = (_e164 * (_e165 - 1f));
let _e168 = texel;
let _e171 = c[0u];
let _e172 = innerWidth;
u = ((_e168 * 0.5f) + (_e171 * _e172));
let _e175 = (*size);
let _e178 = c[1u];
let _e179 = (*size);
let _e181 = (*size);
v = ((0.5f / _e175) + (_e178 * ((_e179 - 1f) / _e181)));
let _e186 = c[2u];
let _e187 = (*size);
slice = (_e186 * (_e187 - 1f));
let _e190 = slice;
lower = floor(_e190);
let _e192 = lower;
let _e194 = (*size);
upper = min((_e192 + 1f), (_e194 - 1f));
let _e197 = lower;
let _e198 = sliceWidth;
let _e200 = u;
let _e202 = v;
let _e204 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e197 * _e198) + _e200), _e202));
a = _e204.xyz;
let _e206 = upper;
let _e207 = sliceWidth;
let _e209 = u;
let _e211 = v;
let _e213 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e206 * _e207) + _e209), _e211));
b = _e213.xyz;
let _e215 = a;
let _e216 = b;
let _e217 = slice;
let _e218 = lower;
return mix(_e215, _e216, vec3((_e217 - _e218)));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e144 = (*linear);
let _e146 = (*linear);
let _e151 = (*linear);
return mix((_e144 * 12.92f), ((pow(max(_e146, 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), _e151));
}
fn Luma_u0028_vf3_u003b(color_1: ptr<function, vec3<f32>>) -> f32 {
let _e144 = (*color_1);
return dot(_e144, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn AgxSigmoid_u0028_vf3_u003b(color_2: ptr<function, vec3<f32>>) -> vec3<f32> {
var v_1: vec3<f32>;
var v2_: vec3<f32>;
var v4_: vec3<f32>;
let _e147 = (*color_2);
v_1 = clamp(log2(max(_e147, 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 _e151 = v_1;
v_1 = ((_e151 - vec3<f32>(-12.47393f, -12.47393f, -12.47393f)) / vec3(16.499998f));
let _e155 = v_1;
let _e156 = v_1;
v2_ = (_e155 * _e156);
let _e158 = v2_;
let _e159 = v2_;
v4_ = (_e158 * _e159);
let _e161 = v4_;
let _e163 = v2_;
let _e165 = v4_;
let _e167 = v_1;
let _e170 = v4_;
let _e173 = v2_;
let _e175 = v_1;
let _e178 = v2_;
let _e181 = v_1;
v_1 = ((((((((_e161 * 15.5f) * _e163) - ((_e165 * 40.14f) * _e167)) + (_e170 * 31.96f)) - ((_e173 * 6.868f) * _e175)) + (_e178 * 0.4298f)) + (_e181 * 0.1191f)) - vec3(0.00232f));
let _e186 = v_1;
return clamp(_e186, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAgx_u0028_vf3_u003b(color_3: ptr<function, vec3<f32>>) -> vec3<f32> {
var v_2: vec3<f32>;
var param_1: vec3<f32>;
let _e146 = (*color_3);
param_1 = (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)) * max(_e146, vec3<f32>(0f, 0f, 0f)));
let _e149 = AgxSigmoid_u0028_vf3_u003b((¶m_1));
v_2 = _e149;
let _e150 = v_2;
v_2 = (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)) * _e150);
let _e152 = v_2;
return clamp(pow(max(_e152, vec3<f32>(0f, 0f, 0f)), vec3<f32>(2.2f, 2.2f, 2.2f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAgxFull_u0028_vf3_u003b(color_4: ptr<function, vec3<f32>>) -> vec3<f32> {
var param_2: vec3<f32>;
let _e145 = (*color_4);
param_2 = _e145;
let _e146 = TonemapAgx_u0028_vf3_u003b((¶m_2));
return _e146;
}
fn TonemapReinhard_u0028_vf3_u003b(color_5: ptr<function, vec3<f32>>) -> vec3<f32> {
var numerator: vec3<f32>;
let _e145 = (*color_5);
let _e146 = (*color_5);
numerator = (_e145 * (vec3<f32>(1f, 1f, 1f) + (_e146 / vec3<f32>(16f, 16f, 16f))));
let _e150 = numerator;
let _e151 = (*color_5);
return clamp((_e150 / (vec3<f32>(1f, 1f, 1f) + _e151)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAces_u0028_vf3_u003b(color_6: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e144 = (*color_6);
let _e145 = (*color_6);
let _e150 = (*color_6);
let _e151 = (*color_6);
return clamp(((_e144 * ((_e145 * 2.51f) + vec3(0.03f))) / ((_e150 * ((_e151 * 2.43f) + vec3(0.59f))) + vec3(0.14f))), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapNeutral_u0028_vf3_u003b(color_7: ptr<function, vec3<f32>>) -> vec3<f32> {
var minChannel: f32;
var offset: f32;
var local_1: f32;
var peak: f32;
var newPeak: f32;
var desaturate: f32;
let _e151 = (*color_7)[0u];
let _e153 = (*color_7)[1u];
let _e155 = (*color_7)[2u];
minChannel = min(_e151, min(_e153, _e155));
let _e158 = minChannel;
if (_e158 < 0.08f) {
let _e160 = minChannel;
let _e161 = minChannel;
let _e163 = minChannel;
local_1 = (_e160 - ((6.25f * _e161) * _e163));
} else {
local_1 = 0.04f;
}
let _e166 = local_1;
offset = _e166;
let _e167 = offset;
let _e168 = (*color_7);
(*color_7) = (_e168 - vec3(_e167));
let _e172 = (*color_7)[0u];
let _e174 = (*color_7)[1u];
let _e176 = (*color_7)[2u];
peak = max(_e172, max(_e174, _e176));
let _e179 = peak;
if (_e179 < 0.76f) {
let _e181 = (*color_7);
return _e181;
}
let _e182 = peak;
newPeak = (1f - (0.0576f / ((_e182 + 0.24f) - 0.76f)));
let _e187 = newPeak;
let _e188 = peak;
let _e190 = (*color_7);
(*color_7) = (_e190 * (_e187 / _e188));
let _e192 = peak;
let _e193 = newPeak;
desaturate = (1f - (1f / ((0.15f * (_e192 - _e193)) + 1f)));
let _e199 = (*color_7);
let _e200 = newPeak;
let _e202 = desaturate;
return mix(_e199, vec3(_e200), vec3(_e202));
}
fn SampleDisplay_u0028_vf3_u003b(color_8: ptr<function, vec3<f32>>) -> vec3<f32> {
var size_1: f32;
var c_1: vec3<f32>;
var sliceWidth_1: f32;
var texel_1: f32;
var innerWidth_1: f32;
var u_1: f32;
var v_3: f32;
var slice_1: f32;
var lower_1: f32;
var upper_1: f32;
var a_1: vec3<f32>;
var b_1: vec3<f32>;
let _e158 = composite_info.contact[1u];
size_1 = max(_e158, 2f);
let _e160 = (*color_8);
c_1 = clamp(((log2((max(_e160, vec3<f32>(0.0000000001f, 0.0000000001f, 0.0000000001f)) / vec3(0.18f))) + vec3(10f)) / vec3(20f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e170 = size_1;
sliceWidth_1 = (1f / _e170);
let _e172 = size_1;
let _e173 = size_1;
texel_1 = (1f / (_e172 * _e173));
let _e176 = texel_1;
let _e177 = size_1;
innerWidth_1 = (_e176 * (_e177 - 1f));
let _e180 = texel_1;
let _e183 = c_1[0u];
let _e184 = innerWidth_1;
u_1 = ((_e180 * 0.5f) + (_e183 * _e184));
let _e187 = size_1;
let _e190 = c_1[1u];
let _e191 = size_1;
let _e193 = size_1;
v_3 = ((0.5f / _e187) + (_e190 * ((_e191 - 1f) / _e193)));
let _e198 = c_1[2u];
let _e199 = size_1;
slice_1 = (_e198 * (_e199 - 1f));
let _e202 = slice_1;
lower_1 = floor(_e202);
let _e204 = lower_1;
let _e206 = size_1;
upper_1 = min((_e204 + 1f), (_e206 - 1f));
let _e209 = lower_1;
let _e210 = sliceWidth_1;
let _e212 = u_1;
let _e214 = v_3;
let _e216 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e209 * _e210) + _e212), _e214));
a_1 = _e216.xyz;
let _e218 = upper_1;
let _e219 = sliceWidth_1;
let _e221 = u_1;
let _e223 = v_3;
let _e225 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e218 * _e219) + _e221), _e223));
b_1 = _e225.xyz;
let _e227 = a_1;
let _e228 = b_1;
let _e229 = slice_1;
let _e230 = lower_1;
return mix(_e227, _e228, vec3((_e229 - _e230)));
}
fn TonemapBy_u0028_vf3_u003b_i1_u003b(color_9: ptr<function, vec3<f32>>, curve: ptr<function, i32>) -> vec3<f32> {
var param_3: vec3<f32>;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
let _e151 = (*curve);
if (_e151 == 6i) {
let _e153 = (*color_9);
param_3 = _e153;
let _e154 = SampleDisplay_u0028_vf3_u003b((¶m_3));
return _e154;
}
let _e155 = (*curve);
if (_e155 == 1i) {
let _e157 = (*color_9);
param_4 = _e157;
let _e158 = TonemapNeutral_u0028_vf3_u003b((¶m_4));
return _e158;
}
let _e159 = (*curve);
if (_e159 == 2i) {
let _e161 = (*color_9);
param_5 = _e161;
let _e162 = TonemapAces_u0028_vf3_u003b((¶m_5));
return _e162;
}
let _e163 = (*curve);
if (_e163 == 3i) {
let _e165 = (*color_9);
param_6 = _e165;
let _e166 = TonemapAgx_u0028_vf3_u003b((¶m_6));
return _e166;
}
let _e167 = (*curve);
if (_e167 == 4i) {
let _e169 = (*color_9);
param_7 = _e169;
let _e170 = TonemapReinhard_u0028_vf3_u003b((¶m_7));
return _e170;
}
let _e171 = (*curve);
if (_e171 == 5i) {
let _e173 = (*color_9);
param_8 = _e173;
let _e174 = TonemapAgxFull_u0028_vf3_u003b((¶m_8));
return _e174;
}
let _e175 = (*color_9);
return _e175;
}
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 occlusion: vec4<f32>;
var ao: f32;
var contact: f32;
var localStops: f32;
var exposed: vec3<f32>;
var color_10: vec3<f32>;
var param_9: vec3<f32>;
var param_10: i32;
var contrast: f32;
var saturation: f32;
var temperature: f32;
var param_11: vec3<f32>;
var lift: vec3<f32>;
var gammaCurve: vec3<f32>;
var gain: vec3<f32>;
var balance: f32;
var tint: f32;
var lutStrength: f32;
var encodedIn: vec3<f32>;
var param_12: vec3<f32>;
var graded: vec3<f32>;
var param_13: vec3<f32>;
var param_14: f32;
var param_15: vec3<f32>;
var vignette: f32;
var fromCentre_1: vec2<f32>;
var aspect: f32;
var radius: f32;
var encoded_1: vec3<f32>;
var param_16: vec3<f32>;
var grain: f32;
var param_17: vec2<f32>;
var dither: f32;
var param_18: vec2<f32>;
let _e185 = composite_info.look[3u];
dispersion = _e185;
let _e186 = dispersion;
if (_e186 > 0f) {
let _e188 = v_uv_1;
fromCentre = (_e188 - vec2<f32>(0.5f, 0.5f));
let _e190 = fromCentre;
let _e191 = dispersion;
step_uv = (_e190 * _e191);
let _e193 = v_uv_1;
let _e194 = textureSample(scene_texture_tex, scene_texture_smp, _e193);
scene = _e194;
let _e195 = v_uv_1;
let _e196 = step_uv;
let _e198 = textureSample(scene_texture_tex, scene_texture_smp, (_e195 + _e196));
scene[0u] = _e198.x;
let _e201 = v_uv_1;
let _e202 = step_uv;
let _e204 = textureSample(scene_texture_tex, scene_texture_smp, (_e201 - _e202));
scene[2u] = _e204.z;
} else {
let _e207 = v_uv_1;
let _e208 = textureSample(scene_texture_tex, scene_texture_smp, _e207);
scene = _e208;
}
let _e209 = v_uv_1;
let _e210 = textureSample(bloom_texture_tex, bloom_texture_smp, _e209);
bloom = _e210.xyz;
let _e213 = composite_info.ao_texel;
half_texel = (_e213.xy * 0.5f);
let _e216 = v_uv_1;
let _e218 = half_texel[0u];
let _e220 = half_texel[1u];
let _e223 = textureSample(ao_texture_tex, ao_texture_smp, (_e216 + vec2<f32>(_e218, _e220)));
let _e224 = v_uv_1;
let _e226 = half_texel[0u];
let _e229 = half_texel[1u];
let _e232 = textureSample(ao_texture_tex, ao_texture_smp, (_e224 + vec2<f32>(-(_e226), _e229)));
let _e234 = v_uv_1;
let _e236 = half_texel[0u];
let _e238 = half_texel[1u];
let _e242 = textureSample(ao_texture_tex, ao_texture_smp, (_e234 + vec2<f32>(_e236, -(_e238))));
let _e244 = v_uv_1;
let _e246 = half_texel[0u];
let _e249 = half_texel[1u];
let _e253 = textureSample(ao_texture_tex, ao_texture_smp, (_e244 + vec2<f32>(-(_e246), -(_e249))));
occlusion = ((((_e223 + _e232) + _e242) + _e253) * 0.25f);
let _e257 = occlusion[3u];
ao = _e257;
let _e258 = ao;
let _e261 = composite_info.params[3u];
ao = mix(1f, _e258, clamp(_e261, 0f, 1f));
let _e264 = v_uv_1;
let _e265 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e264);
contact = _e265.x;
let _e267 = contact;
let _e270 = composite_info.contact[0u];
let _e273 = ao;
ao = (_e273 * mix(1f, _e267, clamp(_e270, 0f, 1f)));
let _e275 = v_uv_1;
let _e276 = textureSample(local_exposure_texture_tex, local_exposure_texture_smp, _e275);
localStops = _e276.x;
let _e278 = scene;
let _e280 = localStops;
let _e283 = composite_info.contact[3u];
exposed = (_e278.xyz * exp2((_e280 * _e283)));
let _e287 = exposed;
let _e288 = ao;
let _e290 = bloom;
let _e293 = composite_info.params[1u];
color_10 = ((_e287 * _e288) + (_e290 * _e293));
let _e296 = occlusion;
let _e300 = composite_info.contact[2u];
let _e304 = composite_info.params[3u];
let _e307 = color_10;
color_10 = (_e307 + ((_e296.xyz * _e300) * clamp(_e304, 0f, 1f)));
let _e311 = composite_info.params[0u];
let _e313 = color_10;
color_10 = (_e313 * max(_e311, 0f));
let _e317 = composite_info.params[2u];
let _e320 = color_10;
param_9 = _e320;
param_10 = i32((_e317 + 0.5f));
let _e321 = TonemapBy_u0028_vf3_u003b_i1_u003b((¶m_9), (¶m_10));
color_10 = _e321;
let _e324 = composite_info.look[0u];
contrast = _e324;
let _e327 = composite_info.look[1u];
saturation = _e327;
let _e330 = composite_info.look[2u];
temperature = _e330;
let _e331 = contrast;
if (_e331 != 1f) {
let _e333 = color_10;
let _e337 = contrast;
color_10 = (vec3<f32>(0.18f, 0.18f, 0.18f) * pow((max(_e333, vec3<f32>(0f, 0f, 0f)) / vec3(0.18f)), vec3(_e337)));
}
let _e341 = color_10;
param_11 = _e341;
let _e342 = Luma_u0028_vf3_u003b((¶m_11));
let _e344 = color_10;
let _e345 = saturation;
color_10 = mix(vec3(_e342), _e344, vec3(_e345));
let _e348 = temperature;
let _e351 = temperature;
let _e355 = color_10;
color_10 = (_e355 * vec3<f32>((1f + (_e348 * 0.1f)), 1f, (1f - (_e351 * 0.1f))));
let _e358 = composite_info.lift;
lift = _e358.xyz;
let _e361 = composite_info.gamma;
gammaCurve = _e361.xyz;
let _e364 = composite_info.gain;
gain = _e364.xyz;
let _e366 = color_10;
let _e367 = lift;
let _e370 = lift;
color_10 = ((_e366 * (vec3<f32>(1f, 1f, 1f) - _e367)) + _e370);
let _e372 = color_10;
color_10 = max(_e372, vec3<f32>(0f, 0f, 0f));
let _e374 = gammaCurve;
if any((_e374 != vec3<f32>(1f, 1f, 1f))) {
let _e377 = color_10;
let _e378 = gammaCurve;
color_10 = pow(_e377, (vec3<f32>(1f, 1f, 1f) / _e378));
}
let _e381 = gain;
let _e382 = color_10;
color_10 = (_e382 * _e381);
let _e386 = composite_info.output_encode[1u];
balance = _e386;
let _e389 = composite_info.output_encode[2u];
tint = _e389;
let _e390 = balance;
let _e392 = tint;
if ((_e390 != 0f) || (_e392 != 0f)) {
let _e395 = balance;
let _e398 = tint;
let _e401 = balance;
let _e405 = color_10;
color_10 = (_e405 * vec3<f32>((1f + (_e395 * 0.2f)), (1f + (_e398 * 0.15f)), (1f - (_e401 * 0.2f))));
let _e407 = tint;
let _e410 = color_10[0u];
color_10[0u] = (_e410 - (_e407 * 0.075f));
let _e413 = tint;
let _e416 = color_10[2u];
color_10[2u] = (_e416 - (_e413 * 0.075f));
}
let _e421 = composite_info.ao_texel[2u];
lutStrength = _e421;
let _e422 = lutStrength;
if (_e422 > 0f) {
let _e424 = color_10;
param_12 = clamp(_e424, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e426 = LinearToSrgb_u0028_vf3_u003b((¶m_12));
encodedIn = _e426;
let _e429 = composite_info.ao_texel[3u];
let _e431 = encodedIn;
param_13 = _e431;
param_14 = max(_e429, 2f);
let _e432 = SampleLut_u0028_vf3_u003b_f1_u003b((¶m_13), (¶m_14));
param_15 = _e432;
let _e433 = SrgbToLinear_u0028_vf3_u003b((¶m_15));
graded = _e433;
let _e434 = color_10;
let _e435 = graded;
let _e436 = lutStrength;
color_10 = mix(_e434, _e435, vec3(clamp(_e436, 0f, 1f)));
}
let _e442 = composite_info.look_more[0u];
vignette = _e442;
let _e443 = vignette;
if (_e443 > 0f) {
let _e445 = v_uv_1;
fromCentre_1 = (_e445 - vec2<f32>(0.5f, 0.5f));
let _e449 = composite_info.look_more[3u];
aspect = max(_e449, 0.0001f);
let _e451 = aspect;
let _e454 = composite_info.look_more[1u];
let _e457 = fromCentre_1[0u];
fromCentre_1[0u] = (_e457 * mix(1f, _e451, _e454));
let _e460 = fromCentre_1;
radius = (length(_e460) * 1.4142135f);
let _e463 = vignette;
let _e465 = radius;
let _e468 = color_10;
color_10 = (_e468 * mix(1f, (1f - _e463), clamp(_e465, 0f, 1f)));
}
let _e470 = color_10;
param_16 = max(_e470, vec3<f32>(0f, 0f, 0f));
let _e472 = LinearToSrgb_u0028_vf3_u003b((¶m_16));
encoded_1 = _e472;
let _e475 = composite_info.look_more[2u];
grain = _e475;
let _e476 = grain;
if (_e476 > 0f) {
let _e478 = TargetFragCoord_u0028_();
param_17 = _e478;
let _e479 = Hash_u0028_vf2_u003b((¶m_17));
let _e481 = grain;
let _e484 = encoded_1;
encoded_1 = (_e484 + vec3(((_e479 - 0.5f) * _e481)));
}
let _e488 = composite_info.output_encode[0u];
dither = _e488;
let _e489 = dither;
if (_e489 > 0f) {
let _e491 = TargetFragCoord_u0028_();
param_18 = _e491;
let _e492 = BayerCell_u0028_vf2_u003b((¶m_18));
let _e494 = dither;
let _e497 = encoded_1;
encoded_1 = (_e497 + vec3(((_e492 + 0.03125f) * _e494)));
}
let _e499 = encoded_1;
let _e501 = scene[3u];
frag_color = vec4<f32>(_e499.x, _e499.y, _e499.z, _e501);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
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,
),
],
),
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'bloom_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'contact_shadow_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'display_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'local_exposure_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lut_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Easu': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
struct EasuInfo {
source: vec4<f32>,
params: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var source_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> easu_info: EasuInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Hash_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
let _e42 = (*at);
return fract((sin(dot(_e42, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e43 = (*rows);
if (_e43 > 0f) {
let _e46 = gl_FragCoord_1[0u];
let _e47 = (*rows);
let _e49 = gl_FragCoord_1[1u];
local = vec2<f32>(_e46, (_e47 - _e49));
} else {
let _e52 = gl_FragCoord_1;
local = _e52.xy;
}
let _e54 = local;
return _e54;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param: f32;
let _e44 = frag_coord_info.origin[0u];
param = _e44;
let _e45 = FragCoordFromTop_u0028_f1_u003b((¶m));
return _e45;
}
fn TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(off: ptr<function, vec2<f32>>, dir: ptr<function, vec2<f32>>, len2_: ptr<function, vec2<f32>>, lob: ptr<function, f32>, clp: ptr<function, f32>) -> f32 {
var v: vec2<f32>;
var d2_: f32;
var wB: f32;
var wA: f32;
let _e51 = (*off)[0u];
let _e53 = (*dir)[0u];
let _e56 = (*off)[1u];
let _e58 = (*dir)[1u];
let _e62 = (*off)[0u];
let _e64 = (*dir)[1u];
let _e68 = (*off)[1u];
let _e70 = (*dir)[0u];
v = vec2<f32>(((_e51 * _e53) + (_e56 * _e58)), ((_e62 * -(_e64)) + (_e68 * _e70)));
let _e74 = (*len2_);
let _e75 = v;
v = (_e75 * _e74);
let _e77 = v;
let _e78 = v;
let _e80 = (*clp);
d2_ = min(dot(_e77, _e78), _e80);
let _e82 = d2_;
wB = ((0.4f * _e82) - 1f);
let _e85 = (*lob);
let _e86 = d2_;
wA = ((_e85 * _e86) - 1f);
let _e89 = wB;
let _e90 = wB;
wB = (_e90 * _e89);
let _e92 = wA;
let _e93 = wA;
wA = (_e93 * _e92);
let _e95 = wB;
wB = ((1.5625f * _e95) - 0.5625f);
let _e98 = wB;
let _e99 = wA;
return (_e98 * _e99);
}
fn EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(dir_1: ptr<function, vec2<f32>>, len: ptr<function, f32>, w: ptr<function, f32>, a: ptr<function, f32>, b: ptr<function, f32>, c: ptr<function, f32>, d: ptr<function, f32>, e: ptr<function, f32>) {
var lenX: f32;
var dirX: f32;
var stretchX: f32;
var lenY: f32;
var dirY: f32;
var stretchY: f32;
let _e55 = (*d);
let _e56 = (*c);
let _e59 = (*c);
let _e60 = (*b);
lenX = max(abs((_e55 - _e56)), abs((_e59 - _e60)));
let _e64 = (*d);
let _e65 = (*b);
dirX = (_e64 - _e65);
let _e67 = dirX;
let _e69 = lenX;
stretchX = clamp((abs(_e67) / max(_e69, 0.000001f)), 0f, 1f);
let _e73 = (*e);
let _e74 = (*c);
let _e77 = (*c);
let _e78 = (*a);
lenY = max(abs((_e73 - _e74)), abs((_e77 - _e78)));
let _e82 = (*e);
let _e83 = (*a);
dirY = (_e82 - _e83);
let _e85 = dirY;
let _e87 = lenY;
stretchY = clamp((abs(_e85) / max(_e87, 0.000001f)), 0f, 1f);
let _e91 = dirX;
let _e92 = dirY;
let _e94 = (*w);
let _e96 = (*dir_1);
(*dir_1) = (_e96 + (vec2<f32>(_e91, _e92) * _e94));
let _e98 = stretchX;
let _e99 = stretchX;
let _e101 = stretchY;
let _e102 = stretchY;
let _e105 = (*w);
let _e107 = (*len);
(*len) = (_e107 + (((_e98 * _e99) + (_e101 * _e102)) * _e105));
return;
}
fn EasuLuma_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> f32 {
let _e43 = (*c_1)[1u];
let _e45 = (*c_1)[0u];
let _e47 = (*c_1)[2u];
return (_e43 + (0.5f * (_e45 + _e47)));
}
fn Tap_u0028_vf2_u003b(pixel: ptr<function, vec2<f32>>) -> vec3<f32> {
let _e42 = (*pixel);
let _e46 = easu_info.source;
let _e49 = textureSampleLevel(source_texture_tex, source_texture_smp, ((_e42 + vec2(0.5f)) * _e46.zw), 0f);
return _e49.xyz;
}
fn main_1() {
var pp: vec2<f32>;
var fp: vec2<f32>;
var b_1: vec3<f32>;
var param_1: vec2<f32>;
var c_2: vec3<f32>;
var param_2: vec2<f32>;
var e_1: vec3<f32>;
var param_3: vec2<f32>;
var f: vec3<f32>;
var param_4: vec2<f32>;
var g: vec3<f32>;
var param_5: vec2<f32>;
var h: vec3<f32>;
var param_6: vec2<f32>;
var i: vec3<f32>;
var param_7: vec2<f32>;
var j: vec3<f32>;
var param_8: vec2<f32>;
var k: vec3<f32>;
var param_9: vec2<f32>;
var l: vec3<f32>;
var param_10: vec2<f32>;
var n: vec3<f32>;
var param_11: vec2<f32>;
var o: vec3<f32>;
var param_12: vec2<f32>;
var bL: f32;
var param_13: vec3<f32>;
var cL: f32;
var param_14: vec3<f32>;
var eL: f32;
var param_15: vec3<f32>;
var fL: f32;
var param_16: vec3<f32>;
var gL: f32;
var param_17: vec3<f32>;
var hL: f32;
var param_18: vec3<f32>;
var iL: f32;
var param_19: vec3<f32>;
var jL: f32;
var param_20: vec3<f32>;
var kL: f32;
var param_21: vec3<f32>;
var lL: f32;
var param_22: vec3<f32>;
var nL: f32;
var param_23: vec3<f32>;
var oL: f32;
var param_24: vec3<f32>;
var dir_2: vec2<f32>;
var len_1: f32;
var param_25: vec2<f32>;
var param_26: f32;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var param_31: f32;
var param_32: f32;
var param_33: vec2<f32>;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
var param_40: f32;
var param_41: vec2<f32>;
var param_42: f32;
var param_43: f32;
var param_44: f32;
var param_45: f32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: f32;
var param_51: f32;
var param_52: f32;
var param_53: f32;
var param_54: f32;
var param_55: f32;
var param_56: f32;
var dirR: f32;
var featureless: bool;
var local_1: vec2<f32>;
var stretch: f32;
var len2_1: vec2<f32>;
var lob_1: f32;
var clp_1: f32;
var sum: vec3<f32>;
var weight: f32;
var w_1: f32;
var param_57: vec2<f32>;
var param_58: vec2<f32>;
var param_59: vec2<f32>;
var param_60: f32;
var param_61: f32;
var param_62: vec2<f32>;
var param_63: vec2<f32>;
var param_64: vec2<f32>;
var param_65: f32;
var param_66: f32;
var param_67: vec2<f32>;
var param_68: vec2<f32>;
var param_69: vec2<f32>;
var param_70: f32;
var param_71: f32;
var param_72: vec2<f32>;
var param_73: vec2<f32>;
var param_74: vec2<f32>;
var param_75: f32;
var param_76: f32;
var param_77: vec2<f32>;
var param_78: vec2<f32>;
var param_79: vec2<f32>;
var param_80: f32;
var param_81: f32;
var param_82: vec2<f32>;
var param_83: vec2<f32>;
var param_84: vec2<f32>;
var param_85: f32;
var param_86: f32;
var param_87: vec2<f32>;
var param_88: vec2<f32>;
var param_89: vec2<f32>;
var param_90: f32;
var param_91: f32;
var param_92: vec2<f32>;
var param_93: vec2<f32>;
var param_94: vec2<f32>;
var param_95: f32;
var param_96: f32;
var param_97: vec2<f32>;
var param_98: vec2<f32>;
var param_99: vec2<f32>;
var param_100: f32;
var param_101: f32;
var param_102: vec2<f32>;
var param_103: vec2<f32>;
var param_104: vec2<f32>;
var param_105: f32;
var param_106: f32;
var param_107: vec2<f32>;
var param_108: vec2<f32>;
var param_109: vec2<f32>;
var param_110: f32;
var param_111: f32;
var param_112: vec2<f32>;
var param_113: vec2<f32>;
var param_114: vec2<f32>;
var param_115: f32;
var param_116: f32;
var lo: vec3<f32>;
var hi: vec3<f32>;
var color: vec3<f32>;
var grain: f32;
var param_117: vec2<f32>;
let _e200 = v_uv_1;
let _e202 = easu_info.source;
pp = ((_e200 * _e202.xy) - vec2(0.5f));
let _e207 = pp;
fp = floor(_e207);
let _e209 = fp;
let _e210 = pp;
pp = (_e210 - _e209);
let _e212 = fp;
param_1 = (_e212 + vec2<f32>(0f, -1f));
let _e214 = Tap_u0028_vf2_u003b((¶m_1));
b_1 = _e214;
let _e215 = fp;
param_2 = (_e215 + vec2<f32>(1f, -1f));
let _e217 = Tap_u0028_vf2_u003b((¶m_2));
c_2 = _e217;
let _e218 = fp;
param_3 = (_e218 + vec2<f32>(-1f, 0f));
let _e220 = Tap_u0028_vf2_u003b((¶m_3));
e_1 = _e220;
let _e221 = fp;
param_4 = _e221;
let _e222 = Tap_u0028_vf2_u003b((¶m_4));
f = _e222;
let _e223 = fp;
param_5 = (_e223 + vec2<f32>(1f, 0f));
let _e225 = Tap_u0028_vf2_u003b((¶m_5));
g = _e225;
let _e226 = fp;
param_6 = (_e226 + vec2<f32>(2f, 0f));
let _e228 = Tap_u0028_vf2_u003b((¶m_6));
h = _e228;
let _e229 = fp;
param_7 = (_e229 + vec2<f32>(-1f, 1f));
let _e231 = Tap_u0028_vf2_u003b((¶m_7));
i = _e231;
let _e232 = fp;
param_8 = (_e232 + vec2<f32>(0f, 1f));
let _e234 = Tap_u0028_vf2_u003b((¶m_8));
j = _e234;
let _e235 = fp;
param_9 = (_e235 + vec2<f32>(1f, 1f));
let _e237 = Tap_u0028_vf2_u003b((¶m_9));
k = _e237;
let _e238 = fp;
param_10 = (_e238 + vec2<f32>(2f, 1f));
let _e240 = Tap_u0028_vf2_u003b((¶m_10));
l = _e240;
let _e241 = fp;
param_11 = (_e241 + vec2<f32>(0f, 2f));
let _e243 = Tap_u0028_vf2_u003b((¶m_11));
n = _e243;
let _e244 = fp;
param_12 = (_e244 + vec2<f32>(1f, 2f));
let _e246 = Tap_u0028_vf2_u003b((¶m_12));
o = _e246;
let _e247 = b_1;
param_13 = _e247;
let _e248 = EasuLuma_u0028_vf3_u003b((¶m_13));
bL = _e248;
let _e249 = c_2;
param_14 = _e249;
let _e250 = EasuLuma_u0028_vf3_u003b((¶m_14));
cL = _e250;
let _e251 = e_1;
param_15 = _e251;
let _e252 = EasuLuma_u0028_vf3_u003b((¶m_15));
eL = _e252;
let _e253 = f;
param_16 = _e253;
let _e254 = EasuLuma_u0028_vf3_u003b((¶m_16));
fL = _e254;
let _e255 = g;
param_17 = _e255;
let _e256 = EasuLuma_u0028_vf3_u003b((¶m_17));
gL = _e256;
let _e257 = h;
param_18 = _e257;
let _e258 = EasuLuma_u0028_vf3_u003b((¶m_18));
hL = _e258;
let _e259 = i;
param_19 = _e259;
let _e260 = EasuLuma_u0028_vf3_u003b((¶m_19));
iL = _e260;
let _e261 = j;
param_20 = _e261;
let _e262 = EasuLuma_u0028_vf3_u003b((¶m_20));
jL = _e262;
let _e263 = k;
param_21 = _e263;
let _e264 = EasuLuma_u0028_vf3_u003b((¶m_21));
kL = _e264;
let _e265 = l;
param_22 = _e265;
let _e266 = EasuLuma_u0028_vf3_u003b((¶m_22));
lL = _e266;
let _e267 = n;
param_23 = _e267;
let _e268 = EasuLuma_u0028_vf3_u003b((¶m_23));
nL = _e268;
let _e269 = o;
param_24 = _e269;
let _e270 = EasuLuma_u0028_vf3_u003b((¶m_24));
oL = _e270;
dir_2 = vec2<f32>(0f, 0f);
len_1 = 0f;
let _e272 = pp[0u];
let _e275 = pp[1u];
let _e278 = dir_2;
param_25 = _e278;
let _e279 = len_1;
param_26 = _e279;
param_27 = ((1f - _e272) * (1f - _e275));
let _e280 = bL;
param_28 = _e280;
let _e281 = eL;
param_29 = _e281;
let _e282 = fL;
param_30 = _e282;
let _e283 = gL;
param_31 = _e283;
let _e284 = jL;
param_32 = _e284;
EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_25), (¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
let _e285 = param_25;
dir_2 = _e285;
let _e286 = param_26;
len_1 = _e286;
let _e288 = pp[0u];
let _e290 = pp[1u];
let _e293 = dir_2;
param_33 = _e293;
let _e294 = len_1;
param_34 = _e294;
param_35 = (_e288 * (1f - _e290));
let _e295 = cL;
param_36 = _e295;
let _e296 = fL;
param_37 = _e296;
let _e297 = gL;
param_38 = _e297;
let _e298 = hL;
param_39 = _e298;
let _e299 = kL;
param_40 = _e299;
EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39), (¶m_40));
let _e300 = param_33;
dir_2 = _e300;
let _e301 = param_34;
len_1 = _e301;
let _e303 = pp[0u];
let _e306 = pp[1u];
let _e308 = dir_2;
param_41 = _e308;
let _e309 = len_1;
param_42 = _e309;
param_43 = ((1f - _e303) * _e306);
let _e310 = fL;
param_44 = _e310;
let _e311 = iL;
param_45 = _e311;
let _e312 = jL;
param_46 = _e312;
let _e313 = kL;
param_47 = _e313;
let _e314 = nL;
param_48 = _e314;
EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_41), (¶m_42), (¶m_43), (¶m_44), (¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e315 = param_41;
dir_2 = _e315;
let _e316 = param_42;
len_1 = _e316;
let _e318 = pp[0u];
let _e320 = pp[1u];
let _e322 = dir_2;
param_49 = _e322;
let _e323 = len_1;
param_50 = _e323;
param_51 = (_e318 * _e320);
let _e324 = gL;
param_52 = _e324;
let _e325 = jL;
param_53 = _e325;
let _e326 = kL;
param_54 = _e326;
let _e327 = lL;
param_55 = _e327;
let _e328 = oL;
param_56 = _e328;
EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53), (¶m_54), (¶m_55), (¶m_56));
let _e329 = param_49;
dir_2 = _e329;
let _e330 = param_50;
len_1 = _e330;
let _e331 = dir_2;
let _e332 = dir_2;
dirR = dot(_e331, _e332);
let _e334 = dirR;
featureless = (_e334 < 0.000030517578f);
let _e336 = featureless;
if _e336 {
local_1 = vec2<f32>(1f, 0f);
} else {
let _e337 = dir_2;
let _e338 = dirR;
local_1 = (_e337 * inverseSqrt(max(_e338, 0.000000000001f)));
}
let _e342 = local_1;
dir_2 = _e342;
let _e343 = len_1;
len_1 = (_e343 * 0.5f);
let _e345 = len_1;
let _e346 = len_1;
len_1 = (_e346 * _e345);
let _e348 = dir_2;
let _e349 = dir_2;
let _e352 = dir_2[0u];
let _e355 = dir_2[1u];
stretch = (dot(_e348, _e349) / max(abs(_e352), abs(_e355)));
let _e359 = stretch;
let _e361 = len_1;
let _e364 = len_1;
len2_1 = vec2<f32>((1f + ((_e359 - 1f) * _e361)), (1f - (0.5f * _e364)));
let _e368 = len_1;
lob_1 = (0.5f - (0.29f * _e368));
let _e371 = lob_1;
clp_1 = (1f / _e371);
sum = vec3<f32>(0f, 0f, 0f);
weight = 0f;
let _e373 = pp;
param_57 = (vec2<f32>(0f, -1f) - _e373);
let _e375 = dir_2;
param_58 = _e375;
let _e376 = len2_1;
param_59 = _e376;
let _e377 = lob_1;
param_60 = _e377;
let _e378 = clp_1;
param_61 = _e378;
let _e379 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_57), (¶m_58), (¶m_59), (¶m_60), (¶m_61));
w_1 = _e379;
let _e380 = b_1;
let _e381 = w_1;
let _e383 = sum;
sum = (_e383 + (_e380 * _e381));
let _e385 = w_1;
let _e386 = weight;
weight = (_e386 + _e385);
let _e388 = pp;
param_62 = (vec2<f32>(1f, -1f) - _e388);
let _e390 = dir_2;
param_63 = _e390;
let _e391 = len2_1;
param_64 = _e391;
let _e392 = lob_1;
param_65 = _e392;
let _e393 = clp_1;
param_66 = _e393;
let _e394 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_62), (¶m_63), (¶m_64), (¶m_65), (¶m_66));
w_1 = _e394;
let _e395 = c_2;
let _e396 = w_1;
let _e398 = sum;
sum = (_e398 + (_e395 * _e396));
let _e400 = w_1;
let _e401 = weight;
weight = (_e401 + _e400);
let _e403 = pp;
param_67 = (vec2<f32>(-1f, 1f) - _e403);
let _e405 = dir_2;
param_68 = _e405;
let _e406 = len2_1;
param_69 = _e406;
let _e407 = lob_1;
param_70 = _e407;
let _e408 = clp_1;
param_71 = _e408;
let _e409 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_67), (¶m_68), (¶m_69), (¶m_70), (¶m_71));
w_1 = _e409;
let _e410 = i;
let _e411 = w_1;
let _e413 = sum;
sum = (_e413 + (_e410 * _e411));
let _e415 = w_1;
let _e416 = weight;
weight = (_e416 + _e415);
let _e418 = pp;
param_72 = (vec2<f32>(0f, 1f) - _e418);
let _e420 = dir_2;
param_73 = _e420;
let _e421 = len2_1;
param_74 = _e421;
let _e422 = lob_1;
param_75 = _e422;
let _e423 = clp_1;
param_76 = _e423;
let _e424 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_72), (¶m_73), (¶m_74), (¶m_75), (¶m_76));
w_1 = _e424;
let _e425 = j;
let _e426 = w_1;
let _e428 = sum;
sum = (_e428 + (_e425 * _e426));
let _e430 = w_1;
let _e431 = weight;
weight = (_e431 + _e430);
let _e433 = pp;
param_77 = (vec2<f32>(0f, 0f) - _e433);
let _e435 = dir_2;
param_78 = _e435;
let _e436 = len2_1;
param_79 = _e436;
let _e437 = lob_1;
param_80 = _e437;
let _e438 = clp_1;
param_81 = _e438;
let _e439 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_77), (¶m_78), (¶m_79), (¶m_80), (¶m_81));
w_1 = _e439;
let _e440 = f;
let _e441 = w_1;
let _e443 = sum;
sum = (_e443 + (_e440 * _e441));
let _e445 = w_1;
let _e446 = weight;
weight = (_e446 + _e445);
let _e448 = pp;
param_82 = (vec2<f32>(-1f, 0f) - _e448);
let _e450 = dir_2;
param_83 = _e450;
let _e451 = len2_1;
param_84 = _e451;
let _e452 = lob_1;
param_85 = _e452;
let _e453 = clp_1;
param_86 = _e453;
let _e454 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_82), (¶m_83), (¶m_84), (¶m_85), (¶m_86));
w_1 = _e454;
let _e455 = e_1;
let _e456 = w_1;
let _e458 = sum;
sum = (_e458 + (_e455 * _e456));
let _e460 = w_1;
let _e461 = weight;
weight = (_e461 + _e460);
let _e463 = pp;
param_87 = (vec2<f32>(1f, 1f) - _e463);
let _e465 = dir_2;
param_88 = _e465;
let _e466 = len2_1;
param_89 = _e466;
let _e467 = lob_1;
param_90 = _e467;
let _e468 = clp_1;
param_91 = _e468;
let _e469 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_87), (¶m_88), (¶m_89), (¶m_90), (¶m_91));
w_1 = _e469;
let _e470 = k;
let _e471 = w_1;
let _e473 = sum;
sum = (_e473 + (_e470 * _e471));
let _e475 = w_1;
let _e476 = weight;
weight = (_e476 + _e475);
let _e478 = pp;
param_92 = (vec2<f32>(2f, 1f) - _e478);
let _e480 = dir_2;
param_93 = _e480;
let _e481 = len2_1;
param_94 = _e481;
let _e482 = lob_1;
param_95 = _e482;
let _e483 = clp_1;
param_96 = _e483;
let _e484 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_92), (¶m_93), (¶m_94), (¶m_95), (¶m_96));
w_1 = _e484;
let _e485 = l;
let _e486 = w_1;
let _e488 = sum;
sum = (_e488 + (_e485 * _e486));
let _e490 = w_1;
let _e491 = weight;
weight = (_e491 + _e490);
let _e493 = pp;
param_97 = (vec2<f32>(2f, 0f) - _e493);
let _e495 = dir_2;
param_98 = _e495;
let _e496 = len2_1;
param_99 = _e496;
let _e497 = lob_1;
param_100 = _e497;
let _e498 = clp_1;
param_101 = _e498;
let _e499 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_97), (¶m_98), (¶m_99), (¶m_100), (¶m_101));
w_1 = _e499;
let _e500 = h;
let _e501 = w_1;
let _e503 = sum;
sum = (_e503 + (_e500 * _e501));
let _e505 = w_1;
let _e506 = weight;
weight = (_e506 + _e505);
let _e508 = pp;
param_102 = (vec2<f32>(1f, 0f) - _e508);
let _e510 = dir_2;
param_103 = _e510;
let _e511 = len2_1;
param_104 = _e511;
let _e512 = lob_1;
param_105 = _e512;
let _e513 = clp_1;
param_106 = _e513;
let _e514 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_102), (¶m_103), (¶m_104), (¶m_105), (¶m_106));
w_1 = _e514;
let _e515 = g;
let _e516 = w_1;
let _e518 = sum;
sum = (_e518 + (_e515 * _e516));
let _e520 = w_1;
let _e521 = weight;
weight = (_e521 + _e520);
let _e523 = pp;
param_107 = (vec2<f32>(1f, 2f) - _e523);
let _e525 = dir_2;
param_108 = _e525;
let _e526 = len2_1;
param_109 = _e526;
let _e527 = lob_1;
param_110 = _e527;
let _e528 = clp_1;
param_111 = _e528;
let _e529 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_107), (¶m_108), (¶m_109), (¶m_110), (¶m_111));
w_1 = _e529;
let _e530 = o;
let _e531 = w_1;
let _e533 = sum;
sum = (_e533 + (_e530 * _e531));
let _e535 = w_1;
let _e536 = weight;
weight = (_e536 + _e535);
let _e538 = pp;
param_112 = (vec2<f32>(0f, 2f) - _e538);
let _e540 = dir_2;
param_113 = _e540;
let _e541 = len2_1;
param_114 = _e541;
let _e542 = lob_1;
param_115 = _e542;
let _e543 = clp_1;
param_116 = _e543;
let _e544 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_112), (¶m_113), (¶m_114), (¶m_115), (¶m_116));
w_1 = _e544;
let _e545 = n;
let _e546 = w_1;
let _e548 = sum;
sum = (_e548 + (_e545 * _e546));
let _e550 = w_1;
let _e551 = weight;
weight = (_e551 + _e550);
let _e553 = f;
let _e554 = g;
let _e556 = j;
let _e557 = k;
lo = min(min(_e553, _e554), min(_e556, _e557));
let _e560 = f;
let _e561 = g;
let _e563 = j;
let _e564 = k;
hi = max(max(_e560, _e561), max(_e563, _e564));
let _e567 = sum;
let _e568 = weight;
let _e572 = lo;
let _e573 = hi;
color = clamp((_e567 / vec3(max(_e568, 0.000001f))), _e572, _e573);
let _e577 = easu_info.params[0u];
grain = _e577;
let _e578 = TargetFragCoord_u0028_();
param_117 = _e578;
let _e579 = Hash_u0028_vf2_u003b((¶m_117));
let _e581 = grain;
let _e584 = color;
color = (_e584 + vec3(((_e579 - 0.5f) * _e581)));
let _e586 = color;
frag_color = vec4<f32>(_e586.x, _e586.y, _e586.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'EasuInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'source',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LocalExposure': WebGpuStage(
wgsl: r'''
struct LocalExposureInfo {
stops: vec4<f32>,
camera: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> local_exposure_info: LocalExposureInfo;
@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 WellExposed_u0028_f1_u003b(y: ptr<function, f32>) -> f32 {
var display: f32;
var off: f32;
let _e24 = (*y);
let _e25 = (*y);
display = pow((_e24 / (1f + _e25)), 0.45454547f);
let _e29 = display;
off = (_e29 - 0.5f);
let _e31 = off;
let _e33 = off;
return exp(((-(_e31) * _e33) / 0.08f));
}
fn Luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {
let _e22 = (*c);
return dot(_e22, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var t: vec2<f32>;
var y_1: f32;
var param: vec3<f32>;
var param_1: vec3<f32>;
var param_2: vec3<f32>;
var param_3: vec3<f32>;
var shadow: f32;
var highlight: f32;
var param_4: f32;
var param_5: f32;
var param_6: f32;
let _e33 = local_exposure_info.stops;
t = (_e33.zw * 2f);
let _e36 = v_uv_1;
let _e38 = t[0u];
let _e41 = t[1u];
let _e45 = textureSample(scene_texture_tex, scene_texture_smp, (_e36 + vec2<f32>(-(_e38), -(_e41))));
param = _e45.xyz;
let _e47 = Luma_u0028_vf3_u003b((¶m));
let _e48 = v_uv_1;
let _e50 = t[0u];
let _e52 = t[1u];
let _e56 = textureSample(scene_texture_tex, scene_texture_smp, (_e48 + vec2<f32>(_e50, -(_e52))));
param_1 = _e56.xyz;
let _e58 = Luma_u0028_vf3_u003b((¶m_1));
let _e60 = v_uv_1;
let _e62 = t[0u];
let _e65 = t[1u];
let _e68 = textureSample(scene_texture_tex, scene_texture_smp, (_e60 + vec2<f32>(-(_e62), _e65)));
param_2 = _e68.xyz;
let _e70 = Luma_u0028_vf3_u003b((¶m_2));
let _e72 = v_uv_1;
let _e74 = t[0u];
let _e76 = t[1u];
let _e79 = textureSample(scene_texture_tex, scene_texture_smp, (_e72 + vec2<f32>(_e74, _e76)));
param_3 = _e79.xyz;
let _e81 = Luma_u0028_vf3_u003b((¶m_3));
y_1 = (0.25f * (((_e47 + _e58) + _e70) + _e81));
let _e84 = y_1;
let _e88 = local_exposure_info.camera[0u];
y_1 = (max(_e84, 0f) * max(_e88, 0f));
let _e93 = local_exposure_info.stops[0u];
shadow = exp2(_e93);
let _e97 = local_exposure_info.stops[1u];
highlight = exp2(-(_e97));
let _e100 = y_1;
let _e101 = shadow;
param_4 = (_e100 * _e101);
let _e103 = WellExposed_u0028_f1_u003b((¶m_4));
let _e105 = y_1;
param_5 = _e105;
let _e106 = WellExposed_u0028_f1_u003b((¶m_5));
let _e108 = y_1;
let _e109 = highlight;
param_6 = (_e108 * _e109);
let _e111 = WellExposed_u0028_f1_u003b((¶m_6));
frag_color = vec4<f32>((_e103 + 0.0001f), (_e106 + 0.0001f), (_e111 + 0.0001f), 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: 'LocalExposureInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'stops', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LocalExposureBlur': WebGpuStage(
wgsl: r'''
struct LocalExposureBlurInfo {
step: vec4<f32>,
stops: vec4<f32>,
}
@group(1) @binding(1)
var weight_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var weight_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> blur_info: LocalExposureBlurInfo;
var<private> frag_color: vec4<f32>;
fn main_1() {
var sum: vec3<f32>;
var total: f32;
var i: i32;
var w: f32;
var weights: vec3<f32>;
var stops: f32;
var local: vec4<f32>;
sum = vec3<f32>(0f, 0f, 0f);
total = 0f;
i = -6i;
loop {
let _e25 = i;
if (_e25 <= 6i) {
let _e27 = i;
let _e28 = i;
w = exp((-(f32((_e27 * _e28))) / 18f));
let _e34 = v_uv_1;
let _e36 = blur_info.step;
let _e38 = i;
let _e42 = textureSample(weight_texture_tex, weight_texture_smp, (_e34 + (_e36.xy * f32(_e38))));
let _e44 = w;
let _e46 = sum;
sum = (_e46 + (_e42.xyz * _e44));
let _e48 = w;
let _e49 = total;
total = (_e49 + _e48);
continue;
} else {
break;
}
continuing {
let _e51 = i;
i = (_e51 + 1i);
}
}
let _e53 = sum;
let _e54 = total;
weights = (_e53 / vec3(_e54));
let _e58 = weights[0u];
let _e61 = blur_info.stops[0u];
let _e64 = weights[2u];
let _e67 = blur_info.stops[1u];
let _e71 = weights[0u];
let _e73 = weights[1u];
let _e76 = weights[2u];
stops = (((_e58 * _e61) - (_e64 * _e67)) / max(((_e71 + _e73) + _e76), 0.000001f));
let _e82 = blur_info.step[2u];
if (_e82 > 0.5f) {
let _e84 = stops;
local = vec4<f32>(_e84, _e84, _e84, 1f);
} else {
let _e86 = weights;
local = vec4<f32>(_e86.x, _e86.y, _e86.z, 1f);
}
let _e91 = local;
frag_color = _e91;
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: 'LocalExposureBlurInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'step', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'stops',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'weight_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
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 SearchStep_u0028_i1_u003b(i: ptr<function, i32>) -> f32 {
var local: f32;
var local_1: f32;
let _e37 = (*i);
if (_e37 == 1i) {
local = 1.5f;
} else {
let _e39 = (*i);
if (_e39 == 2i) {
local_1 = 2f;
} else {
let _e41 = (*i);
local_1 = select(12f, 4f, (_e41 == 3i));
}
let _e44 = local_1;
local = _e44;
}
let _e45 = local;
return _e45;
}
fn MinChannel_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> f32 {
let _e36 = (*v)[0u];
let _e38 = (*v)[1u];
let _e40 = (*v)[2u];
return min(_e36, min(_e38, _e40));
}
fn MaxChannel_u0028_vf3_u003b(v_1: ptr<function, vec3<f32>>) -> f32 {
let _e36 = (*v_1)[0u];
let _e38 = (*v_1)[1u];
let _e40 = (*v_1)[2u];
return max(_e36, max(_e38, _e40));
}
fn SharpenRobust_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_f1_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>>, amount: ptr<function, f32>) -> vec3<f32> {
var lowest: vec3<f32>;
var highest: vec3<f32>;
var hitMin: vec3<f32>;
var hitMax: vec3<f32>;
var lobeRgb: vec3<f32>;
var lobe: f32;
var param: vec3<f32>;
let _e47 = (*n);
let _e48 = (*s);
let _e50 = (*w);
let _e51 = (*e);
lowest = min(min(_e47, _e48), min(_e50, _e51));
let _e54 = (*n);
let _e55 = (*s);
let _e57 = (*w);
let _e58 = (*e);
highest = max(max(_e54, _e55), max(_e57, _e58));
let _e61 = lowest;
let _e62 = highest;
hitMin = (_e61 / max((_e62 * 4f), vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
let _e66 = highest;
let _e68 = lowest;
hitMax = ((vec3<f32>(1f, 1f, 1f) - _e66) / min(((_e68 * 4f) - vec3(4f)), vec3<f32>(-0.00001f, -0.00001f, -0.00001f)));
let _e74 = hitMin;
let _e76 = hitMax;
lobeRgb = max(-(_e74), _e76);
let _e78 = lobeRgb;
param = _e78;
let _e79 = MaxChannel_u0028_vf3_u003b((¶m));
let _e82 = (*amount);
lobe = (max(-0.1875f, min(_e79, 0f)) * _e82);
let _e84 = lobe;
let _e85 = (*n);
let _e86 = (*s);
let _e88 = (*w);
let _e90 = (*e);
let _e93 = (*centre);
let _e95 = lobe;
return ((((((_e85 + _e86) + _e88) + _e90) * _e84) + _e93) / vec3(((4f * _e95) + 1f)));
}
fn Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre_1: ptr<function, vec3<f32>>, n_1: ptr<function, vec3<f32>>, s_1: ptr<function, vec3<f32>>, w_1: ptr<function, vec3<f32>>, e_1: ptr<function, vec3<f32>>) -> vec3<f32> {
var strength: f32;
var param_1: 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: f32;
var lowest_1: vec3<f32>;
var highest_1: vec3<f32>;
var room: vec3<f32>;
var amount_1: f32;
var param_7: vec3<f32>;
var average: vec3<f32>;
let _e54 = fxaa_info.sharpen[0u];
strength = _e54;
let _e55 = strength;
if (_e55 <= 0f) {
let _e57 = (*centre_1);
return _e57;
}
let _e60 = fxaa_info.sharpen[1u];
if (_e60 > 0.5f) {
let _e62 = (*centre_1);
param_1 = _e62;
let _e63 = (*n_1);
param_2 = _e63;
let _e64 = (*s_1);
param_3 = _e64;
let _e65 = (*w_1);
param_4 = _e65;
let _e66 = (*e_1);
param_5 = _e66;
let _e67 = strength;
param_6 = _e67;
let _e68 = SharpenRobust_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_f1_u003b((¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
return _e68;
}
let _e69 = (*centre_1);
let _e70 = (*n_1);
let _e71 = (*s_1);
let _e73 = (*w_1);
let _e74 = (*e_1);
lowest_1 = min(_e69, min(min(_e70, _e71), min(_e73, _e74)));
let _e78 = (*centre_1);
let _e79 = (*n_1);
let _e80 = (*s_1);
let _e82 = (*w_1);
let _e83 = (*e_1);
highest_1 = max(_e78, max(max(_e79, _e80), max(_e82, _e83)));
let _e87 = lowest_1;
let _e88 = highest_1;
let _e91 = highest_1;
room = (min(_e87, (vec3<f32>(1f, 1f, 1f) - _e88)) / max(_e91, vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
let _e94 = room;
param_7 = _e94;
let _e95 = MinChannel_u0028_vf3_u003b((¶m_7));
amount_1 = clamp(sqrt(clamp(_e95, 0f, 1f)), 0f, 1f);
let _e99 = (*n_1);
let _e100 = (*s_1);
let _e102 = (*w_1);
let _e104 = (*e_1);
average = ((((_e99 + _e100) + _e102) + _e104) * 0.25f);
let _e107 = (*centre_1);
let _e108 = (*centre_1);
let _e109 = average;
let _e111 = amount_1;
let _e113 = strength;
return (_e107 + (((_e108 - _e109) * _e111) * _e113));
}
fn Weight_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e35 = (*color);
return dot(_e35, vec3<f32>(0.299f, 0.587f, 0.114f));
}
fn main_1() {
var texel: vec2<f32>;
var middle: vec3<f32>;
var mid: f32;
var param_8: vec3<f32>;
var northRgb: vec3<f32>;
var southRgb: vec3<f32>;
var westRgb: vec3<f32>;
var eastRgb: vec3<f32>;
var north: f32;
var param_9: vec3<f32>;
var south: f32;
var param_10: vec3<f32>;
var west: f32;
var param_11: vec3<f32>;
var east: f32;
var param_12: vec3<f32>;
var lowest_2: f32;
var highest_2: f32;
var contrast: f32;
var param_13: vec3<f32>;
var param_14: vec3<f32>;
var param_15: vec3<f32>;
var param_16: vec3<f32>;
var param_17: vec3<f32>;
var northWest: f32;
var param_18: vec3<f32>;
var southEast: f32;
var param_19: vec3<f32>;
var northEast: f32;
var param_20: vec3<f32>;
var southWest: f32;
var param_21: vec3<f32>;
var edgeHorizontal: f32;
var edgeVertical: f32;
var horizontalSpan: bool;
var lowPass: f32;
var subpixC: f32;
var subpixF: f32;
var subpixH: f32;
var lumaN: f32;
var lumaS: f32;
var gradientN: f32;
var gradientS: f32;
var pairN: bool;
var gradient: f32;
var lengthSign: f32;
var local_2: f32;
var pairAverage: f32;
var local_3: f32;
var along: vec2<f32>;
var local_4: vec2<f32>;
var start: vec2<f32>;
var local_5: vec2<f32>;
var gradientScaled: f32;
var posN: vec2<f32>;
var posP: vec2<f32>;
var endN: f32;
var param_22: vec3<f32>;
var endP: f32;
var param_23: vec3<f32>;
var doneN: bool;
var doneP: bool;
var i_1: i32;
var stride: f32;
var param_24: i32;
var param_25: vec3<f32>;
var param_26: vec3<f32>;
var distanceN: f32;
var local_6: f32;
var distanceP: f32;
var local_7: f32;
var middleBelow: bool;
var nearerN: bool;
var goodSpan: bool;
var local_8: bool;
var nearest: f32;
var pixelOffset: f32;
var offset: f32;
var at: vec2<f32>;
var local_9: vec2<f32>;
var smoothed: vec3<f32>;
var param_27: vec3<f32>;
var param_28: vec3<f32>;
var param_29: vec3<f32>;
var param_30: vec3<f32>;
var param_31: vec3<f32>;
let _e121 = fxaa_info.params;
texel = _e121.xy;
let _e123 = v_uv_1;
let _e124 = textureSampleLevel(source_texture_tex, source_texture_smp, _e123, 0f);
middle = _e124.xyz;
let _e126 = middle;
param_8 = _e126;
let _e127 = Weight_u0028_vf3_u003b((¶m_8));
mid = _e127;
let _e128 = v_uv_1;
let _e130 = texel[1u];
let _e134 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e128 + vec2<f32>(0f, -(_e130))), 0f);
northRgb = _e134.xyz;
let _e136 = v_uv_1;
let _e138 = texel[1u];
let _e141 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e136 + vec2<f32>(0f, _e138)), 0f);
southRgb = _e141.xyz;
let _e143 = v_uv_1;
let _e145 = texel[0u];
let _e149 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e143 + vec2<f32>(-(_e145), 0f)), 0f);
westRgb = _e149.xyz;
let _e151 = v_uv_1;
let _e153 = texel[0u];
let _e156 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e151 + vec2<f32>(_e153, 0f)), 0f);
eastRgb = _e156.xyz;
let _e158 = northRgb;
param_9 = _e158;
let _e159 = Weight_u0028_vf3_u003b((¶m_9));
north = _e159;
let _e160 = southRgb;
param_10 = _e160;
let _e161 = Weight_u0028_vf3_u003b((¶m_10));
south = _e161;
let _e162 = westRgb;
param_11 = _e162;
let _e163 = Weight_u0028_vf3_u003b((¶m_11));
west = _e163;
let _e164 = eastRgb;
param_12 = _e164;
let _e165 = Weight_u0028_vf3_u003b((¶m_12));
east = _e165;
let _e166 = mid;
let _e167 = north;
let _e168 = south;
let _e170 = west;
let _e171 = east;
lowest_2 = min(_e166, min(min(_e167, _e168), min(_e170, _e171)));
let _e175 = mid;
let _e176 = north;
let _e177 = south;
let _e179 = west;
let _e180 = east;
highest_2 = max(_e175, max(max(_e176, _e177), max(_e179, _e180)));
let _e184 = highest_2;
let _e185 = lowest_2;
contrast = (_e184 - _e185);
let _e187 = contrast;
let _e188 = highest_2;
let _e191 = fxaa_info.params[2u];
if (_e187 < max(0.0312f, (_e188 * _e191))) {
let _e195 = middle;
param_13 = _e195;
let _e196 = northRgb;
param_14 = _e196;
let _e197 = southRgb;
param_15 = _e197;
let _e198 = westRgb;
param_16 = _e198;
let _e199 = eastRgb;
param_17 = _e199;
let _e200 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_13), (¶m_14), (¶m_15), (¶m_16), (¶m_17));
frag_color = vec4<f32>(_e200.x, _e200.y, _e200.z, 1f);
return;
}
let _e205 = v_uv_1;
let _e206 = texel;
let _e208 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e205 - _e206), 0f);
param_18 = _e208.xyz;
let _e210 = Weight_u0028_vf3_u003b((¶m_18));
northWest = _e210;
let _e211 = v_uv_1;
let _e212 = texel;
let _e214 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e211 + _e212), 0f);
param_19 = _e214.xyz;
let _e216 = Weight_u0028_vf3_u003b((¶m_19));
southEast = _e216;
let _e217 = v_uv_1;
let _e219 = texel[0u];
let _e221 = texel[1u];
let _e225 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e217 + vec2<f32>(_e219, -(_e221))), 0f);
param_20 = _e225.xyz;
let _e227 = Weight_u0028_vf3_u003b((¶m_20));
northEast = _e227;
let _e228 = v_uv_1;
let _e230 = texel[0u];
let _e233 = texel[1u];
let _e236 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e228 + vec2<f32>(-(_e230), _e233)), 0f);
param_21 = _e236.xyz;
let _e238 = Weight_u0028_vf3_u003b((¶m_21));
southWest = _e238;
let _e239 = northWest;
let _e240 = southWest;
let _e242 = west;
let _e246 = north;
let _e247 = south;
let _e249 = mid;
let _e255 = northEast;
let _e256 = southEast;
let _e258 = east;
edgeHorizontal = ((abs(((_e239 + _e240) - (2f * _e242))) + (2f * abs(((_e246 + _e247) - (2f * _e249))))) + abs(((_e255 + _e256) - (2f * _e258))));
let _e263 = northWest;
let _e264 = northEast;
let _e266 = north;
let _e270 = west;
let _e271 = east;
let _e273 = mid;
let _e279 = southWest;
let _e280 = southEast;
let _e282 = south;
edgeVertical = ((abs(((_e263 + _e264) - (2f * _e266))) + (2f * abs(((_e270 + _e271) - (2f * _e273))))) + abs(((_e279 + _e280) - (2f * _e282))));
let _e287 = edgeHorizontal;
let _e288 = edgeVertical;
horizontalSpan = (_e287 >= _e288);
let _e290 = north;
let _e291 = south;
let _e293 = west;
let _e295 = east;
let _e298 = northWest;
let _e300 = northEast;
let _e302 = southWest;
let _e304 = southEast;
lowPass = ((((((2f * (((_e290 + _e291) + _e293) + _e295)) + _e298) + _e300) + _e302) + _e304) / 12f);
let _e307 = lowPass;
let _e308 = mid;
let _e311 = contrast;
subpixC = clamp((abs((_e307 - _e308)) / _e311), 0f, 1f);
let _e314 = subpixC;
let _e317 = subpixC;
let _e319 = subpixC;
subpixF = (((3f - (2f * _e314)) * _e317) * _e319);
let _e321 = subpixF;
let _e322 = subpixF;
let _e326 = fxaa_info.params[3u];
subpixH = ((_e321 * _e322) * _e326);
let _e328 = horizontalSpan;
let _e329 = north;
let _e330 = west;
lumaN = select(_e330, _e329, _e328);
let _e332 = horizontalSpan;
let _e333 = south;
let _e334 = east;
lumaS = select(_e334, _e333, _e332);
let _e336 = lumaN;
let _e337 = mid;
gradientN = (_e336 - _e337);
let _e339 = lumaS;
let _e340 = mid;
gradientS = (_e339 - _e340);
let _e342 = gradientN;
let _e344 = gradientS;
pairN = (abs(_e342) >= abs(_e344));
let _e347 = gradientN;
let _e349 = gradientS;
gradient = max(abs(_e347), abs(_e349));
let _e352 = horizontalSpan;
if _e352 {
let _e354 = texel[1u];
local_2 = _e354;
} else {
let _e356 = texel[0u];
local_2 = _e356;
}
let _e357 = local_2;
lengthSign = _e357;
let _e358 = pairN;
if _e358 {
let _e359 = lengthSign;
lengthSign = -(_e359);
}
let _e361 = pairN;
if _e361 {
let _e362 = lumaN;
let _e363 = mid;
local_3 = (_e362 + _e363);
} else {
let _e365 = lumaS;
let _e366 = mid;
local_3 = (_e365 + _e366);
}
let _e368 = local_3;
pairAverage = (0.5f * _e368);
let _e370 = horizontalSpan;
if _e370 {
let _e372 = texel[0u];
local_4 = vec2<f32>(_e372, 0f);
} else {
let _e375 = texel[1u];
local_4 = vec2<f32>(0f, _e375);
}
let _e377 = local_4;
along = _e377;
let _e378 = v_uv_1;
let _e379 = horizontalSpan;
if _e379 {
let _e380 = lengthSign;
local_5 = vec2<f32>(0f, (_e380 * 0.5f));
} else {
let _e383 = lengthSign;
local_5 = vec2<f32>((_e383 * 0.5f), 0f);
}
let _e386 = local_5;
start = (_e378 + _e386);
let _e388 = gradient;
gradientScaled = (_e388 * 0.25f);
let _e390 = start;
let _e391 = along;
posN = (_e390 - _e391);
let _e393 = start;
let _e394 = along;
posP = (_e393 + _e394);
let _e396 = posN;
let _e397 = textureSampleLevel(source_texture_tex, source_texture_smp, _e396, 0f);
param_22 = _e397.xyz;
let _e399 = Weight_u0028_vf3_u003b((¶m_22));
let _e400 = pairAverage;
endN = (_e399 - _e400);
let _e402 = posP;
let _e403 = textureSampleLevel(source_texture_tex, source_texture_smp, _e402, 0f);
param_23 = _e403.xyz;
let _e405 = Weight_u0028_vf3_u003b((¶m_23));
let _e406 = pairAverage;
endP = (_e405 - _e406);
let _e408 = endN;
let _e410 = gradientScaled;
doneN = (abs(_e408) >= _e410);
let _e412 = endP;
let _e414 = gradientScaled;
doneP = (abs(_e412) >= _e414);
i_1 = 1i;
loop {
let _e416 = i_1;
if (_e416 < 5i) {
let _e418 = doneN;
let _e419 = doneP;
if (_e418 && _e419) {
break;
}
let _e421 = i_1;
param_24 = _e421;
let _e422 = SearchStep_u0028_i1_u003b((¶m_24));
stride = _e422;
let _e423 = doneN;
if !(_e423) {
let _e425 = along;
let _e426 = stride;
let _e428 = posN;
posN = (_e428 - (_e425 * _e426));
let _e430 = posN;
let _e431 = textureSampleLevel(source_texture_tex, source_texture_smp, _e430, 0f);
param_25 = _e431.xyz;
let _e433 = Weight_u0028_vf3_u003b((¶m_25));
let _e434 = pairAverage;
endN = (_e433 - _e434);
let _e436 = endN;
let _e438 = gradientScaled;
doneN = (abs(_e436) >= _e438);
}
let _e440 = doneP;
if !(_e440) {
let _e442 = along;
let _e443 = stride;
let _e445 = posP;
posP = (_e445 + (_e442 * _e443));
let _e447 = posP;
let _e448 = textureSampleLevel(source_texture_tex, source_texture_smp, _e447, 0f);
param_26 = _e448.xyz;
let _e450 = Weight_u0028_vf3_u003b((¶m_26));
let _e451 = pairAverage;
endP = (_e450 - _e451);
let _e453 = endP;
let _e455 = gradientScaled;
doneP = (abs(_e453) >= _e455);
}
continue;
} else {
break;
}
continuing {
let _e457 = i_1;
i_1 = (_e457 + 1i);
}
}
let _e459 = horizontalSpan;
if _e459 {
let _e461 = v_uv_1[0u];
let _e463 = posN[0u];
local_6 = (_e461 - _e463);
} else {
let _e466 = v_uv_1[1u];
let _e468 = posN[1u];
local_6 = (_e466 - _e468);
}
let _e470 = local_6;
distanceN = _e470;
let _e471 = horizontalSpan;
if _e471 {
let _e473 = posP[0u];
let _e475 = v_uv_1[0u];
local_7 = (_e473 - _e475);
} else {
let _e478 = posP[1u];
let _e480 = v_uv_1[1u];
local_7 = (_e478 - _e480);
}
let _e482 = local_7;
distanceP = _e482;
let _e483 = mid;
let _e484 = pairAverage;
middleBelow = ((_e483 - _e484) < 0f);
let _e487 = distanceN;
let _e488 = distanceP;
nearerN = (_e487 < _e488);
let _e490 = nearerN;
if _e490 {
let _e491 = endN;
let _e493 = middleBelow;
local_8 = ((_e491 < 0f) != _e493);
} else {
let _e495 = endP;
let _e497 = middleBelow;
local_8 = ((_e495 < 0f) != _e497);
}
let _e499 = local_8;
goodSpan = _e499;
let _e500 = distanceN;
let _e501 = distanceP;
nearest = min(_e500, _e501);
let _e503 = nearest;
let _e504 = distanceN;
let _e505 = distanceP;
pixelOffset = (0.5f - (_e503 / (_e504 + _e505)));
let _e509 = goodSpan;
let _e510 = pixelOffset;
let _e512 = subpixH;
offset = max(select(0f, _e510, _e509), _e512);
let _e514 = v_uv_1;
let _e515 = horizontalSpan;
if _e515 {
let _e516 = offset;
let _e517 = lengthSign;
local_9 = vec2<f32>(0f, (_e516 * _e517));
} else {
let _e520 = offset;
let _e521 = lengthSign;
local_9 = vec2<f32>((_e520 * _e521), 0f);
}
let _e524 = local_9;
at = (_e514 + _e524);
let _e526 = at;
let _e527 = textureSampleLevel(source_texture_tex, source_texture_smp, _e526, 0f);
smoothed = _e527.xyz;
let _e529 = smoothed;
param_27 = _e529;
let _e530 = northRgb;
param_28 = _e530;
let _e531 = southRgb;
param_29 = _e531;
let _e532 = westRgb;
param_30 = _e532;
let _e533 = eastRgb;
param_31 = _e533;
let _e534 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30), (¶m_31));
frag_color = vec4<f32>(_e534.x, _e534.y, _e534.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_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e19 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e19, 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,
),
],
),
'ParticleSixWay': WebGpuStage(
wgsl: r'''
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
struct ContributorLightInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
slots: vec4<f32>,
}
struct SixWayInfo {
right: vec4<f32>,
up: vec4<f32>,
forward: vec4<f32>,
emission: vec4<f32>,
ambient: vec4<f32>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var light_list_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contributor_light_info: ContributorLightInfo;
@group(1) @binding(3)
var<uniform> six_way_info: SixWayInfo;
@group(1) @binding(8)
var six_way_positive_tex: texture_2d<f32>;
@group(1) @binding(9)
var six_way_positive_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(6)
var six_way_negative_tex: texture_2d<f32>;
@group(1) @binding(7)
var six_way_negative_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
fn SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b(l: ptr<function, vec3<f32>>, positive: ptr<function, vec3<f32>>, negative: ptr<function, vec3<f32>>) -> f32 {
var x: f32;
var y: f32;
var z: f32;
var local: f32;
var local_1: f32;
var local_2: f32;
let _e53 = (*l);
let _e55 = six_way_info.right;
x = dot(_e53, _e55.xyz);
let _e58 = (*l);
let _e60 = six_way_info.up;
y = dot(_e58, _e60.xyz);
let _e63 = (*l);
let _e65 = six_way_info.forward;
z = dot(_e63, _e65.xyz);
let _e68 = x;
let _e69 = x;
let _e71 = x;
if (_e71 > 0f) {
let _e74 = (*positive)[0u];
local = _e74;
} else {
let _e76 = (*negative)[0u];
local = _e76;
}
let _e77 = local;
let _e79 = y;
let _e80 = y;
let _e82 = y;
if (_e82 > 0f) {
let _e85 = (*positive)[1u];
local_1 = _e85;
} else {
let _e87 = (*negative)[1u];
local_1 = _e87;
}
let _e88 = local_1;
let _e91 = z;
let _e92 = z;
let _e94 = z;
if (_e94 > 0f) {
let _e97 = (*positive)[2u];
local_2 = _e97;
} else {
let _e99 = (*negative)[2u];
local_2 = _e99;
}
let _e100 = local_2;
return ((((_e68 * _e69) * _e77) + ((_e79 * _e80) * _e88)) + ((_e91 * _e92) * _e100));
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot: ptr<function, i32>) -> f32 {
var lane: i32;
var local_3: f32;
var local_4: f32;
var local_5: f32;
let _e50 = (*slot);
let _e51 = (*slot);
lane = (_e50 - ((_e51 / 4i) * 4i));
let _e55 = lane;
if (_e55 == 0i) {
let _e58 = (*four)[0u];
local_3 = _e58;
} else {
let _e59 = lane;
if (_e59 == 1i) {
let _e62 = (*four)[1u];
local_4 = _e62;
} else {
let _e63 = lane;
if (_e63 == 2i) {
let _e66 = (*four)[2u];
local_5 = _e66;
} else {
let _e68 = (*four)[3u];
local_5 = _e68;
}
let _e69 = local_5;
local_4 = _e69;
}
let _e70 = local_4;
local_3 = _e70;
}
let _e71 = local_3;
return _e71;
}
fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
var param: vec4<f32>;
var param_1: i32;
let _e47 = (*slot_1);
let _e51 = light_list_info.scales[(_e47 / 4i)];
param = _e51;
let _e52 = (*slot_1);
param_1 = _e52;
let _e53 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m), (¶m_1));
return _e53;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a: vec4<f32>;
var b: vec4<f32>;
let _e49 = light_list_info.slot_rows[0i];
let _e50 = (*row);
a = abs((_e49 - vec4(_e50)));
let _e56 = light_list_info.slot_rows[1i];
let _e57 = (*row);
b = abs((_e56 - vec4(_e57)));
let _e62 = a[0u];
let _e64 = a[1u];
let _e67 = a[2u];
let _e69 = a[3u];
let _e73 = b[0u];
let _e75 = b[1u];
let _e78 = b[2u];
let _e80 = b[3u];
return (min(min(min(_e62, _e64), min(_e67, _e69)), min(min(_e73, _e75), min(_e78, _e80))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_2: vec4<f32>;
var param_3: i32;
let _e47 = (*slot_2);
let _e51 = light_list_info.indices[(_e47 / 4i)];
param_2 = _e51;
let _e52 = (*slot_2);
param_3 = _e52;
let _e53 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_2), (¶m_3));
return _e53;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e46 = (*texel);
let _e50 = light_list_info.list[1u];
let _e52 = (*row_1);
let _e56 = light_list_info.list[2u];
let _e59 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e46 + 0.5f) * _e50), ((_e52 + 0.5f) * _e56)), 0f);
return _e59;
}
fn ClusterRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var entry: f32;
var row_2: f32;
var within: f32;
var texel_1: f32;
var four_1: vec4<f32>;
var param_4: f32;
var param_5: f32;
var param_6: vec4<f32>;
var param_7: i32;
let _e54 = g_cluster_offset;
let _e55 = (*slot_3);
entry = (_e54 + f32(_e55));
let _e58 = entry;
row_2 = floor((_e58 / 16f));
let _e61 = entry;
let _e62 = row_2;
within = (_e61 - (_e62 * 16f));
let _e65 = within;
texel_1 = floor((_e65 / 4f));
let _e70 = light_list_info.cluster_depth[3u];
let _e71 = row_2;
let _e73 = texel_1;
param_4 = _e73;
param_5 = (_e70 + _e71);
let _e74 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_4), (¶m_5));
four_1 = _e74;
let _e75 = within;
let _e76 = texel_1;
let _e81 = four_1;
param_6 = _e81;
param_7 = i32(((_e75 - (_e76 * 4f)) + 0.5f));
let _e82 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_6), (¶m_7));
return _e82;
}
fn Clustered_u0028_() -> bool {
let _e46 = light_list_info.cluster_grid[3u];
return (_e46 > 0.5f);
}
fn ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b(index: ptr<function, i32>, world: ptr<function, vec3<f32>>, toLight: ptr<function, vec3<f32>>, radiance: ptr<function, vec3<f32>>) {
var position: vec4<f32>;
var color: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var clustered: bool;
var listRow: f32;
var local_6: f32;
var param_8: i32;
var param_9: i32;
var v: f32;
var u: f32;
var local_7: f32;
var param_10: f32;
var param_11: i32;
var type_30: f32;
var directional: bool;
var offset: vec3<f32>;
var distance_: f32;
var aim: vec3<f32>;
var degenerate: bool;
var local_8: vec3<f32>;
var ratio: f32;
var local_9: f32;
var window: f32;
var falloff: f32;
var spot: bool;
var ramp: f32;
var local_10: f32;
var attenuation: f32;
var local_11: f32;
var local_12: f32;
let _e80 = (*index);
if (_e80 < 8i) {
let _e82 = (*index);
let _e85 = contributor_light_info.light_position[_e82];
position = _e85;
let _e86 = (*index);
let _e89 = contributor_light_info.light_color[_e86];
color = _e89;
let _e90 = (*index);
let _e93 = contributor_light_info.light_direction[_e90];
direction = _e93;
let _e94 = (*index);
let _e97 = contributor_light_info.light_cone[_e94];
cone = _e97;
} else {
let _e98 = (*index);
slot_4 = (_e98 - 8i);
let _e100 = Clustered_u0028_();
clustered = _e100;
let _e101 = clustered;
if _e101 {
let _e102 = slot_4;
param_8 = _e102;
let _e103 = ClusterRow_u0028_i1_u003b((¶m_8));
local_6 = _e103;
} else {
let _e104 = slot_4;
param_9 = _e104;
let _e105 = LightListRow_u0028_i1_u003b((¶m_9));
local_6 = _e105;
}
let _e106 = local_6;
listRow = _e106;
let _e107 = listRow;
let _e111 = light_list_info.list[2u];
v = ((_e107 + 0.5f) * _e111);
let _e115 = light_list_info.list[1u];
u = _e115;
let _e116 = u;
let _e118 = v;
let _e120 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e116), _e118), 0f);
position = _e120;
let _e121 = u;
let _e123 = v;
let _e125 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e121), _e123), 0f);
color = _e125;
let _e126 = u;
let _e128 = v;
let _e130 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e126), _e128), 0f);
direction = _e130;
let _e131 = u;
let _e133 = v;
let _e135 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e131), _e133), 0f);
cone = _e135;
let _e136 = clustered;
if _e136 {
let _e137 = listRow;
param_10 = _e137;
let _e138 = InSlots_u0028_f1_u003b((¶m_10));
local_7 = select(1f, 0f, _e138);
} else {
let _e140 = slot_4;
param_11 = _e140;
let _e141 = LightListScale_u0028_i1_u003b((¶m_11));
local_7 = _e141;
}
let _e142 = local_7;
let _e144 = color[3u];
color[3u] = (_e144 * _e142);
}
let _e148 = position[3u];
type_30 = _e148;
let _e149 = type_30;
directional = (_e149 < 0.5f);
let _e151 = position;
let _e153 = (*world);
offset = (_e151.xyz - _e153);
let _e155 = offset;
distance_ = length(_e155);
let _e157 = direction;
aim = normalize(_e157.xyz);
let _e160 = directional;
let _e162 = distance_;
degenerate = (!(_e160) && (_e162 < 0.000001f));
let _e165 = directional;
if _e165 {
let _e166 = aim;
local_8 = -(_e166);
} else {
let _e168 = offset;
let _e169 = distance_;
local_8 = (_e168 / vec3(max(_e169, 0.000001f)));
}
let _e173 = local_8;
(*toLight) = _e173;
let _e175 = direction[3u];
if (_e175 > 0f) {
let _e177 = distance_;
let _e179 = direction[3u];
local_9 = (_e177 / _e179);
} else {
local_9 = 0f;
}
let _e181 = local_9;
ratio = _e181;
let _e182 = ratio;
let _e183 = ratio;
let _e185 = ratio;
let _e187 = ratio;
window = clamp((1f - (((_e182 * _e183) * _e185) * _e187)), 0f, 1f);
let _e191 = window;
let _e192 = window;
let _e194 = distance_;
let _e195 = distance_;
falloff = ((_e191 * _e192) / max((_e194 * _e195), 0.0001f));
let _e199 = type_30;
let _e201 = type_30;
spot = ((_e199 > 1.5f) && (_e201 < 2.5f));
let _e204 = spot;
if _e204 {
let _e205 = aim;
let _e206 = (*toLight);
let _e210 = cone[1u];
let _e213 = cone[0u];
let _e215 = cone[1u];
local_10 = clamp(((dot(_e205, -(_e206)) - _e210) / max((_e213 - _e215), 0.0001f)), 0f, 1f);
} else {
local_10 = 1f;
}
let _e220 = local_10;
ramp = _e220;
let _e221 = directional;
if _e221 {
local_11 = 1f;
} else {
let _e222 = degenerate;
if _e222 {
local_12 = 0f;
} else {
let _e223 = falloff;
let _e224 = ramp;
local_12 = (_e223 * _e224);
}
let _e226 = local_12;
local_11 = _e226;
}
let _e227 = local_11;
attenuation = _e227;
let _e228 = color;
let _e231 = color[3u];
let _e233 = attenuation;
(*radiance) = ((_e228.xyz * _e231) * _e233);
return;
}
fn FindCluster_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) {
var clip: vec4<f32>;
var ndc: vec2<f32>;
var grid: vec3<f32>;
var near: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_13: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_12: f32;
var param_13: f32;
let _e59 = light_list_info.cluster_view_projection;
let _e60 = (*world_1);
clip = (_e59 * vec4<f32>(_e60.x, _e60.y, _e60.z, 1f));
let _e66 = clip;
let _e69 = clip[3u];
ndc = (_e66.xy / vec2(max(_e69, 0.000001f)));
let _e74 = light_list_info.cluster_grid;
grid = _e74.xyz;
let _e78 = light_list_info.cluster_depth[0u];
near = _e78;
let _e80 = ndc[0u];
let _e84 = grid[0u];
let _e88 = grid[0u];
tx = clamp(floor((((_e80 * 0.5f) + 0.5f) * _e84)), 0f, (_e88 - 1f));
let _e92 = ndc[1u];
let _e96 = grid[1u];
let _e100 = grid[1u];
ty = clamp(floor((((_e92 * 0.5f) + 0.5f) * _e96)), 0f, (_e100 - 1f));
let _e104 = clip[3u];
let _e105 = near;
if (_e104 <= _e105) {
local_13 = 0f;
} else {
let _e108 = clip[3u];
let _e109 = near;
let _e114 = light_list_info.cluster_depth[1u];
let _e118 = grid[2u];
local_13 = clamp(floor((log((_e108 / _e109)) * _e114)), 0f, (_e118 - 1f));
}
let _e121 = local_13;
tz = _e121;
let _e122 = tx;
let _e123 = ty;
let _e125 = grid[0u];
let _e128 = tz;
let _e130 = grid[0u];
let _e133 = grid[1u];
cell = ((_e122 + (_e123 * _e125)) + ((_e128 * _e130) * _e133));
let _e136 = cell;
row_3 = floor((_e136 / 4f));
let _e139 = cell;
let _e140 = row_3;
let _e145 = light_list_info.cluster_depth[2u];
let _e146 = row_3;
param_12 = (_e139 - (_e140 * 4f));
param_13 = (_e145 + _e146);
let _e148 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_12), (¶m_13));
header = _e148;
let _e150 = header[0u];
g_cluster_offset = _e150;
let _e152 = header[1u];
g_cluster_count = _e152;
return;
}
fn ContributorLightCount_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) -> i32 {
var tail: f32;
var param_14: vec3<f32>;
let _e49 = light_list_info.list[0u];
tail = _e49;
let _e50 = Clustered_u0028_();
if _e50 {
let _e51 = (*world_2);
param_14 = _e51;
FindCluster_u0028_vf3_u003b((¶m_14));
let _e52 = g_cluster_count;
tail = _e52;
}
let _e55 = contributor_light_info.slots[0u];
let _e59 = tail;
return (clamp(i32((_e55 + 0.5f)), 0i, 8i) + clamp(i32((_e59 + 0.5f)), 0i, 24i));
}
fn main_1() {
var positive_1: vec4<f32>;
var negative_1: vec4<f32>;
var lit: vec3<f32>;
var count: i32;
var param_15: vec3<f32>;
var i: i32;
var l_1: vec3<f32>;
var radiance_1: vec3<f32>;
var param_16: i32;
var param_17: vec3<f32>;
var param_18: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec3<f32>;
var param_21: vec3<f32>;
var param_22: vec3<f32>;
var mean: f32;
var color_1: vec3<f32>;
var fogged: f32;
var coverage: f32;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e63 = v_uv_1;
let _e64 = textureSample(six_way_positive_tex, six_way_positive_smp, _e63);
positive_1 = _e64;
let _e65 = v_uv_1;
let _e66 = textureSample(six_way_negative_tex, six_way_negative_smp, _e65);
negative_1 = _e66;
lit = vec3<f32>(0f, 0f, 0f);
let _e67 = v_world_position_1;
param_15 = _e67;
let _e68 = ContributorLightCount_u0028_vf3_u003b((¶m_15));
count = _e68;
i = 0i;
loop {
let _e69 = i;
if (_e69 < 32i) {
let _e71 = i;
let _e72 = count;
if (_e71 >= _e72) {
break;
}
let _e74 = i;
param_16 = _e74;
let _e75 = v_world_position_1;
param_17 = _e75;
ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
let _e76 = param_18;
l_1 = _e76;
let _e77 = param_19;
radiance_1 = _e77;
let _e78 = radiance_1;
let _e79 = l_1;
param_20 = _e79;
let _e80 = positive_1;
param_21 = _e80.xyz;
let _e82 = negative_1;
param_22 = _e82.xyz;
let _e84 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_20), (¶m_21), (¶m_22));
let _e86 = lit;
lit = (_e86 + (_e78 * _e84));
continue;
} else {
break;
}
continuing {
let _e88 = i;
i = (_e88 + 1i);
}
}
let _e91 = positive_1[0u];
let _e93 = positive_1[1u];
let _e96 = positive_1[2u];
let _e99 = negative_1[0u];
let _e102 = negative_1[1u];
let _e105 = negative_1[2u];
mean = ((((((_e91 + _e93) + _e96) + _e99) + _e102) + _e105) / 6f);
let _e108 = v_color_1;
let _e110 = lit;
let _e112 = six_way_info.ambient;
let _e114 = mean;
let _e119 = six_way_info.emission;
let _e122 = negative_1[3u];
color_1 = ((_e108.xyz * (_e110 + (_e112.xyz * _e114))) + (_e119.xyz * _e122));
fogged = 1f;
let _e127 = fog_info.fog[3u];
if (_e127 > 0f) {
let _e131 = fog_info.fog[3u];
let _e133 = v_world_position_1;
let _e135 = fog_info.eye;
fogged = clamp(exp((-(_e131) * distance(_e133, _e135.xyz))), 0f, 1f);
}
let _e142 = fog_info.fog;
let _e144 = color_1;
let _e145 = fogged;
color_1 = mix(_e142.xyz, _e144, vec3(_e145));
let _e149 = v_color_1[3u];
let _e151 = positive_1[3u];
coverage = clamp((_e149 * _e151), 0f, 1f);
let _e154 = color_1;
let _e155 = coverage;
let _e156 = (_e154 * _e155);
let _e157 = coverage;
frag_color = vec4<f32>(_e156.x, _e156.y, _e156.z, _e157);
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: 'ContributorLightInfo',
group: 1,
binding: 0,
sizeInBytes: 528,
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: 'slots',
offsetInBytes: 512,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 1,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'SixWayInfo',
group: 1,
binding: 3,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'right', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'up', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emission',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'six_way_negative',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'six_way_positive',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ParticleSoft': WebGpuStage(
wgsl: r'''
struct SoftParticleInfo {
target_: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(2)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var scene_depth_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> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e21 = (*rows);
if (_e21 > 0f) {
let _e24 = gl_FragCoord_1[0u];
let _e25 = (*rows);
let _e27 = gl_FragCoord_1[1u];
local = vec2<f32>(_e24, (_e25 - _e27));
} else {
let _e30 = gl_FragCoord_1;
local = _e30.xy;
}
let _e32 = local;
return _e32;
}
fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var depth: f32;
var fade: f32;
let _e27 = soft_particle_info.target_[2u];
param = _e27;
let _e28 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e30 = soft_particle_info.target_;
uv = (_e28 * _e30.xy);
let _e33 = uv;
let _e34 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e33, 0f);
stored = _e34.w;
let _e36 = (*world);
let _e38 = soft_particle_info.eye;
let _e42 = soft_particle_info.forward;
depth = dot((_e36 - _e38.xyz), _e42.xyz);
let _e45 = stored;
let _e46 = depth;
let _e50 = soft_particle_info.target_[3u];
fade = clamp(((_e45 - _e46) * _e50), 0f, 1f);
let _e53 = stored;
let _e55 = fade;
return select(1f, _e55, (_e53 > 0f));
}
fn main_1() {
var centred: vec2<f32>;
var radius: f32;
var falloff: f32;
var intensity: f32;
var fogged: f32;
var param_1: vec3<f32>;
let _e25 = v_uv_1;
centred = ((_e25 * 2f) - vec2(1f));
let _e29 = centred;
radius = length(_e29);
let _e31 = radius;
falloff = (1f - smoothstep(0f, 1f, _e31));
let _e34 = falloff;
let _e35 = falloff;
intensity = (_e34 * _e35);
fogged = 1f;
let _e39 = fog_info.fog[3u];
if (_e39 > 0f) {
let _e43 = fog_info.fog[3u];
let _e45 = v_world_position_1;
let _e47 = fog_info.eye;
fogged = clamp(exp((-(_e43) * distance(_e45, _e47.xyz))), 0f, 1f);
}
let _e53 = v_world_position_1;
param_1 = _e53;
let _e54 = SoftParticleFade_u0028_vf3_u003b((¶m_1));
let _e55 = intensity;
intensity = (_e55 * _e54);
let _e57 = v_color_1;
let _e60 = v_color_1[3u];
let _e62 = intensity;
let _e64 = fogged;
let _e65 = (((_e57.xyz * _e60) * _e62) * _e64);
frag_color = vec4<f32>(_e65.x, _e65.y, _e65.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
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),
],
),
WebGpuBlock(
name: 'SoftParticleInfo',
group: 1,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_depth_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ParticleTexturedSoft': WebGpuStage(
wgsl: r'''
struct SoftParticleInfo {
target_: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(4)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var scene_depth_texture_smp: sampler;
@group(1) @binding(2)
var particle_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
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 FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e22 = (*rows);
if (_e22 > 0f) {
let _e25 = gl_FragCoord_1[0u];
let _e26 = (*rows);
let _e28 = gl_FragCoord_1[1u];
local = vec2<f32>(_e25, (_e26 - _e28));
} else {
let _e31 = gl_FragCoord_1;
local = _e31.xy;
}
let _e33 = local;
return _e33;
}
fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var depth: f32;
var fade: f32;
let _e28 = soft_particle_info.target_[2u];
param = _e28;
let _e29 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e31 = soft_particle_info.target_;
uv = (_e29 * _e31.xy);
let _e34 = uv;
let _e35 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e34, 0f);
stored = _e35.w;
let _e37 = (*world);
let _e39 = soft_particle_info.eye;
let _e43 = soft_particle_info.forward;
depth = dot((_e37 - _e39.xyz), _e43.xyz);
let _e46 = stored;
let _e47 = depth;
let _e51 = soft_particle_info.target_[3u];
fade = clamp(((_e46 - _e47) * _e51), 0f, 1f);
let _e54 = stored;
let _e56 = fade;
return select(1f, _e56, (_e54 > 0f));
}
fn main_1() {
var texel: vec4<f32>;
var fogged: f32;
var scale: f32;
var param_1: vec3<f32>;
let _e24 = v_uv_1;
let _e25 = textureSample(particle_texture_tex, particle_texture_smp, _e24);
texel = _e25;
fogged = 1f;
let _e28 = fog_info.fog[3u];
if (_e28 > 0f) {
let _e32 = fog_info.fog[3u];
let _e34 = v_world_position_1;
let _e36 = fog_info.eye;
fogged = clamp(exp((-(_e32) * distance(_e34, _e36.xyz))), 0f, 1f);
}
let _e43 = v_color_1[3u];
let _e45 = texel[3u];
let _e47 = fogged;
scale = ((_e43 * _e45) * _e47);
let _e49 = v_world_position_1;
param_1 = _e49;
let _e50 = SoftParticleFade_u0028_vf3_u003b((¶m_1));
let _e51 = scale;
scale = (_e51 * _e50);
let _e53 = v_color_1;
let _e55 = texel;
let _e58 = scale;
let _e59 = ((_e53.xyz * _e55.xyz) * _e58);
frag_color = vec4<f32>(_e59.x, _e59.y, _e59.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
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),
],
),
WebGpuBlock(
name: 'SoftParticleInfo',
group: 1,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'particle_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_depth_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ParticleSixWaySoft': WebGpuStage(
wgsl: r'''
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
struct ContributorLightInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
slots: vec4<f32>,
}
struct SoftParticleInfo {
target_: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct SixWayInfo {
right: vec4<f32>,
up: vec4<f32>,
forward: vec4<f32>,
emission: vec4<f32>,
ambient: vec4<f32>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(5)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var light_list_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contributor_light_info: ContributorLightInfo;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(7)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_depth_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> six_way_info: SixWayInfo;
@group(1) @binding(11)
var six_way_positive_tex: texture_2d<f32>;
@group(1) @binding(12)
var six_way_positive_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var six_way_negative_tex: texture_2d<f32>;
@group(1) @binding(10)
var six_way_negative_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e50 = (*rows);
if (_e50 > 0f) {
let _e53 = gl_FragCoord_1[0u];
let _e54 = (*rows);
let _e56 = gl_FragCoord_1[1u];
local = vec2<f32>(_e53, (_e54 - _e56));
} else {
let _e59 = gl_FragCoord_1;
local = _e59.xy;
}
let _e61 = local;
return _e61;
}
fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var depth: f32;
var fade: f32;
let _e56 = soft_particle_info.target_[2u];
param = _e56;
let _e57 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e59 = soft_particle_info.target_;
uv = (_e57 * _e59.xy);
let _e62 = uv;
let _e63 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e62, 0f);
stored = _e63.w;
let _e65 = (*world);
let _e67 = soft_particle_info.eye;
let _e71 = soft_particle_info.forward;
depth = dot((_e65 - _e67.xyz), _e71.xyz);
let _e74 = stored;
let _e75 = depth;
let _e79 = soft_particle_info.target_[3u];
fade = clamp(((_e74 - _e75) * _e79), 0f, 1f);
let _e82 = stored;
let _e84 = fade;
return select(1f, _e84, (_e82 > 0f));
}
fn SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b(l: ptr<function, vec3<f32>>, positive: ptr<function, vec3<f32>>, negative: ptr<function, vec3<f32>>) -> f32 {
var x: f32;
var y: f32;
var z: f32;
var local_1: f32;
var local_2: f32;
var local_3: f32;
let _e57 = (*l);
let _e59 = six_way_info.right;
x = dot(_e57, _e59.xyz);
let _e62 = (*l);
let _e64 = six_way_info.up;
y = dot(_e62, _e64.xyz);
let _e67 = (*l);
let _e69 = six_way_info.forward;
z = dot(_e67, _e69.xyz);
let _e72 = x;
let _e73 = x;
let _e75 = x;
if (_e75 > 0f) {
let _e78 = (*positive)[0u];
local_1 = _e78;
} else {
let _e80 = (*negative)[0u];
local_1 = _e80;
}
let _e81 = local_1;
let _e83 = y;
let _e84 = y;
let _e86 = y;
if (_e86 > 0f) {
let _e89 = (*positive)[1u];
local_2 = _e89;
} else {
let _e91 = (*negative)[1u];
local_2 = _e91;
}
let _e92 = local_2;
let _e95 = z;
let _e96 = z;
let _e98 = z;
if (_e98 > 0f) {
let _e101 = (*positive)[2u];
local_3 = _e101;
} else {
let _e103 = (*negative)[2u];
local_3 = _e103;
}
let _e104 = local_3;
return ((((_e72 * _e73) * _e81) + ((_e83 * _e84) * _e92)) + ((_e95 * _e96) * _e104));
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot: ptr<function, i32>) -> f32 {
var lane: i32;
var local_4: f32;
var local_5: f32;
var local_6: f32;
let _e54 = (*slot);
let _e55 = (*slot);
lane = (_e54 - ((_e55 / 4i) * 4i));
let _e59 = lane;
if (_e59 == 0i) {
let _e62 = (*four)[0u];
local_4 = _e62;
} else {
let _e63 = lane;
if (_e63 == 1i) {
let _e66 = (*four)[1u];
local_5 = _e66;
} else {
let _e67 = lane;
if (_e67 == 2i) {
let _e70 = (*four)[2u];
local_6 = _e70;
} else {
let _e72 = (*four)[3u];
local_6 = _e72;
}
let _e73 = local_6;
local_5 = _e73;
}
let _e74 = local_5;
local_4 = _e74;
}
let _e75 = local_4;
return _e75;
}
fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
var param_1: vec4<f32>;
var param_2: i32;
let _e51 = (*slot_1);
let _e55 = light_list_info.scales[(_e51 / 4i)];
param_1 = _e55;
let _e56 = (*slot_1);
param_2 = _e56;
let _e57 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_1), (¶m_2));
return _e57;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a: vec4<f32>;
var b: vec4<f32>;
let _e53 = light_list_info.slot_rows[0i];
let _e54 = (*row);
a = abs((_e53 - vec4(_e54)));
let _e60 = light_list_info.slot_rows[1i];
let _e61 = (*row);
b = abs((_e60 - vec4(_e61)));
let _e66 = a[0u];
let _e68 = a[1u];
let _e71 = a[2u];
let _e73 = a[3u];
let _e77 = b[0u];
let _e79 = b[1u];
let _e82 = b[2u];
let _e84 = b[3u];
return (min(min(min(_e66, _e68), min(_e71, _e73)), min(min(_e77, _e79), min(_e82, _e84))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_3: vec4<f32>;
var param_4: i32;
let _e51 = (*slot_2);
let _e55 = light_list_info.indices[(_e51 / 4i)];
param_3 = _e55;
let _e56 = (*slot_2);
param_4 = _e56;
let _e57 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_3), (¶m_4));
return _e57;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e50 = (*texel);
let _e54 = light_list_info.list[1u];
let _e56 = (*row_1);
let _e60 = light_list_info.list[2u];
let _e63 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e50 + 0.5f) * _e54), ((_e56 + 0.5f) * _e60)), 0f);
return _e63;
}
fn ClusterRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var entry: f32;
var row_2: f32;
var within: f32;
var texel_1: f32;
var four_1: vec4<f32>;
var param_5: f32;
var param_6: f32;
var param_7: vec4<f32>;
var param_8: i32;
let _e58 = g_cluster_offset;
let _e59 = (*slot_3);
entry = (_e58 + f32(_e59));
let _e62 = entry;
row_2 = floor((_e62 / 16f));
let _e65 = entry;
let _e66 = row_2;
within = (_e65 - (_e66 * 16f));
let _e69 = within;
texel_1 = floor((_e69 / 4f));
let _e74 = light_list_info.cluster_depth[3u];
let _e75 = row_2;
let _e77 = texel_1;
param_5 = _e77;
param_6 = (_e74 + _e75);
let _e78 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_5), (¶m_6));
four_1 = _e78;
let _e79 = within;
let _e80 = texel_1;
let _e85 = four_1;
param_7 = _e85;
param_8 = i32(((_e79 - (_e80 * 4f)) + 0.5f));
let _e86 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_7), (¶m_8));
return _e86;
}
fn Clustered_u0028_() -> bool {
let _e50 = light_list_info.cluster_grid[3u];
return (_e50 > 0.5f);
}
fn ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b(index: ptr<function, i32>, world_1: ptr<function, vec3<f32>>, toLight: ptr<function, vec3<f32>>, radiance: ptr<function, vec3<f32>>) {
var position: vec4<f32>;
var color: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var clustered: bool;
var listRow: f32;
var local_7: f32;
var param_9: i32;
var param_10: i32;
var v: f32;
var u: f32;
var local_8: f32;
var param_11: f32;
var param_12: i32;
var type_31: f32;
var directional: bool;
var offset: vec3<f32>;
var distance_: f32;
var aim: vec3<f32>;
var degenerate: bool;
var local_9: vec3<f32>;
var ratio: f32;
var local_10: f32;
var window: f32;
var falloff: f32;
var spot: bool;
var ramp: f32;
var local_11: f32;
var attenuation: f32;
var local_12: f32;
var local_13: f32;
let _e84 = (*index);
if (_e84 < 8i) {
let _e86 = (*index);
let _e89 = contributor_light_info.light_position[_e86];
position = _e89;
let _e90 = (*index);
let _e93 = contributor_light_info.light_color[_e90];
color = _e93;
let _e94 = (*index);
let _e97 = contributor_light_info.light_direction[_e94];
direction = _e97;
let _e98 = (*index);
let _e101 = contributor_light_info.light_cone[_e98];
cone = _e101;
} else {
let _e102 = (*index);
slot_4 = (_e102 - 8i);
let _e104 = Clustered_u0028_();
clustered = _e104;
let _e105 = clustered;
if _e105 {
let _e106 = slot_4;
param_9 = _e106;
let _e107 = ClusterRow_u0028_i1_u003b((¶m_9));
local_7 = _e107;
} else {
let _e108 = slot_4;
param_10 = _e108;
let _e109 = LightListRow_u0028_i1_u003b((¶m_10));
local_7 = _e109;
}
let _e110 = local_7;
listRow = _e110;
let _e111 = listRow;
let _e115 = light_list_info.list[2u];
v = ((_e111 + 0.5f) * _e115);
let _e119 = light_list_info.list[1u];
u = _e119;
let _e120 = u;
let _e122 = v;
let _e124 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e120), _e122), 0f);
position = _e124;
let _e125 = u;
let _e127 = v;
let _e129 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e125), _e127), 0f);
color = _e129;
let _e130 = u;
let _e132 = v;
let _e134 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e130), _e132), 0f);
direction = _e134;
let _e135 = u;
let _e137 = v;
let _e139 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e135), _e137), 0f);
cone = _e139;
let _e140 = clustered;
if _e140 {
let _e141 = listRow;
param_11 = _e141;
let _e142 = InSlots_u0028_f1_u003b((¶m_11));
local_8 = select(1f, 0f, _e142);
} else {
let _e144 = slot_4;
param_12 = _e144;
let _e145 = LightListScale_u0028_i1_u003b((¶m_12));
local_8 = _e145;
}
let _e146 = local_8;
let _e148 = color[3u];
color[3u] = (_e148 * _e146);
}
let _e152 = position[3u];
type_31 = _e152;
let _e153 = type_31;
directional = (_e153 < 0.5f);
let _e155 = position;
let _e157 = (*world_1);
offset = (_e155.xyz - _e157);
let _e159 = offset;
distance_ = length(_e159);
let _e161 = direction;
aim = normalize(_e161.xyz);
let _e164 = directional;
let _e166 = distance_;
degenerate = (!(_e164) && (_e166 < 0.000001f));
let _e169 = directional;
if _e169 {
let _e170 = aim;
local_9 = -(_e170);
} else {
let _e172 = offset;
let _e173 = distance_;
local_9 = (_e172 / vec3(max(_e173, 0.000001f)));
}
let _e177 = local_9;
(*toLight) = _e177;
let _e179 = direction[3u];
if (_e179 > 0f) {
let _e181 = distance_;
let _e183 = direction[3u];
local_10 = (_e181 / _e183);
} else {
local_10 = 0f;
}
let _e185 = local_10;
ratio = _e185;
let _e186 = ratio;
let _e187 = ratio;
let _e189 = ratio;
let _e191 = ratio;
window = clamp((1f - (((_e186 * _e187) * _e189) * _e191)), 0f, 1f);
let _e195 = window;
let _e196 = window;
let _e198 = distance_;
let _e199 = distance_;
falloff = ((_e195 * _e196) / max((_e198 * _e199), 0.0001f));
let _e203 = type_31;
let _e205 = type_31;
spot = ((_e203 > 1.5f) && (_e205 < 2.5f));
let _e208 = spot;
if _e208 {
let _e209 = aim;
let _e210 = (*toLight);
let _e214 = cone[1u];
let _e217 = cone[0u];
let _e219 = cone[1u];
local_11 = clamp(((dot(_e209, -(_e210)) - _e214) / max((_e217 - _e219), 0.0001f)), 0f, 1f);
} else {
local_11 = 1f;
}
let _e224 = local_11;
ramp = _e224;
let _e225 = directional;
if _e225 {
local_12 = 1f;
} else {
let _e226 = degenerate;
if _e226 {
local_13 = 0f;
} else {
let _e227 = falloff;
let _e228 = ramp;
local_13 = (_e227 * _e228);
}
let _e230 = local_13;
local_12 = _e230;
}
let _e231 = local_12;
attenuation = _e231;
let _e232 = color;
let _e235 = color[3u];
let _e237 = attenuation;
(*radiance) = ((_e232.xyz * _e235) * _e237);
return;
}
fn FindCluster_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) {
var clip: vec4<f32>;
var ndc: vec2<f32>;
var grid: vec3<f32>;
var near: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_14: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_13: f32;
var param_14: f32;
let _e63 = light_list_info.cluster_view_projection;
let _e64 = (*world_2);
clip = (_e63 * vec4<f32>(_e64.x, _e64.y, _e64.z, 1f));
let _e70 = clip;
let _e73 = clip[3u];
ndc = (_e70.xy / vec2(max(_e73, 0.000001f)));
let _e78 = light_list_info.cluster_grid;
grid = _e78.xyz;
let _e82 = light_list_info.cluster_depth[0u];
near = _e82;
let _e84 = ndc[0u];
let _e88 = grid[0u];
let _e92 = grid[0u];
tx = clamp(floor((((_e84 * 0.5f) + 0.5f) * _e88)), 0f, (_e92 - 1f));
let _e96 = ndc[1u];
let _e100 = grid[1u];
let _e104 = grid[1u];
ty = clamp(floor((((_e96 * 0.5f) + 0.5f) * _e100)), 0f, (_e104 - 1f));
let _e108 = clip[3u];
let _e109 = near;
if (_e108 <= _e109) {
local_14 = 0f;
} else {
let _e112 = clip[3u];
let _e113 = near;
let _e118 = light_list_info.cluster_depth[1u];
let _e122 = grid[2u];
local_14 = clamp(floor((log((_e112 / _e113)) * _e118)), 0f, (_e122 - 1f));
}
let _e125 = local_14;
tz = _e125;
let _e126 = tx;
let _e127 = ty;
let _e129 = grid[0u];
let _e132 = tz;
let _e134 = grid[0u];
let _e137 = grid[1u];
cell = ((_e126 + (_e127 * _e129)) + ((_e132 * _e134) * _e137));
let _e140 = cell;
row_3 = floor((_e140 / 4f));
let _e143 = cell;
let _e144 = row_3;
let _e149 = light_list_info.cluster_depth[2u];
let _e150 = row_3;
param_13 = (_e143 - (_e144 * 4f));
param_14 = (_e149 + _e150);
let _e152 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_13), (¶m_14));
header = _e152;
let _e154 = header[0u];
g_cluster_offset = _e154;
let _e156 = header[1u];
g_cluster_count = _e156;
return;
}
fn ContributorLightCount_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) -> i32 {
var tail: f32;
var param_15: vec3<f32>;
let _e53 = light_list_info.list[0u];
tail = _e53;
let _e54 = Clustered_u0028_();
if _e54 {
let _e55 = (*world_3);
param_15 = _e55;
FindCluster_u0028_vf3_u003b((¶m_15));
let _e56 = g_cluster_count;
tail = _e56;
}
let _e59 = contributor_light_info.slots[0u];
let _e63 = tail;
return (clamp(i32((_e59 + 0.5f)), 0i, 8i) + clamp(i32((_e63 + 0.5f)), 0i, 24i));
}
fn main_1() {
var positive_1: vec4<f32>;
var negative_1: vec4<f32>;
var lit: vec3<f32>;
var count: i32;
var param_16: vec3<f32>;
var i: i32;
var l_1: vec3<f32>;
var radiance_1: vec3<f32>;
var param_17: i32;
var param_18: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec3<f32>;
var param_21: vec3<f32>;
var param_22: vec3<f32>;
var param_23: vec3<f32>;
var mean: f32;
var color_1: vec3<f32>;
var fogged: f32;
var coverage: f32;
var param_24: vec3<f32>;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e68 = v_uv_1;
let _e69 = textureSample(six_way_positive_tex, six_way_positive_smp, _e68);
positive_1 = _e69;
let _e70 = v_uv_1;
let _e71 = textureSample(six_way_negative_tex, six_way_negative_smp, _e70);
negative_1 = _e71;
lit = vec3<f32>(0f, 0f, 0f);
let _e72 = v_world_position_1;
param_16 = _e72;
let _e73 = ContributorLightCount_u0028_vf3_u003b((¶m_16));
count = _e73;
i = 0i;
loop {
let _e74 = i;
if (_e74 < 32i) {
let _e76 = i;
let _e77 = count;
if (_e76 >= _e77) {
break;
}
let _e79 = i;
param_17 = _e79;
let _e80 = v_world_position_1;
param_18 = _e80;
ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e81 = param_19;
l_1 = _e81;
let _e82 = param_20;
radiance_1 = _e82;
let _e83 = radiance_1;
let _e84 = l_1;
param_21 = _e84;
let _e85 = positive_1;
param_22 = _e85.xyz;
let _e87 = negative_1;
param_23 = _e87.xyz;
let _e89 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_21), (¶m_22), (¶m_23));
let _e91 = lit;
lit = (_e91 + (_e83 * _e89));
continue;
} else {
break;
}
continuing {
let _e93 = i;
i = (_e93 + 1i);
}
}
let _e96 = positive_1[0u];
let _e98 = positive_1[1u];
let _e101 = positive_1[2u];
let _e104 = negative_1[0u];
let _e107 = negative_1[1u];
let _e110 = negative_1[2u];
mean = ((((((_e96 + _e98) + _e101) + _e104) + _e107) + _e110) / 6f);
let _e113 = v_color_1;
let _e115 = lit;
let _e117 = six_way_info.ambient;
let _e119 = mean;
let _e124 = six_way_info.emission;
let _e127 = negative_1[3u];
color_1 = ((_e113.xyz * (_e115 + (_e117.xyz * _e119))) + (_e124.xyz * _e127));
fogged = 1f;
let _e132 = fog_info.fog[3u];
if (_e132 > 0f) {
let _e136 = fog_info.fog[3u];
let _e138 = v_world_position_1;
let _e140 = fog_info.eye;
fogged = clamp(exp((-(_e136) * distance(_e138, _e140.xyz))), 0f, 1f);
}
let _e147 = fog_info.fog;
let _e149 = color_1;
let _e150 = fogged;
color_1 = mix(_e147.xyz, _e149, vec3(_e150));
let _e154 = v_color_1[3u];
let _e156 = positive_1[3u];
coverage = clamp((_e154 * _e156), 0f, 1f);
let _e159 = v_world_position_1;
param_24 = _e159;
let _e160 = SoftParticleFade_u0028_vf3_u003b((¶m_24));
let _e161 = coverage;
coverage = (_e161 * _e160);
let _e163 = color_1;
let _e164 = coverage;
let _e165 = (_e163 * _e164);
let _e166 = coverage;
frag_color = vec4<f32>(_e165.x, _e165.y, _e165.z, _e166);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ContributorLightInfo',
group: 1,
binding: 0,
sizeInBytes: 528,
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: 'slots',
offsetInBytes: 512,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 1,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
WebGpuBlock(
name: 'SixWayInfo',
group: 1,
binding: 3,
sizeInBytes: 80,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'right', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'up', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emission',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient',
offsetInBytes: 64,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'SoftParticleInfo',
group: 1,
binding: 4,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_depth_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'six_way_negative',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'six_way_positive',
group: 1,
textureBinding: 11,
samplerBinding: 12,
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>[],
),
'SplatHashed': WebGpuStage(
wgsl: r'''
struct SplatHashInfo {
frame: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(1)
var<uniform> splat_hash_info: SplatHashInfo;
@group(1) @binding(2)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var blue_noise_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e40 = (*rows);
if (_e40 > 0f) {
let _e43 = gl_FragCoord_1[0u];
let _e44 = (*rows);
let _e46 = gl_FragCoord_1[1u];
local = vec2<f32>(_e43, (_e44 - _e46));
} else {
let _e49 = gl_FragCoord_1;
local = _e49.xy;
}
let _e51 = local;
return _e51;
}
fn main_1() {
var power: f32;
var alpha: f32;
var along: f32;
var identity: f32;
var mixed: f32;
var row: f32;
var offset: vec2<f32>;
var slice: f32;
var cell: vec2<f32>;
var param: f32;
var corner: vec2<f32>;
var threshold: f32;
var colour: vec3<f32>;
var visibility: f32;
let _e52 = v_uv_1;
let _e53 = v_uv_1;
power = (-0.5f * dot(_e52, _e53));
let _e56 = power;
if (_e56 < -4.5f) {
discard;
}
let _e59 = v_color_1[3u];
let _e60 = power;
alpha = (_e59 * exp(_e60));
let _e63 = alpha;
if (_e63 < 0.003921569f) {
discard;
}
let _e65 = v_world_position_1;
let _e67 = splat_hash_info.eye;
let _e71 = splat_hash_info.forward;
along = dot((_e65 - _e67.xyz), _e71.xyz);
let _e74 = along;
let _e77 = v_color_1;
identity = (floor((_e74 * 1000f)) + floor(dot(_e77, vec4<f32>(255f, 1785f, 7905f, 32385f))));
let _e81 = identity;
identity = (_e81 - (floor((_e81 / 4096f)) * 4096f));
let _e86 = identity;
let _e88 = ((_e86 * 1597f) + 2531f);
mixed = (_e88 - (floor((_e88 / 4096f)) * 4096f));
let _e93 = mixed;
let _e94 = mixed;
let _e96 = ((2f * _e94) + 1f);
let _e101 = (_e93 * (_e96 - (floor((_e96 / 4096f)) * 4096f)));
mixed = (_e101 - (floor((_e101 / 4096f)) * 4096f));
let _e106 = mixed;
row = floor((_e106 / 64f));
let _e109 = mixed;
let _e110 = row;
let _e112 = (_e109 + (_e110 * 37f));
let _e117 = row;
offset = vec2<f32>((_e112 - (floor((_e112 / 64f)) * 64f)), _e117);
let _e121 = splat_hash_info.frame[0u];
slice = _e121;
let _e124 = splat_hash_info.frame[1u];
param = _e124;
let _e125 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e127 = offset;
let _e128 = (floor(_e125) + _e127);
let _e129 = vec2(64f);
cell = (_e128 - (floor((_e128 / _e129)) * _e129));
let _e134 = slice;
let _e139 = slice;
corner = (vec2<f32>((_e134 - (floor((_e134 / 8f)) * 8f)), floor((_e139 / 8f))) * 64f);
let _e144 = corner;
let _e145 = cell;
let _e150 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, (((_e144 + _e145) + vec2(0.5f)) / vec2<f32>(512f, 256f)), 0f);
threshold = (_e150.x * 0.99609375f);
let _e153 = alpha;
let _e154 = threshold;
if (_e153 <= _e154) {
discard;
}
let _e156 = v_color_1;
colour = _e156.xyz;
let _e160 = fog_info.fog[3u];
if (_e160 > 0f) {
let _e164 = fog_info.fog[3u];
let _e166 = v_world_position_1;
let _e168 = fog_info.eye;
visibility = clamp(exp((-(_e164) * distance(_e166, _e168.xyz))), 0f, 1f);
let _e175 = fog_info.fog;
let _e177 = colour;
let _e178 = visibility;
colour = mix(_e175.xyz, _e177, vec3(_e178));
}
let _e181 = colour;
frag_color = vec4<f32>(_e181.x, _e181.y, _e181.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
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),
],
),
WebGpuBlock(
name: 'SplatHashInfo',
group: 1,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'frame', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'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 FragCoordInfo {
origin: vec4<f32>,
}
struct NoiseInfo {
noise: vec4<f32>,
}
struct ReflectionInfo {
view_projection: mat4x4<f32>,
inverse_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
environment: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> reflection_info: ReflectionInfo;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(6)
var environment_texture_smp: sampler;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e68 = (*at);
let _e70 = reflection_info.camera;
let _e74 = reflection_info.forward;
return dot((_e68 - _e70.xyz), _e74.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e69 = (*ndc)[0u];
let _e73 = (*ndc)[1u];
return vec2<f32>(((_e69 * 0.5f) + 0.5f), (0.5f - (_e73 * 0.5f)));
}
fn UvOf_u0028_vf3_u003b(at_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var clip: vec4<f32>;
var param: vec2<f32>;
let _e71 = reflection_info.view_projection;
let _e72 = (*at_1);
clip = (_e71 * vec4<f32>(_e72.x, _e72.y, _e72.z, 1f));
let _e79 = clip[3u];
if (_e79 <= 0f) {
return vec2<f32>(-1f, -1f);
}
let _e81 = clip;
let _e84 = clip[3u];
param = (_e81.xy / vec2(_e84));
let _e87 = UvFromNdc_u0028_vf2_u003b((¶m));
return _e87;
}
fn BayerCell_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e73 = (*at_2)[0u];
x = i32((_e73 - (floor((_e73 / 4f)) * 4f)));
let _e80 = (*at_2)[1u];
y = i32((_e80 - (floor((_e80 / 4f)) * 4f)));
let _e86 = y;
let _e88 = x;
index = ((_e86 * 4i) + _e88);
value = 0f;
let _e90 = index;
if (_e90 == 0i) {
value = 0f;
} else {
let _e92 = index;
if (_e92 == 1i) {
value = 8f;
} else {
let _e94 = index;
if (_e94 == 2i) {
value = 2f;
} else {
let _e96 = index;
if (_e96 == 3i) {
value = 10f;
} else {
let _e98 = index;
if (_e98 == 4i) {
value = 12f;
} else {
let _e100 = index;
if (_e100 == 5i) {
value = 4f;
} else {
let _e102 = index;
if (_e102 == 6i) {
value = 14f;
} else {
let _e104 = index;
if (_e104 == 7i) {
value = 6f;
} else {
let _e106 = index;
if (_e106 == 8i) {
value = 3f;
} else {
let _e108 = index;
if (_e108 == 9i) {
value = 11f;
} else {
let _e110 = index;
if (_e110 == 10i) {
value = 1f;
} else {
let _e112 = index;
if (_e112 == 11i) {
value = 9f;
} else {
let _e114 = index;
if (_e114 == 12i) {
value = 15f;
} else {
let _e116 = index;
if (_e116 == 13i) {
value = 7f;
} else {
let _e118 = index;
if (_e118 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e120 = value;
return (_e120 / 16f);
}
fn BlueNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell: vec2<f32>;
var corner: vec2<f32>;
var uv: vec2<f32>;
let _e74 = noise_info.noise[1u];
slice = _e74;
let _e75 = (*at_3);
let _e76 = floor(_e75);
let _e77 = vec2(64f);
cell = (_e76 - (floor((_e76 / _e77)) * _e77));
let _e82 = slice;
let _e87 = slice;
corner = (vec2<f32>((_e82 - (floor((_e82 / 8f)) * 8f)), floor((_e87 / 8f))) * 64f);
let _e92 = corner;
let _e93 = cell;
uv = (((_e92 + _e93) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e98 = uv;
let _e99 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e98, 0f);
return (_e99.x * 0.99609375f);
}
fn PixelNoise_u0028_vf2_u003b(at_4: ptr<function, vec2<f32>>) -> f32 {
var local: f32;
var param_1: vec2<f32>;
var param_2: vec2<f32>;
let _e73 = noise_info.noise[0u];
if (_e73 > 0.5f) {
let _e75 = (*at_4);
param_1 = _e75;
let _e76 = BlueNoise_u0028_vf2_u003b((¶m_1));
local = _e76;
} else {
let _e77 = (*at_4);
param_2 = _e77;
let _e78 = BayerCell_u0028_vf2_u003b((¶m_2));
local = _e78;
}
let _e79 = local;
return _e79;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_1: vec2<f32>;
let _e69 = (*rows);
if (_e69 > 0f) {
let _e72 = gl_FragCoord_1[0u];
let _e73 = (*rows);
let _e75 = gl_FragCoord_1[1u];
local_1 = vec2<f32>(_e72, (_e73 - _e75));
} else {
let _e78 = gl_FragCoord_1;
local_1 = _e78.xy;
}
let _e80 = local_1;
return _e80;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_3: f32;
let _e70 = frag_coord_info.origin[0u];
param_3 = _e70;
let _e71 = FragCoordFromTop_u0028_f1_u003b((¶m_3));
return _e71;
}
fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_1: 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 _e74 = (*uv_1)[0u];
let _e78 = (*uv_1)[1u];
xy = vec2<f32>(((_e74 * 2f) - 1f), (1f - (_e78 * 2f)));
let _e83 = reflection_info.inverse_view_projection;
let _e84 = xy;
nearH = (_e83 * vec4<f32>(_e84.x, _e84.y, 0f, 1f));
let _e90 = reflection_info.inverse_view_projection;
let _e91 = xy;
farH = (_e90 * vec4<f32>(_e91.x, _e91.y, 1f, 1f));
let _e96 = nearH;
let _e99 = nearH[3u];
(*origin) = (_e96.xyz / vec3(_e99));
let _e102 = farH;
let _e105 = farH[3u];
let _e108 = (*origin);
(*along) = normalize(((_e102.xyz / vec3(_e105)) - _e108));
return;
}
fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var origin_1: vec3<f32>;
var along_1: vec3<f32>;
var param_4: vec2<f32>;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var axis: vec3<f32>;
let _e75 = (*uv_2);
param_4 = _e75;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_4), (¶m_5), (¶m_6));
let _e76 = param_5;
origin_1 = _e76;
let _e77 = param_6;
along_1 = _e77;
let _e79 = reflection_info.forward;
axis = _e79.xyz;
let _e81 = origin_1;
let _e82 = along_1;
let _e83 = (*depth);
let _e84 = origin_1;
let _e86 = reflection_info.camera;
let _e89 = axis;
let _e92 = along_1;
let _e93 = axis;
return (_e81 + (_e82 * ((_e83 - dot((_e84 - _e86.xyz), _e89)) / dot(_e92, _e93))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local_2: f32;
var local_3: f32;
let _e72 = (*e);
(*e) = ((_e72 * 2f) - vec2(1f));
let _e76 = (*e);
let _e78 = (*e)[0u];
let _e82 = (*e)[1u];
n = vec3<f32>(_e76.x, _e76.y, ((1f - abs(_e78)) - abs(_e82)));
let _e89 = n[2u];
t = max(-(_e89), 0f);
let _e93 = n[0u];
if (_e93 >= 0f) {
let _e95 = t;
local_2 = -(_e95);
} else {
let _e97 = t;
local_2 = _e97;
}
let _e98 = local_2;
let _e100 = n[0u];
n[0u] = (_e100 + _e98);
let _e104 = n[1u];
if (_e104 >= 0f) {
let _e106 = t;
local_3 = -(_e106);
} else {
let _e108 = t;
local_3 = _e108;
}
let _e109 = local_3;
let _e111 = n[1u];
n[1u] = (_e111 + _e109);
let _e114 = n;
return normalize(_e114);
}
fn main_1() {
var surface: vec4<f32>;
var scene: vec3<f32>;
var debugOnly: bool;
var background: vec3<f32>;
var normal: vec3<f32>;
var param_7: vec2<f32>;
var roughness: f32;
var polish: f32;
var position: vec3<f32>;
var param_8: vec2<f32>;
var param_9: f32;
var rayOrigin: vec3<f32>;
var viewRay: vec3<f32>;
var param_10: vec2<f32>;
var param_11: vec3<f32>;
var param_12: 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 jitter: f32;
var param_13: vec2<f32>;
var travelled: f32;
var march: vec3<f32>;
var reach: f32;
var hitColor: vec3<f32>;
var hit: f32;
var i: i32;
var uv_3: vec2<f32>;
var param_14: vec3<f32>;
var sceneDepth: f32;
var marchDepth: f32;
var param_15: vec3<f32>;
var seen: vec3<f32>;
var param_16: vec2<f32>;
var param_17: f32;
var behind: f32;
var seenNormal: vec3<f32>;
var param_18: vec2<f32>;
var lo: vec3<f32>;
var hi: vec3<f32>;
var j: i32;
var mid: vec3<f32>;
var at_5: vec2<f32>;
var param_19: vec3<f32>;
var d: f32;
var local_4: f32;
var param_20: vec3<f32>;
var hitUv: vec2<f32>;
var param_21: vec3<f32>;
var edge: vec2<f32>;
var border: f32;
var along_2: f32;
var fresnel: f32;
var reflection: vec3<f32>;
var confidence: f32;
var levels: f32;
var environment: vec3<f32>;
var local_5: vec3<f32>;
var replaced: vec3<f32>;
var composed: vec3<f32>;
var local_6: vec3<f32>;
var phi_653_: bool;
var phi_660_: bool;
var phi_667_: bool;
var phi_718_: bool;
var phi_772_: bool;
let _e132 = v_uv_1;
let _e133 = textureSample(surface_texture_tex, surface_texture_smp, _e132);
surface = _e133;
let _e134 = v_uv_1;
let _e135 = textureSample(scene_texture_tex, scene_texture_smp, _e134);
scene = _e135.xyz;
let _e139 = reflection_info.screen[3u];
debugOnly = (_e139 > 0.5f);
let _e141 = debugOnly;
let _e142 = scene;
background = select(_e142, vec3<f32>(0f, 0f, 0f), vec3(_e141));
let _e146 = surface[3u];
if (_e146 <= 0f) {
let _e148 = background;
frag_color = vec4<f32>(_e148.x, _e148.y, _e148.z, 1f);
return;
}
let _e153 = surface;
param_7 = _e153.xy;
let _e155 = DecodeOctahedral_u0028_vf2_u003b((¶m_7));
normal = _e155;
let _e157 = surface[2u];
roughness = _e157;
let _e158 = roughness;
polish = (1f - smoothstep(0.05f, 0.25f, _e158));
let _e161 = polish;
if (_e161 <= 0f) {
let _e163 = background;
frag_color = vec4<f32>(_e163.x, _e163.y, _e163.z, 1f);
return;
}
let _e168 = v_uv_1;
param_8 = _e168;
let _e170 = surface[3u];
param_9 = _e170;
let _e171 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_8), (¶m_9));
position = _e171;
let _e172 = v_uv_1;
param_10 = _e172;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_10), (¶m_11), (¶m_12));
let _e173 = param_11;
rayOrigin = _e173;
let _e174 = param_12;
viewRay = _e174;
let _e175 = viewRay;
toEye = -(_e175);
let _e177 = normal;
let _e178 = toEye;
facing = dot(_e177, _e178);
let _e180 = facing;
if (_e180 <= 0.05f) {
let _e182 = background;
frag_color = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
return;
}
let _e187 = toEye;
let _e189 = normal;
ray = reflect(-(_e187), _e189);
let _e193 = reflection_info.params[0u];
steps = i32(_e193);
let _e197 = reflection_info.params[1u];
stride = _e197;
let _e200 = reflection_info.params[2u];
thickness = _e200;
let _e203 = reflection_info.params[3u];
intensity = _e203;
let _e204 = TargetFragCoord_u0028_();
param_13 = _e204;
let _e205 = PixelNoise_u0028_vf2_u003b((¶m_13));
jitter = (0.5f + _e205);
let _e207 = stride;
let _e208 = jitter;
travelled = (_e207 * _e208);
let _e210 = position;
let _e211 = normal;
let _e214 = ray;
let _e215 = travelled;
march = ((_e210 + (_e211 * 0.01f)) + (_e214 * _e215));
let _e218 = stride;
let _e219 = steps;
reach = (_e218 * (f32(_e219) + 0.5f));
hitColor = vec3<f32>(0f, 0f, 0f);
hit = 0f;
i = 0i;
loop {
let _e223 = i;
if (_e223 < 64i) {
let _e225 = i;
let _e226 = steps;
if (_e225 >= _e226) {
break;
}
let _e228 = march;
param_14 = _e228;
let _e229 = UvOf_u0028_vf3_u003b((¶m_14));
uv_3 = _e229;
let _e231 = uv_3[0u];
if (_e231 < -0.5f) {
break;
}
let _e234 = uv_3[0u];
let _e235 = (_e234 < 0f);
phi_653_ = _e235;
if !(_e235) {
let _e238 = uv_3[0u];
phi_653_ = (_e238 > 1f);
}
let _e241 = phi_653_;
phi_660_ = _e241;
if !(_e241) {
let _e244 = uv_3[1u];
phi_660_ = (_e244 < 0f);
}
let _e247 = phi_660_;
phi_667_ = _e247;
if !(_e247) {
let _e250 = uv_3[1u];
phi_667_ = (_e250 > 1f);
}
let _e253 = phi_667_;
if _e253 {
break;
}
let _e254 = uv_3;
let _e255 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e254, 0f);
sceneDepth = _e255.w;
let _e257 = march;
param_15 = _e257;
let _e258 = DepthOf_u0028_vf3_u003b((¶m_15));
marchDepth = _e258;
let _e259 = sceneDepth;
let _e261 = marchDepth;
let _e262 = sceneDepth;
if ((_e259 > 0f) && (_e261 > _e262)) {
let _e265 = uv_3;
param_16 = _e265;
let _e266 = sceneDepth;
param_17 = _e266;
let _e267 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_16), (¶m_17));
seen = _e267;
let _e268 = march;
let _e269 = seen;
behind = distance(_e268, _e269);
let _e271 = uv_3;
let _e272 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e271, 0f);
param_18 = _e272.xy;
let _e274 = DecodeOctahedral_u0028_vf2_u003b((¶m_18));
seenNormal = _e274;
let _e275 = behind;
let _e276 = thickness;
let _e277 = (_e275 < _e276);
phi_718_ = _e277;
if _e277 {
let _e278 = seenNormal;
let _e279 = ray;
phi_718_ = (dot(_e278, _e279) < 0f);
}
let _e283 = phi_718_;
if _e283 {
let _e284 = march;
let _e285 = ray;
let _e286 = stride;
let _e287 = travelled;
lo = (_e284 - (_e285 * min(_e286, _e287)));
let _e291 = march;
hi = _e291;
j = 0i;
loop {
let _e292 = j;
if (_e292 < 5i) {
let _e294 = lo;
let _e295 = hi;
mid = ((_e294 + _e295) * 0.5f);
let _e298 = mid;
param_19 = _e298;
let _e299 = UvOf_u0028_vf3_u003b((¶m_19));
at_5 = _e299;
let _e301 = at_5[0u];
if (_e301 < -0.5f) {
local_4 = 0f;
} else {
let _e303 = at_5;
let _e304 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e303, 0f);
local_4 = _e304.w;
}
let _e306 = local_4;
d = _e306;
let _e307 = d;
let _e308 = (_e307 > 0f);
phi_772_ = _e308;
if _e308 {
let _e309 = mid;
param_20 = _e309;
let _e310 = DepthOf_u0028_vf3_u003b((¶m_20));
let _e311 = d;
phi_772_ = (_e310 > _e311);
}
let _e314 = phi_772_;
if _e314 {
let _e315 = mid;
hi = _e315;
} else {
let _e316 = mid;
lo = _e316;
}
continue;
} else {
break;
}
continuing {
let _e317 = j;
j = (_e317 + 1i);
}
}
let _e319 = hi;
param_21 = _e319;
let _e320 = UvOf_u0028_vf3_u003b((¶m_21));
hitUv = _e320;
let _e322 = hitUv[0u];
if (_e322 < -0.5f) {
let _e324 = uv_3;
hitUv = _e324;
}
let _e325 = hitUv;
let _e326 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e325, 0f);
hitColor = _e326.xyz;
let _e328 = hitUv;
edge = abs(((_e328 * 2f) - vec2(1f)));
let _e334 = edge[0u];
let _e336 = edge[1u];
border = (1f - max(_e334, _e336));
let _e339 = travelled;
let _e340 = reach;
along_2 = clamp((1f - (_e339 / _e340)), 0f, 1f);
let _e344 = border;
let _e346 = along_2;
let _e348 = along_2;
hit = ((smoothstep(0f, 0.15f, _e344) * _e346) * _e348);
break;
}
}
let _e350 = ray;
let _e351 = stride;
let _e353 = march;
march = (_e353 + (_e350 * _e351));
let _e355 = stride;
let _e356 = travelled;
travelled = (_e356 + _e355);
continue;
} else {
break;
}
continuing {
let _e358 = i;
i = (_e358 + 1i);
}
}
let _e360 = facing;
fresnel = (0.04f + (0.96f * pow((1f - _e360), 5f)));
let _e365 = hitColor;
let _e366 = hit;
let _e368 = intensity;
let _e370 = polish;
let _e372 = fresnel;
reflection = ((((_e365 * _e366) * _e368) * _e370) * _e372);
let _e374 = hit;
let _e375 = intensity;
let _e377 = polish;
confidence = ((_e374 * _e375) * _e377);
let _e381 = reflection_info.environment[0u];
levels = _e381;
let _e382 = levels;
if (_e382 > 0f) {
let _e384 = ray;
let _e385 = roughness;
let _e386 = levels;
let _e388 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e384, (_e385 * _e386));
let _e392 = reflection_info.environment[1u];
local_5 = (_e388.xyz * _e392);
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e394 = local_5;
environment = _e394;
let _e395 = environment;
let _e396 = confidence;
let _e398 = fresnel;
replaced = ((_e395 * _e396) * _e398);
let _e400 = levels;
if (_e400 > 0f) {
let _e402 = scene;
let _e403 = reflection;
let _e405 = replaced;
local_6 = max(((_e402 + _e403) - _e405), vec3<f32>(0f, 0f, 0f));
} else {
let _e408 = scene;
let _e409 = reflection;
local_6 = (_e408 + _e409);
}
let _e411 = local_6;
composed = _e411;
let _e412 = debugOnly;
let _e413 = reflection;
let _e414 = composed;
let _e416 = select(_e414, _e413, vec3(_e412));
frag_color = vec4<f32>(_e416.x, _e416.y, _e416.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'NoiseInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'ReflectionInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
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,
),
WebGpuBlockMember(
name: 'environment',
offsetInBytes: 192,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Ssao': WebGpuStage(
wgsl: r'''
struct NoiseInfo {
noise: vec4<f32>,
}
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> noise_info: NoiseInfo;
@group(1) @binding(4)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var blue_noise_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> ssao_info: SsaoInfo;
@group(1) @binding(8)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var surface_texture_smp: sampler;
@group(1) @binding(6)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var scene_texture_smp: sampler;
@group(1) @binding(2)
var albedo_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var albedo_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 _e166 = (*at);
let _e168 = ssao_info.camera;
let _e172 = ssao_info.forward;
return dot((_e166 - _e168.xyz), _e172.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e167 = (*ndc)[0u];
let _e171 = (*ndc)[1u];
return vec2<f32>(((_e167 * 0.5f) + 0.5f), (0.5f - (_e171 * 0.5f)));
}
fn KernelTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec3<f32> {
let _e166 = (*i);
if (_e166 == 0i) {
return vec3<f32>(0.5381f, 0.1856f, 0.4319f);
}
let _e168 = (*i);
if (_e168 == 1i) {
return vec3<f32>(0.1379f, 0.2486f, 0.443f);
}
let _e170 = (*i);
if (_e170 == 2i) {
return vec3<f32>(0.3371f, 0.5679f, 0.0057f);
}
let _e172 = (*i);
if (_e172 == 3i) {
return vec3<f32>(-0.6999f, -0.0451f, 0.0019f);
}
let _e174 = (*i);
if (_e174 == 4i) {
return vec3<f32>(0.0689f, -0.1598f, -0.8547f);
}
let _e176 = (*i);
if (_e176 == 5i) {
return vec3<f32>(0.056f, 0.0069f, -0.1843f);
}
let _e178 = (*i);
if (_e178 == 6i) {
return vec3<f32>(-0.0146f, 0.1402f, 0.0762f);
}
let _e180 = (*i);
if (_e180 == 7i) {
return vec3<f32>(0.01f, -0.1924f, -0.0344f);
}
let _e182 = (*i);
if (_e182 == 8i) {
return vec3<f32>(-0.3577f, -0.5301f, -0.4358f);
}
let _e184 = (*i);
if (_e184 == 9i) {
return vec3<f32>(-0.3169f, 0.1063f, 0.0158f);
}
let _e186 = (*i);
if (_e186 == 10i) {
return vec3<f32>(0.0103f, -0.5869f, 0.0046f);
}
return vec3<f32>(-0.0897f, -0.494f, 0.3287f);
}
fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell: vec2<f32>;
var corner: vec2<f32>;
var uv: vec2<f32>;
let _e172 = noise_info.noise[1u];
slice = _e172;
let _e173 = (*at_1);
let _e174 = floor(_e173);
let _e175 = vec2(64f);
cell = (_e174 - (floor((_e174 / _e175)) * _e175));
let _e180 = slice;
let _e185 = slice;
corner = (vec2<f32>((_e180 - (floor((_e180 / 8f)) * 8f)), floor((_e185 / 8f))) * 64f);
let _e190 = corner;
let _e191 = cell;
uv = (((_e190 + _e191) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e196 = uv;
let _e197 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e196, 0f);
return (_e197.x * 0.99609375f);
}
fn Rotation_u0028_vf2_u003b(uv_1: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixel: vec2<f32>;
var angle: f32;
var param: vec2<f32>;
var oddX: bool;
var oddY: bool;
let _e171 = (*uv_1);
let _e173 = ssao_info.screen;
pixel = floor((_e171 / _e173.xy));
let _e179 = noise_info.noise[0u];
if (_e179 > 0.5f) {
let _e181 = pixel;
param = _e181;
let _e182 = BlueNoise_u0028_vf2_u003b((¶m));
angle = (6.2831855f * _e182);
let _e184 = angle;
let _e186 = angle;
return vec2<f32>(cos(_e184), sin(_e186));
}
let _e190 = pixel[0u];
oddX = ((_e190 - (floor((_e190 / 2f)) * 2f)) >= 1f);
let _e197 = pixel[1u];
oddY = ((_e197 - (floor((_e197 / 2f)) * 2f)) >= 1f);
let _e203 = oddX;
let _e204 = oddY;
if (_e203 && _e204) {
return vec2<f32>(-0.7071f, -0.7071f);
}
let _e206 = oddX;
if _e206 {
return vec2<f32>(0.7071f, -0.7071f);
}
let _e207 = oddY;
if _e207 {
return vec2<f32>(-0.7071f, 0.7071f);
}
return vec2<f32>(1f, 0f);
}
fn MultiBounce_u0028_f1_u003b_vf3_u003b(visible: ptr<function, f32>, albedo: ptr<function, vec3<f32>>) -> f32 {
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var v: vec3<f32>;
var bounced: vec3<f32>;
let _e172 = (*albedo);
a = ((_e172 * 2.0404f) - vec3(0.3324f));
let _e176 = (*albedo);
b = ((_e176 * -4.7951f) + vec3(0.6417f));
let _e180 = (*albedo);
c = ((_e180 * 2.7552f) + vec3(0.6903f));
let _e184 = (*visible);
v = vec3(_e184);
let _e186 = v;
let _e187 = v;
let _e188 = a;
let _e190 = b;
let _e192 = v;
let _e194 = c;
let _e196 = v;
bounced = max(_e186, (((((_e187 * _e188) + _e190) * _e192) + _e194) * _e196));
let _e199 = bounced;
return dot(_e199, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn SrgbToLinearAlbedo_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e166 = (*srgb);
let _e169 = (*srgb);
let _e174 = (*srgb);
return mix((_e166 / vec3(12.92f)), pow(((_e169 + 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), _e174));
}
fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_2: 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 _e172 = (*uv_2)[0u];
let _e176 = (*uv_2)[1u];
xy = vec2<f32>(((_e172 * 2f) - 1f), (1f - (_e176 * 2f)));
let _e181 = ssao_info.inverse_view_projection;
let _e182 = xy;
nearH = (_e181 * vec4<f32>(_e182.x, _e182.y, 0f, 1f));
let _e188 = ssao_info.inverse_view_projection;
let _e189 = xy;
farH = (_e188 * vec4<f32>(_e189.x, _e189.y, 1f, 1f));
let _e194 = nearH;
let _e197 = nearH[3u];
(*origin) = (_e194.xyz / vec3(_e197));
let _e200 = farH;
let _e203 = farH[3u];
let _e206 = (*origin);
(*along) = normalize(((_e200.xyz / vec3(_e203)) - _e206));
return;
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var origin_1: vec3<f32>;
var along_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: vec3<f32>;
var param_3: vec3<f32>;
var axis: vec3<f32>;
let _e173 = (*uv_3);
param_1 = _e173;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_1), (¶m_2), (¶m_3));
let _e174 = param_2;
origin_1 = _e174;
let _e175 = param_3;
along_1 = _e175;
let _e177 = ssao_info.forward;
axis = _e177.xyz;
let _e179 = origin_1;
let _e180 = along_1;
let _e181 = (*depth);
let _e182 = origin_1;
let _e184 = ssao_info.camera;
let _e187 = axis;
let _e190 = along_1;
let _e191 = axis;
return (_e179 + (_e180 * ((_e181 - dot((_e182 - _e184.xyz), _e187)) / dot(_e190, _e191))));
}
fn BayerCell_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e171 = (*at_2)[0u];
x = i32((_e171 - (floor((_e171 / 4f)) * 4f)));
let _e178 = (*at_2)[1u];
y = i32((_e178 - (floor((_e178 / 4f)) * 4f)));
let _e184 = y;
let _e186 = x;
index = ((_e184 * 4i) + _e186);
value = 0f;
let _e188 = index;
if (_e188 == 0i) {
value = 0f;
} else {
let _e190 = index;
if (_e190 == 1i) {
value = 8f;
} else {
let _e192 = index;
if (_e192 == 2i) {
value = 2f;
} else {
let _e194 = index;
if (_e194 == 3i) {
value = 10f;
} else {
let _e196 = index;
if (_e196 == 4i) {
value = 12f;
} else {
let _e198 = index;
if (_e198 == 5i) {
value = 4f;
} else {
let _e200 = index;
if (_e200 == 6i) {
value = 14f;
} else {
let _e202 = index;
if (_e202 == 7i) {
value = 6f;
} else {
let _e204 = index;
if (_e204 == 8i) {
value = 3f;
} else {
let _e206 = index;
if (_e206 == 9i) {
value = 11f;
} else {
let _e208 = index;
if (_e208 == 10i) {
value = 1f;
} else {
let _e210 = index;
if (_e210 == 11i) {
value = 9f;
} else {
let _e212 = index;
if (_e212 == 12i) {
value = 15f;
} else {
let _e214 = index;
if (_e214 == 13i) {
value = 7f;
} else {
let _e216 = index;
if (_e216 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e218 = value;
return (_e218 / 16f);
}
fn PixelNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
var local: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
let _e171 = noise_info.noise[0u];
if (_e171 > 0.5f) {
let _e173 = (*at_3);
param_4 = _e173;
let _e174 = BlueNoise_u0028_vf2_u003b((¶m_4));
local = _e174;
} else {
let _e175 = (*at_3);
param_5 = _e175;
let _e176 = BayerCell_u0028_vf2_u003b((¶m_5));
local = _e176;
}
let _e177 = local;
return _e177;
}
fn PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b(point: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>, radius: ptr<function, f32>) -> f32 {
var across: vec3<f32>;
var here: vec4<f32>;
var there: vec4<f32>;
var param_6: vec2<f32>;
var param_7: vec2<f32>;
let _e173 = (*view);
let _e175 = (*view)[1u];
across = normalize(cross(_e173, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 1f, 0f), vec3((abs(_e175) < 0.99f)))));
let _e183 = ssao_info.view_projection;
let _e184 = (*point);
here = (_e183 * vec4<f32>(_e184.x, _e184.y, _e184.z, 1f));
let _e191 = ssao_info.view_projection;
let _e192 = (*point);
let _e193 = across;
let _e194 = (*radius);
let _e196 = (_e192 + (_e193 * _e194));
there = (_e191 * vec4<f32>(_e196.x, _e196.y, _e196.z, 1f));
let _e202 = there;
let _e205 = there[3u];
param_6 = (_e202.xy / vec2(_e205));
let _e208 = UvFromNdc_u0028_vf2_u003b((¶m_6));
let _e209 = here;
let _e212 = here[3u];
param_7 = (_e209.xy / vec2(_e212));
let _e215 = UvFromNdc_u0028_vf2_u003b((¶m_7));
let _e218 = ssao_info.screen;
return length(((_e208 - _e215) / _e218.xy));
}
fn EyeWard_u0028_vf2_u003b(uv_4: ptr<function, vec2<f32>>) -> vec3<f32> {
var origin_2: vec3<f32>;
var along_2: vec3<f32>;
var param_8: vec2<f32>;
var param_9: vec3<f32>;
var param_10: vec3<f32>;
let _e171 = (*uv_4);
param_8 = _e171;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_8), (¶m_9), (¶m_10));
let _e172 = param_9;
origin_2 = _e172;
let _e173 = param_10;
along_2 = _e173;
let _e174 = along_2;
return -(_e174);
}
fn GtaoVisibility_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_5: ptr<function, vec2<f32>>, point_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>) -> f32 {
var view_1: vec3<f32>;
var param_11: vec2<f32>;
var radius_1: f32;
var steps: i32;
var pixelRadius: f32;
var param_12: vec3<f32>;
var param_13: vec3<f32>;
var param_14: f32;
var pixel_1: vec2<f32>;
var noise: f32;
var param_15: vec2<f32>;
var depth_1: f32;
var visibility: f32;
var slices: f32;
var slice_1: i32;
var phi: f32;
var direction: vec2<f32>;
var along_3: vec3<f32>;
var param_16: vec2<f32>;
var param_17: f32;
var tangent: vec3<f32>;
var tangentLength: f32;
var axis_1: vec3<f32>;
var projected: vec3<f32>;
var projectedLength: f32;
var n: f32;
var side: i32;
var s: f32;
var best: f32;
var i_1: i32;
var t: f32;
var at_4: vec2<f32>;
var d: f32;
var toSample: vec3<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var distance_: f32;
var cosine: f32;
var fade: f32;
var horizons: array<f32, 2>;
var h1_: f32;
var h2_: f32;
var local_1: f32;
var phi_886_: bool;
var phi_893_: bool;
var phi_900_: bool;
let _e211 = (*uv_5);
param_11 = _e211;
let _e212 = EyeWard_u0028_vf2_u003b((¶m_11));
view_1 = _e212;
let _e215 = ssao_info.params[0u];
radius_1 = max(_e215, 0.0001f);
let _e219 = ssao_info.params[1u];
steps = clamp((i32((_e219 + 0.5f)) / 4i), 1i, 4i);
let _e224 = (*point_1);
param_12 = _e224;
let _e225 = view_1;
param_13 = _e225;
let _e226 = radius_1;
param_14 = _e226;
let _e227 = PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14));
pixelRadius = _e227;
let _e228 = (*uv_5);
let _e230 = ssao_info.screen;
pixel_1 = floor((_e228 / _e230.xy));
let _e234 = pixel_1;
param_15 = _e234;
let _e235 = PixelNoise_u0028_vf2_u003b((¶m_15));
noise = _e235;
let _e236 = (*uv_5);
let _e237 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e236, 0f);
depth_1 = _e237.w;
visibility = 0f;
slices = 0f;
slice_1 = 0i;
loop {
let _e239 = slice_1;
if (_e239 < 2i) {
let _e241 = slice_1;
let _e243 = noise;
phi = ((f32(_e241) + _e243) * 1.5707963f);
let _e246 = phi;
let _e248 = phi;
let _e252 = ssao_info.screen;
direction = (vec2<f32>(cos(_e246), sin(_e248)) * _e252.xy);
let _e255 = (*uv_5);
let _e256 = direction;
param_16 = (_e255 + _e256);
let _e258 = depth_1;
param_17 = _e258;
let _e259 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_16), (¶m_17));
let _e260 = (*point_1);
along_3 = (_e259 - _e260);
let _e262 = along_3;
let _e263 = view_1;
let _e264 = along_3;
let _e265 = view_1;
tangent = (_e262 - (_e263 * dot(_e264, _e265)));
let _e269 = tangent;
tangentLength = length(_e269);
let _e271 = tangentLength;
if (_e271 < 0.000001f) {
continue;
}
let _e273 = tangentLength;
let _e274 = tangent;
tangent = (_e274 / vec3(_e273));
let _e277 = tangent;
let _e278 = view_1;
axis_1 = normalize(cross(_e277, _e278));
let _e281 = (*normal);
let _e282 = axis_1;
let _e283 = (*normal);
let _e284 = axis_1;
projected = (_e281 - (_e282 * dot(_e283, _e284)));
let _e288 = projected;
projectedLength = length(_e288);
let _e290 = projectedLength;
if (_e290 < 0.0001f) {
continue;
}
let _e292 = projected;
let _e293 = tangent;
let _e296 = projected;
let _e297 = projectedLength;
let _e300 = view_1;
n = (sign(dot(_e292, _e293)) * acos(clamp(dot((_e296 / vec3(_e297)), _e300), 0f, 1f)));
side = 0i;
loop {
let _e305 = side;
if (_e305 < 2i) {
let _e307 = side;
s = select(1f, -1f, (_e307 == 0i));
best = -1f;
i_1 = 0i;
loop {
let _e310 = i_1;
if (_e310 < 4i) {
let _e312 = i_1;
let _e313 = steps;
if (_e312 >= _e313) {
break;
}
let _e315 = i_1;
let _e318 = noise;
let _e321 = steps;
t = (((f32(_e315) + 0.5f) + (0.5f * _e318)) / f32(_e321));
let _e324 = (*uv_5);
let _e325 = s;
let _e326 = direction;
let _e328 = pixelRadius;
let _e330 = t;
at_4 = (_e324 + (((_e326 * _e325) * _e328) * _e330));
let _e334 = at_4[0u];
let _e335 = (_e334 < 0f);
phi_886_ = _e335;
if !(_e335) {
let _e338 = at_4[0u];
phi_886_ = (_e338 > 1f);
}
let _e341 = phi_886_;
phi_893_ = _e341;
if !(_e341) {
let _e344 = at_4[1u];
phi_893_ = (_e344 < 0f);
}
let _e347 = phi_893_;
phi_900_ = _e347;
if !(_e347) {
let _e350 = at_4[1u];
phi_900_ = (_e350 > 1f);
}
let _e353 = phi_900_;
if _e353 {
continue;
}
let _e354 = at_4;
let _e355 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e354, 0f);
d = _e355.w;
let _e357 = d;
if (_e357 <= 0f) {
continue;
}
let _e359 = at_4;
param_18 = _e359;
let _e360 = d;
param_19 = _e360;
let _e361 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_18), (¶m_19));
let _e362 = (*point_1);
toSample = (_e361 - _e362);
let _e364 = toSample;
distance_ = length(_e364);
let _e366 = distance_;
if (_e366 < 0.00001f) {
continue;
}
let _e368 = toSample;
let _e369 = distance_;
let _e372 = view_1;
cosine = dot((_e368 / vec3(_e369)), _e372);
let _e374 = distance_;
let _e375 = distance_;
let _e377 = radius_1;
let _e378 = radius_1;
fade = clamp((1f - ((_e374 * _e375) / (_e377 * _e378))), 0f, 1f);
let _e383 = best;
let _e384 = cosine;
let _e385 = fade;
best = max(_e383, mix(-1f, _e384, _e385));
continue;
} else {
break;
}
continuing {
let _e388 = i_1;
i_1 = (_e388 + 1i);
}
}
let _e390 = side;
let _e391 = s;
let _e392 = best;
horizons[_e390] = (_e391 * acos(clamp(_e392, -1f, 1f)));
continue;
} else {
break;
}
continuing {
let _e397 = side;
side = (_e397 + 1i);
}
}
let _e399 = n;
let _e401 = horizons[0i];
let _e402 = n;
h1_ = (_e399 + clamp((_e401 - _e402), -1.5707963f, 1.5707963f));
let _e406 = n;
let _e408 = horizons[1i];
let _e409 = n;
h2_ = (_e406 + clamp((_e408 - _e409), -1.5707963f, 1.5707963f));
let _e413 = projectedLength;
let _e415 = h1_;
let _e417 = n;
let _e421 = n;
let _e424 = h1_;
let _e426 = n;
let _e430 = h2_;
let _e432 = n;
let _e436 = n;
let _e439 = h2_;
let _e441 = n;
let _e447 = visibility;
visibility = (_e447 + ((_e413 * 0.25f) * (((-(cos(((2f * _e415) - _e417))) + cos(_e421)) + ((2f * _e424) * sin(_e426))) + ((-(cos(((2f * _e430) - _e432))) + cos(_e436)) + ((2f * _e439) * sin(_e441))))));
let _e449 = slices;
slices = (_e449 + 1f);
continue;
} else {
break;
}
continuing {
let _e451 = slice_1;
slice_1 = (_e451 + 1i);
}
}
let _e453 = slices;
if (_e453 > 0f) {
let _e455 = visibility;
let _e456 = slices;
local_1 = clamp((_e455 / _e456), 0f, 1f);
} else {
local_1 = 1f;
}
let _e459 = local_1;
return _e459;
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var t_1: f32;
var local_2: f32;
var local_3: f32;
let _e170 = (*e);
(*e) = ((_e170 * 2f) - vec2(1f));
let _e174 = (*e);
let _e176 = (*e)[0u];
let _e180 = (*e)[1u];
n_1 = vec3<f32>(_e174.x, _e174.y, ((1f - abs(_e176)) - abs(_e180)));
let _e187 = n_1[2u];
t_1 = max(-(_e187), 0f);
let _e191 = n_1[0u];
if (_e191 >= 0f) {
let _e193 = t_1;
local_2 = -(_e193);
} else {
let _e195 = t_1;
local_2 = _e195;
}
let _e196 = local_2;
let _e198 = n_1[0u];
n_1[0u] = (_e198 + _e196);
let _e202 = n_1[1u];
if (_e202 >= 0f) {
let _e204 = t_1;
local_3 = -(_e204);
} else {
let _e206 = t_1;
local_3 = _e206;
}
let _e207 = local_3;
let _e209 = n_1[1u];
n_1[1u] = (_e209 + _e207);
let _e212 = n_1;
return normalize(_e212);
}
fn SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b(m0_: ptr<function, vec4<f32>>, m1_: ptr<function, vec4<f32>>, m2_: ptr<function, vec4<f32>>, m3_: ptr<function, vec4<f32>>) -> f32 {
let _e169 = (*m0_);
let _e170 = (*m1_);
let _e172 = (*m2_);
let _e174 = (*m3_);
return dot((((_e169 + _e170) + _e172) + _e174), vec4<f32>(1f, 1f, 1f, 1f));
}
fn SectorRun_u0028_f1_u003b_f1_u003b_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b(low: ptr<function, f32>, high: ptr<function, f32>, m0_1: ptr<function, vec4<f32>>, m1_1: ptr<function, vec4<f32>>, m2_1: ptr<function, vec4<f32>>, m3_1: ptr<function, vec4<f32>>) {
let _e171 = (*low);
let _e174 = (*high);
(*m0_1) = (step(vec4(_e171), vec4<f32>(0.03125f, 0.09375f, 0.15625f, 0.21875f)) * step(vec4<f32>(0.03125f, 0.09375f, 0.15625f, 0.21875f), vec4(_e174)));
let _e178 = (*low);
let _e181 = (*high);
(*m1_1) = (step(vec4(_e178), vec4<f32>(0.28125f, 0.34375f, 0.40625f, 0.46875f)) * step(vec4<f32>(0.28125f, 0.34375f, 0.40625f, 0.46875f), vec4(_e181)));
let _e185 = (*low);
let _e188 = (*high);
(*m2_1) = (step(vec4(_e185), vec4<f32>(0.53125f, 0.59375f, 0.65625f, 0.71875f)) * step(vec4<f32>(0.53125f, 0.59375f, 0.65625f, 0.71875f), vec4(_e188)));
let _e192 = (*low);
let _e195 = (*high);
(*m3_1) = (step(vec4(_e192), vec4<f32>(0.78125f, 0.84375f, 0.90625f, 0.96875f)) * step(vec4<f32>(0.78125f, 0.84375f, 0.90625f, 0.96875f), vec4(_e195)));
return;
}
fn SsilLight_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_6: ptr<function, vec2<f32>>, point_2: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>) -> vec4<f32> {
var view_2: vec3<f32>;
var param_20: vec2<f32>;
var radius_2: f32;
var thickness: f32;
var steps_1: i32;
var pixelRadius_1: f32;
var param_21: vec3<f32>;
var param_22: vec3<f32>;
var param_23: f32;
var pixel_2: vec2<f32>;
var noise_1: f32;
var param_24: vec2<f32>;
var depth_2: f32;
var light: vec3<f32>;
var open: f32;
var slices_1: f32;
var slice_2: i32;
var phi_1: f32;
var direction_1: vec2<f32>;
var along_4: vec3<f32>;
var param_25: vec2<f32>;
var param_26: f32;
var tangent_1: vec3<f32>;
var tangentLength_1: f32;
var axis_2: vec3<f32>;
var projected_1: vec3<f32>;
var projectedLength_1: f32;
var n_2: f32;
var c0_: vec4<f32>;
var c1_: vec4<f32>;
var c2_: vec4<f32>;
var c3_: vec4<f32>;
var side_1: i32;
var s_1: f32;
var i_2: i32;
var t_2: f32;
var at_5: vec2<f32>;
var sampled: vec4<f32>;
var front: vec3<f32>;
var param_27: vec2<f32>;
var param_28: f32;
var toward: vec3<f32>;
var back: vec3<f32>;
var a_1: f32;
var b_1: f32;
var lowAngle: f32;
var highAngle: f32;
var m0_2: vec4<f32>;
var m1_2: vec4<f32>;
var m2_2: vec4<f32>;
var m3_2: vec4<f32>;
var param_29: f32;
var param_30: f32;
var param_31: vec4<f32>;
var param_32: vec4<f32>;
var param_33: vec4<f32>;
var param_34: vec4<f32>;
var fresh: f32;
var param_35: vec4<f32>;
var param_36: vec4<f32>;
var param_37: vec4<f32>;
var param_38: vec4<f32>;
var radiance: vec3<f32>;
var cosine_1: f32;
var param_39: vec2<f32>;
var param_40: vec4<f32>;
var param_41: vec4<f32>;
var param_42: vec4<f32>;
var param_43: vec4<f32>;
var count: f32;
var albedo_1: vec3<f32>;
var local_4: vec3<f32>;
var param_44: vec3<f32>;
var local_5: vec4<f32>;
var phi_1365_: bool;
var phi_1372_: bool;
var phi_1379_: bool;
let _e242 = (*uv_6);
param_20 = _e242;
let _e243 = EyeWard_u0028_vf2_u003b((¶m_20));
view_2 = _e243;
let _e246 = ssao_info.params[0u];
radius_2 = max(_e246, 0.0001f);
let _e250 = ssao_info.screen[3u];
thickness = max(_e250, 0.001f);
let _e254 = ssao_info.params[1u];
steps_1 = clamp((i32((_e254 + 0.5f)) / 4i), 1i, 4i);
let _e259 = (*point_2);
param_21 = _e259;
let _e260 = view_2;
param_22 = _e260;
let _e261 = radius_2;
param_23 = _e261;
let _e262 = PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_21), (¶m_22), (¶m_23));
pixelRadius_1 = _e262;
let _e263 = (*uv_6);
let _e265 = ssao_info.screen;
pixel_2 = floor((_e263 / _e265.xy));
let _e269 = pixel_2;
param_24 = _e269;
let _e270 = PixelNoise_u0028_vf2_u003b((¶m_24));
noise_1 = _e270;
let _e271 = (*uv_6);
let _e272 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e271, 0f);
depth_2 = _e272.w;
light = vec3<f32>(0f, 0f, 0f);
open = 0f;
slices_1 = 0f;
slice_2 = 0i;
loop {
let _e274 = slice_2;
if (_e274 < 2i) {
let _e276 = slice_2;
let _e278 = noise_1;
phi_1 = ((f32(_e276) + _e278) * 1.5707963f);
let _e281 = phi_1;
let _e283 = phi_1;
let _e287 = ssao_info.screen;
direction_1 = (vec2<f32>(cos(_e281), sin(_e283)) * _e287.xy);
let _e290 = (*uv_6);
let _e291 = direction_1;
param_25 = (_e290 + _e291);
let _e293 = depth_2;
param_26 = _e293;
let _e294 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_25), (¶m_26));
let _e295 = (*point_2);
along_4 = (_e294 - _e295);
let _e297 = along_4;
let _e298 = view_2;
let _e299 = along_4;
let _e300 = view_2;
tangent_1 = (_e297 - (_e298 * dot(_e299, _e300)));
let _e304 = tangent_1;
tangentLength_1 = length(_e304);
let _e306 = tangentLength_1;
if (_e306 < 0.000001f) {
continue;
}
let _e308 = tangentLength_1;
let _e309 = tangent_1;
tangent_1 = (_e309 / vec3(_e308));
let _e312 = tangent_1;
let _e313 = view_2;
axis_2 = normalize(cross(_e312, _e313));
let _e316 = (*normal_1);
let _e317 = axis_2;
let _e318 = (*normal_1);
let _e319 = axis_2;
projected_1 = (_e316 - (_e317 * dot(_e318, _e319)));
let _e323 = projected_1;
projectedLength_1 = length(_e323);
let _e325 = projectedLength_1;
if (_e325 < 0.0001f) {
continue;
}
let _e327 = projected_1;
let _e328 = tangent_1;
let _e331 = projected_1;
let _e332 = projectedLength_1;
let _e335 = view_2;
n_2 = (sign(dot(_e327, _e328)) * acos(clamp(dot((_e331 / vec3(_e332)), _e335), 0f, 1f)));
c0_ = vec4<f32>(0f, 0f, 0f, 0f);
c1_ = vec4<f32>(0f, 0f, 0f, 0f);
c2_ = vec4<f32>(0f, 0f, 0f, 0f);
c3_ = vec4<f32>(0f, 0f, 0f, 0f);
side_1 = 0i;
loop {
let _e340 = side_1;
if (_e340 < 2i) {
let _e342 = side_1;
s_1 = select(1f, -1f, (_e342 == 0i));
i_2 = 0i;
loop {
let _e345 = i_2;
if (_e345 < 4i) {
let _e347 = i_2;
let _e348 = steps_1;
if (_e347 >= _e348) {
break;
}
let _e350 = i_2;
let _e353 = noise_1;
let _e356 = steps_1;
t_2 = (((f32(_e350) + 0.5f) + (0.5f * _e353)) / f32(_e356));
let _e359 = (*uv_6);
let _e360 = s_1;
let _e361 = direction_1;
let _e363 = pixelRadius_1;
let _e365 = t_2;
at_5 = (_e359 + (((_e361 * _e360) * _e363) * _e365));
let _e369 = at_5[0u];
let _e370 = (_e369 < 0f);
phi_1365_ = _e370;
if !(_e370) {
let _e373 = at_5[0u];
phi_1365_ = (_e373 > 1f);
}
let _e376 = phi_1365_;
phi_1372_ = _e376;
if !(_e376) {
let _e379 = at_5[1u];
phi_1372_ = (_e379 < 0f);
}
let _e382 = phi_1372_;
phi_1379_ = _e382;
if !(_e382) {
let _e385 = at_5[1u];
phi_1379_ = (_e385 > 1f);
}
let _e388 = phi_1379_;
if _e388 {
continue;
}
let _e389 = at_5;
let _e390 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e389, 0f);
sampled = _e390;
let _e392 = sampled[3u];
if (_e392 <= 0f) {
continue;
}
let _e394 = at_5;
param_27 = _e394;
let _e396 = sampled[3u];
param_28 = _e396;
let _e397 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_27), (¶m_28));
let _e398 = (*point_2);
front = (_e397 - _e398);
let _e400 = front;
let _e402 = radius_2;
if (length(_e400) > _e402) {
continue;
}
let _e404 = front;
toward = normalize(_e404);
let _e406 = front;
let _e407 = view_2;
let _e408 = thickness;
back = (_e406 - (_e407 * _e408));
let _e411 = s_1;
let _e412 = toward;
let _e413 = view_2;
a_1 = (_e411 * acos(clamp(dot(_e412, _e413), -1f, 1f)));
let _e418 = s_1;
let _e419 = back;
let _e421 = view_2;
b_1 = (_e418 * acos(clamp(dot(normalize(_e419), _e421), -1f, 1f)));
let _e426 = a_1;
let _e427 = b_1;
let _e429 = n_2;
lowAngle = (((min(_e426, _e427) - _e429) + 1.5707963f) / 3.1415927f);
let _e433 = a_1;
let _e434 = b_1;
let _e436 = n_2;
highAngle = (((max(_e433, _e434) - _e436) + 1.5707963f) / 3.1415927f);
let _e440 = lowAngle;
param_29 = _e440;
let _e441 = highAngle;
param_30 = _e441;
SectorRun_u0028_f1_u003b_f1_u003b_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((¶m_29), (¶m_30), (¶m_31), (¶m_32), (¶m_33), (¶m_34));
let _e442 = param_31;
m0_2 = _e442;
let _e443 = param_32;
m1_2 = _e443;
let _e444 = param_33;
m2_2 = _e444;
let _e445 = param_34;
m3_2 = _e445;
let _e446 = m0_2;
let _e447 = c0_;
let _e451 = m1_2;
let _e452 = c1_;
let _e456 = m2_2;
let _e457 = c2_;
let _e461 = m3_2;
let _e462 = c3_;
param_35 = (_e446 * (vec4(1f) - _e447));
param_36 = (_e451 * (vec4(1f) - _e452));
param_37 = (_e456 * (vec4(1f) - _e457));
param_38 = (_e461 * (vec4(1f) - _e462));
let _e466 = SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38));
fresh = _e466;
let _e467 = at_5;
let _e468 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e467, 0f);
radiance = _e468.xyz;
let _e470 = (*normal_1);
let _e471 = toward;
let _e474 = sampled;
param_39 = _e474.xy;
let _e476 = DecodeOctahedral_u0028_vf2_u003b((¶m_39));
let _e477 = toward;
cosine_1 = (max(dot(_e470, _e471), 0f) * max(dot(_e476, -(_e477)), 0f));
let _e482 = radiance;
let _e483 = cosine_1;
let _e485 = fresh;
let _e489 = light;
light = (_e489 + (((_e482 * _e483) * _e485) / vec3(16f)));
let _e491 = c0_;
let _e492 = m0_2;
c0_ = max(_e491, _e492);
let _e494 = c1_;
let _e495 = m1_2;
c1_ = max(_e494, _e495);
let _e497 = c2_;
let _e498 = m2_2;
c2_ = max(_e497, _e498);
let _e500 = c3_;
let _e501 = m3_2;
c3_ = max(_e500, _e501);
continue;
} else {
break;
}
continuing {
let _e503 = i_2;
i_2 = (_e503 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e505 = side_1;
side_1 = (_e505 + 1i);
}
}
let _e507 = c0_;
param_40 = _e507;
let _e508 = c1_;
param_41 = _e508;
let _e509 = c2_;
param_42 = _e509;
let _e510 = c3_;
param_43 = _e510;
let _e511 = SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43));
let _e514 = open;
open = (_e514 + (1f - (_e511 / 16f)));
let _e516 = slices_1;
slices_1 = (_e516 + 1f);
continue;
} else {
break;
}
continuing {
let _e518 = slice_2;
slice_2 = (_e518 + 1i);
}
}
let _e520 = slices_1;
count = max(_e520, 1f);
let _e524 = ssao_info.params[2u];
if (_e524 > 0.5f) {
let _e526 = (*uv_6);
let _e527 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e526, 0f);
param_44 = _e527.xyz;
let _e529 = SrgbToLinearAlbedo_u0028_vf3_u003b((¶m_44));
local_4 = _e529;
} else {
local_4 = vec3<f32>(0.5f, 0.5f, 0.5f);
}
let _e530 = local_4;
albedo_1 = _e530;
let _e531 = slices_1;
if (_e531 > 0f) {
let _e533 = light;
let _e534 = count;
let _e537 = albedo_1;
let _e538 = ((_e533 / vec3(_e534)) * _e537);
let _e539 = open;
let _e540 = count;
local_5 = vec4<f32>(_e538.x, _e538.y, _e538.z, (_e539 / _e540));
} else {
local_5 = vec4<f32>(0f, 0f, 0f, 1f);
}
let _e546 = local_5;
return _e546;
}
fn main_1() {
var surface: vec4<f32>;
var normal_2: vec3<f32>;
var param_45: vec2<f32>;
var param_46: vec2<f32>;
var param_47: f32;
var param_48: vec2<f32>;
var param_49: vec3<f32>;
var param_50: vec3<f32>;
var visible_1: f32;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: vec2<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var shaded: f32;
var local_6: f32;
var param_56: vec3<f32>;
var param_57: f32;
var param_58: vec3<f32>;
var radius_3: f32;
var samples: i32;
var origin_3: vec3<f32>;
var param_59: vec2<f32>;
var param_60: f32;
var rot: vec2<f32>;
var param_61: vec2<f32>;
var occluded: f32;
var i_3: i32;
var tap: vec3<f32>;
var param_62: i32;
var spun: vec3<f32>;
var at_6: vec3<f32>;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_7: vec2<f32>;
var param_63: vec2<f32>;
var there_1: vec4<f32>;
var param_64: vec3<f32>;
var seen: vec3<f32>;
var param_65: vec2<f32>;
var param_66: f32;
var phi_1815_: bool;
let _e206 = v_uv_1;
let _e207 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e206, 0f);
surface = _e207;
let _e209 = surface[3u];
if (_e209 <= 0f) {
let _e213 = ssao_info.screen[2u];
frag_color = select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 1f), vec4((_e213 > 1.5f)));
return;
}
let _e217 = surface;
param_45 = _e217.xy;
let _e219 = DecodeOctahedral_u0028_vf2_u003b((¶m_45));
normal_2 = _e219;
let _e222 = ssao_info.screen[2u];
if (_e222 > 1.5f) {
let _e224 = v_uv_1;
param_46 = _e224;
let _e226 = surface[3u];
param_47 = _e226;
let _e227 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_46), (¶m_47));
let _e228 = v_uv_1;
param_48 = _e228;
param_49 = _e227;
let _e229 = normal_2;
param_50 = _e229;
let _e230 = SsilLight_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_48), (¶m_49), (¶m_50));
frag_color = _e230;
return;
}
let _e233 = ssao_info.screen[2u];
if (_e233 > 0.5f) {
let _e235 = v_uv_1;
param_51 = _e235;
let _e237 = surface[3u];
param_52 = _e237;
let _e238 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_51), (¶m_52));
let _e239 = v_uv_1;
param_53 = _e239;
param_54 = _e238;
let _e240 = normal_2;
param_55 = _e240;
let _e241 = GtaoVisibility_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55));
visible_1 = _e241;
let _e244 = ssao_info.params[2u];
if (_e244 > 0.5f) {
let _e246 = v_uv_1;
let _e247 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e246, 0f);
param_56 = _e247.xyz;
let _e249 = SrgbToLinearAlbedo_u0028_vf3_u003b((¶m_56));
let _e250 = visible_1;
param_57 = _e250;
param_58 = _e249;
let _e251 = MultiBounce_u0028_f1_u003b_vf3_u003b((¶m_57), (¶m_58));
local_6 = _e251;
} else {
let _e252 = visible_1;
local_6 = _e252;
}
let _e253 = local_6;
shaded = _e253;
let _e254 = shaded;
frag_color = vec4(_e254);
return;
}
let _e258 = ssao_info.params[0u];
radius_3 = max(_e258, 0.0001f);
let _e262 = ssao_info.params[1u];
samples = clamp(i32((_e262 + 0.5f)), 1i, 12i);
let _e266 = v_uv_1;
param_59 = _e266;
let _e268 = surface[3u];
param_60 = _e268;
let _e269 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_59), (¶m_60));
let _e270 = normal_2;
let _e273 = ssao_info.params[3u];
origin_3 = (_e269 + (_e270 * _e273));
let _e276 = v_uv_1;
param_61 = _e276;
let _e277 = Rotation_u0028_vf2_u003b((¶m_61));
rot = _e277;
occluded = 0f;
i_3 = 0i;
loop {
let _e278 = i_3;
if (_e278 < 12i) {
let _e280 = i_3;
let _e281 = samples;
if (_e280 >= _e281) {
break;
}
let _e283 = i_3;
param_62 = _e283;
let _e284 = KernelTap_u0028_i1_u003b((¶m_62));
tap = _e284;
let _e286 = tap[0u];
let _e288 = rot[0u];
let _e291 = tap[1u];
let _e293 = rot[1u];
let _e297 = tap[0u];
let _e299 = rot[1u];
let _e302 = tap[1u];
let _e304 = rot[0u];
let _e308 = tap[2u];
spun = vec3<f32>(((_e286 * _e288) - (_e291 * _e293)), ((_e297 * _e299) + (_e302 * _e304)), _e308);
let _e310 = spun;
let _e311 = normal_2;
if (dot(_e310, _e311) < 0f) {
let _e314 = spun;
spun = -(_e314);
}
let _e316 = origin_3;
let _e317 = spun;
let _e318 = radius_3;
at_6 = (_e316 + (_e317 * _e318));
let _e322 = ssao_info.view_projection;
let _e323 = at_6;
clip = (_e322 * vec4<f32>(_e323.x, _e323.y, _e323.z, 1f));
let _e330 = clip[3u];
if (_e330 <= 0f) {
continue;
}
let _e332 = clip;
let _e335 = clip[3u];
ndc_1 = (_e332.xyz / vec3(_e335));
let _e339 = ndc_1[0u];
let _e341 = (abs(_e339) > 1f);
phi_1815_ = _e341;
if !(_e341) {
let _e344 = ndc_1[1u];
phi_1815_ = (abs(_e344) > 1f);
}
let _e348 = phi_1815_;
if _e348 {
continue;
}
let _e349 = ndc_1;
param_63 = _e349.xy;
let _e351 = UvFromNdc_u0028_vf2_u003b((¶m_63));
uv_7 = _e351;
let _e352 = uv_7;
let _e353 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e352, 0f);
there_1 = _e353;
let _e355 = there_1[3u];
if (_e355 <= 0f) {
continue;
}
let _e358 = there_1[3u];
let _e359 = at_6;
param_64 = _e359;
let _e360 = DepthOf_u0028_vf3_u003b((¶m_64));
if (_e358 >= _e360) {
continue;
}
let _e362 = uv_7;
param_65 = _e362;
let _e364 = there_1[3u];
param_66 = _e364;
let _e365 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_65), (¶m_66));
seen = _e365;
let _e366 = radius_3;
let _e367 = seen;
let _e368 = origin_3;
let _e373 = occluded;
occluded = (_e373 + smoothstep(0f, 1f, (_e366 / max(distance(_e367, _e368), 0.0001f))));
continue;
} else {
break;
}
continuing {
let _e375 = i_3;
i_3 = (_e375 + 1i);
}
}
let _e377 = occluded;
let _e378 = samples;
frag_color = vec4(clamp((1f - (_e377 / f32(_e378))), 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: 'NoiseInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'SsaoInfo',
group: 1,
binding: 1,
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: 'albedo_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
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: vec4<f32>;
var centreDepth: f32;
var falloff: f32;
var total: vec4<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;
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;
let _e41 = taps;
if (_e41 < 1f) {
let _e43 = centre;
frag_color = _e43;
return;
}
let _e44 = v_uv_1;
let _e45 = textureSample(surface_texture_tex, surface_texture_smp, _e44);
centreDepth = _e45.w;
let _e49 = blur_info.params[3u];
falloff = max(_e49, 0.0001f);
let _e51 = centre;
total = _e51;
weightSum = 1f;
i = 1i;
loop {
let _e52 = i;
if (_e52 <= 8i) {
let _e54 = i;
let _e56 = taps;
if (f32(_e54) > _e56) {
break;
}
let _e58 = i;
offset = f32(_e58);
let _e62 = blur_info.params[0u];
let _e63 = offset;
steps[0i] = vec2<f32>((_e62 * _e63), 0f);
let _e69 = blur_info.params[0u];
let _e71 = offset;
steps[1i] = vec2<f32>((-(_e69) * _e71), 0f);
let _e77 = blur_info.params[1u];
let _e78 = offset;
steps[2i] = vec2<f32>(0f, (_e77 * _e78));
let _e84 = blur_info.params[1u];
let _e86 = offset;
steps[3i] = vec2<f32>(0f, (-(_e84) * _e86));
s = 0i;
loop {
let _e90 = s;
if (_e90 < 4i) {
let _e92 = v_uv_1;
let _e93 = s;
let _e95 = steps[_e93];
at = (_e92 + _e95);
let _e97 = at;
let _e98 = textureSample(surface_texture_tex, surface_texture_smp, _e97);
depth = _e98.w;
let _e100 = depth;
let _e101 = centreDepth;
let _e105 = falloff;
let _e106 = centreDepth;
closeness = exp((-(abs((_e100 - _e101))) / (_e105 * max(_e106, 0.001f))));
let _e111 = closeness;
let _e112 = offset;
weight = (_e111 / _e112);
let _e114 = at;
let _e115 = textureSample(ao_texture_tex, ao_texture_smp, _e114);
let _e116 = weight;
let _e118 = total;
total = (_e118 + (_e115 * _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;
frag_color = (_e127 / vec4(_e128));
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 FragCoordInfo {
origin: vec4<f32>,
}
struct NoiseInfo {
noise: vec4<f32>,
}
struct ContactShadowInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
to_light: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contact_info: ContactShadowInfo;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e57 = (*ndc)[0u];
let _e61 = (*ndc)[1u];
return vec2<f32>(((_e57 * 0.5f) + 0.5f), (0.5f - (_e61 * 0.5f)));
}
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e56 = (*at);
let _e58 = contact_info.camera;
let _e62 = contact_info.forward;
return dot((_e56 - _e58.xyz), _e62.xyz);
}
fn BayerCell_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e61 = (*at_1)[0u];
x = i32((_e61 - (floor((_e61 / 4f)) * 4f)));
let _e68 = (*at_1)[1u];
y = i32((_e68 - (floor((_e68 / 4f)) * 4f)));
let _e74 = y;
let _e76 = x;
index = ((_e74 * 4i) + _e76);
value = 0f;
let _e78 = index;
if (_e78 == 0i) {
value = 0f;
} else {
let _e80 = index;
if (_e80 == 1i) {
value = 8f;
} else {
let _e82 = index;
if (_e82 == 2i) {
value = 2f;
} else {
let _e84 = index;
if (_e84 == 3i) {
value = 10f;
} else {
let _e86 = index;
if (_e86 == 4i) {
value = 12f;
} else {
let _e88 = index;
if (_e88 == 5i) {
value = 4f;
} else {
let _e90 = index;
if (_e90 == 6i) {
value = 14f;
} else {
let _e92 = index;
if (_e92 == 7i) {
value = 6f;
} else {
let _e94 = index;
if (_e94 == 8i) {
value = 3f;
} else {
let _e96 = index;
if (_e96 == 9i) {
value = 11f;
} else {
let _e98 = index;
if (_e98 == 10i) {
value = 1f;
} else {
let _e100 = index;
if (_e100 == 11i) {
value = 9f;
} else {
let _e102 = index;
if (_e102 == 12i) {
value = 15f;
} else {
let _e104 = index;
if (_e104 == 13i) {
value = 7f;
} else {
let _e106 = index;
if (_e106 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e108 = value;
return (_e108 / 16f);
}
fn BlueNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell: vec2<f32>;
var corner: vec2<f32>;
var uv: vec2<f32>;
let _e62 = noise_info.noise[1u];
slice = _e62;
let _e63 = (*at_2);
let _e64 = floor(_e63);
let _e65 = vec2(64f);
cell = (_e64 - (floor((_e64 / _e65)) * _e65));
let _e70 = slice;
let _e75 = slice;
corner = (vec2<f32>((_e70 - (floor((_e70 / 8f)) * 8f)), floor((_e75 / 8f))) * 64f);
let _e80 = corner;
let _e81 = cell;
uv = (((_e80 + _e81) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e86 = uv;
let _e87 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e86, 0f);
return (_e87.x * 0.99609375f);
}
fn PixelNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
var local: f32;
var param: vec2<f32>;
var param_1: vec2<f32>;
let _e61 = noise_info.noise[0u];
if (_e61 > 0.5f) {
let _e63 = (*at_3);
param = _e63;
let _e64 = BlueNoise_u0028_vf2_u003b((¶m));
local = _e64;
} else {
let _e65 = (*at_3);
param_1 = _e65;
let _e66 = BayerCell_u0028_vf2_u003b((¶m_1));
local = _e66;
}
let _e67 = local;
return _e67;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_1: vec2<f32>;
let _e57 = (*rows);
if (_e57 > 0f) {
let _e60 = gl_FragCoord_1[0u];
let _e61 = (*rows);
let _e63 = gl_FragCoord_1[1u];
local_1 = vec2<f32>(_e60, (_e61 - _e63));
} else {
let _e66 = gl_FragCoord_1;
local_1 = _e66.xy;
}
let _e68 = local_1;
return _e68;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_2: f32;
let _e58 = frag_coord_info.origin[0u];
param_2 = _e58;
let _e59 = FragCoordFromTop_u0028_f1_u003b((¶m_2));
return _e59;
}
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 _e64 = (*uv_1)[0u];
let _e68 = (*uv_1)[1u];
xy = vec2<f32>(((_e64 * 2f) - 1f), (1f - (_e68 * 2f)));
let _e73 = contact_info.inverse_view_projection;
let _e74 = xy;
nearH = (_e73 * vec4<f32>(_e74.x, _e74.y, 0f, 1f));
let _e80 = contact_info.inverse_view_projection;
let _e81 = xy;
farH = (_e80 * vec4<f32>(_e81.x, _e81.y, 1f, 1f));
let _e86 = nearH;
let _e89 = nearH[3u];
origin = (_e86.xyz / vec3(_e89));
let _e92 = farH;
let _e95 = farH[3u];
let _e98 = origin;
along = normalize(((_e92.xyz / vec3(_e95)) - _e98));
let _e102 = contact_info.forward;
axis = _e102.xyz;
let _e104 = origin;
let _e105 = along;
let _e106 = (*depth);
let _e107 = origin;
let _e109 = contact_info.camera;
let _e112 = axis;
let _e115 = along;
let _e116 = axis;
return (_e104 + (_e105 * ((_e106 - dot((_e107 - _e109.xyz), _e112)) / dot(_e115, _e116))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local_2: f32;
var local_3: f32;
let _e60 = (*e);
(*e) = ((_e60 * 2f) - vec2(1f));
let _e64 = (*e);
let _e66 = (*e)[0u];
let _e70 = (*e)[1u];
n = vec3<f32>(_e64.x, _e64.y, ((1f - abs(_e66)) - abs(_e70)));
let _e77 = n[2u];
t = max(-(_e77), 0f);
let _e81 = n[0u];
if (_e81 >= 0f) {
let _e83 = t;
local_2 = -(_e83);
} else {
let _e85 = t;
local_2 = _e85;
}
let _e86 = local_2;
let _e88 = n[0u];
n[0u] = (_e88 + _e86);
let _e92 = n[1u];
if (_e92 >= 0f) {
let _e94 = t;
local_3 = -(_e94);
} else {
let _e96 = t;
local_3 = _e96;
}
let _e97 = local_3;
let _e99 = n[1u];
n[1u] = (_e99 + _e97);
let _e102 = n;
return normalize(_e102);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param_3: vec2<f32>;
var toLight: vec3<f32>;
var reach: f32;
var steps: i32;
var thickness: f32;
var origin_1: vec3<f32>;
var param_4: vec2<f32>;
var param_5: f32;
var stride: f32;
var jitter: f32;
var param_6: vec2<f32>;
var stepDepth: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var tolerance: f32;
var i: i32;
var along_1: f32;
var at_4: vec3<f32>;
var clip: vec4<f32>;
var uv_2: vec2<f32>;
var param_9: vec2<f32>;
var there: vec4<f32>;
var marched: f32;
var param_10: vec3<f32>;
var gap: f32;
var phi_580_: bool;
var phi_587_: bool;
var phi_594_: bool;
let _e82 = v_uv_1;
let _e83 = textureSample(surface_texture_tex, surface_texture_smp, _e82);
surface = _e83;
let _e85 = surface[3u];
if (_e85 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e87 = surface;
param_3 = _e87.xy;
let _e89 = DecodeOctahedral_u0028_vf2_u003b((¶m_3));
normal = _e89;
let _e91 = contact_info.to_light;
toLight = normalize(_e91.xyz);
let _e94 = normal;
let _e95 = toLight;
if (dot(_e94, _e95) <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e100 = contact_info.params[0u];
reach = max(_e100, 0.0001f);
let _e104 = contact_info.params[1u];
steps = clamp(i32((_e104 + 0.5f)), 1i, 16i);
let _e110 = contact_info.params[2u];
thickness = max(_e110, 0.0001f);
let _e112 = v_uv_1;
param_4 = _e112;
let _e114 = surface[3u];
param_5 = _e114;
let _e115 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_4), (¶m_5));
let _e116 = normal;
let _e119 = contact_info.params[3u];
origin_1 = (_e115 + (_e116 * _e119));
let _e122 = reach;
let _e123 = steps;
stride = (_e122 / f32(_e123));
let _e126 = TargetFragCoord_u0028_();
param_6 = _e126;
let _e127 = PixelNoise_u0028_vf2_u003b((¶m_6));
jitter = _e127;
let _e128 = origin_1;
let _e129 = toLight;
let _e130 = stride;
param_7 = (_e128 + (_e129 * _e130));
let _e133 = DepthOf_u0028_vf3_u003b((¶m_7));
let _e134 = origin_1;
param_8 = _e134;
let _e135 = DepthOf_u0028_vf3_u003b((¶m_8));
stepDepth = abs((_e133 - _e135));
let _e138 = thickness;
let _e139 = stepDepth;
tolerance = max(_e138, (2f * _e139));
i = 0i;
loop {
let _e142 = i;
if (_e142 < 16i) {
let _e144 = i;
let _e145 = steps;
if (_e144 >= _e145) {
break;
}
let _e147 = i;
let _e150 = jitter;
along_1 = ((f32(_e147) + 1f) - _e150);
let _e152 = origin_1;
let _e153 = toLight;
let _e154 = stride;
let _e155 = along_1;
at_4 = (_e152 + (_e153 * (_e154 * _e155)));
let _e160 = contact_info.view_projection;
let _e161 = at_4;
clip = (_e160 * vec4<f32>(_e161.x, _e161.y, _e161.z, 1f));
let _e168 = clip[3u];
if (_e168 <= 0f) {
break;
}
let _e170 = clip;
let _e173 = clip[3u];
param_9 = (_e170.xy / vec2(_e173));
let _e176 = UvFromNdc_u0028_vf2_u003b((¶m_9));
uv_2 = _e176;
let _e178 = uv_2[0u];
let _e179 = (_e178 < 0f);
phi_580_ = _e179;
if !(_e179) {
let _e182 = uv_2[0u];
phi_580_ = (_e182 > 1f);
}
let _e185 = phi_580_;
phi_587_ = _e185;
if !(_e185) {
let _e188 = uv_2[1u];
phi_587_ = (_e188 < 0f);
}
let _e191 = phi_587_;
phi_594_ = _e191;
if !(_e191) {
let _e194 = uv_2[1u];
phi_594_ = (_e194 > 1f);
}
let _e197 = phi_594_;
if _e197 {
break;
}
let _e198 = uv_2;
let _e199 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e198, 0f);
there = _e199;
let _e201 = there[3u];
if (_e201 <= 0f) {
continue;
}
let _e203 = at_4;
param_10 = _e203;
let _e204 = DepthOf_u0028_vf3_u003b((¶m_10));
marched = _e204;
let _e205 = marched;
let _e207 = there[3u];
gap = (_e205 - _e207);
let _e209 = gap;
let _e211 = gap;
let _e212 = tolerance;
if ((_e209 > 0f) && (_e211 < _e212)) {
let _e215 = along_1;
let _e218 = steps;
frag_color = vec4((max((_e215 - 1f), 0f) / f32(_e218)));
return;
}
continue;
} else {
break;
}
continuing {
let _e222 = i;
i = (_e222 + 1i);
}
}
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
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,
),
],
),
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'NoiseInfo',
group: 1,
binding: 2,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'CameraVelocity': WebGpuStage(
wgsl: r'''
struct CameraVelocityInfo {
inverse_view_projection: mat4x4<f32>,
previous_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
}
@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>;
@group(1) @binding(0)
var<uniform> velocity_info: CameraVelocityInfo;
var<private> frag_color: vec4<f32>;
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e19 = (*ndc)[0u];
let _e23 = (*ndc)[1u];
return vec2<f32>(((_e19 * 0.5f) + 0.5f), (0.5f - (_e23 * 0.5f)));
}
fn main_1() {
var surface: vec4<f32>;
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var then: vec4<f32>;
var axis: vec3<f32>;
var world: vec3<f32>;
var param: vec2<f32>;
let _e27 = v_uv_1;
let _e28 = textureSample(surface_texture_tex, surface_texture_smp, _e27);
surface = _e28;
let _e30 = v_uv_1[0u];
let _e34 = v_uv_1[1u];
xy = vec2<f32>(((_e30 * 2f) - 1f), (1f - (_e34 * 2f)));
let _e39 = velocity_info.inverse_view_projection;
let _e40 = xy;
nearH = (_e39 * vec4<f32>(_e40.x, _e40.y, 0f, 1f));
let _e46 = velocity_info.inverse_view_projection;
let _e47 = xy;
farH = (_e46 * vec4<f32>(_e47.x, _e47.y, 1f, 1f));
let _e52 = nearH;
let _e55 = nearH[3u];
origin = (_e52.xyz / vec3(_e55));
let _e58 = farH;
let _e61 = farH[3u];
let _e64 = origin;
along = normalize(((_e58.xyz / vec3(_e61)) - _e64));
let _e68 = surface[3u];
if (_e68 <= 0f) {
let _e71 = velocity_info.previous_view_projection;
let _e72 = along;
then = (_e71 * vec4<f32>(_e72.x, _e72.y, _e72.z, 0f));
} else {
let _e79 = velocity_info.forward;
axis = _e79.xyz;
let _e81 = origin;
let _e82 = along;
let _e84 = surface[3u];
let _e85 = origin;
let _e87 = velocity_info.camera;
let _e90 = axis;
let _e93 = along;
let _e94 = axis;
world = (_e81 + (_e82 * ((_e84 - dot((_e85 - _e87.xyz), _e90)) / dot(_e93, _e94))));
let _e100 = velocity_info.previous_view_projection;
let _e101 = world;
then = (_e100 * vec4<f32>(_e101.x, _e101.y, _e101.z, 1f));
}
let _e108 = then[3u];
if (_e108 <= 0f) {
frag_color = vec4<f32>(0f, 0f, 0f, 1f);
return;
}
let _e110 = v_uv_1;
let _e111 = then;
let _e114 = then[3u];
param = (_e111.xy / vec2(_e114));
let _e117 = UvFromNdc_u0028_vf2_u003b((¶m));
let _e118 = (_e110 - _e117);
frag_color = vec4<f32>(_e118.x, _e118.y, 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: 'CameraVelocityInfo',
group: 1,
binding: 0,
sizeInBytes: 160,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'previous_view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 144,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Velocity': WebGpuStage(
wgsl: r'''
struct VelocityInfo {
target_: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> velocity_info: VelocityInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_depth_1: f32;
var<private> v_previous_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_current_1: vec4<f32>;
fn UvFromClip_u0028_vf4_u003b(clip: ptr<function, vec4<f32>>) -> vec2<f32> {
var ndc: vec2<f32>;
let _e20 = (*clip);
let _e23 = (*clip)[3u];
ndc = (_e20.xy / vec2(_e23));
let _e27 = ndc[0u];
let _e31 = ndc[1u];
return vec2<f32>(((_e27 * 0.5f) + 0.5f), (0.5f - (_e31 * 0.5f)));
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e20 = (*rows);
if (_e20 > 0f) {
let _e23 = gl_FragCoord_1[0u];
let _e24 = (*rows);
let _e26 = gl_FragCoord_1[1u];
local = vec2<f32>(_e23, (_e24 - _e26));
} else {
let _e29 = gl_FragCoord_1;
local = _e29.xy;
}
let _e31 = local;
return _e31;
}
fn main_1() {
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var param_1: vec4<f32>;
var param_2: vec4<f32>;
var phi_113_: bool;
let _e25 = velocity_info.target_[2u];
param = _e25;
let _e26 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e28 = velocity_info.target_;
uv = (_e26 * _e28.xy);
let _e31 = uv;
let _e32 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e31, 0f);
stored = _e32.w;
let _e34 = stored;
let _e35 = (_e34 <= 0f);
phi_113_ = _e35;
if !(_e35) {
let _e37 = v_depth_1;
let _e38 = stored;
let _e41 = velocity_info.target_[3u];
phi_113_ = (_e37 > ((_e38 * (1f + _e41)) + 0.001f));
}
let _e47 = phi_113_;
if _e47 {
discard;
}
let _e49 = v_previous_1[3u];
if (_e49 <= 0f) {
frag_color = vec4<f32>(0f, 0f, 0f, 1f);
return;
}
let _e51 = v_current_1;
param_1 = _e51;
let _e52 = UvFromClip_u0028_vf4_u003b((¶m_1));
let _e53 = v_previous_1;
param_2 = _e53;
let _e54 = UvFromClip_u0028_vf4_u003b((¶m_2));
let _e55 = (_e52 - _e54);
frag_color = vec4<f32>(_e55.x, _e55.y, 0f, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_depth: f32, @location(2) v_previous: vec4<f32>, @location(0) v_current: vec4<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_depth_1 = v_depth;
v_previous_1 = v_previous;
v_current_1 = v_current;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'VelocityInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Reactive': WebGpuStage(
wgsl: r'''
struct ReactiveInfo {
target_: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> reactive_info: ReactiveInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_depth_1: f32;
var<private> frag_color: vec4<f32>;
var<private> v_current_1: vec4<f32>;
var<private> v_previous_1: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e19 = (*rows);
if (_e19 > 0f) {
let _e22 = gl_FragCoord_1[0u];
let _e23 = (*rows);
let _e25 = gl_FragCoord_1[1u];
local = vec2<f32>(_e22, (_e23 - _e25));
} else {
let _e28 = gl_FragCoord_1;
local = _e28.xy;
}
let _e30 = local;
return _e30;
}
fn main_1() {
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var hidden: bool;
var coverage: f32;
var phi_90_: bool;
let _e24 = reactive_info.target_[2u];
param = _e24;
let _e25 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e27 = reactive_info.target_;
uv = (_e25 * _e27.xy);
let _e30 = uv;
let _e31 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e30, 0f);
stored = _e31.w;
let _e33 = stored;
let _e34 = (_e33 > 0f);
phi_90_ = _e34;
if _e34 {
let _e35 = v_depth_1;
let _e36 = stored;
let _e39 = reactive_info.target_[3u];
phi_90_ = (_e35 > ((_e36 * (1f + _e39)) + 0.001f));
}
let _e45 = phi_90_;
hidden = _e45;
let _e48 = reactive_info.params[0u];
let _e51 = reactive_info.params[2u];
coverage = (_e48 * _e51);
let _e53 = hidden;
let _e54 = coverage;
if (_e53 || (_e54 <= 0f)) {
discard;
}
let _e57 = coverage;
frag_color = vec4<f32>(0f, 0f, _e57, 0f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_depth: f32, @location(0) v_current: vec4<f32>, @location(2) v_previous: vec4<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_depth_1 = v_depth;
v_current_1 = v_current;
v_previous_1 = v_previous;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ReactiveInfo',
group: 1,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ReactiveSprite': WebGpuStage(
wgsl: r'''
struct ReactiveInfo {
target_: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var sprite_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var sprite_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> reactive_info: ReactiveInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e28 = (*rows);
if (_e28 > 0f) {
let _e31 = gl_FragCoord_1[0u];
let _e32 = (*rows);
let _e34 = gl_FragCoord_1[1u];
local = vec2<f32>(_e31, (_e32 - _e34));
} else {
let _e37 = gl_FragCoord_1;
local = _e37.xy;
}
let _e39 = local;
return _e39;
}
fn main_1() {
var spriteAlpha: f32;
var centred: vec2<f32>;
var falloff: f32;
var disc: f32;
var power: f32;
var gaussian: f32;
var local_1: f32;
var shape: f32;
var coverage: f32;
var local_2: f32;
var uv: vec2<f32>;
var param: f32;
var stored: f32;
var depth: f32;
var hidden: bool;
var reactive: f32;
var phi_171_: bool;
let _e42 = v_uv_1;
let _e43 = textureSample(sprite_texture_tex, sprite_texture_smp, _e42);
spriteAlpha = _e43.w;
let _e45 = v_uv_1;
centred = ((_e45 * 2f) - vec2(1f));
let _e49 = centred;
falloff = (1f - smoothstep(0f, 1f, length(_e49)));
let _e53 = falloff;
let _e54 = falloff;
disc = (_e53 * _e54);
let _e56 = v_uv_1;
let _e57 = v_uv_1;
power = (-0.5f * dot(_e56, _e57));
let _e60 = power;
if (_e60 < -4.5f) {
local_1 = 0f;
} else {
let _e62 = power;
local_1 = exp(_e62);
}
let _e64 = local_1;
gaussian = _e64;
let _e67 = reactive_info.params[1u];
shape = _e67;
let _e69 = v_color_1[3u];
let _e70 = shape;
if (_e70 < 0.5f) {
let _e72 = disc;
local_2 = _e72;
} else {
let _e73 = shape;
let _e75 = gaussian;
let _e76 = spriteAlpha;
local_2 = select(_e76, _e75, (_e73 < 1.5f));
}
let _e78 = local_2;
coverage = (_e69 * _e78);
let _e82 = reactive_info.target_[2u];
param = _e82;
let _e83 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e85 = reactive_info.target_;
uv = (_e83 * _e85.xy);
let _e88 = uv;
let _e89 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e88, 0f);
stored = _e89.w;
let _e91 = v_world_position_1;
let _e93 = reactive_info.eye;
let _e97 = reactive_info.forward;
depth = dot((_e91 - _e93.xyz), _e97.xyz);
let _e100 = stored;
let _e101 = (_e100 > 0f);
phi_171_ = _e101;
if _e101 {
let _e102 = depth;
let _e103 = stored;
let _e106 = reactive_info.target_[3u];
phi_171_ = (_e102 > ((_e103 * (1f + _e106)) + 0.001f));
}
let _e112 = phi_171_;
hidden = _e112;
let _e115 = reactive_info.params[0u];
let _e116 = coverage;
reactive = (_e115 * _e116);
let _e118 = hidden;
let _e119 = reactive;
if (_e118 || (_e119 <= 0f)) {
discard;
}
let _e122 = reactive;
frag_color = vec4<f32>(0f, 0f, _e122, 0f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
main_1();
let _e9 = frag_color;
return _e9;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ReactiveInfo',
group: 1,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'sprite_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'TemporalResolve': WebGpuStage(
wgsl: r'''
struct TemporalInfo {
scene_texel: vec4<f32>,
jitter: vec4<f32>,
params: vec4<f32>,
clip: vec4<f32>,
clip_axes: array<vec4<f32>, 16>,
}
@group(1) @binding(0)
var<uniform> temporal_info: TemporalInfo;
@group(1) @binding(1)
var history_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var history_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(3)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var scene_texture_smp: sampler;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
@group(1) @binding(7)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var velocity_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn Luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {
let _e52 = (*c);
return dot(_e52, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn Unweigh_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {
var param: vec3<f32>;
let _e53 = (*c_1);
let _e54 = (*c_1);
param = _e54;
let _e55 = Luma_u0028_vf3_u003b((¶m));
let _e58 = temporal_info.params[0u];
return (_e53 / vec3(max((1f - (_e55 * _e58)), 0.0001f)));
}
fn YCoCgToRgb_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e53 = (*c_2)[0u];
let _e55 = (*c_2)[1u];
let _e58 = (*c_2)[2u];
let _e61 = (*c_2)[0u];
let _e63 = (*c_2)[2u];
let _e66 = (*c_2)[0u];
let _e68 = (*c_2)[1u];
let _e71 = (*c_2)[2u];
return vec3<f32>(((_e53 + _e55) - _e58), (_e61 + _e63), ((_e66 - _e68) - _e71));
}
fn ClipToBox_u0028_vf3_u003b_vf3_u003b_vf3_u003b(lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>, q: ptr<function, vec3<f32>>) -> vec3<f32> {
var centre: vec3<f32>;
var extent: vec3<f32>;
var v: vec3<f32>;
var units: vec3<f32>;
var most: f32;
var local: vec3<f32>;
let _e60 = (*hi);
let _e61 = (*lo);
centre = ((_e60 + _e61) * 0.5f);
let _e64 = (*hi);
let _e65 = (*lo);
extent = (((_e64 - _e65) * 0.5f) + vec3<f32>(0.00001f, 0.00001f, 0.00001f));
let _e69 = (*q);
let _e70 = centre;
v = (_e69 - _e70);
let _e72 = v;
let _e73 = extent;
units = abs((_e72 / _e73));
let _e77 = units[0u];
let _e79 = units[1u];
let _e81 = units[2u];
most = max(_e77, max(_e79, _e81));
let _e84 = most;
if (_e84 > 1f) {
let _e86 = centre;
let _e87 = v;
let _e88 = most;
local = (_e86 + (_e87 / vec3(_e88)));
} else {
let _e92 = (*q);
local = _e92;
}
let _e93 = local;
return _e93;
}
fn ClipToDop_u0028_vf3_u003b_vf3_u003b_vf3_u005b_9_u005d_u003b(current: ptr<function, vec3<f32>>, history: ptr<function, vec3<f32>>, around: ptr<function, array<vec3<f32>, 9>>) -> vec3<f32> {
var toward: vec3<f32>;
var reach: f32;
var a: i32;
var axis: vec3<f32>;
var at: f32;
var lowest: f32;
var highest: f32;
var sum: f32;
var sumSquares: f32;
var n: i32;
var p: f32;
var mean: f32;
var sigma: f32;
var lo_1: f32;
var hi_1: f32;
var along: f32;
var leave: f32;
var local_1: f32;
var local_2: f32;
let _e73 = (*history);
let _e74 = (*current);
toward = (_e73 - _e74);
reach = 1f;
a = 0i;
loop {
let _e76 = a;
if (_e76 < 16i) {
let _e78 = a;
let _e82 = temporal_info.clip[0u];
if (f32(_e78) < _e82) {
let _e84 = a;
let _e87 = temporal_info.clip_axes[_e84];
axis = _e87.xyz;
let _e89 = (*current);
let _e90 = axis;
at = dot(_e89, _e90);
lowest = 1000000000000000000000000000000f;
highest = -1000000000000000000000000000000f;
sum = 0f;
sumSquares = 0f;
n = 0i;
loop {
let _e92 = n;
if (_e92 < 9i) {
let _e94 = n;
let _e96 = (*around)[_e94];
let _e97 = axis;
p = dot(_e96, _e97);
let _e99 = lowest;
let _e100 = p;
lowest = min(_e99, _e100);
let _e102 = highest;
let _e103 = p;
highest = max(_e102, _e103);
let _e105 = p;
let _e106 = sum;
sum = (_e106 + _e105);
let _e108 = p;
let _e109 = p;
let _e111 = sumSquares;
sumSquares = (_e111 + (_e108 * _e109));
continue;
} else {
break;
}
continuing {
let _e113 = n;
n = (_e113 + 1i);
}
}
let _e115 = sum;
mean = (_e115 / 9f);
let _e117 = sumSquares;
let _e119 = mean;
let _e120 = mean;
sigma = sqrt(max(((_e117 / 9f) - (_e119 * _e120)), 0f));
let _e125 = lowest;
let _e126 = mean;
let _e127 = sigma;
let _e131 = at;
lo_1 = min(max(_e125, (_e126 - (1.25f * _e127))), _e131);
let _e133 = highest;
let _e134 = mean;
let _e135 = sigma;
let _e139 = at;
hi_1 = max(min(_e133, (_e134 + (1.25f * _e135))), _e139);
let _e141 = toward;
let _e142 = axis;
along = dot(_e141, _e142);
let _e144 = along;
if (_e144 > 0.00000001f) {
let _e146 = hi_1;
let _e147 = at;
let _e149 = along;
local_1 = ((_e146 - _e147) / _e149);
} else {
let _e151 = along;
if (_e151 < -0.00000001f) {
let _e153 = lo_1;
let _e154 = at;
let _e156 = along;
local_2 = ((_e153 - _e154) / _e156);
} else {
local_2 = 1f;
}
let _e158 = local_2;
local_1 = _e158;
}
let _e159 = local_1;
leave = _e159;
let _e160 = reach;
let _e161 = leave;
reach = min(_e160, _e161);
}
continue;
} else {
break;
}
continuing {
let _e163 = a;
a = (_e163 + 1i);
}
}
let _e165 = (*current);
let _e166 = toward;
let _e167 = reach;
return (_e165 + (_e166 * max(_e167, 0f)));
}
fn HistoryAt_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {
var size: vec2<f32>;
var position: vec2<f32>;
var centre1_: vec2<f32>;
var f: vec2<f32>;
var w0_: vec2<f32>;
var w1_: vec2<f32>;
var w2_: vec2<f32>;
var w3_: vec2<f32>;
var w12_: vec2<f32>;
var at0_: vec2<f32>;
var at3_: vec2<f32>;
var at12_: vec2<f32>;
var sum_1: vec3<f32>;
let _e66 = temporal_info.params;
size = _e66.zw;
let _e68 = (*uv);
let _e69 = size;
position = (_e68 * _e69);
let _e71 = position;
centre1_ = (floor((_e71 - vec2(0.5f))) + vec2(0.5f));
let _e77 = position;
let _e78 = centre1_;
f = (_e77 - _e78);
let _e80 = f;
let _e81 = f;
let _e82 = f;
w0_ = (_e80 * (vec2(-0.5f) + (_e81 * (vec2(1f) - (_e82 * 0.5f)))));
let _e90 = f;
let _e91 = f;
let _e93 = f;
w1_ = (vec2(1f) + ((_e90 * _e91) * (vec2(-2.5f) + (_e93 * 1.5f))));
let _e100 = f;
let _e101 = f;
let _e102 = f;
w2_ = (_e100 * (vec2(0.5f) + (_e101 * (vec2(2f) - (_e102 * 1.5f)))));
let _e110 = f;
let _e111 = f;
let _e113 = f;
w3_ = ((_e110 * _e111) * (vec2(-0.5f) + (_e113 * 0.5f)));
let _e118 = w1_;
let _e119 = w2_;
w12_ = (_e118 + _e119);
let _e121 = centre1_;
let _e124 = size;
at0_ = ((_e121 - vec2(1f)) / _e124);
let _e126 = centre1_;
let _e129 = size;
at3_ = ((_e126 + vec2(2f)) / _e129);
let _e131 = centre1_;
let _e132 = w2_;
let _e133 = w12_;
let _e136 = size;
at12_ = ((_e131 + (_e132 / _e133)) / _e136);
sum_1 = vec3<f32>(0f, 0f, 0f);
let _e139 = at0_[0u];
let _e141 = at0_[1u];
let _e143 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e139, _e141), 0f);
let _e146 = w0_[0u];
let _e149 = w0_[1u];
let _e151 = sum_1;
sum_1 = (_e151 + ((_e143.xyz * _e146) * _e149));
let _e154 = at12_[0u];
let _e156 = at0_[1u];
let _e158 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e154, _e156), 0f);
let _e161 = w12_[0u];
let _e164 = w0_[1u];
let _e166 = sum_1;
sum_1 = (_e166 + ((_e158.xyz * _e161) * _e164));
let _e169 = at3_[0u];
let _e171 = at0_[1u];
let _e173 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e169, _e171), 0f);
let _e176 = w3_[0u];
let _e179 = w0_[1u];
let _e181 = sum_1;
sum_1 = (_e181 + ((_e173.xyz * _e176) * _e179));
let _e184 = at0_[0u];
let _e186 = at12_[1u];
let _e188 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e184, _e186), 0f);
let _e191 = w0_[0u];
let _e194 = w12_[1u];
let _e196 = sum_1;
sum_1 = (_e196 + ((_e188.xyz * _e191) * _e194));
let _e199 = at12_[0u];
let _e201 = at12_[1u];
let _e203 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e199, _e201), 0f);
let _e206 = w12_[0u];
let _e209 = w12_[1u];
let _e211 = sum_1;
sum_1 = (_e211 + ((_e203.xyz * _e206) * _e209));
let _e214 = at3_[0u];
let _e216 = at12_[1u];
let _e218 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e214, _e216), 0f);
let _e221 = w3_[0u];
let _e224 = w12_[1u];
let _e226 = sum_1;
sum_1 = (_e226 + ((_e218.xyz * _e221) * _e224));
let _e229 = at0_[0u];
let _e231 = at3_[1u];
let _e233 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e229, _e231), 0f);
let _e236 = w0_[0u];
let _e239 = w3_[1u];
let _e241 = sum_1;
sum_1 = (_e241 + ((_e233.xyz * _e236) * _e239));
let _e244 = at12_[0u];
let _e246 = at3_[1u];
let _e248 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e244, _e246), 0f);
let _e251 = w12_[0u];
let _e254 = w3_[1u];
let _e256 = sum_1;
sum_1 = (_e256 + ((_e248.xyz * _e251) * _e254));
let _e259 = at3_[0u];
let _e261 = at3_[1u];
let _e263 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e259, _e261), 0f);
let _e266 = w3_[0u];
let _e269 = w3_[1u];
let _e271 = sum_1;
sum_1 = (_e271 + ((_e263.xyz * _e266) * _e269));
let _e273 = sum_1;
return max(_e273, vec3<f32>(0f, 0f, 0f));
}
fn SameSurface_u0028_f1_u003b_f1_u003b(depth: ptr<function, f32>, then: ptr<function, f32>) -> f32 {
var sky: bool;
var bothSky: bool;
var close: bool;
var phi_391_: bool;
let _e56 = (*depth);
sky = (_e56 <= 0f);
let _e58 = sky;
let _e59 = (*then);
bothSky = (_e58 && (_e59 <= 0f));
let _e62 = sky;
let _e64 = (*then);
let _e66 = (!(_e62) && (_e64 > 0f));
phi_391_ = _e66;
if _e66 {
let _e67 = (*then);
let _e68 = (*depth);
let _e73 = temporal_info.params[1u];
let _e74 = (*depth);
let _e75 = (*then);
phi_391_ = (abs((_e67 - _e68)) <= (_e73 * min(_e74, _e75)));
}
let _e80 = phi_391_;
close = _e80;
let _e81 = bothSky;
let _e82 = close;
return select(0f, 1f, (_e81 || _e82));
}
fn DepthTrust_u0028_f1_u003b_vf2_u003b(depth_1: ptr<function, f32>, uv_1: ptr<function, vec2<f32>>) -> f32 {
var size_1: vec2<f32>;
var position_1: vec2<f32>;
var corner: vec2<f32>;
var f_1: vec2<f32>;
var at0_1: vec2<f32>;
var at1_: vec2<f32>;
var d00_: f32;
var d10_: f32;
var d01_: f32;
var d11_: f32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: f32;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var param_8: f32;
let _e72 = temporal_info.params;
size_1 = _e72.zw;
let _e74 = (*uv_1);
let _e75 = size_1;
position_1 = ((_e74 * _e75) - vec2(0.5f));
let _e79 = position_1;
corner = floor(_e79);
let _e81 = position_1;
let _e82 = corner;
f_1 = (_e81 - _e82);
let _e84 = corner;
let _e87 = size_1;
at0_1 = ((_e84 + vec2(0.5f)) / _e87);
let _e89 = corner;
let _e92 = size_1;
at1_ = ((_e89 + vec2(1.5f)) / _e92);
let _e94 = at0_1;
let _e95 = textureSampleLevel(history_texture_tex, history_texture_smp, _e94, 0f);
d00_ = _e95.w;
let _e98 = at1_[0u];
let _e100 = at0_1[1u];
let _e102 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e98, _e100), 0f);
d10_ = _e102.w;
let _e105 = at0_1[0u];
let _e107 = at1_[1u];
let _e109 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e105, _e107), 0f);
d01_ = _e109.w;
let _e111 = at1_;
let _e112 = textureSampleLevel(history_texture_tex, history_texture_smp, _e111, 0f);
d11_ = _e112.w;
let _e114 = (*depth_1);
param_1 = _e114;
let _e115 = d00_;
param_2 = _e115;
let _e116 = SameSurface_u0028_f1_u003b_f1_u003b((¶m_1), (¶m_2));
let _e118 = f_1[0u];
let _e122 = f_1[1u];
let _e125 = (*depth_1);
param_3 = _e125;
let _e126 = d10_;
param_4 = _e126;
let _e127 = SameSurface_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
let _e129 = f_1[0u];
let _e132 = f_1[1u];
let _e136 = (*depth_1);
param_5 = _e136;
let _e137 = d01_;
param_6 = _e137;
let _e138 = SameSurface_u0028_f1_u003b_f1_u003b((¶m_5), (¶m_6));
let _e140 = f_1[0u];
let _e144 = f_1[1u];
let _e147 = (*depth_1);
param_7 = _e147;
let _e148 = d11_;
param_8 = _e148;
let _e149 = SameSurface_u0028_f1_u003b_f1_u003b((¶m_7), (¶m_8));
let _e151 = f_1[0u];
let _e154 = f_1[1u];
return (((((_e116 * (1f - _e118)) * (1f - _e122)) + ((_e127 * _e129) * (1f - _e132))) + ((_e138 * (1f - _e140)) * _e144)) + ((_e149 * _e151) * _e154));
}
fn RgbToYCoCg_u0028_vf3_u003b(c_3: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e53 = (*c_3)[0u];
let _e56 = (*c_3)[1u];
let _e60 = (*c_3)[2u];
let _e64 = (*c_3)[0u];
let _e67 = (*c_3)[2u];
let _e71 = (*c_3)[0u];
let _e74 = (*c_3)[1u];
let _e78 = (*c_3)[2u];
return vec3<f32>((((0.25f * _e53) + (0.5f * _e56)) + (0.25f * _e60)), ((0.5f * _e64) - (0.5f * _e67)), (((-0.25f * _e71) + (0.5f * _e74)) - (0.25f * _e78)));
}
fn Weigh_u0028_vf3_u003b(c_4: ptr<function, vec3<f32>>) -> vec3<f32> {
var param_9: vec3<f32>;
let _e53 = (*c_4);
let _e54 = (*c_4);
param_9 = _e54;
let _e55 = Luma_u0028_vf3_u003b((¶m_9));
let _e58 = temporal_info.params[0u];
return (_e53 / vec3((1f + (_e55 * _e58))));
}
fn main_1() {
var texel: vec2<f32>;
var sceneUv: vec2<f32>;
var centre_1: vec2<f32>;
var sum_2: vec3<f32>;
var sumSquares_1: vec3<f32>;
var lowest_1: vec3<f32>;
var highest_1: vec3<f32>;
var nearest: f32;
var nearestUv: vec2<f32>;
var dy: i32;
var dx: i32;
var at_1: vec2<f32>;
var c_5: vec3<f32>;
var param_10: vec3<f32>;
var param_11: vec3<f32>;
var around_1: array<vec3<f32>, 9>;
var depth_2: f32;
var current_1: vec3<f32>;
var depth_3: f32;
var then_1: vec2<f32>;
var trust: f32;
var param_12: f32;
var param_13: vec2<f32>;
var mean_1: vec3<f32>;
var sigma_1: vec3<f32>;
var lo_2: vec3<f32>;
var hi_2: vec3<f32>;
var remembered: vec3<f32>;
var param_14: vec2<f32>;
var param_15: vec3<f32>;
var param_16: vec3<f32>;
var clipped: vec3<f32>;
var local_3: vec3<f32>;
var param_17: vec3<f32>;
var param_18: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec3<f32>;
var param_21: array<vec3<f32>, 9>;
var param_22: vec3<f32>;
var param_23: vec3<f32>;
var param_24: vec3<f32>;
var history_1: vec3<f32>;
var param_25: vec3<f32>;
var param_26: vec3<f32>;
var reactive: f32;
var keep: f32;
var exposure: f32;
var wCurrent: f32;
var param_27: vec3<f32>;
var wHistory: f32;
var param_28: vec3<f32>;
var resolved: vec3<f32>;
var phi_931_: bool;
var phi_938_: bool;
var phi_945_: bool;
var phi_952_: bool;
let _e104 = temporal_info.scene_texel;
texel = _e104.xy;
let _e106 = v_uv_1;
let _e108 = temporal_info.jitter;
sceneUv = (_e106 + _e108.xy);
let _e111 = sceneUv;
let _e113 = temporal_info.scene_texel;
let _e119 = texel;
centre_1 = ((floor((_e111 * _e113.zw)) + vec2(0.5f)) * _e119);
sum_2 = vec3<f32>(0f, 0f, 0f);
sumSquares_1 = vec3<f32>(0f, 0f, 0f);
lowest_1 = vec3<f32>(1000000000000000000000000000000f, 1000000000000000000000000000000f, 1000000000000000000000000000000f);
highest_1 = vec3<f32>(-1000000000000000000000000000000f, -1000000000000000000000000000000f, -1000000000000000000000000000000f);
nearest = 1000000000000000000000000000000f;
let _e121 = centre_1;
nearestUv = _e121;
dy = -1i;
loop {
let _e122 = dy;
if (_e122 <= 1i) {
dx = -1i;
loop {
let _e124 = dx;
if (_e124 <= 1i) {
let _e126 = centre_1;
let _e127 = dx;
let _e129 = dy;
let _e132 = texel;
at_1 = (_e126 + (vec2<f32>(f32(_e127), f32(_e129)) * _e132));
let _e135 = at_1;
let _e136 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e135, 0f);
param_10 = _e136.xyz;
let _e138 = Weigh_u0028_vf3_u003b((¶m_10));
param_11 = _e138;
let _e139 = RgbToYCoCg_u0028_vf3_u003b((¶m_11));
c_5 = _e139;
let _e140 = dy;
let _e143 = dx;
let _e146 = c_5;
around_1[((((_e140 + 1i) * 3i) + _e143) + 1i)] = _e146;
let _e148 = c_5;
let _e149 = sum_2;
sum_2 = (_e149 + _e148);
let _e151 = c_5;
let _e152 = c_5;
let _e154 = sumSquares_1;
sumSquares_1 = (_e154 + (_e151 * _e152));
let _e156 = lowest_1;
let _e157 = c_5;
lowest_1 = min(_e156, _e157);
let _e159 = highest_1;
let _e160 = c_5;
highest_1 = max(_e159, _e160);
let _e162 = at_1;
let _e163 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e162, 0f);
depth_2 = _e163.w;
let _e165 = depth_2;
let _e167 = depth_2;
let _e168 = nearest;
if ((_e165 > 0f) && (_e167 < _e168)) {
let _e171 = depth_2;
nearest = _e171;
let _e172 = at_1;
nearestUv = _e172;
}
continue;
} else {
break;
}
continuing {
let _e173 = dx;
dx = (_e173 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e175 = dy;
dy = (_e175 + 1i);
}
}
let _e177 = sceneUv;
let _e178 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e177, 0f);
current_1 = _e178.xyz;
let _e180 = nearest;
let _e182 = nearest;
depth_3 = select(0f, _e182, (_e180 < 1000000000000000000000000000000f));
let _e184 = v_uv_1;
let _e185 = nearestUv;
let _e186 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e185, 0f);
then_1 = (_e184 - _e186.xy);
let _e191 = temporal_info.jitter[3u];
let _e192 = (_e191 < 0.5f);
phi_931_ = _e192;
if !(_e192) {
let _e195 = then_1[0u];
phi_931_ = (_e195 < 0f);
}
let _e198 = phi_931_;
phi_938_ = _e198;
if !(_e198) {
let _e201 = then_1[0u];
phi_938_ = (_e201 > 1f);
}
let _e204 = phi_938_;
phi_945_ = _e204;
if !(_e204) {
let _e207 = then_1[1u];
phi_945_ = (_e207 < 0f);
}
let _e210 = phi_945_;
phi_952_ = _e210;
if !(_e210) {
let _e213 = then_1[1u];
phi_952_ = (_e213 > 1f);
}
let _e216 = phi_952_;
if _e216 {
let _e217 = current_1;
let _e218 = depth_3;
frag_color = vec4<f32>(_e217.x, _e217.y, _e217.z, _e218);
return;
}
let _e223 = depth_3;
param_12 = _e223;
let _e224 = then_1;
param_13 = _e224;
let _e225 = DepthTrust_u0028_f1_u003b_vf2_u003b((¶m_12), (¶m_13));
trust = _e225;
let _e226 = sum_2;
mean_1 = (_e226 / vec3(9f));
let _e229 = sumSquares_1;
let _e232 = mean_1;
let _e233 = mean_1;
sigma_1 = sqrt(max(((_e229 / vec3(9f)) - (_e232 * _e233)), vec3<f32>(0f, 0f, 0f)));
let _e238 = lowest_1;
let _e239 = mean_1;
let _e240 = sigma_1;
lo_2 = max(_e238, (_e239 - (_e240 * 1.25f)));
let _e244 = highest_1;
let _e245 = mean_1;
let _e246 = sigma_1;
hi_2 = min(_e244, (_e245 + (_e246 * 1.25f)));
let _e250 = then_1;
param_14 = _e250;
let _e251 = HistoryAt_u0028_vf2_u003b((¶m_14));
param_15 = _e251;
let _e252 = Weigh_u0028_vf3_u003b((¶m_15));
param_16 = _e252;
let _e253 = RgbToYCoCg_u0028_vf3_u003b((¶m_16));
remembered = _e253;
let _e256 = temporal_info.clip[0u];
if (_e256 > 0.5f) {
let _e258 = current_1;
param_17 = _e258;
let _e259 = Weigh_u0028_vf3_u003b((¶m_17));
param_18 = _e259;
let _e260 = RgbToYCoCg_u0028_vf3_u003b((¶m_18));
param_19 = _e260;
let _e261 = remembered;
param_20 = _e261;
let _e262 = around_1;
param_21 = _e262;
let _e263 = ClipToDop_u0028_vf3_u003b_vf3_u003b_vf3_u005b_9_u005d_u003b((¶m_19), (¶m_20), (¶m_21));
local_3 = _e263;
} else {
let _e264 = lo_2;
param_22 = _e264;
let _e265 = hi_2;
param_23 = _e265;
let _e266 = remembered;
param_24 = _e266;
let _e267 = ClipToBox_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_22), (¶m_23), (¶m_24));
local_3 = _e267;
}
let _e268 = local_3;
clipped = _e268;
let _e269 = clipped;
param_25 = _e269;
let _e270 = YCoCgToRgb_u0028_vf3_u003b((¶m_25));
param_26 = _e270;
let _e271 = Unweigh_u0028_vf3_u003b((¶m_26));
history_1 = _e271;
let _e272 = centre_1;
let _e273 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e272, 0f);
reactive = clamp(_e273.z, 0f, 1f);
let _e278 = temporal_info.jitter[2u];
let _e279 = trust;
let _e281 = reactive;
keep = ((_e278 * _e279) * (1f - _e281));
let _e286 = temporal_info.params[0u];
exposure = _e286;
let _e287 = keep;
let _e289 = current_1;
param_27 = _e289;
let _e290 = Luma_u0028_vf3_u003b((¶m_27));
let _e291 = exposure;
wCurrent = ((1f - _e287) / (1f + (_e290 * _e291)));
let _e295 = keep;
let _e296 = history_1;
param_28 = _e296;
let _e297 = Luma_u0028_vf3_u003b((¶m_28));
let _e298 = exposure;
wHistory = (_e295 / (1f + (_e297 * _e298)));
let _e302 = current_1;
let _e303 = wCurrent;
let _e305 = history_1;
let _e306 = wHistory;
let _e309 = wCurrent;
let _e310 = wHistory;
resolved = (((_e302 * _e303) + (_e305 * _e306)) / vec3(max((_e309 + _e310), 0.000001f)));
let _e315 = resolved;
let _e316 = depth_3;
frag_color = vec4<f32>(_e315.x, _e315.y, _e315.z, _e316);
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: 'TemporalInfo',
group: 1,
binding: 0,
sizeInBytes: 320,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'scene_texel',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'jitter',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'clip', offsetInBytes: 48, sizeInBytes: 16),
WebGpuBlockMember(
name: 'clip_axes',
offsetInBytes: 64,
sizeInBytes: 256,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'history_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'velocity_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'TemporalAccumulate': WebGpuStage(
wgsl: r'''
struct AccumulateInfo {
params: vec4<f32>,
}
@group(1) @binding(1)
var current_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var current_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(5)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var velocity_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> accumulate_info: AccumulateInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var history_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var history_texture_smp: sampler;
fn main_1() {
var now: vec4<f32>;
var then: vec2<f32>;
var texel: vec2<f32>;
var lowest: vec4<f32>;
var highest: vec4<f32>;
var dy: i32;
var dx: i32;
var around: vec4<f32>;
var past: vec4<f32>;
var phi_59_: bool;
var phi_67_: bool;
var phi_74_: bool;
var phi_81_: bool;
let _e26 = v_uv_1;
let _e27 = textureSampleLevel(current_texture_tex, current_texture_smp, _e26, 0f);
now = _e27;
let _e28 = v_uv_1;
let _e29 = v_uv_1;
let _e30 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e29, 0f);
then = (_e28 - _e30.xy);
let _e35 = accumulate_info.params[1u];
let _e36 = (_e35 < 0.5f);
phi_59_ = _e36;
if !(_e36) {
let _e39 = then[0u];
phi_59_ = (_e39 < 0f);
}
let _e42 = phi_59_;
phi_67_ = _e42;
if !(_e42) {
let _e45 = then[0u];
phi_67_ = (_e45 > 1f);
}
let _e48 = phi_67_;
phi_74_ = _e48;
if !(_e48) {
let _e51 = then[1u];
phi_74_ = (_e51 < 0f);
}
let _e54 = phi_74_;
phi_81_ = _e54;
if !(_e54) {
let _e57 = then[1u];
phi_81_ = (_e57 > 1f);
}
let _e60 = phi_81_;
if _e60 {
let _e61 = now;
frag_color = _e61;
return;
}
let _e63 = accumulate_info.params;
texel = _e63.zw;
let _e65 = now;
lowest = _e65;
let _e66 = now;
highest = _e66;
dy = -1i;
loop {
let _e67 = dy;
if (_e67 <= 1i) {
dx = -1i;
loop {
let _e69 = dx;
if (_e69 <= 1i) {
let _e71 = v_uv_1;
let _e72 = dx;
let _e74 = dy;
let _e77 = texel;
let _e80 = textureSampleLevel(current_texture_tex, current_texture_smp, (_e71 + (vec2<f32>(f32(_e72), f32(_e74)) * _e77)), 0f);
around = _e80;
let _e81 = lowest;
let _e82 = around;
lowest = min(_e81, _e82);
let _e84 = highest;
let _e85 = around;
highest = max(_e84, _e85);
continue;
} else {
break;
}
continuing {
let _e87 = dx;
dx = (_e87 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e89 = dy;
dy = (_e89 + 1i);
}
}
let _e91 = then;
let _e92 = textureSampleLevel(history_texture_tex, history_texture_smp, _e91, 0f);
let _e93 = lowest;
let _e94 = highest;
past = clamp(_e92, _e93, _e94);
let _e96 = now;
let _e97 = past;
let _e100 = accumulate_info.params[0u];
frag_color = mix(_e96, _e97, vec4(_e100));
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: 'AccumulateInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'current_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'history_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'velocity_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LightShafts': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
struct NoiseInfo {
noise: vec4<f32>,
}
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>,
sun: vec4<f32>,
bias: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> shaft_info: ShaftInfo;
@group(1) @binding(7)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var shadow_texture_smp: sampler;
@group(1) @binding(5)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
fn HenyeyGreenstein_u0028_f1_u003b_f1_u003b(cosine: ptr<function, f32>, g: ptr<function, f32>) -> f32 {
var g2_: f32;
var denominator: f32;
let _e64 = (*g);
let _e65 = (*g);
g2_ = (_e64 * _e65);
let _e67 = g2_;
let _e69 = (*g);
let _e71 = (*cosine);
denominator = max(((1f + _e67) - ((2f * _e69) * _e71)), 0.0001f);
let _e75 = g2_;
let _e77 = denominator;
let _e79 = denominator;
return ((1f - _e75) / ((12.566371f * _e77) * sqrt(_e79)));
}
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 bias: f32;
var local_2: f32;
var local_3: f32;
var phi_312_: bool;
var phi_323_: bool;
var phi_409_: bool;
var phi_416_: bool;
var phi_423_: bool;
let _e79 = shaft_info.cascades[2u];
cascadeCount = i32((_e79 + 0.5f));
cascade = 0i;
let _e82 = cascadeCount;
let _e83 = (_e82 > 1i);
phi_312_ = _e83;
if _e83 {
let _e84 = (*viewDistance);
let _e87 = shaft_info.cascades[0u];
phi_312_ = (_e84 > _e87);
}
let _e90 = phi_312_;
if _e90 {
cascade = 1i;
}
let _e91 = cascadeCount;
let _e92 = (_e91 > 2i);
phi_323_ = _e92;
if _e92 {
let _e93 = (*viewDistance);
let _e96 = shaft_info.cascades[1u];
phi_323_ = (_e93 > _e96);
}
let _e99 = phi_323_;
if _e99 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e100 = attempt;
if (_e100 < 3i) {
let _e102 = cascade;
let _e103 = attempt;
which = (_e102 + _e103);
let _e105 = which;
let _e106 = cascadeCount;
if (_e105 >= _e106) {
break;
}
let _e108 = which;
if (_e108 == 0i) {
let _e111 = shaft_info.shadow_matrix;
local = _e111;
} else {
let _e112 = which;
if (_e112 == 1i) {
let _e115 = shaft_info.shadow_matrix_far;
local_1 = _e115;
} else {
let _e117 = shaft_info.shadow_matrix_farthest;
local_1 = _e117;
}
let _e118 = local_1;
local = _e118;
}
let _e119 = local;
matrix = _e119;
let _e120 = matrix;
let _e121 = (*world);
lightSpace = (_e120 * vec4<f32>(_e121.x, _e121.y, _e121.z, 1f));
let _e128 = lightSpace[3u];
if (_e128 <= 0f) {
continue;
}
let _e130 = lightSpace;
let _e133 = lightSpace[3u];
candidate = (_e130.xyz / vec3(_e133));
let _e137 = candidate[0u];
let _e141 = candidate[1u];
inTile = vec2<f32>(((_e137 * 0.5f) + 0.5f), (0.5f - (_e141 * 0.5f)));
let _e146 = inTile[0u];
let _e147 = (_e146 < 0f);
phi_409_ = _e147;
if !(_e147) {
let _e150 = inTile[0u];
phi_409_ = (_e150 > 1f);
}
let _e153 = phi_409_;
phi_416_ = _e153;
if !(_e153) {
let _e156 = inTile[1u];
phi_416_ = (_e156 < 0f);
}
let _e159 = phi_416_;
phi_423_ = _e159;
if !(_e159) {
let _e162 = inTile[1u];
phi_423_ = (_e162 > 1f);
}
let _e165 = phi_423_;
if _e165 {
continue;
}
let _e167 = candidate[2u];
if (_e167 > 1f) {
let _e169 = which;
let _e170 = cascadeCount;
if (_e169 < (_e170 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e175 = inTile[0u];
let _e176 = which;
let _e179 = cascadeCount;
let _e183 = inTile[1u];
uv = vec2<f32>(((_e175 + f32(_e176)) / f32(_e179)), _e183);
let _e185 = uv;
let _e186 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e185, 0f);
stored = _e186.x;
let _e188 = which;
if (_e188 == 0i) {
let _e192 = shaft_info.bias[0u];
local_2 = _e192;
} else {
let _e193 = which;
if (_e193 == 1i) {
let _e197 = shaft_info.bias[1u];
local_3 = _e197;
} else {
let _e200 = shaft_info.bias[2u];
local_3 = _e200;
}
let _e201 = local_3;
local_2 = _e201;
}
let _e202 = local_2;
bias = _e202;
let _e204 = candidate[2u];
let _e205 = bias;
let _e207 = stored;
return select(1f, 0f, ((_e204 - _e205) > _e207));
} else {
break;
}
continuing {
let _e210 = attempt;
attempt = (_e210 + 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 _e66 = (*at)[0u];
x = i32((_e66 - (floor((_e66 / 4f)) * 4f)));
let _e73 = (*at)[1u];
y = i32((_e73 - (floor((_e73 / 4f)) * 4f)));
let _e79 = y;
let _e81 = x;
index = ((_e79 * 4i) + _e81);
value = 0f;
let _e83 = index;
if (_e83 == 0i) {
value = 0f;
} else {
let _e85 = index;
if (_e85 == 1i) {
value = 8f;
} else {
let _e87 = index;
if (_e87 == 2i) {
value = 2f;
} else {
let _e89 = index;
if (_e89 == 3i) {
value = 10f;
} else {
let _e91 = index;
if (_e91 == 4i) {
value = 12f;
} else {
let _e93 = index;
if (_e93 == 5i) {
value = 4f;
} else {
let _e95 = index;
if (_e95 == 6i) {
value = 14f;
} else {
let _e97 = index;
if (_e97 == 7i) {
value = 6f;
} else {
let _e99 = index;
if (_e99 == 8i) {
value = 3f;
} else {
let _e101 = index;
if (_e101 == 9i) {
value = 11f;
} else {
let _e103 = index;
if (_e103 == 10i) {
value = 1f;
} else {
let _e105 = index;
if (_e105 == 11i) {
value = 9f;
} else {
let _e107 = index;
if (_e107 == 12i) {
value = 15f;
} else {
let _e109 = index;
if (_e109 == 13i) {
value = 7f;
} else {
let _e111 = index;
if (_e111 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e113 = value;
return (_e113 / 16f);
}
fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell: vec2<f32>;
var corner: vec2<f32>;
var uv_1: vec2<f32>;
let _e67 = noise_info.noise[1u];
slice = _e67;
let _e68 = (*at_1);
let _e69 = floor(_e68);
let _e70 = vec2(64f);
cell = (_e69 - (floor((_e69 / _e70)) * _e70));
let _e75 = slice;
let _e80 = slice;
corner = (vec2<f32>((_e75 - (floor((_e75 / 8f)) * 8f)), floor((_e80 / 8f))) * 64f);
let _e85 = corner;
let _e86 = cell;
uv_1 = (((_e85 + _e86) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e91 = uv_1;
let _e92 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e91, 0f);
return (_e92.x * 0.99609375f);
}
fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var local_4: f32;
var param: vec2<f32>;
var param_1: vec2<f32>;
let _e66 = noise_info.noise[0u];
if (_e66 > 0.5f) {
let _e68 = (*at_2);
param = _e68;
let _e69 = BlueNoise_u0028_vf2_u003b((¶m));
local_4 = _e69;
} else {
let _e70 = (*at_2);
param_1 = _e70;
let _e71 = BayerCell_u0028_vf2_u003b((¶m_1));
local_4 = _e71;
}
let _e72 = local_4;
return _e72;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_5: vec2<f32>;
let _e62 = (*rows);
if (_e62 > 0f) {
let _e65 = gl_FragCoord_1[0u];
let _e66 = (*rows);
let _e68 = gl_FragCoord_1[1u];
local_5 = vec2<f32>(_e65, (_e66 - _e68));
} else {
let _e71 = gl_FragCoord_1;
local_5 = _e71.xy;
}
let _e73 = local_5;
return _e73;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_2: f32;
let _e63 = frag_coord_info.origin[0u];
param_2 = _e63;
let _e64 = FragCoordFromTop_u0028_f1_u003b((¶m_2));
return _e64;
}
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_1: f32;
var toSurface: f32;
var local_6: f32;
var distance_: f32;
var stride: f32;
var offset: f32;
var param_3: vec2<f32>;
var sigma: f32;
var stepTransmittance: f32;
var transmittance: f32;
var eye: vec3<f32>;
var inscatter: f32;
var i: i32;
var travelled: f32;
var at_3: vec3<f32>;
var lit: f32;
var param_4: vec3<f32>;
var param_5: f32;
var phase: f32;
var param_6: f32;
var param_7: f32;
var shaft: vec3<f32>;
let _e90 = v_uv_1;
let _e91 = textureSample(scene_texture_tex, scene_texture_smp, _e90);
scene = _e91;
let _e94 = shaft_info.forward[3u];
steps = i32((_e94 + 0.5f));
let _e97 = steps;
if (_e97 < 1i) {
let _e99 = scene;
frag_color = _e99;
return;
}
let _e101 = v_uv_1[0u];
let _e105 = v_uv_1[1u];
xy = vec2<f32>(((_e101 * 2f) - 1f), (1f - (_e105 * 2f)));
let _e110 = shaft_info.inverse_view_projection;
let _e111 = xy;
nearH = (_e110 * vec4<f32>(_e111.x, _e111.y, 0f, 1f));
let _e117 = shaft_info.inverse_view_projection;
let _e118 = xy;
farH = (_e117 * vec4<f32>(_e118.x, _e118.y, 1f, 1f));
let _e123 = nearH;
let _e126 = nearH[3u];
origin = (_e123.xyz / vec3(_e126));
let _e129 = farH;
let _e132 = farH[3u];
let _e135 = origin;
along = normalize(((_e129.xyz / vec3(_e132)) - _e135));
let _e138 = v_uv_1;
let _e139 = textureSample(surface_texture_tex, surface_texture_smp, _e138);
surfaceDepth = _e139.w;
let _e141 = along;
let _e143 = shaft_info.forward;
cosine_1 = max(dot(_e141, _e143.xyz), 0.0001f);
let _e147 = surfaceDepth;
if (_e147 > 0f) {
let _e149 = surfaceDepth;
let _e150 = cosine_1;
local_6 = (_e149 / _e150);
} else {
local_6 = 1000000000f;
}
let _e152 = local_6;
toSurface = _e152;
let _e155 = shaft_info.camera[3u];
let _e156 = toSurface;
distance_ = min(_e155, _e156);
let _e158 = distance_;
if (_e158 <= 0f) {
let _e160 = scene;
frag_color = _e160;
return;
}
let _e161 = distance_;
let _e162 = steps;
stride = (_e161 / f32(_e162));
let _e165 = TargetFragCoord_u0028_();
param_3 = _e165;
let _e166 = PixelNoise_u0028_vf2_u003b((¶m_3));
let _e167 = stride;
offset = (_e166 * _e167);
let _e171 = shaft_info.scatter[3u];
sigma = max(_e171, 0f);
let _e173 = sigma;
let _e175 = stride;
stepTransmittance = exp((-(_e173) * _e175));
let _e178 = sigma;
let _e180 = offset;
transmittance = exp((-(_e178) * _e180));
let _e184 = shaft_info.camera;
eye = _e184.xyz;
inscatter = 0f;
i = 0i;
loop {
let _e186 = i;
if (_e186 < 64i) {
let _e188 = i;
let _e189 = steps;
if (_e188 >= _e189) {
break;
}
let _e191 = offset;
let _e192 = i;
let _e194 = stride;
travelled = (_e191 + (f32(_e192) * _e194));
let _e197 = origin;
let _e198 = along;
let _e199 = travelled;
at_3 = (_e197 + (_e198 * _e199));
let _e202 = at_3;
let _e203 = eye;
let _e206 = at_3;
param_4 = _e206;
param_5 = length((_e202 - _e203));
let _e207 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_4), (¶m_5));
lit = _e207;
let _e208 = transmittance;
let _e209 = stepTransmittance;
let _e212 = lit;
let _e214 = inscatter;
inscatter = (_e214 + ((_e208 * (1f - _e209)) * _e212));
let _e216 = stepTransmittance;
let _e217 = transmittance;
transmittance = (_e217 * _e216);
continue;
} else {
break;
}
continuing {
let _e219 = i;
i = (_e219 + 1i);
}
}
let _e221 = along;
let _e223 = shaft_info.sun;
param_6 = dot(_e221, _e223.xyz);
let _e228 = shaft_info.sun[3u];
param_7 = _e228;
let _e229 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_6), (¶m_7));
phase = _e229;
let _e231 = shaft_info.scatter;
let _e233 = phase;
let _e234 = inscatter;
shaft = (_e231.xyz * (_e233 * _e234));
let _e237 = scene;
let _e239 = shaft;
let _e240 = (_e237.xyz + _e239);
let _e242 = scene[3u];
frag_color = vec4<f32>(_e240.x, _e240.y, _e240.z, _e242);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'NoiseInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'ShaftInfo',
group: 1,
binding: 2,
sizeInBytes: 352,
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,
),
WebGpuBlockMember(name: 'sun', offsetInBytes: 320, sizeInBytes: 16),
WebGpuBlockMember(
name: 'bias',
offsetInBytes: 336,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VolumetricFog': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
struct NoiseInfo {
noise: vec4<f32>,
}
struct VolumeFogInfo {
inverse_view_projection: mat4x4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
cluster_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
sun: vec4<f32>,
sun_radiance: vec4<f32>,
cascades: vec4<f32>,
bias: vec4<f32>,
medium: vec4<f32>,
albedo: vec4<f32>,
ambient: vec4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
list: 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>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(4)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var blue_noise_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> fog_info: VolumeFogInfo;
@group(1) @binding(12)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var shadow_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(10)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var point_shadow_texture_smp: sampler;
@group(1) @binding(8)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(6)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var light_list_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(14)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn HenyeyGreenstein_u0028_f1_u003b_f1_u003b(cosine: ptr<function, f32>, g: ptr<function, f32>) -> f32 {
var g2_: f32;
var denominator: f32;
let _e85 = (*g);
let _e86 = (*g);
g2_ = (_e85 * _e86);
let _e88 = g2_;
let _e90 = (*g);
let _e92 = (*cosine);
denominator = max(((1f + _e88) - ((2f * _e90) * _e92)), 0.0001f);
let _e96 = g2_;
let _e98 = denominator;
let _e100 = denominator;
return ((1f - _e96) / ((12.566371f * _e98) * sqrt(_e100)));
}
fn LocalLitAt_u0028_vf3_u003b_vf4_u003b(world: ptr<function, vec3<f32>>, cone: ptr<function, vec4<f32>>) -> f32 {
var strength: f32;
var slot: i32;
var toFragment: vec3<f32>;
var distance_: f32;
var range: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv: vec2<f32>;
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
var stored: f32;
var lit: f32;
var phi_608_: bool;
var phi_669_: bool;
let _e100 = point_shadow.params[2u];
strength = _e100;
let _e102 = (*cone)[2u];
let _e104 = strength;
if ((_e102 < 0.5f) || (_e104 <= 0f)) {
return 1f;
}
let _e108 = (*cone)[2u];
slot = i32((_e108 - 0.5f));
let _e111 = (*world);
let _e112 = slot;
let _e115 = point_shadow.lights[_e112];
toFragment = (_e111 - _e115.xyz);
let _e118 = toFragment;
distance_ = length(_e118);
let _e120 = slot;
let _e124 = point_shadow.lights[_e120][3u];
range = max(_e124, 0.0001f);
let _e126 = distance_;
let _e127 = range;
if (_e126 >= _e127) {
return 1f;
}
face = 0i;
let _e130 = (*cone)[3u];
if (_e130 < 0.5f) {
let _e132 = toFragment;
a = abs(_e132);
let _e135 = a[0u];
let _e137 = a[1u];
let _e138 = (_e135 >= _e137);
phi_608_ = _e138;
if _e138 {
let _e140 = a[0u];
let _e142 = a[2u];
phi_608_ = (_e140 >= _e142);
}
let _e145 = phi_608_;
if _e145 {
let _e147 = toFragment[0u];
face = select(1i, 0i, (_e147 > 0f));
} else {
let _e151 = a[1u];
let _e153 = a[2u];
if (_e151 >= _e153) {
let _e156 = toFragment[1u];
face = select(3i, 2i, (_e156 > 0f));
} else {
let _e160 = toFragment[2u];
face = select(5i, 4i, (_e160 > 0f));
}
}
}
let _e163 = slot;
let _e165 = face;
let _e169 = point_shadow.faces[((_e163 * 6i) + _e165)];
let _e170 = (*world);
clip = (_e169 * vec4<f32>(_e170.x, _e170.y, _e170.z, 1f));
let _e177 = clip[3u];
if (_e177 <= 0f) {
return 1f;
}
let _e179 = clip;
let _e182 = clip[3u];
ndc = (_e179.xy / vec2(_e182));
let _e186 = ndc[0u];
let _e188 = (abs(_e186) > 1f);
phi_669_ = _e188;
if !(_e188) {
let _e191 = ndc[1u];
phi_669_ = (abs(_e191) > 1f);
}
let _e195 = phi_669_;
if _e195 {
return 1f;
}
let _e197 = ndc[0u];
let _e201 = ndc[1u];
uv = vec2<f32>(((_e197 * 0.5f) + 0.5f), (0.5f - (_e201 * 0.5f)));
let _e207 = point_shadow.params[0u];
inset = _e207;
let _e208 = uv;
let _e209 = inset;
let _e210 = inset;
local = clamp(_e208, vec2(_e209), vec2((1f - _e210)));
let _e215 = local;
let _e216 = face;
let _e218 = slot;
atlas = ((_e215 + vec2<f32>(f32(_e216), f32(_e218))) * vec2<f32>(0.16666667f, 0.16666667f));
let _e225 = point_shadow.params3_[0u];
if (_e225 > 0.5f) {
let _e228 = atlas[1u];
atlas[1u] = (1f - _e228);
}
let _e231 = atlas;
let _e232 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e231, 0f);
let _e234 = atlas;
let _e235 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e234, 0f);
let _e238 = range;
stored = (min(_e232.x, _e235.x) * _e238);
let _e240 = stored;
let _e241 = range;
if (_e240 >= (_e241 * 0.999f)) {
return 1f;
}
let _e244 = distance_;
let _e247 = point_shadow.params[1u];
let _e249 = stored;
lit = select(1f, 0f, ((_e244 - _e247) > _e249));
let _e252 = lit;
let _e253 = strength;
return mix(1f, _e252, clamp(_e253, 0f, 1f));
}
fn Lane_u0028_vf4_u003b_f1_u003b(four: ptr<function, vec4<f32>>, lane: ptr<function, f32>) -> f32 {
var local_1: f32;
var local_2: f32;
var local_3: f32;
let _e86 = (*lane);
if (_e86 < 0.5f) {
let _e89 = (*four)[0u];
local_1 = _e89;
} else {
let _e90 = (*lane);
if (_e90 < 1.5f) {
let _e93 = (*four)[1u];
local_2 = _e93;
} else {
let _e94 = (*lane);
if (_e94 < 2.5f) {
let _e97 = (*four)[2u];
local_3 = _e97;
} else {
let _e99 = (*four)[3u];
local_3 = _e99;
}
let _e100 = local_3;
local_2 = _e100;
}
let _e101 = local_2;
local_1 = _e101;
}
let _e102 = local_1;
return _e102;
}
fn ListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row: ptr<function, f32>) -> vec4<f32> {
let _e83 = (*texel);
let _e87 = fog_info.list[0u];
let _e89 = (*row);
let _e93 = fog_info.list[1u];
let _e96 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e83 + 0.5f) * _e87), ((_e89 + 0.5f) * _e93)), 0f);
return _e96;
}
fn ClusterLight_u0028_vf3_u003b_vf3_u003b_f1_u003b(world_1: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>, g_1: ptr<function, f32>) -> vec3<f32> {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_4: f32;
var cell: f32;
var headerRow: f32;
var header: vec4<f32>;
var param: f32;
var param_1: f32;
var count: i32;
var total: vec3<f32>;
var i: i32;
var entry: f32;
var entryRow: f32;
var within: f32;
var texel_1: f32;
var four_1: vec4<f32>;
var param_2: f32;
var param_3: f32;
var row_1: f32;
var param_4: vec4<f32>;
var param_5: f32;
var position: vec4<f32>;
var param_6: f32;
var param_7: f32;
var color: vec4<f32>;
var param_8: f32;
var param_9: f32;
var direction: vec4<f32>;
var param_10: f32;
var param_11: f32;
var cone_1: vec4<f32>;
var param_12: f32;
var param_13: f32;
var type_30: f32;
var toLight: vec3<f32>;
var distance_1: f32;
var usable: f32;
var l: vec3<f32>;
var attenuation: f32;
var ratio: f32;
var window: f32;
var cosAngle: f32;
var visibility: f32;
var local_5: f32;
var param_14: vec3<f32>;
var param_15: vec4<f32>;
var param_16: f32;
var param_17: f32;
let _e138 = fog_info.cluster_view_projection;
let _e139 = (*world_1);
clip_1 = (_e138 * vec4<f32>(_e139.x, _e139.y, _e139.z, 1f));
let _e145 = clip_1;
let _e148 = clip_1[3u];
ndc_1 = (_e145.xy / vec2(max(_e148, 0.000001f)));
let _e153 = fog_info.cluster_grid;
grid = _e153.xyz;
let _e157 = fog_info.cluster_depth[0u];
near = _e157;
let _e159 = ndc_1[0u];
let _e163 = grid[0u];
let _e167 = grid[0u];
tx = clamp(floor((((_e159 * 0.5f) + 0.5f) * _e163)), 0f, (_e167 - 1f));
let _e171 = ndc_1[1u];
let _e175 = grid[1u];
let _e179 = grid[1u];
ty = clamp(floor((((_e171 * 0.5f) + 0.5f) * _e175)), 0f, (_e179 - 1f));
let _e183 = clip_1[3u];
let _e184 = near;
if (_e183 <= _e184) {
local_4 = 0f;
} else {
let _e187 = clip_1[3u];
let _e188 = near;
let _e193 = fog_info.cluster_depth[1u];
let _e197 = grid[2u];
local_4 = clamp(floor((log((_e187 / _e188)) * _e193)), 0f, (_e197 - 1f));
}
let _e200 = local_4;
tz = _e200;
let _e201 = tx;
let _e202 = ty;
let _e204 = grid[0u];
let _e207 = tz;
let _e209 = grid[0u];
let _e212 = grid[1u];
cell = ((_e201 + (_e202 * _e204)) + ((_e207 * _e209) * _e212));
let _e215 = cell;
headerRow = floor((_e215 / 4f));
let _e218 = cell;
let _e219 = headerRow;
let _e224 = fog_info.cluster_depth[2u];
let _e225 = headerRow;
param = (_e218 - (_e219 * 4f));
param_1 = (_e224 + _e225);
let _e227 = ListTexel_u0028_f1_u003b_f1_u003b((¶m), (¶m_1));
header = _e227;
let _e229 = header[1u];
count = i32((_e229 + 0.5f));
total = vec3<f32>(0f, 0f, 0f);
i = 0i;
loop {
let _e232 = i;
if (_e232 < 16i) {
let _e234 = i;
let _e235 = count;
if (_e234 >= _e235) {
break;
}
let _e238 = header[0u];
let _e239 = i;
entry = (_e238 + f32(_e239));
let _e242 = entry;
entryRow = floor((_e242 / 16f));
let _e245 = entry;
let _e246 = entryRow;
within = (_e245 - (_e246 * 16f));
let _e249 = within;
texel_1 = floor((_e249 / 4f));
let _e254 = fog_info.cluster_depth[3u];
let _e255 = entryRow;
let _e257 = texel_1;
param_2 = _e257;
param_3 = (_e254 + _e255);
let _e258 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_2), (¶m_3));
four_1 = _e258;
let _e259 = within;
let _e260 = texel_1;
let _e263 = four_1;
param_4 = _e263;
param_5 = (_e259 - (_e260 * 4f));
let _e264 = Lane_u0028_vf4_u003b_f1_u003b((¶m_4), (¶m_5));
row_1 = _e264;
param_6 = 0f;
let _e265 = row_1;
param_7 = _e265;
let _e266 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_6), (¶m_7));
position = _e266;
param_8 = 1f;
let _e267 = row_1;
param_9 = _e267;
let _e268 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_8), (¶m_9));
color = _e268;
param_10 = 2f;
let _e269 = row_1;
param_11 = _e269;
let _e270 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_10), (¶m_11));
direction = _e270;
param_12 = 3f;
let _e271 = row_1;
param_13 = _e271;
let _e272 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_12), (¶m_13));
cone_1 = _e272;
let _e274 = position[3u];
type_30 = _e274;
let _e275 = position;
let _e277 = (*world_1);
toLight = (_e275.xyz - _e277);
let _e279 = toLight;
distance_1 = length(_e279);
let _e281 = type_30;
let _e283 = type_30;
let _e286 = distance_1;
usable = select(0f, 1f, (((_e281 > 0.5f) && (_e283 < 2.5f)) && (_e286 > 0.0001f)));
let _e290 = toLight;
let _e291 = distance_1;
l = (_e290 / vec3(max(_e291, 0.0001f)));
let _e295 = distance_1;
let _e296 = distance_1;
attenuation = (1f / max((_e295 * _e296), 0.0001f));
let _e301 = direction[3u];
if (_e301 > 0f) {
let _e303 = distance_1;
let _e305 = direction[3u];
ratio = (_e303 / _e305);
let _e307 = ratio;
let _e308 = ratio;
let _e310 = ratio;
let _e312 = ratio;
window = clamp((1f - (((_e307 * _e308) * _e310) * _e312)), 0f, 1f);
let _e316 = window;
let _e317 = window;
let _e319 = attenuation;
attenuation = (_e319 * (_e316 * _e317));
}
let _e321 = type_30;
let _e323 = type_30;
if ((_e321 > 1.5f) && (_e323 < 2.5f)) {
let _e326 = direction;
let _e329 = l;
cosAngle = dot(normalize(_e326.xyz), -(_e329));
let _e332 = cosAngle;
let _e334 = cone_1[1u];
let _e337 = cone_1[0u];
let _e339 = cone_1[1u];
let _e343 = attenuation;
attenuation = (_e343 * clamp(((_e332 - _e334) / (_e337 - _e339)), 0f, 1f));
}
let _e345 = attenuation;
let _e346 = usable;
if ((_e345 * _e346) > 0f) {
let _e349 = (*world_1);
param_14 = _e349;
let _e350 = cone_1;
param_15 = _e350;
let _e351 = LocalLitAt_u0028_vf3_u003b_vf4_u003b((¶m_14), (¶m_15));
local_5 = _e351;
} else {
local_5 = 1f;
}
let _e352 = local_5;
visibility = _e352;
let _e353 = color;
let _e356 = color[3u];
let _e357 = attenuation;
let _e359 = usable;
let _e361 = visibility;
let _e363 = (*along);
let _e364 = l;
param_16 = dot(_e363, _e364);
let _e366 = (*g_1);
param_17 = _e366;
let _e367 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_16), (¶m_17));
let _e370 = total;
total = (_e370 + (_e353.xyz * ((((_e356 * _e357) * _e359) * _e361) * _e367)));
continue;
} else {
break;
}
continuing {
let _e372 = i;
i = (_e372 + 1i);
}
}
let _e374 = total;
return _e374;
}
fn LitAt_u0028_vf3_u003b_f1_u003b(world_2: 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_6: mat4x4<f32>;
var local_7: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var uv_1: vec2<f32>;
var stored_1: f32;
var bias: f32;
var local_8: f32;
var local_9: f32;
var phi_358_: bool;
var phi_369_: bool;
var phi_454_: bool;
var phi_461_: bool;
var phi_468_: bool;
let _e100 = fog_info.cascades[2u];
cascadeCount = i32((_e100 + 0.5f));
cascade = 0i;
let _e103 = cascadeCount;
let _e104 = (_e103 > 1i);
phi_358_ = _e104;
if _e104 {
let _e105 = (*viewDistance);
let _e108 = fog_info.cascades[0u];
phi_358_ = (_e105 > _e108);
}
let _e111 = phi_358_;
if _e111 {
cascade = 1i;
}
let _e112 = cascadeCount;
let _e113 = (_e112 > 2i);
phi_369_ = _e113;
if _e113 {
let _e114 = (*viewDistance);
let _e117 = fog_info.cascades[1u];
phi_369_ = (_e114 > _e117);
}
let _e120 = phi_369_;
if _e120 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e121 = attempt;
if (_e121 < 3i) {
let _e123 = cascade;
let _e124 = attempt;
which = (_e123 + _e124);
let _e126 = which;
let _e127 = cascadeCount;
if (_e126 >= _e127) {
break;
}
let _e129 = which;
if (_e129 == 0i) {
let _e132 = fog_info.shadow_matrix;
local_6 = _e132;
} else {
let _e133 = which;
if (_e133 == 1i) {
let _e136 = fog_info.shadow_matrix_far;
local_7 = _e136;
} else {
let _e138 = fog_info.shadow_matrix_farthest;
local_7 = _e138;
}
let _e139 = local_7;
local_6 = _e139;
}
let _e140 = local_6;
matrix = _e140;
let _e141 = matrix;
let _e142 = (*world_2);
lightSpace = (_e141 * vec4<f32>(_e142.x, _e142.y, _e142.z, 1f));
let _e149 = lightSpace[3u];
if (_e149 <= 0f) {
continue;
}
let _e151 = lightSpace;
let _e154 = lightSpace[3u];
candidate = (_e151.xyz / vec3(_e154));
let _e158 = candidate[0u];
let _e162 = candidate[1u];
inTile = vec2<f32>(((_e158 * 0.5f) + 0.5f), (0.5f - (_e162 * 0.5f)));
let _e167 = inTile[0u];
let _e168 = (_e167 < 0f);
phi_454_ = _e168;
if !(_e168) {
let _e171 = inTile[0u];
phi_454_ = (_e171 > 1f);
}
let _e174 = phi_454_;
phi_461_ = _e174;
if !(_e174) {
let _e177 = inTile[1u];
phi_461_ = (_e177 < 0f);
}
let _e180 = phi_461_;
phi_468_ = _e180;
if !(_e180) {
let _e183 = inTile[1u];
phi_468_ = (_e183 > 1f);
}
let _e186 = phi_468_;
if _e186 {
continue;
}
let _e188 = candidate[2u];
if (_e188 > 1f) {
let _e190 = which;
let _e191 = cascadeCount;
if (_e190 < (_e191 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e196 = inTile[0u];
let _e197 = which;
let _e200 = cascadeCount;
let _e204 = inTile[1u];
uv_1 = vec2<f32>(((_e196 + f32(_e197)) / f32(_e200)), _e204);
let _e206 = uv_1;
let _e207 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e206, 0f);
stored_1 = _e207.x;
let _e209 = which;
if (_e209 == 0i) {
let _e213 = fog_info.bias[0u];
local_8 = _e213;
} else {
let _e214 = which;
if (_e214 == 1i) {
let _e218 = fog_info.bias[1u];
local_9 = _e218;
} else {
let _e221 = fog_info.bias[2u];
local_9 = _e221;
}
let _e222 = local_9;
local_8 = _e222;
}
let _e223 = local_8;
bias = _e223;
let _e225 = candidate[2u];
let _e226 = bias;
let _e228 = stored_1;
return select(1f, 0f, ((_e225 - _e226) > _e228));
} else {
break;
}
continuing {
let _e231 = attempt;
attempt = (_e231 + 1i);
}
}
return 1f;
}
fn Density_u0028_f1_u003b(y: ptr<function, f32>) -> f32 {
var exponent: f32;
let _e85 = fog_info.medium[1u];
let _e87 = (*y);
let _e90 = fog_info.medium[2u];
exponent = clamp((-(_e85) * (_e87 - _e90)), -30f, 30f);
let _e96 = fog_info.medium[0u];
let _e98 = exponent;
return (max(_e96, 0f) * exp(_e98));
}
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y_1: i32;
var index: i32;
var value: f32;
let _e87 = (*at)[0u];
x = i32((_e87 - (floor((_e87 / 4f)) * 4f)));
let _e94 = (*at)[1u];
y_1 = i32((_e94 - (floor((_e94 / 4f)) * 4f)));
let _e100 = y_1;
let _e102 = x;
index = ((_e100 * 4i) + _e102);
value = 0f;
let _e104 = index;
if (_e104 == 0i) {
value = 0f;
} else {
let _e106 = index;
if (_e106 == 1i) {
value = 8f;
} else {
let _e108 = index;
if (_e108 == 2i) {
value = 2f;
} else {
let _e110 = index;
if (_e110 == 3i) {
value = 10f;
} else {
let _e112 = index;
if (_e112 == 4i) {
value = 12f;
} else {
let _e114 = index;
if (_e114 == 5i) {
value = 4f;
} else {
let _e116 = index;
if (_e116 == 6i) {
value = 14f;
} else {
let _e118 = index;
if (_e118 == 7i) {
value = 6f;
} else {
let _e120 = index;
if (_e120 == 8i) {
value = 3f;
} else {
let _e122 = index;
if (_e122 == 9i) {
value = 11f;
} else {
let _e124 = index;
if (_e124 == 10i) {
value = 1f;
} else {
let _e126 = index;
if (_e126 == 11i) {
value = 9f;
} else {
let _e128 = index;
if (_e128 == 12i) {
value = 15f;
} else {
let _e130 = index;
if (_e130 == 13i) {
value = 7f;
} else {
let _e132 = index;
if (_e132 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e134 = value;
return (_e134 / 16f);
}
fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell_1: vec2<f32>;
var corner: vec2<f32>;
var uv_2: vec2<f32>;
let _e88 = noise_info.noise[1u];
slice = _e88;
let _e89 = (*at_1);
let _e90 = floor(_e89);
let _e91 = vec2(64f);
cell_1 = (_e90 - (floor((_e90 / _e91)) * _e91));
let _e96 = slice;
let _e101 = slice;
corner = (vec2<f32>((_e96 - (floor((_e96 / 8f)) * 8f)), floor((_e101 / 8f))) * 64f);
let _e106 = corner;
let _e107 = cell_1;
uv_2 = (((_e106 + _e107) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e112 = uv_2;
let _e113 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e112, 0f);
return (_e113.x * 0.99609375f);
}
fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var local_10: f32;
var param_18: vec2<f32>;
var param_19: vec2<f32>;
let _e87 = noise_info.noise[0u];
if (_e87 > 0.5f) {
let _e89 = (*at_2);
param_18 = _e89;
let _e90 = BlueNoise_u0028_vf2_u003b((¶m_18));
local_10 = _e90;
} else {
let _e91 = (*at_2);
param_19 = _e91;
let _e92 = BayerCell_u0028_vf2_u003b((¶m_19));
local_10 = _e92;
}
let _e93 = local_10;
return _e93;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_11: vec2<f32>;
let _e83 = (*rows);
if (_e83 > 0f) {
let _e86 = gl_FragCoord_1[0u];
let _e87 = (*rows);
let _e89 = gl_FragCoord_1[1u];
local_11 = vec2<f32>(_e86, (_e87 - _e89));
} else {
let _e92 = gl_FragCoord_1;
local_11 = _e92.xy;
}
let _e94 = local_11;
return _e94;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_20: f32;
let _e84 = frag_coord_info.origin[0u];
param_20 = _e84;
let _e85 = FragCoordFromTop_u0028_f1_u003b((¶m_20));
return _e85;
}
fn main_1() {
var steps: i32;
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var nearPoint: vec3<f32>;
var along_1: vec3<f32>;
var cosine_1: f32;
var origin: vec3<f32>;
var surfaceDepth: f32;
var toSurface: f32;
var local_12: f32;
var distance_2: f32;
var stride: f32;
var offset: f32;
var param_21: vec2<f32>;
var g_2: f32;
var sunPhase: f32;
var param_22: f32;
var param_23: f32;
var clustered: bool;
var eye: vec3<f32>;
var transmittance: f32;
var inscatter: vec3<f32>;
var i_1: i32;
var travelled: f32;
var at_3: vec3<f32>;
var stepTransmittance: f32;
var param_24: f32;
var light: vec3<f32>;
var param_25: vec3<f32>;
var param_26: f32;
var param_27: vec3<f32>;
var param_28: vec3<f32>;
var param_29: f32;
let _e117 = fog_info.forward[3u];
steps = i32((_e117 + 0.5f));
let _e121 = v_uv_1[0u];
let _e125 = v_uv_1[1u];
xy = vec2<f32>(((_e121 * 2f) - 1f), (1f - (_e125 * 2f)));
let _e130 = fog_info.inverse_view_projection;
let _e131 = xy;
nearH = (_e130 * vec4<f32>(_e131.x, _e131.y, 0f, 1f));
let _e137 = fog_info.inverse_view_projection;
let _e138 = xy;
farH = (_e137 * vec4<f32>(_e138.x, _e138.y, 1f, 1f));
let _e143 = nearH;
let _e146 = nearH[3u];
nearPoint = (_e143.xyz / vec3(_e146));
let _e149 = farH;
let _e152 = farH[3u];
let _e155 = nearPoint;
along_1 = normalize(((_e149.xyz / vec3(_e152)) - _e155));
let _e158 = along_1;
let _e160 = fog_info.forward;
cosine_1 = max(dot(_e158, _e160.xyz), 0.0001f);
let _e164 = nearPoint;
let _e165 = along_1;
let _e166 = nearPoint;
let _e168 = fog_info.camera;
let _e172 = fog_info.forward;
let _e175 = cosine_1;
origin = (_e164 - (_e165 * (dot((_e166 - _e168.xyz), _e172.xyz) / _e175)));
let _e179 = v_uv_1;
let _e180 = textureSample(surface_texture_tex, surface_texture_smp, _e179);
surfaceDepth = _e180.w;
let _e182 = surfaceDepth;
if (_e182 > 0f) {
let _e184 = surfaceDepth;
let _e185 = cosine_1;
local_12 = (_e184 / _e185);
} else {
local_12 = 1000000000f;
}
let _e187 = local_12;
toSurface = _e187;
let _e190 = fog_info.camera[3u];
let _e191 = toSurface;
distance_2 = min(_e190, _e191);
let _e193 = steps;
let _e195 = distance_2;
if ((_e193 < 1i) || (_e195 <= 0f)) {
frag_color = vec4<f32>(0f, 0f, 0f, 1f);
return;
}
let _e198 = distance_2;
let _e199 = steps;
stride = (_e198 / f32(_e199));
let _e202 = TargetFragCoord_u0028_();
param_21 = _e202;
let _e203 = PixelNoise_u0028_vf2_u003b((¶m_21));
let _e204 = stride;
offset = (_e203 * _e204);
let _e208 = fog_info.sun[3u];
g_2 = _e208;
let _e209 = along_1;
let _e211 = fog_info.sun;
param_22 = dot(_e209, _e211.xyz);
let _e214 = g_2;
param_23 = _e214;
let _e215 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_22), (¶m_23));
sunPhase = _e215;
let _e218 = fog_info.albedo[3u];
clustered = (_e218 > 0.5f);
let _e221 = fog_info.camera;
eye = _e221.xyz;
transmittance = 1f;
inscatter = vec3<f32>(0f, 0f, 0f);
i_1 = 0i;
loop {
let _e223 = i_1;
if (_e223 < 64i) {
let _e225 = i_1;
let _e226 = steps;
if (_e225 >= _e226) {
break;
}
let _e228 = offset;
let _e229 = i_1;
let _e231 = stride;
travelled = (_e228 + (f32(_e229) * _e231));
let _e234 = origin;
let _e235 = along_1;
let _e236 = travelled;
at_3 = (_e234 + (_e235 * _e236));
let _e240 = at_3[1u];
param_24 = _e240;
let _e241 = Density_u0028_f1_u003b((¶m_24));
let _e243 = stride;
stepTransmittance = exp((-(_e241) * _e243));
let _e247 = fog_info.sun_radiance;
let _e249 = sunPhase;
let _e250 = at_3;
let _e251 = eye;
let _e254 = at_3;
param_25 = _e254;
param_26 = length((_e250 - _e251));
let _e255 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_25), (¶m_26));
let _e259 = fog_info.ambient;
light = ((_e247.xyz * (_e249 * _e255)) + (_e259.xyz * 0.07957747f));
let _e263 = clustered;
if _e263 {
let _e265 = fog_info.albedo;
let _e267 = at_3;
param_27 = _e267;
let _e268 = along_1;
param_28 = _e268;
let _e269 = g_2;
param_29 = _e269;
let _e270 = ClusterLight_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29));
let _e272 = light;
light = (_e272 + (_e265.xyz * _e270));
}
let _e274 = light;
let _e275 = transmittance;
let _e276 = stepTransmittance;
let _e280 = inscatter;
inscatter = (_e280 + (_e274 * (_e275 * (1f - _e276))));
let _e282 = stepTransmittance;
let _e283 = transmittance;
transmittance = (_e283 * _e282);
continue;
} else {
break;
}
continuing {
let _e285 = i_1;
i_1 = (_e285 + 1i);
}
}
let _e287 = inscatter;
let _e288 = transmittance;
frag_color = vec4<f32>(_e287.x, _e287.y, _e287.z, _e288);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'NoiseInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 2,
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,
),
],
),
WebGpuBlock(
name: 'VolumeFogInfo',
group: 1,
binding: 3,
sizeInBytes: 512,
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: 'cluster_view_projection',
offsetInBytes: 256,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 320,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 336,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'sun', offsetInBytes: 352, sizeInBytes: 16),
WebGpuBlockMember(
name: 'sun_radiance',
offsetInBytes: 368,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cascades',
offsetInBytes: 384,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'bias',
offsetInBytes: 400,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'medium',
offsetInBytes: 416,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'albedo',
offsetInBytes: 432,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient',
offsetInBytes: 448,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 464,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 480,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'list',
offsetInBytes: 496,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VolumetricFogUpsample': WebGpuStage(
wgsl: r'''
struct FogUpsampleInfo {
size: vec4<f32>,
occlusion: vec4<f32>,
}
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> upsample_info: FogUpsampleInfo;
@group(1) @binding(5)
var fog_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var fog_texture_smp: sampler;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
@group(1) @binding(3)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var contact_shadow_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn DepthAt_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> f32 {
var depth: f32;
let _e35 = (*uv);
let _e36 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e35, 0f);
depth = _e36.w;
let _e38 = depth;
let _e40 = depth;
return select(1000000f, _e40, (_e38 > 0f));
}
fn Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b(cell: ptr<function, vec2<f32>>, share: ptr<function, f32>, here: ptr<function, f32>, sum: ptr<function, vec4<f32>>, weight: ptr<function, f32>) {
var size: vec2<f32>;
var uv_1: vec2<f32>;
var difference: f32;
var param: vec2<f32>;
var w: f32;
let _e44 = upsample_info.size;
size = _e44.xy;
let _e46 = (*cell);
let _e47 = size;
let _e53 = size;
uv_1 = ((clamp(_e46, vec2<f32>(0f, 0f), (_e47 - vec2(1f))) + vec2(0.5f)) / _e53);
let _e55 = uv_1;
param = _e55;
let _e56 = DepthAt_u0028_vf2_u003b((¶m));
let _e57 = (*here);
let _e60 = (*here);
difference = (abs((_e56 - _e57)) / max(_e60, 0.001f));
let _e63 = (*share);
let _e64 = difference;
w = (_e63 / (0.01f + _e64));
let _e67 = uv_1;
let _e68 = textureSampleLevel(fog_texture_tex, fog_texture_smp, _e67, 0f);
let _e69 = w;
let _e71 = (*sum);
(*sum) = (_e71 + (_e68 * _e69));
let _e73 = w;
let _e74 = (*weight);
(*weight) = (_e74 + _e73);
return;
}
fn main_1() {
var scene: vec4<f32>;
var size_1: vec2<f32>;
var at: vec2<f32>;
var base: vec2<f32>;
var f: vec2<f32>;
var here_1: f32;
var param_1: vec2<f32>;
var sum_1: vec4<f32>;
var weight_1: f32;
var param_2: vec2<f32>;
var param_3: f32;
var param_4: f32;
var param_5: vec4<f32>;
var param_6: f32;
var param_7: vec2<f32>;
var param_8: f32;
var param_9: f32;
var param_10: vec4<f32>;
var param_11: f32;
var param_12: vec2<f32>;
var param_13: f32;
var param_14: f32;
var param_15: vec4<f32>;
var param_16: f32;
var param_17: vec2<f32>;
var param_18: f32;
var param_19: f32;
var param_20: vec4<f32>;
var param_21: f32;
var fog: vec4<f32>;
var local: vec4<f32>;
var half_texel: vec2<f32>;
var occlusion: vec4<f32>;
var strength: f32;
var ao: f32;
var contact: f32;
var surfaceLight: vec3<f32>;
let _e70 = v_uv_1;
let _e71 = textureSample(scene_texture_tex, scene_texture_smp, _e70);
scene = _e71;
let _e73 = upsample_info.size;
size_1 = max(_e73.xy, vec2<f32>(1f, 1f));
let _e76 = v_uv_1;
let _e77 = size_1;
at = ((_e76 * _e77) - vec2(0.5f));
let _e81 = at;
base = floor(_e81);
let _e83 = at;
let _e84 = base;
f = (_e83 - _e84);
let _e86 = v_uv_1;
param_1 = _e86;
let _e87 = DepthAt_u0028_vf2_u003b((¶m_1));
here_1 = _e87;
sum_1 = vec4<f32>(0f, 0f, 0f, 0f);
weight_1 = 0f;
let _e89 = f[0u];
let _e92 = f[1u];
let _e95 = base;
param_2 = _e95;
param_3 = ((1f - _e89) * (1f - _e92));
let _e96 = here_1;
param_4 = _e96;
let _e97 = sum_1;
param_5 = _e97;
let _e98 = weight_1;
param_6 = _e98;
Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e99 = param_5;
sum_1 = _e99;
let _e100 = param_6;
weight_1 = _e100;
let _e101 = base;
let _e104 = f[0u];
let _e106 = f[1u];
param_7 = (_e101 + vec2<f32>(1f, 0f));
param_8 = (_e104 * (1f - _e106));
let _e109 = here_1;
param_9 = _e109;
let _e110 = sum_1;
param_10 = _e110;
let _e111 = weight_1;
param_11 = _e111;
Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((¶m_7), (¶m_8), (¶m_9), (¶m_10), (¶m_11));
let _e112 = param_10;
sum_1 = _e112;
let _e113 = param_11;
weight_1 = _e113;
let _e114 = base;
let _e117 = f[0u];
let _e120 = f[1u];
param_12 = (_e114 + vec2<f32>(0f, 1f));
param_13 = ((1f - _e117) * _e120);
let _e122 = here_1;
param_14 = _e122;
let _e123 = sum_1;
param_15 = _e123;
let _e124 = weight_1;
param_16 = _e124;
Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15), (¶m_16));
let _e125 = param_15;
sum_1 = _e125;
let _e126 = param_16;
weight_1 = _e126;
let _e127 = base;
let _e130 = f[0u];
let _e132 = f[1u];
param_17 = (_e127 + vec2<f32>(1f, 1f));
param_18 = (_e130 * _e132);
let _e134 = here_1;
param_19 = _e134;
let _e135 = sum_1;
param_20 = _e135;
let _e136 = weight_1;
param_21 = _e136;
Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20), (¶m_21));
let _e137 = param_20;
sum_1 = _e137;
let _e138 = param_21;
weight_1 = _e138;
let _e139 = weight_1;
if (_e139 > 0.000001f) {
let _e141 = sum_1;
let _e142 = weight_1;
local = (_e141 / vec4(_e142));
} else {
local = vec4<f32>(0f, 0f, 0f, 1f);
}
let _e145 = local;
fog = _e145;
let _e147 = upsample_info.size;
half_texel = (_e147.zw * 0.5f);
let _e150 = v_uv_1;
let _e152 = half_texel[0u];
let _e154 = half_texel[1u];
let _e157 = textureSample(ao_texture_tex, ao_texture_smp, (_e150 + vec2<f32>(_e152, _e154)));
let _e158 = v_uv_1;
let _e160 = half_texel[0u];
let _e163 = half_texel[1u];
let _e166 = textureSample(ao_texture_tex, ao_texture_smp, (_e158 + vec2<f32>(-(_e160), _e163)));
let _e168 = v_uv_1;
let _e170 = half_texel[0u];
let _e172 = half_texel[1u];
let _e176 = textureSample(ao_texture_tex, ao_texture_smp, (_e168 + vec2<f32>(_e170, -(_e172))));
let _e178 = v_uv_1;
let _e180 = half_texel[0u];
let _e183 = half_texel[1u];
let _e187 = textureSample(ao_texture_tex, ao_texture_smp, (_e178 + vec2<f32>(-(_e180), -(_e183))));
occlusion = ((((_e157 + _e166) + _e176) + _e187) * 0.25f);
let _e192 = upsample_info.occlusion[0u];
strength = clamp(_e192, 0f, 1f);
let _e195 = occlusion[3u];
let _e196 = strength;
ao = mix(1f, _e195, _e196);
let _e198 = v_uv_1;
let _e199 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e198);
contact = _e199.x;
let _e201 = contact;
let _e204 = upsample_info.occlusion[1u];
let _e207 = ao;
ao = (_e207 * mix(1f, _e201, clamp(_e204, 0f, 1f)));
let _e209 = scene;
let _e211 = ao;
let _e213 = occlusion;
let _e217 = upsample_info.occlusion[2u];
let _e219 = strength;
surfaceLight = ((_e209.xyz * _e211) + ((_e213.xyz * _e217) * _e219));
let _e222 = surfaceLight;
let _e224 = fog[3u];
let _e226 = fog;
let _e228 = ((_e222 * _e224) + _e226.xyz);
let _e230 = scene[3u];
frag_color = vec4<f32>(_e228.x, _e228.y, _e228.z, _e230);
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: 'FogUpsampleInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'size', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'occlusion',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'contact_shadow_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'fog_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DepthOfField': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
struct DofInfo {
lens: vec4<f32>,
params: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(0)
var<uniform> dof_info: DofInfo;
@group(1) @binding(4)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(6)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var surface_texture_smp: sampler;
@group(1) @binding(2)
var coc_tile_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var coc_tile_texture_smp: sampler;
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e63 = (*at)[0u];
x = i32((_e63 - (floor((_e63 / 4f)) * 4f)));
let _e70 = (*at)[1u];
y = i32((_e70 - (floor((_e70 / 4f)) * 4f)));
let _e76 = y;
let _e78 = x;
index = ((_e76 * 4i) + _e78);
value = 0f;
let _e80 = index;
if (_e80 == 0i) {
value = 0f;
} else {
let _e82 = index;
if (_e82 == 1i) {
value = 8f;
} else {
let _e84 = index;
if (_e84 == 2i) {
value = 2f;
} else {
let _e86 = index;
if (_e86 == 3i) {
value = 10f;
} else {
let _e88 = index;
if (_e88 == 4i) {
value = 12f;
} else {
let _e90 = index;
if (_e90 == 5i) {
value = 4f;
} else {
let _e92 = index;
if (_e92 == 6i) {
value = 14f;
} else {
let _e94 = index;
if (_e94 == 7i) {
value = 6f;
} else {
let _e96 = index;
if (_e96 == 8i) {
value = 3f;
} else {
let _e98 = index;
if (_e98 == 9i) {
value = 11f;
} else {
let _e100 = index;
if (_e100 == 10i) {
value = 1f;
} else {
let _e102 = index;
if (_e102 == 11i) {
value = 9f;
} else {
let _e104 = index;
if (_e104 == 12i) {
value = 15f;
} else {
let _e106 = index;
if (_e106 == 13i) {
value = 7f;
} else {
let _e108 = index;
if (_e108 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e110 = value;
return (_e110 / 16f);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e59 = (*rows);
if (_e59 > 0f) {
let _e62 = gl_FragCoord_1[0u];
let _e63 = (*rows);
let _e65 = gl_FragCoord_1[1u];
local = vec2<f32>(_e62, (_e63 - _e65));
} else {
let _e68 = gl_FragCoord_1;
local = _e68.xy;
}
let _e70 = local;
return _e70;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param: f32;
let _e60 = frag_coord_info.origin[0u];
param = _e60;
let _e61 = FragCoordFromTop_u0028_f1_u003b((¶m));
return _e61;
}
fn CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b(depth: ptr<function, f32>, lens: ptr<function, vec4<f32>>, params: ptr<function, vec4<f32>>) -> f32 {
var focus: f32;
var focal: f32;
var fnumber: f32;
var denominator: f32;
var ratio: f32;
var local_1: f32;
var diameter: f32;
let _e68 = (*lens)[0u];
focus = max(_e68, 0.001f);
let _e71 = (*lens)[1u];
focal = max(_e71, 0.0001f);
let _e74 = (*lens)[2u];
fnumber = max(_e74, 0.001f);
let _e76 = fnumber;
let _e77 = focus;
let _e78 = focal;
denominator = max((_e76 * (_e77 - _e78)), 0.000001f);
let _e82 = (*depth);
if (_e82 <= 0f) {
local_1 = 1f;
} else {
let _e84 = (*depth);
let _e85 = focus;
let _e88 = (*depth);
local_1 = (abs((_e84 - _e85)) / _e88);
}
let _e90 = local_1;
ratio = _e90;
let _e91 = ratio;
let _e92 = focal;
let _e93 = focal;
let _e96 = denominator;
diameter = ((_e91 * (_e92 * _e93)) / _e96);
let _e98 = diameter;
let _e101 = (*params)[3u];
let _e104 = (*params)[2u];
return min(((_e98 * 0.5f) * _e101), max(_e104, 0f));
}
fn CircleAt_u0028_f1_u003b(depth_1: ptr<function, f32>) -> f32 {
var param_1: f32;
var param_2: vec4<f32>;
var param_3: vec4<f32>;
let _e61 = (*depth_1);
param_1 = _e61;
let _e63 = dof_info.lens;
param_2 = _e63;
let _e65 = dof_info.params;
param_3 = _e65;
let _e66 = CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b((¶m_1), (¶m_2), (¶m_3));
return _e66;
}
fn main_1() {
var centre: vec4<f32>;
var samples: i32;
var centreDepth: f32;
var radius: f32;
var param_4: f32;
var gather: f32;
var total: vec3<f32>;
var weight: f32;
var nearTotal: vec3<f32>;
var nearWeight: f32;
var nearCover: f32;
var centreFar: f32;
var turn: f32;
var param_5: vec2<f32>;
var i: i32;
var t: f32;
var r: f32;
var angle: f32;
var at_1: vec2<f32>;
var tap: vec4<f32>;
var tapDepth: f32;
var tapRadius: f32;
var param_6: f32;
var tapFar: f32;
var tapReach: f32;
var local_2: f32;
var reach: f32;
var spread: f32;
var far: vec3<f32>;
var near: vec3<f32>;
var cover: f32;
let _e88 = v_uv_1;
let _e89 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e88, 0f);
centre = _e89;
let _e92 = dof_info.lens[3u];
samples = i32((_e92 + 0.5f));
let _e95 = samples;
if (_e95 < 1i) {
let _e97 = centre;
frag_color = _e97;
return;
}
let _e98 = v_uv_1;
let _e99 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e98, 0f);
centreDepth = _e99.w;
let _e101 = centreDepth;
param_4 = _e101;
let _e102 = CircleAt_u0028_f1_u003b((¶m_4));
radius = _e102;
let _e103 = v_uv_1;
let _e104 = textureSampleLevel(coc_tile_texture_tex, coc_tile_texture_smp, _e103, 0f);
let _e106 = radius;
gather = max(_e104.x, _e106);
let _e108 = gather;
if (_e108 < 0.5f) {
let _e110 = centre;
frag_color = _e110;
return;
}
let _e111 = centre;
total = _e111.xyz;
weight = 1f;
nearTotal = vec3<f32>(0f, 0f, 0f);
nearWeight = 0f;
nearCover = 0f;
let _e113 = centreDepth;
let _e115 = centreDepth;
centreFar = select(_e115, 1000000000f, (_e113 <= 0f));
let _e117 = TargetFragCoord_u0028_();
param_5 = _e117;
let _e118 = BayerCell_u0028_vf2_u003b((¶m_5));
turn = (6.2831855f * _e118);
i = 1i;
loop {
let _e120 = i;
if (_e120 <= 64i) {
let _e122 = i;
let _e123 = samples;
if (_e122 > _e123) {
break;
}
let _e125 = i;
let _e128 = samples;
t = ((f32(_e125) - 0.5f) / f32(_e128));
let _e131 = t;
let _e133 = gather;
r = (sqrt(_e131) * _e133);
let _e135 = i;
let _e138 = turn;
angle = ((f32(_e135) * 2.3999631f) + _e138);
let _e140 = v_uv_1;
let _e141 = angle;
let _e143 = angle;
let _e146 = r;
let _e149 = dof_info.params;
at_1 = (_e140 + ((vec2<f32>(cos(_e141), sin(_e143)) * _e146) * _e149.xy));
let _e153 = at_1;
let _e154 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e153, 0f);
tap = _e154;
let _e155 = at_1;
let _e156 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e155, 0f);
tapDepth = _e156.w;
let _e158 = tapDepth;
param_6 = _e158;
let _e159 = CircleAt_u0028_f1_u003b((¶m_6));
tapRadius = _e159;
let _e160 = tapDepth;
let _e162 = tapDepth;
tapFar = select(_e162, 1000000000f, (_e160 <= 0f));
let _e164 = tapFar;
let _e165 = centreFar;
if (_e164 > _e165) {
let _e167 = tapRadius;
let _e168 = radius;
local_2 = min(_e167, _e168);
} else {
let _e170 = tapRadius;
local_2 = _e170;
}
let _e171 = local_2;
tapReach = _e171;
let _e172 = tapReach;
let _e173 = r;
reach = clamp(((_e172 - _e173) + 0.5f), 0f, 1f);
let _e177 = tapFar;
let _e178 = centreFar;
let _e180 = tapRadius;
let _e181 = radius;
if ((_e177 < _e178) && (_e180 > _e181)) {
let _e184 = gather;
let _e185 = tapRadius;
spread = (_e184 / max(_e185, 0.5f));
let _e188 = tap;
let _e190 = reach;
let _e192 = nearTotal;
nearTotal = (_e192 + (_e188.xyz * _e190));
let _e194 = reach;
let _e195 = nearWeight;
nearWeight = (_e195 + _e194);
let _e197 = reach;
let _e198 = spread;
let _e200 = spread;
let _e202 = nearCover;
nearCover = (_e202 + ((_e197 * _e198) * _e200));
} else {
let _e204 = tap;
let _e206 = reach;
let _e208 = total;
total = (_e208 + (_e204.xyz * _e206));
let _e210 = reach;
let _e211 = weight;
weight = (_e211 + _e210);
}
continue;
} else {
break;
}
continuing {
let _e213 = i;
i = (_e213 + 1i);
}
}
let _e215 = total;
let _e216 = weight;
far = (_e215 / vec3(_e216));
let _e219 = nearTotal;
let _e220 = nearWeight;
near = (_e219 / vec3(max(_e220, 0.00001f)));
let _e224 = nearCover;
let _e225 = samples;
cover = clamp((_e224 / f32(_e225)), 0f, 1f);
let _e229 = far;
let _e230 = near;
let _e231 = cover;
let _e233 = mix(_e229, _e230, vec3(_e231));
let _e235 = centre[3u];
frag_color = vec4<f32>(_e233.x, _e233.y, _e233.z, _e235);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
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,
),
],
),
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'coc_tile_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DofTileMax': WebGpuStage(
wgsl: r'''
struct DofTileInfo {
lens: vec4<f32>,
params: vec4<f32>,
source: vec4<f32>,
target_: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> dof_tile_info: DofTileInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b(depth: ptr<function, f32>, lens: ptr<function, vec4<f32>>, params: ptr<function, vec4<f32>>) -> f32 {
var focus: f32;
var focal: f32;
var fnumber: f32;
var denominator: f32;
var ratio: f32;
var local: f32;
var diameter: f32;
let _e31 = (*lens)[0u];
focus = max(_e31, 0.001f);
let _e34 = (*lens)[1u];
focal = max(_e34, 0.0001f);
let _e37 = (*lens)[2u];
fnumber = max(_e37, 0.001f);
let _e39 = fnumber;
let _e40 = focus;
let _e41 = focal;
denominator = max((_e39 * (_e40 - _e41)), 0.000001f);
let _e45 = (*depth);
if (_e45 <= 0f) {
local = 1f;
} else {
let _e47 = (*depth);
let _e48 = focus;
let _e51 = (*depth);
local = (abs((_e47 - _e48)) / _e51);
}
let _e53 = local;
ratio = _e53;
let _e54 = ratio;
let _e55 = focal;
let _e56 = focal;
let _e59 = denominator;
diameter = ((_e54 * (_e55 * _e56)) / _e59);
let _e61 = diameter;
let _e64 = (*params)[3u];
let _e67 = (*params)[2u];
return min(((_e61 * 0.5f) * _e64), max(_e67, 0f));
}
fn main_1() {
var taps: i32;
var texel: vec2<f32>;
var row: f32;
var first: f32;
var largest: f32;
var i: i32;
var at: vec2<f32>;
var depth_1: f32;
var param: f32;
var param_1: vec4<f32>;
var param_2: vec4<f32>;
let _e33 = dof_tile_info.source[2u];
taps = i32((_e33 + 0.5f));
let _e36 = v_uv_1;
let _e38 = dof_tile_info.target_;
texel = floor((_e36 * _e38.xy));
let _e43 = texel[1u];
let _e47 = dof_tile_info.source[1u];
row = ((_e43 + 0.5f) * _e47);
let _e50 = texel[0u];
let _e51 = taps;
first = (_e50 * f32(_e51));
largest = 0f;
i = 0i;
loop {
let _e54 = i;
if (_e54 < 64i) {
let _e56 = i;
let _e57 = taps;
if (_e56 >= _e57) {
break;
}
let _e59 = first;
let _e60 = i;
let _e66 = dof_tile_info.source[0u];
let _e68 = row;
at = vec2<f32>((((_e59 + f32(_e60)) + 0.5f) * _e66), _e68);
let _e70 = at;
let _e71 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e70, 0f);
depth_1 = _e71.w;
let _e73 = largest;
let _e74 = depth_1;
param = _e74;
let _e76 = dof_tile_info.lens;
param_1 = _e76;
let _e78 = dof_tile_info.params;
param_2 = _e78;
let _e79 = CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2));
largest = max(_e73, _e79);
continue;
} else {
break;
}
continuing {
let _e81 = i;
i = (_e81 + 1i);
}
}
let _e83 = largest;
frag_color = vec4<f32>(_e83, 0f, 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: 'DofTileInfo',
group: 1,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'lens', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'source',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VelocityTileMax': WebGpuStage(
wgsl: r'''
struct TileMaxInfo {
source: vec4<f32>,
params: vec4<f32>,
target_: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> tile_info: TileMaxInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var velocity_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn HalfMotion_u0028_vf2_u003b(motion: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixels: vec2<f32>;
var span: f32;
var most: f32;
var local: vec2<f32>;
let _e21 = (*motion);
let _e23 = tile_info.params;
pixels = (_e21 * _e23.xy);
let _e26 = pixels;
span = length(_e26);
let _e30 = tile_info.params[2u];
most = max(_e30, 0f);
let _e32 = span;
let _e33 = most;
if (_e32 > _e33) {
let _e35 = pixels;
let _e36 = most;
let _e37 = span;
local = (_e35 * (_e36 / _e37));
} else {
let _e40 = pixels;
local = _e40;
}
let _e41 = local;
return _e41;
}
fn main_1() {
var walk: vec2<f32>;
var tile: vec2<f32>;
var taps: i32;
var start: vec2<f32>;
var longest: vec2<f32>;
var longestSpan: f32;
var i: i32;
var at: vec2<f32>;
var motion_1: vec2<f32>;
var param: vec2<f32>;
var span_1: f32;
let _e28 = tile_info.source;
walk = _e28.zw;
let _e30 = v_uv_1;
let _e32 = tile_info.target_;
tile = floor((_e30 * _e32.xy));
let _e38 = tile_info.params[3u];
taps = i32((_e38 + 0.5f));
let _e41 = tile;
let _e42 = taps;
let _e45 = walk;
start = (_e41 * mix(vec2<f32>(1f, 1f), vec2(f32(_e42)), _e45));
longest = vec2<f32>(0f, 0f);
longestSpan = 0f;
i = 0i;
loop {
let _e48 = i;
if (_e48 < 64i) {
let _e50 = i;
let _e51 = taps;
if (_e50 >= _e51) {
break;
}
let _e53 = start;
let _e54 = walk;
let _e55 = i;
let _e62 = tile_info.source;
at = (((_e53 + (_e54 * f32(_e55))) + vec2(0.5f)) * _e62.xy);
let _e65 = at;
let _e66 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e65, 0f);
param = _e66.xy;
let _e68 = HalfMotion_u0028_vf2_u003b((¶m));
motion_1 = _e68;
let _e69 = motion_1;
let _e70 = motion_1;
span_1 = dot(_e69, _e70);
let _e72 = span_1;
let _e73 = longestSpan;
if (_e72 > _e73) {
let _e75 = motion_1;
longest = _e75;
let _e76 = span_1;
longestSpan = _e76;
}
continue;
} else {
break;
}
continuing {
let _e77 = i;
i = (_e77 + 1i);
}
}
let _e79 = longest;
frag_color = vec4<f32>(_e79.x, _e79.y, 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: 'TileMaxInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'source',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'velocity_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VelocityNeighborMax': WebGpuStage(
wgsl: r'''
struct NeighborMaxInfo {
texel: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> neighbor_info: NeighborMaxInfo;
@group(1) @binding(1)
var tile_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var tile_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn main_1() {
var longest: vec2<f32>;
var longestSpan: f32;
var dy: i32;
var dx: i32;
var at: vec2<f32>;
var motion: vec2<f32>;
var span: f32;
longest = vec2<f32>(0f, 0f);
longestSpan = 0f;
dy = -1i;
loop {
let _e18 = dy;
if (_e18 <= 1i) {
dx = -1i;
loop {
let _e20 = dx;
if (_e20 <= 1i) {
let _e22 = v_uv_1;
let _e23 = dx;
let _e25 = dy;
let _e29 = neighbor_info.texel;
at = (_e22 + (vec2<f32>(f32(_e23), f32(_e25)) * _e29.xy));
let _e33 = at;
let _e34 = textureSampleLevel(tile_texture_tex, tile_texture_smp, _e33, 0f);
motion = _e34.xy;
let _e36 = motion;
let _e37 = motion;
span = dot(_e36, _e37);
let _e39 = span;
let _e40 = longestSpan;
if (_e39 > _e40) {
let _e42 = motion;
longest = _e42;
let _e43 = span;
longestSpan = _e43;
}
continue;
} else {
break;
}
continuing {
let _e44 = dx;
dx = (_e44 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e46 = dy;
dy = (_e46 + 1i);
}
}
let _e48 = longest;
frag_color = vec4<f32>(_e48.x, _e48.y, 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: 'NeighborMaxInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'texel', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'tile_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MotionBlur': WebGpuStage(
wgsl: r'''
struct FragCoordInfo {
origin: vec4<f32>,
}
struct NoiseInfo {
noise: vec4<f32>,
}
struct MotionBlurInfo {
scene: vec4<f32>,
params: vec4<f32>,
tiles: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> blur_info: MotionBlurInfo;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(5)
var neighbor_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var neighbor_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(11)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var velocity_texture_smp: sampler;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
fn Reaches_u0028_f1_u003b_f1_u003b(gap: ptr<function, f32>, span: ptr<function, f32>) -> f32 {
let _e65 = (*span);
let _e67 = (*span);
let _e69 = (*gap);
return (1f - smoothstep((_e65 - 0.5f), (_e67 + 0.5f), _e69));
}
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e69 = (*at)[0u];
x = i32((_e69 - (floor((_e69 / 4f)) * 4f)));
let _e76 = (*at)[1u];
y = i32((_e76 - (floor((_e76 / 4f)) * 4f)));
let _e82 = y;
let _e84 = x;
index = ((_e82 * 4i) + _e84);
value = 0f;
let _e86 = index;
if (_e86 == 0i) {
value = 0f;
} else {
let _e88 = index;
if (_e88 == 1i) {
value = 8f;
} else {
let _e90 = index;
if (_e90 == 2i) {
value = 2f;
} else {
let _e92 = index;
if (_e92 == 3i) {
value = 10f;
} else {
let _e94 = index;
if (_e94 == 4i) {
value = 12f;
} else {
let _e96 = index;
if (_e96 == 5i) {
value = 4f;
} else {
let _e98 = index;
if (_e98 == 6i) {
value = 14f;
} else {
let _e100 = index;
if (_e100 == 7i) {
value = 6f;
} else {
let _e102 = index;
if (_e102 == 8i) {
value = 3f;
} else {
let _e104 = index;
if (_e104 == 9i) {
value = 11f;
} else {
let _e106 = index;
if (_e106 == 10i) {
value = 1f;
} else {
let _e108 = index;
if (_e108 == 11i) {
value = 9f;
} else {
let _e110 = index;
if (_e110 == 12i) {
value = 15f;
} else {
let _e112 = index;
if (_e112 == 13i) {
value = 7f;
} else {
let _e114 = index;
if (_e114 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e116 = value;
return (_e116 / 16f);
}
fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
var slice: f32;
var cell: vec2<f32>;
var corner: vec2<f32>;
var uv: vec2<f32>;
let _e70 = noise_info.noise[1u];
slice = _e70;
let _e71 = (*at_1);
let _e72 = floor(_e71);
let _e73 = vec2(64f);
cell = (_e72 - (floor((_e72 / _e73)) * _e73));
let _e78 = slice;
let _e83 = slice;
corner = (vec2<f32>((_e78 - (floor((_e78 / 8f)) * 8f)), floor((_e83 / 8f))) * 64f);
let _e88 = corner;
let _e89 = cell;
uv = (((_e88 + _e89) + vec2(0.5f)) / vec2<f32>(512f, 256f));
let _e94 = uv;
let _e95 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e94, 0f);
return (_e95.x * 0.99609375f);
}
fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
var local: f32;
var param: vec2<f32>;
var param_1: vec2<f32>;
let _e69 = noise_info.noise[0u];
if (_e69 > 0.5f) {
let _e71 = (*at_2);
param = _e71;
let _e72 = BlueNoise_u0028_vf2_u003b((¶m));
local = _e72;
} else {
let _e73 = (*at_2);
param_1 = _e73;
let _e74 = BayerCell_u0028_vf2_u003b((¶m_1));
local = _e74;
}
let _e75 = local;
return _e75;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_1: vec2<f32>;
let _e65 = (*rows);
if (_e65 > 0f) {
let _e68 = gl_FragCoord_1[0u];
let _e69 = (*rows);
let _e71 = gl_FragCoord_1[1u];
local_1 = vec2<f32>(_e68, (_e69 - _e71));
} else {
let _e74 = gl_FragCoord_1;
local_1 = _e74.xy;
}
let _e76 = local_1;
return _e76;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_2: f32;
let _e66 = frag_coord_info.origin[0u];
param_2 = _e66;
let _e67 = FragCoordFromTop_u0028_f1_u003b((¶m_2));
return _e67;
}
fn Far_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {
let _e64 = (*depth);
let _e66 = (*depth);
return select(_e66, 1000000000f, (_e64 <= 0f));
}
fn HalfMotion_u0028_vf2_u003b(motion: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixels: vec2<f32>;
var span_1: f32;
var most: f32;
var local_2: vec2<f32>;
let _e68 = (*motion);
let _e70 = blur_info.params;
pixels = (_e68 * _e70.xy);
let _e73 = pixels;
span_1 = length(_e73);
let _e77 = blur_info.params[2u];
most = max(_e77, 0f);
let _e79 = span_1;
let _e80 = most;
if (_e79 > _e80) {
let _e82 = pixels;
let _e83 = most;
let _e84 = span_1;
local_2 = (_e82 * (_e83 / _e84));
} else {
let _e87 = pixels;
local_2 = _e87;
}
let _e88 = local_2;
return _e88;
}
fn main_1() {
var centre: vec4<f32>;
var here: vec2<f32>;
var tile: vec2<f32>;
var dominant: vec2<f32>;
var reach: f32;
var samples: i32;
var ownSpan: f32;
var param_3: vec2<f32>;
var ownDepth: f32;
var param_4: f32;
var extent: f32;
var stride: f32;
var ownShare: f32;
var front: vec3<f32>;
var frontCover: f32;
var level: vec3<f32>;
var levelCover: f32;
var back: vec3<f32>;
var backWeight: f32;
var jitter: f32;
var param_5: vec2<f32>;
var middle: i32;
var i: i32;
var t: f32;
var there: vec2<f32>;
var at_3: vec2<f32>;
var gap_1: f32;
var tap: vec3<f32>;
var tapSpan: f32;
var param_6: vec2<f32>;
var tapDepth: f32;
var param_7: f32;
var nearer: f32;
var behind: f32;
var share: f32;
var param_8: f32;
var param_9: f32;
var nearness: f32;
var own: vec3<f32>;
var behindColor: vec3<f32>;
var local_3: vec3<f32>;
var under: vec3<f32>;
var over: vec3<f32>;
var local_4: vec3<f32>;
let _e107 = v_uv_1;
let _e108 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e107, 0f);
centre = _e108;
let _e109 = v_uv_1;
let _e111 = blur_info.scene;
here = (_e109 * _e111.zw);
let _e114 = here;
let _e117 = blur_info.tiles[2u];
tile = floor((_e114 / vec2(max(_e117, 1f))));
let _e122 = tile;
let _e126 = blur_info.tiles;
let _e129 = textureSampleLevel(neighbor_texture_tex, neighbor_texture_smp, ((_e122 + vec2(0.5f)) / _e126.xy), 0f);
dominant = _e129.xy;
let _e131 = dominant;
reach = length(_e131);
let _e135 = blur_info.params[3u];
samples = i32((_e135 + 0.5f));
let _e138 = reach;
let _e140 = samples;
if ((_e138 <= 0.5f) || (_e140 < 1i)) {
let _e143 = centre;
frag_color = _e143;
return;
}
let _e144 = v_uv_1;
let _e145 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e144, 0f);
param_3 = _e145.xy;
let _e147 = HalfMotion_u0028_vf2_u003b((¶m_3));
ownSpan = max(length(_e147), 0.5f);
let _e150 = v_uv_1;
let _e151 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e150, 0f);
param_4 = _e151.w;
let _e153 = Far_u0028_f1_u003b((¶m_4));
ownDepth = _e153;
let _e156 = blur_info.tiles[3u];
extent = max(_e156, 0.0001f);
let _e158 = reach;
let _e160 = samples;
stride = ((2f * _e158) / f32((_e160 + 1i)));
let _e164 = stride;
let _e166 = ownSpan;
ownShare = min((max(_e164, 1f) / (2f * _e166)), 1f);
front = vec3<f32>(0f, 0f, 0f);
frontCover = 0f;
let _e170 = centre;
let _e172 = ownShare;
level = (_e170.xyz * _e172);
let _e174 = ownShare;
levelCover = _e174;
back = vec3<f32>(0f, 0f, 0f);
backWeight = 0f;
let _e175 = TargetFragCoord_u0028_();
param_5 = _e175;
let _e176 = PixelNoise_u0028_vf2_u003b((¶m_5));
jitter = (_e176 - 0.5f);
let _e178 = samples;
middle = ((_e178 - 1i) / 2i);
i = 0i;
loop {
let _e181 = i;
if (_e181 < 64i) {
let _e183 = i;
let _e184 = samples;
if (_e183 >= _e184) {
break;
}
let _e186 = i;
let _e187 = middle;
if (_e186 == _e187) {
continue;
}
let _e189 = i;
let _e191 = jitter;
let _e194 = samples;
t = mix(-1f, 1f, (((f32(_e189) + _e191) + 1f) / f32((_e194 + 1i))));
let _e199 = here;
let _e200 = dominant;
let _e201 = t;
there = (floor((_e199 + (_e200 * _e201))) + vec2(0.5f));
let _e207 = there;
let _e209 = blur_info.scene;
at_3 = (_e207 * _e209.xy);
let _e212 = there;
let _e213 = here;
gap_1 = length((_e212 - _e213));
let _e216 = at_3;
let _e217 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e216, 0f);
tap = _e217.xyz;
let _e219 = at_3;
let _e220 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e219, 0f);
param_6 = _e220.xy;
let _e222 = HalfMotion_u0028_vf2_u003b((¶m_6));
tapSpan = max(length(_e222), 0.5f);
let _e225 = at_3;
let _e226 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e225, 0f);
param_7 = _e226.w;
let _e228 = Far_u0028_f1_u003b((¶m_7));
tapDepth = _e228;
let _e229 = ownDepth;
let _e230 = tapDepth;
let _e232 = extent;
nearer = clamp(((_e229 - _e230) / _e232), 0f, 1f);
let _e235 = tapDepth;
let _e236 = ownDepth;
let _e238 = extent;
behind = clamp(((_e235 - _e236) / _e238), 0f, 1f);
let _e241 = gap_1;
param_8 = _e241;
let _e242 = tapSpan;
param_9 = _e242;
let _e243 = Reaches_u0028_f1_u003b_f1_u003b((¶m_8), (¶m_9));
let _e244 = stride;
let _e245 = tapSpan;
share = (_e243 * min((_e244 / (2f * _e245)), 1f));
let _e250 = tap;
let _e251 = nearer;
let _e252 = share;
let _e255 = front;
front = (_e255 + (_e250 * (_e251 * _e252)));
let _e257 = nearer;
let _e258 = share;
let _e260 = frontCover;
frontCover = (_e260 + (_e257 * _e258));
let _e262 = tap;
let _e263 = nearer;
let _e265 = behind;
let _e267 = share;
let _e270 = level;
level = (_e270 + (_e262 * (((1f - _e263) - _e265) * _e267)));
let _e272 = nearer;
let _e274 = behind;
let _e276 = share;
let _e278 = levelCover;
levelCover = (_e278 + (((1f - _e272) - _e274) * _e276));
let _e280 = behind;
let _e281 = gap_1;
let _e282 = gap_1;
nearness = (_e280 / max((_e281 * _e282), 1f));
let _e286 = tap;
let _e287 = nearness;
let _e289 = back;
back = (_e289 + (_e286 * _e287));
let _e291 = nearness;
let _e292 = backWeight;
backWeight = (_e292 + _e291);
continue;
} else {
break;
}
continuing {
let _e294 = i;
i = (_e294 + 1i);
}
}
let _e296 = level;
let _e297 = levelCover;
own = (_e296 / vec3(_e297));
let _e300 = backWeight;
if (_e300 > 0f) {
let _e302 = back;
let _e303 = backWeight;
local_3 = (_e302 / vec3(_e303));
} else {
let _e306 = own;
local_3 = _e306;
}
let _e307 = local_3;
behindColor = _e307;
let _e308 = behindColor;
let _e309 = own;
let _e310 = levelCover;
under = mix(_e308, _e309, vec3(min(_e310, 1f)));
let _e314 = frontCover;
if (_e314 > 0f) {
let _e316 = front;
let _e317 = frontCover;
local_4 = (_e316 / vec3(_e317));
} else {
let _e320 = under;
local_4 = _e320;
}
let _e321 = local_4;
over = _e321;
let _e322 = under;
let _e323 = over;
let _e324 = frontCover;
let _e327 = mix(_e322, _e323, vec3(min(_e324, 1f)));
let _e329 = centre[3u];
frag_color = vec4<f32>(_e327.x, _e327.y, _e327.z, _e329);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_uv_1 = v_uv;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FragCoordInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'origin',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'MotionBlurInfo',
group: 1,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'scene', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'NoiseInfo',
group: 1,
binding: 2,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blue_noise_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'neighbor_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'velocity_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
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 alpha2_: f32;
var up: vec3<f32>;
var right: vec3<f32>;
var ahead: vec3<f32>;
var sum: vec3<f32>;
var weight: f32;
var i: i32;
var e: f32;
var theta: f32;
var cosH: f32;
var sinH: 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;
alpha2_ = (_e83 * _e84);
let _e87 = axis[2u];
up = select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e87) < 0.999f)));
let _e92 = up;
let _e93 = axis;
right = normalize(cross(_e92, _e93));
let _e96 = axis;
let _e97 = right;
ahead = cross(_e96, _e97);
sum = vec3<f32>(0f, 0f, 0f);
weight = 0f;
i = 0i;
loop {
let _e99 = i;
if (_e99 < 128i) {
let _e101 = i;
let _e102 = samples;
if (_e101 >= _e102) {
break;
}
let _e104 = i;
let _e107 = samples;
e = ((f32(_e104) + 0.5f) / f32(_e107));
let _e110 = i;
theta = (2.3999631f * f32(_e110));
let _e113 = e;
let _e115 = alpha2_;
let _e117 = e;
cosH = sqrt(((1f - _e113) / (1f + ((_e115 - 1f) * _e117))));
let _e122 = cosH;
let _e123 = cosH;
sinH = sqrt(max((1f - (_e122 * _e123)), 0f));
let _e128 = cosH;
let _e130 = sinH;
let _e132 = theta;
let _e135 = cosH;
let _e137 = sinH;
let _e139 = theta;
let _e142 = cosH;
let _e144 = cosH;
tap = vec3<f32>((((2f * _e128) * _e130) * cos(_e132)), (((2f * _e135) * _e137) * sin(_e139)), (((2f * _e142) * _e144) - 1f));
let _e148 = right;
let _e150 = tap[0u];
let _e152 = ahead;
let _e154 = tap[1u];
let _e157 = axis;
let _e159 = tap[2u];
dir = (((_e148 * _e150) + (_e152 * _e154)) + (_e157 * _e159));
let _e162 = dir;
let _e163 = axis;
cosine = dot(_e162, _e163);
let _e165 = cosine;
if (_e165 <= 0f) {
continue;
}
let _e167 = dir;
let _e168 = lod;
let _e169 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e167, _e168);
let _e171 = cosine;
let _e173 = sum;
sum = (_e173 + (_e169.xyz * _e171));
let _e175 = cosine;
let _e176 = weight;
weight = (_e176 + _e175);
continue;
} else {
break;
}
continuing {
let _e178 = i;
i = (_e178 + 1i);
}
}
let _e180 = weight;
if (_e180 > 0f) {
let _e182 = sum;
let _e183 = weight;
local = (_e182 / vec3(_e183));
} else {
local = vec3<f32>(0f, 0f, 0f);
}
let _e186 = local;
frag_color = vec4<f32>(_e186.x, _e186.y, _e186.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_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e24 = shadow_light.light[3u];
range = max(_e24, 0.0001f);
let _e26 = v_world_position_1;
let _e28 = shadow_light.light;
distance_ = length((_e26 - _e28.xyz));
let _e32 = distance_;
let _e33 = range;
frag_color = vec4<f32>(clamp((_e32 / _e33), 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_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = 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 _e39 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e39, 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_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e28 = v_texcoord_1;
let _e29 = textureSample(base_color_texture_tex, base_color_texture_smp, _e28);
let _e33 = mask_info.mask[1u];
alpha = (_e29.w * _e33);
let _e35 = alpha;
let _e38 = mask_info.mask[0u];
if (_e35 < _e38) {
discard;
}
let _e42 = shadow_light.light[3u];
range = max(_e42, 0.0001f);
let _e44 = v_world_position_1;
let _e46 = shadow_light.light;
distance_ = length((_e44 - _e46.xyz));
let _e50 = distance_;
let _e51 = range;
frag_color = vec4<f32>(clamp((_e50 / _e51), 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,
),
],
),
'ShadowCopy': WebGpuStage(
wgsl: r'''
struct ShadowCopyInfo {
tile: vec4<f32>,
shift: vec4<f32>,
}
struct FragmentOutput {
@location(0) member: vec4<f32>,
@builtin(frag_depth) member_1: f32,
}
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> copy_info: ShadowCopyInfo;
@group(1) @binding(1)
var static_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var static_shadow_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
var<private> gl_FragDepth: f32 = 0f;
fn main_1() {
var from_: vec2<f32>;
var inside: bool;
var stored: f32;
var depth: f32;
var local: f32;
var phi_40_: bool;
let _e19 = v_uv_1;
let _e21 = copy_info.shift;
from_ = (_e19 - _e21.xy);
let _e24 = from_;
let _e26 = all((_e24 >= vec2<f32>(0f, 0f)));
phi_40_ = _e26;
if _e26 {
let _e27 = from_;
phi_40_ = all((_e27 <= vec2<f32>(1f, 1f)));
}
let _e31 = phi_40_;
inside = _e31;
let _e33 = copy_info.tile;
let _e35 = from_;
let _e40 = copy_info.tile;
let _e44 = textureSampleLevel(static_shadow_texture_tex, static_shadow_texture_smp, (_e33.xy + (clamp(_e35, vec2(0f), vec2(1f)) * _e40.zw)), 0f);
stored = _e44.x;
let _e46 = inside;
let _e47 = stored;
if (_e46 && (_e47 < 1f)) {
let _e50 = stored;
let _e53 = copy_info.shift[2u];
local = clamp((_e50 + _e53), 0f, 1f);
} else {
local = 1f;
}
let _e56 = local;
depth = _e56;
let _e57 = depth;
frag_color = vec4<f32>(_e57, 0f, 0f, 1f);
let _e59 = depth;
gl_FragDepth = _e59;
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> FragmentOutput {
v_uv_1 = v_uv;
main_1();
let _e4 = frag_color;
let _e5 = gl_FragDepth;
return FragmentOutput(_e4, _e5);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShadowCopyInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'tile', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'shift',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'static_shadow_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'EvsmFilter': WebGpuStage(
wgsl: r'''
struct EvsmFilterInfo {
axis: vec4<f32>,
tile: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> evsm_info: EvsmFilterInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var evsm_source_tex: texture_2d<f32>;
@group(1) @binding(2)
var evsm_source_smp: sampler;
var<private> frag_color: vec4<f32>;
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d: f32;
let _e24 = (*depth);
d = ((2f * clamp(_e24, 0f, 1f)) - 1f);
let _e28 = d;
let _e31 = d;
return vec2<f32>(exp((40f * _e28)), -(exp((-5f * _e31))));
}
fn EvsmMoments_u0028_f1_u003b(depth_1: ptr<function, f32>) -> vec4<f32> {
var warped: vec2<f32>;
var param: f32;
let _e25 = (*depth_1);
param = _e25;
let _e26 = EvsmWarp_u0028_f1_u003b((¶m));
warped = _e26;
let _e28 = warped[0u];
let _e30 = warped[0u];
let _e32 = warped[0u];
let _e35 = warped[1u];
let _e37 = warped[1u];
let _e39 = warped[1u];
return vec4<f32>(_e28, (_e30 * _e32), _e35, (_e37 * _e39));
}
fn main_1() {
var count: f32;
var which: f32;
var lo: vec2<f32>;
var hi: vec2<f32>;
var taps: f32;
var sigma: f32;
var warp: bool;
var total: vec4<f32>;
var weightSum: f32;
var i: i32;
var offset: f32;
var at: vec2<f32>;
var texel: vec4<f32>;
var value: vec4<f32>;
var local: vec4<f32>;
var param_1: f32;
var weight: f32;
let _e41 = evsm_info.tile[0u];
count = max(_e41, 1f);
let _e44 = v_uv_1[0u];
let _e45 = count;
let _e48 = count;
which = min(floor((_e44 * _e45)), (_e48 - 1f));
let _e51 = which;
let _e52 = count;
let _e56 = evsm_info.tile[1u];
let _e60 = evsm_info.tile[2u];
lo = vec2<f32>(((_e51 / _e52) + _e56), _e60);
let _e62 = which;
let _e64 = count;
let _e68 = evsm_info.tile[1u];
let _e72 = evsm_info.tile[2u];
hi = vec2<f32>((((_e62 + 1f) / _e64) - _e68), (1f - _e72));
let _e77 = evsm_info.axis[2u];
taps = clamp(_e77, 0f, 8f);
let _e79 = taps;
sigma = max((_e79 * 0.5f), 0.5f);
let _e84 = evsm_info.axis[3u];
warp = (_e84 > 0.5f);
total = vec4<f32>(0f, 0f, 0f, 0f);
weightSum = 0f;
i = -8i;
loop {
let _e86 = i;
if (_e86 <= 8i) {
let _e88 = i;
offset = f32(_e88);
let _e90 = offset;
let _e92 = taps;
if (abs(_e90) > _e92) {
continue;
}
let _e94 = v_uv_1;
let _e96 = evsm_info.axis;
let _e98 = offset;
let _e101 = lo;
let _e102 = hi;
at = clamp((_e94 + (_e96.xy * _e98)), _e101, _e102);
let _e104 = at;
let _e105 = textureSampleLevel(evsm_source_tex, evsm_source_smp, _e104, 0f);
texel = _e105;
let _e106 = warp;
if _e106 {
let _e108 = texel[0u];
param_1 = _e108;
let _e109 = EvsmMoments_u0028_f1_u003b((¶m_1));
local = _e109;
} else {
let _e110 = texel;
local = _e110;
}
let _e111 = local;
value = _e111;
let _e112 = offset;
let _e113 = offset;
let _e116 = sigma;
let _e118 = sigma;
weight = exp((-((_e112 * _e113)) / ((2f * _e116) * _e118)));
let _e122 = value;
let _e123 = weight;
let _e125 = total;
total = (_e125 + (_e122 * _e123));
let _e127 = weight;
let _e128 = weightSum;
weightSum = (_e128 + _e127);
continue;
} else {
break;
}
continuing {
let _e130 = i;
i = (_e130 + 1i);
}
}
let _e132 = total;
let _e133 = weightSum;
frag_color = (_e132 / vec4(_e133));
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: 'EvsmFilterInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'axis', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'tile', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'evsm_source',
group: 1,
textureBinding: 1,
samplerBinding: 2,
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,
),
],
),
'DepthPyramid': WebGpuStage(
wgsl: r'''
struct DepthPyramidInfo {
block: vec4<f32>,
range: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> pyramid_info: DepthPyramidInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn main_1() {
var blockUv: vec2<f32>;
var tapsX: f32;
var tapsY: f32;
var corner: vec2<f32>;
var stepUv: vec2<f32>;
var farthest: f32;
var nearest: f32;
var empty: f32;
var j: i32;
var i: i32;
var at: vec2<f32>;
var depth: f32;
var steps: f32;
var scaled: f32;
var high: f32;
var rest: f32;
var middle: f32;
var low: f32;
var ratio: f32;
var local: f32;
var flatness: f32;
var local_1: f32;
let _e46 = pyramid_info.block;
blockUv = _e46.xy;
let _e50 = pyramid_info.block[2u];
tapsX = clamp(ceil((_e50 - 0.001f)), 1f, 32f);
let _e56 = pyramid_info.block[3u];
tapsY = clamp(ceil((_e56 - 0.001f)), 1f, 32f);
let _e60 = v_uv_1;
let _e61 = blockUv;
corner = (_e60 - (_e61 * 0.5f));
let _e64 = blockUv;
let _e65 = tapsX;
let _e66 = tapsY;
stepUv = (_e64 / vec2<f32>(_e65, _e66));
farthest = 0f;
nearest = 300000000000000000000000000000000000000f;
empty = 0f;
j = 0i;
loop {
let _e69 = j;
if (_e69 < 32i) {
let _e71 = j;
let _e73 = tapsY;
if (f32(_e71) >= _e73) {
break;
}
i = 0i;
loop {
let _e75 = i;
if (_e75 < 32i) {
let _e77 = i;
let _e79 = tapsX;
if (f32(_e77) >= _e79) {
break;
}
let _e81 = corner;
let _e82 = i;
let _e84 = j;
let _e89 = stepUv;
at = (_e81 + ((vec2<f32>(f32(_e82), f32(_e84)) + vec2(0.5f)) * _e89));
let _e92 = at;
let _e93 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e92, 0f);
depth = _e93.w;
let _e95 = depth;
let _e97 = empty;
empty = select(1f, _e97, (_e95 > 0f));
let _e99 = farthest;
let _e100 = depth;
farthest = max(_e99, _e100);
let _e102 = nearest;
let _e103 = depth;
nearest = min(_e102, _e103);
continue;
} else {
break;
}
continuing {
let _e105 = i;
i = (_e105 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e107 = j;
j = (_e107 + 1i);
}
}
steps = 16777215f;
let _e109 = farthest;
let _e112 = pyramid_info.range[0u];
let _e115 = steps;
scaled = ceil((clamp((_e109 * _e112), 0f, 1f) * _e115));
let _e118 = scaled;
high = floor((_e118 / 65536f));
let _e121 = scaled;
let _e122 = high;
rest = (_e121 - (_e122 * 65536f));
let _e125 = rest;
middle = floor((_e125 / 256f));
let _e128 = rest;
let _e129 = middle;
low = (_e128 - (_e129 * 256f));
let _e132 = farthest;
if (_e132 > 0f) {
let _e134 = nearest;
let _e135 = farthest;
local = clamp((_e134 / _e135), 0f, 1f);
} else {
local = 0f;
}
let _e138 = local;
ratio = _e138;
let _e139 = ratio;
flatness = (128f + floor(((_e139 * 127f) + 0.001f)));
let _e144 = high;
let _e146 = middle;
let _e148 = low;
let _e150 = empty;
if (_e150 > 0f) {
local_1 = 0f;
} else {
let _e152 = flatness;
local_1 = (_e152 / 255f);
}
let _e154 = local_1;
frag_color = vec4<f32>((_e144 / 255f), (_e146 / 255f), (_e148 / 255f), _e154);
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: 'DepthPyramidInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'block', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'range',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_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_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: 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_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
let _e28 = id_info.mask[0u];
cutoff = _e28;
let _e29 = cutoff;
if (_e29 >= 0f) {
let _e31 = v_texcoord_1;
let _e32 = textureSample(base_color_texture_tex, base_color_texture_smp, _e31);
let _e36 = id_info.mask[1u];
let _e39 = v_color_1[3u];
alpha = ((_e32.w * _e36) * _e39);
let _e41 = alpha;
let _e42 = cutoff;
if (_e41 < _e42) {
discard;
}
}
let _e45 = id_info.id;
let _e46 = _e45.xyz;
frag_color = vec4<f32>(_e46.x, _e46.y, _e46.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>[],
),
'FieldDecay': WebGpuStage(
wgsl: r'''
struct FieldDecayInfo {
params: vec4<f32>,
}
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var field_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var field_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> field_decay: FieldDecayInfo;
fn main_1() {
let _e9 = v_uv_1;
let _e10 = textureSampleLevel(field_texture_tex, field_texture_smp, _e9, 0f);
let _e13 = field_decay.params[0u];
let _e17 = field_decay.params[1u];
frag_color = ((_e10 * _e13) + vec4(_e17));
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: 'FieldDecayInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'field_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'IrradianceConvolve': WebGpuStage(
wgsl: r'''
struct ConvolveInfo {
probe: vec4<f32>,
tiles: vec4<f32>,
atlas: vec4<f32>,
}
@group(1) @binding(7)
var surface_texture_tex: texture_cube<f32>;
@group(1) @binding(8)
var surface_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> convolve_info: ConvolveInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var field_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var field_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var seed_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var seed_texture_smp: sampler;
@group(1) @binding(3)
var radiance_texture_tex: texture_cube<f32>;
@group(1) @binding(4)
var radiance_texture_smp: sampler;
fn DistanceAlong_u0028_vf3_u003b(direction: ptr<function, vec3<f32>>) -> f32 {
var depth: f32;
var axis: f32;
let _e29 = (*direction);
let _e30 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e29, 0f);
depth = _e30.w;
let _e32 = depth;
if (_e32 <= 0f) {
let _e36 = convolve_info.tiles[3u];
return _e36;
}
let _e38 = (*direction)[0u];
let _e41 = (*direction)[1u];
let _e44 = (*direction)[2u];
axis = max(abs(_e38), max(abs(_e41), abs(_e44)));
let _e48 = depth;
let _e49 = axis;
return (_e48 / max(_e49, 0.0001f));
}
fn CubeTexel_u0028_i1_u003b_f1_u003b_f1_u003b(face: ptr<function, i32>, a: ptr<function, f32>, b: ptr<function, f32>) -> vec3<f32> {
var side: f32;
var axis_1: i32;
let _e31 = (*face);
side = select(-1f, 1f, ((_e31 & 1i) == 0i));
let _e35 = (*face);
axis_1 = (_e35 >> bitcast<u32>(1i));
let _e38 = axis_1;
if (_e38 == 0i) {
let _e40 = side;
let _e41 = (*a);
let _e42 = (*b);
return vec3<f32>(_e40, _e41, _e42);
}
let _e44 = axis_1;
if (_e44 == 1i) {
let _e46 = (*a);
let _e47 = side;
let _e48 = (*b);
return vec3<f32>(_e46, _e47, _e48);
}
let _e50 = (*a);
let _e51 = (*b);
let _e52 = side;
return vec3<f32>(_e50, _e51, _e52);
}
fn DecodeProbeOctahedral_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {
var xy: vec2<f32>;
var z: f32;
var t: f32;
var n: vec3<f32>;
var local: f32;
var local_1: f32;
let _e33 = (*uv);
xy = ((_e33 * 2f) - vec2(1f));
let _e38 = xy[0u];
let _e42 = xy[1u];
z = ((1f - abs(_e38)) - abs(_e42));
let _e45 = z;
t = max(-(_e45), 0f);
let _e49 = xy[0u];
let _e51 = xy[0u];
if (_e51 >= 0f) {
let _e53 = t;
local = -(_e53);
} else {
let _e55 = t;
local = _e55;
}
let _e56 = local;
let _e59 = xy[1u];
let _e61 = xy[1u];
if (_e61 >= 0f) {
let _e63 = t;
local_1 = -(_e63);
} else {
let _e65 = t;
local_1 = _e65;
}
let _e66 = local_1;
let _e68 = z;
n = vec3<f32>((_e49 + _e56), (_e59 + _e66), _e68);
let _e70 = n;
return normalize(_e70);
}
fn InteriorOf_u0028_vf2_u003b_f1_u003b(local_2: ptr<function, vec2<f32>>, interior: ptr<function, f32>) -> vec2<f32> {
var last: f32;
var i: vec2<f32>;
var left: bool;
var right: bool;
var top: bool;
var bottom: bool;
var phi_165_: bool;
let _e34 = (*interior);
last = (_e34 - 1f);
let _e36 = (*local_2);
i = (_e36 - vec2(1f));
let _e40 = (*local_2)[0u];
left = (_e40 < 0.5f);
let _e43 = (*local_2)[0u];
let _e44 = (*interior);
right = (_e43 > (_e44 + 0.5f));
let _e48 = (*local_2)[1u];
top = (_e48 < 0.5f);
let _e51 = (*local_2)[1u];
let _e52 = (*interior);
bottom = (_e51 > (_e52 + 0.5f));
let _e55 = left;
let _e56 = right;
let _e57 = (_e55 || _e56);
phi_165_ = _e57;
if _e57 {
let _e58 = top;
let _e59 = bottom;
phi_165_ = (_e58 || _e59);
}
let _e62 = phi_165_;
if _e62 {
let _e63 = left;
let _e64 = last;
let _e66 = top;
let _e67 = last;
return vec2<f32>(select(0f, _e64, _e63), select(0f, _e67, _e66));
}
let _e70 = top;
if _e70 {
let _e71 = last;
let _e73 = i[0u];
return vec2<f32>((_e71 - _e73), 0f);
}
let _e76 = bottom;
if _e76 {
let _e77 = last;
let _e79 = i[0u];
let _e81 = last;
return vec2<f32>((_e77 - _e79), _e81);
}
let _e83 = left;
if _e83 {
let _e84 = last;
let _e86 = i[1u];
return vec2<f32>(0f, (_e84 - _e86));
}
let _e89 = right;
if _e89 {
let _e90 = last;
let _e91 = last;
let _e93 = i[1u];
return vec2<f32>(_e90, (_e91 - _e93));
}
let _e96 = i;
return _e96;
}
fn main_1() {
var size: vec2<f32>;
var pixel: vec2<f32>;
var old: vec4<f32>;
var columns: f32;
var target_: f32;
var irradianceTile: f32;
var depthTile: f32;
var momentsTop: f32;
var moments: bool;
var stride: f32;
var local_3: vec2<f32>;
var local_4: vec2<f32>;
var tile: vec2<f32>;
var interior_1: f32;
var texel: vec2<f32>;
var param: vec2<f32>;
var param_1: f32;
var normal: vec3<f32>;
var param_2: vec2<f32>;
var captureSide: i32;
var span: f32;
var light: vec3<f32>;
var mean: f32;
var square: f32;
var weight: f32;
var face_1: i32;
var row: i32;
var column: i32;
var a_1: f32;
var b_1: f32;
var inverse: f32;
var direction_1: vec3<f32>;
var param_3: i32;
var param_4: f32;
var param_5: f32;
var solidAngle: f32;
var cosine: f32;
var c2_: f32;
var w: f32;
var distance_: f32;
var param_6: vec3<f32>;
var w_1: f32;
var keep: f32;
var fresh: vec2<f32>;
var local_5: vec2<f32>;
var fresh_1: vec3<f32>;
var local_6: vec3<f32>;
var phi_375_: bool;
let _e74 = convolve_info.atlas;
size = _e74.xy;
let _e76 = v_uv_1;
let _e77 = size;
pixel = floor((_e76 * _e77));
let _e80 = pixel;
let _e83 = size;
let _e85 = textureSampleLevel(field_texture_tex, field_texture_smp, ((_e80 + vec2(0.5f)) / _e83), 0f);
old = _e85;
let _e88 = convolve_info.probe[1u];
if (_e88 > 0.5f) {
let _e90 = pixel;
let _e93 = size;
let _e95 = textureSampleLevel(seed_texture_tex, seed_texture_smp, ((_e90 + vec2(0.5f)) / _e93), 0f);
frag_color = _e95;
return;
}
let _e98 = convolve_info.probe[3u];
columns = _e98;
let _e101 = convolve_info.probe[0u];
target_ = _e101;
let _e104 = convolve_info.tiles[0u];
irradianceTile = _e104;
let _e107 = convolve_info.tiles[1u];
depthTile = _e107;
let _e110 = convolve_info.tiles[2u];
momentsTop = _e110;
let _e112 = pixel[1u];
let _e113 = momentsTop;
moments = (_e112 >= _e113);
let _e115 = moments;
let _e116 = depthTile;
let _e117 = irradianceTile;
stride = (select(_e117, _e116, _e115) + 2f);
let _e120 = moments;
if _e120 {
let _e122 = pixel[0u];
let _e124 = pixel[1u];
let _e125 = momentsTop;
local_4 = vec2<f32>(_e122, (_e124 - _e125));
} else {
let _e128 = pixel;
local_4 = _e128;
}
let _e129 = local_4;
local_3 = _e129;
let _e130 = local_3;
let _e131 = stride;
tile = floor((_e130 / vec2(_e131)));
let _e136 = tile[1u];
let _e137 = columns;
let _e140 = tile[0u];
let _e142 = target_;
let _e143 = (((_e136 * _e137) + _e140) != _e142);
phi_375_ = _e143;
if !(_e143) {
let _e146 = tile[0u];
let _e147 = columns;
phi_375_ = (_e146 >= _e147);
}
let _e150 = phi_375_;
if _e150 {
let _e151 = old;
frag_color = _e151;
return;
}
let _e152 = moments;
let _e153 = depthTile;
let _e154 = irradianceTile;
interior_1 = select(_e154, _e153, _e152);
let _e156 = local_3;
let _e157 = tile;
let _e158 = stride;
param = (_e156 - (_e157 * _e158));
let _e161 = interior_1;
param_1 = _e161;
let _e162 = InteriorOf_u0028_vf2_u003b_f1_u003b((¶m), (¶m_1));
texel = _e162;
let _e163 = texel;
let _e166 = interior_1;
param_2 = ((_e163 + vec2(0.5f)) / vec2(_e166));
let _e169 = DecodeProbeOctahedral_u0028_vf2_u003b((¶m_2));
normal = _e169;
let _e172 = convolve_info.atlas[2u];
captureSide = max(i32((_e172 + 0.5f)), 1i);
let _e176 = captureSide;
span = (2f / f32(_e176));
light = vec3<f32>(0f, 0f, 0f);
mean = 0f;
square = 0f;
weight = 0f;
face_1 = 0i;
loop {
let _e179 = face_1;
if (_e179 < 6i) {
row = 0i;
loop {
let _e181 = row;
let _e182 = captureSide;
if (_e181 < _e182) {
column = 0i;
loop {
let _e184 = column;
let _e185 = captureSide;
if (_e184 < _e185) {
let _e187 = column;
let _e190 = span;
a_1 = (((f32(_e187) + 0.5f) * _e190) - 1f);
let _e193 = row;
let _e196 = span;
b_1 = (((f32(_e193) + 0.5f) * _e196) - 1f);
let _e199 = a_1;
let _e200 = a_1;
let _e203 = b_1;
let _e204 = b_1;
inverse = inverseSqrt(((1f + (_e199 * _e200)) + (_e203 * _e204)));
let _e208 = face_1;
param_3 = _e208;
let _e209 = a_1;
param_4 = _e209;
let _e210 = b_1;
param_5 = _e210;
let _e211 = CubeTexel_u0028_i1_u003b_f1_u003b_f1_u003b((¶m_3), (¶m_4), (¶m_5));
let _e212 = inverse;
direction_1 = (_e211 * _e212);
let _e214 = inverse;
let _e215 = inverse;
let _e217 = inverse;
solidAngle = ((_e214 * _e215) * _e217);
let _e219 = normal;
let _e220 = direction_1;
cosine = dot(_e219, _e220);
let _e222 = cosine;
if (_e222 <= 0f) {
continue;
}
let _e224 = moments;
if _e224 {
let _e225 = cosine;
let _e226 = cosine;
c2_ = (_e225 * _e226);
let _e228 = c2_;
let _e229 = c2_;
let _e231 = c2_;
let _e233 = solidAngle;
w = (((_e228 * _e229) * _e231) * _e233);
let _e235 = direction_1;
param_6 = _e235;
let _e236 = DistanceAlong_u0028_vf3_u003b((¶m_6));
distance_ = _e236;
let _e237 = distance_;
let _e238 = w;
let _e240 = mean;
mean = (_e240 + (_e237 * _e238));
let _e242 = distance_;
let _e243 = distance_;
let _e245 = w;
let _e247 = square;
square = (_e247 + ((_e242 * _e243) * _e245));
let _e249 = w;
let _e250 = weight;
weight = (_e250 + _e249);
} else {
let _e252 = cosine;
let _e253 = solidAngle;
w_1 = (_e252 * _e253);
let _e255 = direction_1;
let _e256 = textureSampleLevel(radiance_texture_tex, radiance_texture_smp, _e255, 0f);
let _e258 = w_1;
let _e260 = light;
light = (_e260 + (_e256.xyz * _e258));
let _e262 = w_1;
let _e263 = weight;
weight = (_e263 + _e262);
}
continue;
} else {
break;
}
continuing {
let _e265 = column;
column = (_e265 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e267 = row;
row = (_e267 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e269 = face_1;
face_1 = (_e269 + 1i);
}
}
let _e273 = convolve_info.probe[2u];
keep = _e273;
let _e274 = moments;
if _e274 {
let _e275 = weight;
if (_e275 > 0f) {
let _e277 = mean;
let _e278 = square;
let _e280 = weight;
local_5 = (vec2<f32>(_e277, _e278) / vec2(_e280));
} else {
let _e283 = old;
local_5 = _e283.xy;
}
let _e285 = local_5;
fresh = _e285;
let _e286 = fresh;
let _e287 = old;
let _e289 = keep;
let _e291 = mix(_e286, _e287.xy, vec2(_e289));
frag_color = vec4<f32>(_e291.x, _e291.y, 0f, 1f);
} else {
let _e295 = weight;
if (_e295 > 0f) {
let _e297 = light;
let _e298 = weight;
local_6 = (_e297 / vec3(_e298));
} else {
let _e301 = old;
local_6 = _e301.xyz;
}
let _e303 = local_6;
fresh_1 = _e303;
let _e304 = fresh_1;
let _e305 = old;
let _e307 = keep;
let _e309 = mix(_e304, _e305.xyz, vec3(_e307));
let _e311 = old[3u];
frag_color = vec4<f32>(_e309.x, _e309.y, _e309.z, _e311);
}
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: 'ConvolveInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'probe', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'tiles',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'atlas',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'field_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'radiance_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'seed_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.cube,
),
],
),
'WboitResolve': WebGpuStage(
wgsl: r'''
@group(1) @binding(0)
var accumulation_texture_tex: texture_2d<f32>;
@group(1) @binding(1)
var accumulation_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(2)
var revealage_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var revealage_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn main_1() {
var accumulation: vec4<f32>;
var coverage: f32;
var average: vec3<f32>;
let _e15 = v_uv_1;
let _e16 = textureSample(accumulation_texture_tex, accumulation_texture_smp, _e15);
accumulation = _e16;
let _e17 = v_uv_1;
let _e18 = textureSample(revealage_texture_tex, revealage_texture_smp, _e17);
coverage = (1f - _e18.x);
let _e21 = accumulation;
let _e25 = accumulation[3u];
average = (min(_e21.xyz, vec3<f32>(65504f, 65504f, 65504f)) / vec3(clamp(_e25, 0.00001f, 65504f)));
let _e29 = average;
let _e30 = coverage;
let _e31 = (_e29 * _e30);
let _e32 = coverage;
frag_color = vec4<f32>(_e31.x, _e31.y, _e31.z, _e32);
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>[
WebGpuSampler(
name: 'accumulation_texture',
group: 1,
textureBinding: 0,
samplerBinding: 1,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'revealage_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'SceneColourCopy': WebGpuStage(
wgsl: r'''
struct SceneCopyInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> copy_info: SceneCopyInfo;
@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 taps: f32;
var texel: vec2<f32>;
var first: f32;
var sum: vec3<f32>;
var j: i32;
var i: i32;
var offset: vec2<f32>;
let _e22 = copy_info.params[0u];
taps = _e22;
let _e24 = copy_info.params;
texel = _e24.yz;
let _e26 = taps;
first = (1f - _e26);
sum = vec3<f32>(0f, 0f, 0f);
j = 0i;
loop {
let _e28 = j;
if (_e28 < 16i) {
let _e30 = j;
let _e32 = taps;
if (f32(_e30) >= _e32) {
break;
}
i = 0i;
loop {
let _e34 = i;
if (_e34 < 16i) {
let _e36 = i;
let _e38 = taps;
if (f32(_e36) >= _e38) {
break;
}
let _e40 = first;
let _e41 = i;
let _e45 = first;
let _e46 = j;
let _e51 = texel;
offset = (vec2<f32>((_e40 + (2f * f32(_e41))), (_e45 + (2f * f32(_e46)))) * _e51);
let _e53 = v_uv_1;
let _e54 = offset;
let _e56 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e53 + _e54), 0f);
let _e58 = sum;
sum = (_e58 + _e56.xyz);
continue;
} else {
break;
}
continuing {
let _e60 = i;
i = (_e60 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e62 = j;
j = (_e62 + 1i);
}
}
let _e64 = sum;
let _e65 = taps;
let _e66 = taps;
let _e69 = (_e64 / vec3((_e65 * _e66)));
frag_color = vec4<f32>(_e69.x, _e69.y, _e69.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: 'SceneCopyInfo',
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,
),
],
),
'Impostor': 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,
integrated: f32,
ltc: vec3<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>,
cluster_view_projection: mat4x4<f32>,
cluster_grid: vec4<f32>,
cluster_depth: vec4<f32>,
slot_rows: array<vec4<f32>, 2>,
}
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>,
shadow_bias: vec4<f32>,
target_origin: 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(2) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
@location(0) member_2: vec4<f32>,
}
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(6)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@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>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(12)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var point_shadow_texture_smp: sampler;
@group(1) @binding(10)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(14)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var shadow_texture_smp: sampler;
@group(1) @binding(8)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e165 = v_world_position_1;
let _e167 = fog_info.eye;
let _e171 = fog_info.forward;
return dot((_e165 - _e167.xyz), _e171.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e170 = ViewDepth_u0028_();
z = abs(_e170);
let _e172 = z;
near = (_e172 / 5f);
let _e174 = z;
far = (_e174 / 200f);
let _e176 = far;
let _e177 = far;
let _e179 = far;
far3_ = ((_e176 * _e177) * _e179);
let _e181 = (*alpha);
let _e182 = near;
let _e183 = near;
let _e186 = far3_;
let _e187 = far3_;
return (_e181 * clamp((10f / ((0.00001f + (_e182 * _e183)) + (_e186 * _e187))), 0.01f, 3000f));
}
fn WriteWeightedBlended_u0028_() {
var mode: f32;
var alpha_1: f32;
var weight: f32;
var param: f32;
var accumulate: vec4<f32>;
var revealage: bool;
var local: vec4<f32>;
let _e174 = fog_info.forward[3u];
mode = _e174;
let _e175 = mode;
if (_e175 > 0.5f) {
let _e178 = frag_color[3u];
alpha_1 = _e178;
let _e179 = alpha_1;
param = _e179;
let _e180 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e180;
let _e181 = frag_color;
let _e183 = weight;
let _e184 = (_e181.xyz * _e183);
let _e185 = alpha_1;
let _e186 = weight;
accumulate = vec4<f32>(_e184.x, _e184.y, _e184.z, (_e185 * _e186));
let _e192 = mode;
let _e194 = mode;
revealage = ((_e192 > 1.5f) && (_e194 < 2.5f));
let _e197 = revealage;
if _e197 {
let _e198 = alpha_1;
local = vec4(_e198);
} else {
let _e200 = accumulate;
local = _e200;
}
let _e201 = local;
frag_color = _e201;
let _e202 = mode;
if (_e202 > 2.5f) {
let _e204 = alpha_1;
frag_surface = vec4(_e204);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e168 = (*n)[0u];
let _e171 = (*n)[1u];
let _e175 = (*n)[2u];
let _e178 = (*n);
(*n) = (_e178 / vec3(((abs(_e168) + abs(_e171)) + abs(_e175))));
let _e181 = (*n);
e = _e181.xy;
let _e184 = (*n)[2u];
if (_e184 < 0f) {
let _e186 = (*n);
let _e192 = (*n)[0u];
let _e196 = (*n)[1u];
e = ((vec2(1f) - abs(_e186.yx)) * vec2<f32>(select(-1f, 1f, (_e192 >= 0f)), select(-1f, 1f, (_e196 >= 0f))));
}
let _e201 = e;
return ((_e201 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e166 = (*linear);
let _e168 = (*linear);
let _e172 = (*linear);
return mix((_e166 * 12.92f), ((pow(_e168, 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), _e172));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e169 = g_albedo;
param_1 = clamp(_e169, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e171 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e171.x, _e171.y, _e171.z, 1f);
let _e176 = g_debug_surface_on;
if _e176 {
let _e177 = g_debug_surface;
let _e178 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e177.x, _e177.y, _e177.z, _e178);
return;
}
let _e183 = v_normal_1;
geometric = normalize(_e183);
let _e185 = gl_FrontFacing_1;
if !(_e185) {
let _e187 = geometric;
geometric = -(_e187);
}
let _e189 = geometric;
param_2 = _e189;
let _e190 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e191 = (*roughness);
let _e193 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e190.x, _e190.y, clamp(_e191, 0f, 1f), _e193);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e165 = v_world_position_1;
let _e167 = fog_info.eye;
return distance(_e165, _e167.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e170 = fog_info.fog[3u];
density = _e170;
let _e171 = density;
if (_e171 <= 0f) {
let _e173 = (*color);
return _e173;
}
let _e174 = EyeDistance_u0028_();
d = _e174;
let _e176 = fog_info.fog;
let _e178 = (*color);
let _e179 = density;
let _e181 = d;
return mix(_e176.xyz, _e178, vec3(clamp(exp((-(_e179) * _e181)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e171 = g_premultiply;
let _e172 = (*alpha_2);
weight_1 = select(1f, _e172, _e171);
let _e174 = (*linearColor);
param_3 = _e174;
let _e175 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e176 = weight_1;
let _e177 = (_e175 * _e176);
let _e178 = (*alpha_2);
frag_color = vec4<f32>(_e177.x, _e177.y, _e177.z, _e178);
let _e183 = (*roughness_1);
param_4 = _e183;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
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_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e168 = (*s).albedo;
return _e168;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e166 = (*i);
if (_e166 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e168 = (*i);
if (_e168 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e170 = (*i);
if (_e170 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e172 = (*i);
if (_e172 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e174 = (*i);
if (_e174 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e176 = (*i);
if (_e176 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e178 = (*i);
if (_e178 == 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_5: i32;
let _e171 = (*i_1);
param_5 = _e171;
let _e172 = PointShadowDiskTap_u0028_i1_u003b((¶m_5));
p = _e172;
let _e174 = p[0u];
let _e175 = (*ca);
let _e178 = p[1u];
let _e179 = (*sa);
let _e183 = p[0u];
let _e184 = (*sa);
let _e187 = p[1u];
let _e188 = (*ca);
let _e192 = (*radius);
return (vec2<f32>(((_e174 * _e175) - (_e178 * _e179)), ((_e183 * _e184) + (_e187 * _e188))) * _e192);
}
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_1: vec2<f32>;
var atlas: vec2<f32>;
let _e174 = point_shadow.params[0u];
inset = _e174;
let _e175 = (*uv);
let _e176 = (*offset);
let _e178 = inset;
let _e179 = inset;
local_1 = clamp((_e175 + _e176), vec2(_e178), vec2((1f - _e179)));
let _e184 = local_1;
let _e185 = (*tile);
atlas = ((_e184 + _e185) * vec2<f32>(0.16666667f, 0.16666667f));
let _e190 = point_shadow.params3_[0u];
if (_e190 > 0.5f) {
let _e193 = atlas[1u];
atlas[1u] = (1f - _e193);
}
let _e196 = atlas;
let _e197 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e196, 0f);
let _e199 = atlas;
let _e200 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e199, 0f);
let _e203 = (*range);
return (min(_e197.x, _e200.x) * _e203);
}
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_6: vec2<f32>;
var param_7: vec2<f32>;
var param_8: vec2<f32>;
var param_9: f32;
let _e175 = (*uv_1);
param_6 = _e175;
let _e176 = (*offset_1);
param_7 = _e176;
let _e177 = (*tile_1);
param_8 = _e177;
let _e178 = (*range_1);
param_9 = _e178;
let _e179 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9));
stored = _e179;
let _e180 = stored;
let _e181 = (*range_1);
if (_e180 >= (_e181 * 0.999f)) {
return 1f;
}
let _e184 = (*receiver);
let _e185 = stored;
return select(1f, 0f, (_e184 > _e185));
}
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_10: vec2<f32>;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_14: i32;
var param_15: f32;
var param_16: f32;
var param_17: f32;
var param_18: vec2<f32>;
var param_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e196 = point_shadow.params2_[1u];
lightRadius = _e196;
let _e199 = point_shadow.params2_[0u];
minRadius = _e199;
let _e202 = point_shadow.params2_[2u];
maxRadius = _e202;
let _e203 = lightRadius;
if (_e203 <= 0f) {
let _e205 = (*uv_2);
param_10 = _e205;
param_11 = vec2<f32>(0f, 0f);
let _e206 = (*tile_2);
param_12 = _e206;
let _e207 = (*range_2);
param_13 = _e207;
let _e208 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13));
(*blockerOut) = _e208;
let _e209 = minRadius;
return _e209;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e210 = i_2;
if (_e210 < 8i) {
let _e212 = i_2;
param_14 = _e212;
let _e213 = (*ca_1);
param_15 = _e213;
let _e214 = (*sa_1);
param_16 = _e214;
let _e215 = maxRadius;
param_17 = _e215;
let _e216 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_14), (¶m_15), (¶m_16), (¶m_17));
let _e217 = (*uv_2);
param_18 = _e217;
param_19 = _e216;
let _e218 = (*tile_2);
param_20 = _e218;
let _e219 = (*range_2);
param_21 = _e219;
let _e220 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_18), (¶m_19), (¶m_20), (¶m_21));
stored_1 = _e220;
let _e221 = stored_1;
let _e222 = (*range_2);
if (_e221 >= (_e222 * 0.999f)) {
continue;
}
let _e225 = stored_1;
let _e226 = (*receiver_1);
if (_e225 >= _e226) {
continue;
}
let _e228 = stored_1;
let _e229 = sum;
sum = (_e229 + _e228);
let _e231 = count;
count = (_e231 + 1f);
continue;
} else {
break;
}
continuing {
let _e233 = i_2;
i_2 = (_e233 + 1i);
}
}
let _e235 = count;
if (_e235 < 0.5f) {
return -1f;
}
let _e237 = sum;
let _e238 = count;
blocker = max((_e237 / _e238), 0.0001f);
let _e241 = blocker;
(*blockerOut) = _e241;
let _e242 = lightRadius;
let _e243 = (*receiver_1);
let _e244 = blocker;
let _e248 = blocker;
world = ((_e242 * max((_e243 - _e244), 0f)) / _e248);
let _e250 = world;
let _e251 = (*receiver_1);
let _e253 = (*tanHalf);
let _e256 = minRadius;
let _e257 = maxRadius;
return clamp((_e250 / ((2f * _e251) * _e253)), _e256, _e257);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_2: vec2<f32>;
let _e167 = (*rows);
if (_e167 > 0f) {
let _e170 = gl_FragCoord_1[0u];
let _e171 = (*rows);
let _e173 = gl_FragCoord_1[1u];
local_2 = vec2<f32>(_e170, (_e171 - _e173));
} else {
let _e176 = gl_FragCoord_1;
local_2 = _e176.xy;
}
let _e178 = local_2;
return _e178;
}
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 param_22: 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_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var local_3: vec3<f32>;
var lit: f32;
var param_31: vec2<f32>;
var param_32: vec2<f32>;
var param_33: vec2<f32>;
var param_34: f32;
var param_35: f32;
var i_3: i32;
var param_36: i32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
var param_40: vec2<f32>;
var param_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: f32;
var param_44: f32;
var phi_2339_: bool;
var phi_2400_: bool;
let _e219 = (*lightIndex);
let _e223 = point_shadow.slots[_e219][0u];
slot = i32((_e223 + 0.5f));
let _e226 = (*lightIndex);
let _e230 = point_shadow.slots[_e226][0u];
if (_e230 < 0f) {
return 1f;
}
let _e234 = point_shadow.params[2u];
strength = _e234;
let _e235 = strength;
if (_e235 <= 0f) {
return 1f;
}
let _e237 = slot;
let _e240 = point_shadow.lights[_e237];
let _e242 = (*world_1);
toLight = (_e240.xyz - _e242);
let _e244 = toLight;
toLightLength = max(length(_e244), 0.000001f);
let _e247 = (*normal);
let _e248 = toLight;
let _e249 = toLightLength;
nDotL = max(dot(_e247, (_e248 / vec3(_e249))), 0.15f);
let _e254 = nDotL;
let _e255 = nDotL;
let _e260 = nDotL;
let _e261 = nDotL;
slope = min((sqrt(max((1f - (_e254 * _e255)), 0f)) / (_e260 * _e261)), 8f);
let _e265 = toLightLength;
let _e267 = (*lightIndex);
let _e271 = point_shadow.slots[_e267][2u];
let _e276 = point_shadow.params3_[1u];
texel = (((2f * _e265) * max(_e271, 0.0001f)) * _e276);
let _e278 = (*world_1);
let _e279 = (*normal);
let _e280 = texel;
let _e284 = point_shadow.params[3u];
let _e286 = slope;
origin = (_e278 + (((_e279 * _e280) * _e284) * (1f + _e286)));
let _e290 = origin;
let _e291 = slot;
let _e294 = point_shadow.lights[_e291];
toFragment = (_e290 - _e294.xyz);
let _e297 = toFragment;
distance_ = length(_e297);
let _e299 = slot;
let _e303 = point_shadow.lights[_e299][3u];
range_3 = max(_e303, 0.0001f);
let _e305 = distance_;
let _e306 = range_3;
if (_e305 >= _e306) {
return 1f;
}
face = 0i;
let _e308 = (*lightIndex);
let _e312 = point_shadow.slots[_e308][1u];
if (_e312 < 0.5f) {
let _e314 = toFragment;
a = abs(_e314);
let _e317 = a[0u];
let _e319 = a[1u];
let _e320 = (_e317 >= _e319);
phi_2339_ = _e320;
if _e320 {
let _e322 = a[0u];
let _e324 = a[2u];
phi_2339_ = (_e322 >= _e324);
}
let _e327 = phi_2339_;
if _e327 {
let _e329 = toFragment[0u];
face = select(1i, 0i, (_e329 > 0f));
} else {
let _e333 = a[1u];
let _e335 = a[2u];
if (_e333 >= _e335) {
let _e338 = toFragment[1u];
face = select(3i, 2i, (_e338 > 0f));
} else {
let _e342 = toFragment[2u];
face = select(5i, 4i, (_e342 > 0f));
}
}
}
let _e345 = slot;
let _e347 = face;
let _e351 = point_shadow.faces[((_e345 * 6i) + _e347)];
let _e352 = origin;
clip = (_e351 * vec4<f32>(_e352.x, _e352.y, _e352.z, 1f));
let _e359 = clip[3u];
if (_e359 <= 0f) {
return 1f;
}
let _e361 = clip;
let _e364 = clip[3u];
ndc = (_e361.xy / vec2(_e364));
let _e368 = ndc[0u];
let _e370 = (abs(_e368) > 1f);
phi_2400_ = _e370;
if !(_e370) {
let _e373 = ndc[1u];
phi_2400_ = (abs(_e373) > 1f);
}
let _e377 = phi_2400_;
if _e377 {
return 1f;
}
let _e379 = ndc[0u];
let _e383 = ndc[1u];
uv_3 = vec2<f32>(((_e379 * 0.5f) + 0.5f), (0.5f - (_e383 * 0.5f)));
let _e387 = face;
let _e389 = slot;
tile_3 = vec2<f32>(f32(_e387), f32(_e389));
let _e392 = distance_;
let _e395 = point_shadow.params[1u];
receiver_2 = (_e392 - _e395);
let _e399 = frag_info.target_origin[0u];
param_22 = _e399;
let _e400 = FragCoordFromTop_u0028_f1_u003b((¶m_22));
noise = fract((52.982918f * fract(dot(_e400, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e405 = noise;
angle = (_e405 * 6.2831855f);
let _e407 = angle;
ca_2 = cos(_e407);
let _e409 = angle;
sa_2 = sin(_e409);
let _e411 = (*lightIndex);
let _e415 = point_shadow.slots[_e411][2u];
tanHalf_1 = max(_e415, 0.0001f);
blocker_1 = -1f;
let _e417 = uv_3;
param_23 = _e417;
let _e418 = tile_3;
param_24 = _e418;
let _e419 = range_3;
param_25 = _e419;
let _e420 = receiver_2;
param_26 = _e420;
let _e421 = ca_2;
param_27 = _e421;
let _e422 = sa_2;
param_28 = _e422;
let _e423 = tanHalf_1;
param_29 = _e423;
let _e424 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27), (¶m_28), (¶m_29), (¶m_30));
let _e425 = param_30;
blocker_1 = _e425;
radius_1 = _e424;
let _e428 = point_shadow.params2_[3u];
if (_e428 > 0.5f) {
g_debug_surface_on = true;
let _e430 = radius_1;
if (_e430 < 0f) {
local_3 = vec3<f32>(0f, 0f, 1f);
} else {
let _e432 = radius_1;
let _e435 = point_shadow.params2_[2u];
let _e439 = blocker_1;
let _e440 = range_3;
local_3 = vec3<f32>(clamp((_e432 / max(_e435, 0.000001f)), 0f, 1f), clamp((_e439 / _e440), 0f, 1f), 0f);
}
let _e444 = local_3;
g_debug_surface = _e444;
}
let _e445 = radius_1;
if (_e445 < 0f) {
return 1f;
}
let _e447 = uv_3;
param_31 = _e447;
param_32 = vec2<f32>(0f, 0f);
let _e448 = tile_3;
param_33 = _e448;
let _e449 = range_3;
param_34 = _e449;
let _e450 = receiver_2;
param_35 = _e450;
let _e451 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_31), (¶m_32), (¶m_33), (¶m_34), (¶m_35));
lit = _e451;
let _e452 = radius_1;
if (_e452 > 0f) {
i_3 = 0i;
loop {
let _e454 = i_3;
if (_e454 < 8i) {
let _e456 = i_3;
param_36 = _e456;
let _e457 = ca_2;
param_37 = _e457;
let _e458 = sa_2;
param_38 = _e458;
let _e459 = radius_1;
param_39 = _e459;
let _e460 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e461 = uv_3;
param_40 = _e461;
param_41 = _e460;
let _e462 = tile_3;
param_42 = _e462;
let _e463 = range_3;
param_43 = _e463;
let _e464 = receiver_2;
param_44 = _e464;
let _e465 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
let _e466 = lit;
lit = (_e466 + _e465);
continue;
} else {
break;
}
continuing {
let _e468 = i_3;
i_3 = (_e468 + 1i);
}
}
let _e470 = lit;
lit = (_e470 * 0.11111111f);
}
let _e472 = lit;
let _e473 = strength;
return mix(1f, _e472, clamp(_e473, 0f, 1f));
}
fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
var r: f32;
var theta: f32;
let _e170 = (*i_4);
let _e173 = (*n_1);
r = sqrt(((f32(_e170) + 0.5f) / f32(_e173)));
let _e177 = (*i_4);
let _e180 = (*turn);
theta = ((f32(_e177) * 2.3999631f) + _e180);
let _e182 = r;
let _e183 = theta;
let _e185 = theta;
return (vec2<f32>(cos(_e183), sin(_e185)) * _e182);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_45: f32;
let _e169 = frag_info.target_origin[0u];
param_45 = _e169;
let _e170 = FragCoordFromTop_u0028_f1_u003b((¶m_45));
let _e173 = frag_info.target_origin[3u];
at = (_e170 + vec2((5.588238f * max(_e173, 0f))));
let _e178 = at;
return fract((52.982918f * fract(dot(_e178, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
var variance: f32;
var d_1: f32;
var pMax: f32;
var reduced: f32;
let _e174 = (*moments)[1u];
let _e176 = (*moments)[0u];
let _e178 = (*moments)[0u];
let _e181 = (*minVariance);
variance = max((_e174 - (_e176 * _e178)), _e181);
let _e183 = (*t);
let _e185 = (*moments)[0u];
d_1 = (_e183 - _e185);
let _e187 = variance;
let _e188 = variance;
let _e189 = d_1;
let _e190 = d_1;
pMax = (_e187 / (_e188 + (_e189 * _e190)));
let _e194 = pMax;
let _e195 = (*bleed);
let _e197 = (*bleed);
reduced = clamp(((_e194 - _e195) / max((1f - _e197), 0.0001f)), 0f, 1f);
let _e202 = (*t);
let _e204 = (*moments)[0u];
let _e206 = reduced;
return select(_e206, 1f, (_e202 <= _e204));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e167 = (*depth);
d_2 = ((2f * clamp(_e167, 0f, 1f)) - 1f);
let _e171 = d_2;
let _e174 = d_2;
return vec2<f32>(exp((40f * _e171)), -(exp((-5f * _e174))));
}
fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
var warped: vec2<f32>;
var param_46: f32;
var scale: vec2<f32>;
var positive: f32;
var param_47: vec2<f32>;
var param_48: f32;
var param_49: f32;
var param_50: f32;
var negative: f32;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var param_54: f32;
let _e181 = (*depth_1);
param_46 = _e181;
let _e182 = EvsmWarp_u0028_f1_u003b((¶m_46));
warped = _e182;
let _e183 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e183);
let _e186 = scale[0u];
let _e188 = scale[0u];
let _e190 = (*moments_1);
param_47 = _e190.xy;
let _e193 = warped[0u];
param_48 = _e193;
param_49 = (_e186 * _e188);
let _e194 = (*bleed_1);
param_50 = _e194;
let _e195 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_47), (¶m_48), (¶m_49), (¶m_50));
positive = _e195;
let _e197 = scale[1u];
let _e199 = scale[1u];
let _e201 = (*moments_1);
param_51 = _e201.zw;
let _e204 = warped[1u];
param_52 = _e204;
param_53 = (_e197 * _e199);
let _e205 = (*bleed_1);
param_54 = _e205;
let _e206 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_51), (¶m_52), (¶m_53), (¶m_54));
negative = _e206;
let _e207 = positive;
let _e208 = negative;
return min(_e207, _e208);
}
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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_4: mat4x4<f32>;
var local_5: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var local_6: f32;
var local_7: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var softness: f32;
var lit_1: f32;
var moments_2: vec4<f32>;
var param_55: vec4<f32>;
var param_56: f32;
var param_57: f32;
var y: i32;
var x: i32;
var occluder: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var occluder_1: f32;
var param_58: i32;
var param_59: i32;
var param_60: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var occluder_2: f32;
var param_61: i32;
var param_62: i32;
var param_63: f32;
var phi_2719_: bool;
var phi_2730_: bool;
var phi_2886_: bool;
var phi_2893_: bool;
var phi_2900_: bool;
let _e226 = frag_info.shadow_params[3u];
strength_1 = _e226;
let _e227 = strength_1;
if (_e227 <= 0f) {
return 1f;
}
let _e229 = (*lightIndex_1);
let _e232 = frag_info.frame_params[2u];
if (_e229 != i32((_e232 + 0.5f))) {
return 1f;
}
let _e238 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e238 + 0.5f));
let _e241 = v_world_position_1;
let _e243 = frag_info.camera_position;
viewDistance = length((_e241 - _e243.xyz));
cascade = 0i;
let _e247 = cascadeCount;
let _e248 = (_e247 > 1i);
phi_2719_ = _e248;
if _e248 {
let _e249 = viewDistance;
let _e252 = frag_info.shadow_cascades[0u];
phi_2719_ = (_e249 > _e252);
}
let _e255 = phi_2719_;
if _e255 {
cascade = 1i;
}
let _e256 = cascadeCount;
let _e257 = (_e256 > 2i);
phi_2730_ = _e257;
if _e257 {
let _e258 = viewDistance;
let _e261 = frag_info.shadow_cascades[1u];
phi_2730_ = (_e258 > _e261);
}
let _e264 = phi_2730_;
if _e264 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
attempt = 0i;
loop {
let _e265 = attempt;
if (_e265 < 3i) {
let _e267 = cascade;
let _e268 = attempt;
which = (_e267 + _e268);
let _e270 = which;
let _e271 = cascadeCount;
if (_e270 >= _e271) {
break;
}
let _e273 = which;
if (_e273 == 0i) {
let _e276 = frag_info.shadow_matrix;
local_4 = _e276;
} else {
let _e277 = which;
if (_e277 == 1i) {
let _e280 = frag_info.shadow_matrix_far;
local_5 = _e280;
} else {
let _e282 = frag_info.shadow_matrix_farthest;
local_5 = _e282;
}
let _e283 = local_5;
local_4 = _e283;
}
let _e284 = local_4;
matrix = _e284;
let _e287 = matrix[0][0u];
let _e290 = matrix[1][0u];
let _e293 = matrix[2][0u];
axisX = vec3<f32>(_e287, _e290, _e293);
let _e297 = matrix[0][1u];
let _e300 = matrix[1][1u];
let _e303 = matrix[2][1u];
axisY = vec3<f32>(_e297, _e300, _e303);
let _e305 = axisX;
rowX = max(length(_e305), 0.000001f);
let _e308 = axisY;
rowY = max(length(_e308), 0.000001f);
let _e313 = frag_info.shadow_cascades[3u];
let _e315 = rowX;
texelMetres = ((2f * _e313) / _e315);
let _e319 = frag_info.shadow_cascades[3u];
let _e322 = (*s_1).n;
let _e323 = axisX;
let _e326 = rowX;
let _e327 = rowX;
let _e331 = (*s_1).n;
let _e332 = axisY;
let _e335 = rowY;
let _e336 = rowY;
reach = ((3f * _e319) * ((abs(dot(_e322, _e323)) / (_e326 * _e327)) + (abs(dot(_e331, _e332)) / (_e335 * _e336))));
let _e341 = v_world_position_1;
let _e343 = (*s_1).n;
let _e346 = frag_info.shadow_params[2u];
let _e347 = reach;
origin_1 = (_e341 + (_e343 * (_e346 + _e347)));
let _e351 = matrix;
let _e352 = origin_1;
lightSpace = (_e351 * vec4<f32>(_e352.x, _e352.y, _e352.z, 1f));
let _e359 = lightSpace[3u];
if (_e359 <= 0f) {
continue;
}
let _e361 = lightSpace;
let _e364 = lightSpace[3u];
candidate = (_e361.xyz / vec3(_e364));
let _e368 = candidate[0u];
let _e372 = candidate[1u];
inTile = vec2<f32>(((_e368 * 0.5f) + 0.5f), (0.5f - (_e372 * 0.5f)));
let _e377 = inTile[0u];
let _e378 = (_e377 < 0f);
phi_2886_ = _e378;
if !(_e378) {
let _e381 = inTile[0u];
phi_2886_ = (_e381 > 1f);
}
let _e384 = phi_2886_;
phi_2893_ = _e384;
if !(_e384) {
let _e387 = inTile[1u];
phi_2893_ = (_e387 < 0f);
}
let _e390 = phi_2893_;
phi_2900_ = _e390;
if !(_e390) {
let _e393 = inTile[1u];
phi_2900_ = (_e393 > 1f);
}
let _e396 = phi_2900_;
if _e396 {
continue;
}
let _e398 = candidate[2u];
if (_e398 > 1f) {
let _e400 = which;
let _e401 = cascadeCount;
if (_e400 < (_e401 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e406 = inTile[0u];
let _e407 = which;
let _e410 = cascadeCount;
let _e414 = inTile[1u];
uv_4 = vec2<f32>(((_e406 + f32(_e407)) / f32(_e410)), _e414);
let _e416 = candidate;
projected = _e416;
let _e417 = which;
cascade = _e417;
let _e418 = texelMetres;
cascadeTexel = _e418;
let _e421 = matrix[0][2u];
let _e424 = matrix[1][2u];
let _e427 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e421, _e424, _e427)), 0.000001f));
found = true;
break;
} else {
break;
}
continuing {
let _e432 = attempt;
attempt = (_e432 + 1i);
}
}
let _e434 = found;
if !(_e434) {
return 1f;
}
let _e436 = cascade;
if (_e436 == 0i) {
let _e440 = frag_info.shadow_bias[0u];
local_6 = _e440;
} else {
let _e441 = cascade;
if (_e441 == 1i) {
let _e445 = frag_info.shadow_bias[1u];
local_7 = _e445;
} else {
let _e448 = frag_info.shadow_bias[2u];
local_7 = _e448;
}
let _e449 = local_7;
local_6 = _e449;
}
let _e450 = local_6;
bias = _e450;
let _e453 = frag_info.shadow_params[0u];
let _e456 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e453, _e456);
let _e458 = cascade;
let _e460 = cascadeCount;
let _e464 = texel_1;
tileLo = (vec2<f32>((f32(_e458) / f32(_e460)), 0f) + (_e464 * 0.5f));
let _e467 = cascade;
let _e470 = cascadeCount;
let _e474 = texel_1;
tileHi = (vec2<f32>((f32((_e467 + 1i)) / f32(_e470)), 1f) - (_e474 * 0.5f));
let _e479 = frag_info.ambient_ground[3u];
softness = _e479;
lit_1 = 0f;
let _e480 = softness;
if (_e480 < 0f) {
let _e482 = uv_4;
let _e483 = tileLo;
let _e484 = tileHi;
let _e486 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e482, _e483, _e484), 0f);
moments_2 = _e486;
let _e488 = projected[2u];
let _e489 = bias;
let _e491 = softness;
let _e495 = moments_2;
param_55 = _e495;
param_56 = (_e488 - _e489);
param_57 = clamp((-(_e491) - 1f), 0f, 0.95f);
let _e496 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_55), (¶m_56), (¶m_57));
lit_1 = _e496;
} else {
let _e497 = softness;
if (_e497 <= 0f) {
y = -1i;
loop {
let _e499 = y;
if (_e499 <= 1i) {
x = -1i;
loop {
let _e501 = x;
if (_e501 <= 1i) {
let _e503 = uv_4;
let _e504 = x;
let _e506 = y;
let _e509 = texel_1;
let _e512 = tileLo;
let _e513 = tileHi;
let _e515 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e503 + (vec2<f32>(f32(_e504), f32(_e506)) * _e509)), _e512, _e513), 0f);
occluder = _e515.x;
let _e518 = projected[2u];
let _e519 = bias;
let _e521 = occluder;
let _e524 = lit_1;
lit_1 = (_e524 + select(1f, 0f, ((_e518 - _e519) > _e521)));
continue;
} else {
break;
}
continuing {
let _e526 = x;
x = (_e526 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e528 = y;
y = (_e528 + 1i);
}
}
let _e530 = lit_1;
lit_1 = (_e530 * 0.11111111f);
} else {
let _e532 = softness;
spread = tan(min(_e532, 0.5f));
let _e535 = ShadowNoise_u0028_();
turn_1 = (_e535 * 6.2831855f);
let _e537 = spread;
let _e539 = projected[2u];
let _e541 = cascadeDepth;
let _e543 = cascadeTexel;
searchRadius = clamp((((_e537 * _e539) * _e541) / _e543), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e546 = i_5;
if (_e546 < 16i) {
let _e548 = uv_4;
let _e549 = i_5;
param_58 = _e549;
param_59 = 16i;
let _e550 = turn_1;
param_60 = _e550;
let _e551 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60));
let _e552 = texel_1;
let _e554 = searchRadius;
let _e557 = tileLo;
let _e558 = tileHi;
let _e560 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e548 + ((_e551 * _e552) * _e554)), _e557, _e558), 0f);
occluder_1 = _e560.x;
let _e563 = projected[2u];
let _e564 = bias;
let _e566 = occluder_1;
if ((_e563 - _e564) > _e566) {
let _e568 = occluder_1;
let _e569 = blockerSum;
blockerSum = (_e569 + _e568);
let _e571 = blockerCount;
blockerCount = (_e571 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e573 = i_5;
i_5 = (_e573 + 1i);
}
}
let _e575 = blockerCount;
if (_e575 <= 0f) {
return 1f;
}
let _e578 = projected[2u];
let _e579 = blockerSum;
let _e580 = blockerCount;
let _e584 = cascadeDepth;
gap = (max((_e578 - (_e579 / _e580)), 0f) * _e584);
let _e586 = spread;
let _e587 = gap;
let _e589 = cascadeTexel;
radius_2 = clamp(((_e586 * _e587) / _e589), 1f, 16f);
i_6 = 0i;
loop {
let _e592 = i_6;
if (_e592 < 16i) {
let _e594 = uv_4;
let _e595 = turn_1;
let _e597 = i_6;
param_61 = _e597;
param_62 = 16i;
param_63 = (_e595 + 1f);
let _e598 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_61), (¶m_62), (¶m_63));
let _e599 = texel_1;
let _e601 = radius_2;
let _e604 = tileLo;
let _e605 = tileHi;
let _e607 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e594 + ((_e598 * _e599) * _e601)), _e604, _e605), 0f);
occluder_2 = _e607.x;
let _e610 = projected[2u];
let _e611 = bias;
let _e613 = occluder_2;
let _e616 = lit_1;
lit_1 = (_e616 + select(1f, 0f, ((_e610 - _e611) > _e613)));
continue;
} else {
break;
}
continuing {
let _e618 = i_6;
i_6 = (_e618 + 1i);
}
}
let _e620 = lit_1;
lit_1 = (_e620 * 0.0625f);
}
}
let _e622 = lit_1;
let _e623 = strength_1;
return mix(1f, _e622, clamp(_e623, 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_64: Surface;
var param_65: LightSample;
var param_66: i32;
let _e171 = (*s_2);
param_64 = _e171;
let _e172 = (*light_2);
param_65 = _e172;
let _e173 = (*index);
param_66 = _e173;
let _e174 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_64), (¶m_65), (¶m_66));
return _e174;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e166 = (*index_1);
return (_e166 < 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 _e170 = (*distance_1);
let _e171 = (*distance_1);
attenuation = (1f / max((_e170 * _e171), 0.0001f));
let _e175 = (*range_4);
if (_e175 > 0f) {
let _e177 = (*distance_1);
let _e178 = (*range_4);
ratio = (_e177 / _e178);
let _e180 = ratio;
let _e181 = ratio;
let _e183 = ratio;
let _e185 = ratio;
window = clamp((1f - (((_e180 * _e181) * _e183) * _e185)), 0f, 1f);
let _e189 = window;
let _e190 = window;
let _e192 = attenuation;
attenuation = (_e192 * (_e189 * _e190));
}
let _e194 = attenuation;
return _e194;
}
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_2: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t_1: f32;
var local_8: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e182 = (*halfWidth);
let _e183 = (*halfHeight);
n_2 = cross(_e182, _e183);
let _e185 = n_2;
nLen = length(_e185);
let _e187 = nLen;
if (_e187 < 0.000000000001f) {
let _e189 = (*centre);
return _e189;
}
let _e190 = nLen;
let _e191 = n_2;
n_2 = (_e191 / vec3(_e190));
let _e194 = (*centre);
let _e195 = (*world_2);
toPlane = (_e194 - _e195);
let _e197 = (*mirror);
let _e198 = n_2;
denom = dot(_e197, _e198);
let _e200 = denom;
if (abs(_e200) < 0.00001f) {
let _e203 = toPlane;
let _e204 = n_2;
let _e205 = toPlane;
let _e206 = n_2;
onPlane = (_e203 - (_e204 * dot(_e205, _e206)));
} else {
let _e210 = toPlane;
let _e211 = n_2;
let _e213 = denom;
t_1 = (dot(_e210, _e211) / _e213);
let _e215 = t_1;
if (_e215 > 0f) {
let _e217 = (*mirror);
let _e218 = t_1;
local_8 = (_e217 * _e218);
} else {
let _e220 = toPlane;
let _e221 = n_2;
let _e222 = toPlane;
let _e223 = n_2;
local_8 = (_e220 - (_e221 * dot(_e222, _e223)));
}
let _e227 = local_8;
onPlane = _e227;
}
let _e228 = onPlane;
let _e229 = toPlane;
offset_2 = (_e228 - _e229);
let _e231 = (*halfWidth);
let _e232 = (*halfWidth);
wLen2_ = max(dot(_e231, _e232), 0.000000000001f);
let _e235 = (*halfHeight);
let _e236 = (*halfHeight);
hLen2_ = max(dot(_e235, _e236), 0.000000000001f);
let _e239 = offset_2;
let _e240 = (*halfWidth);
let _e242 = wLen2_;
u = clamp((dot(_e239, _e240) / _e242), -1f, 1f);
let _e245 = offset_2;
let _e246 = (*halfHeight);
let _e248 = hLen2_;
v = clamp((dot(_e245, _e246) / _e248), -1f, 1f);
let _e251 = (*centre);
let _e252 = (*halfWidth);
let _e253 = u;
let _e256 = (*halfHeight);
let _e257 = v;
return ((_e251 + (_e252 * _e253)) + (_e256 * _e257));
}
fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
var ua: vec3<f32>;
var ub: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
var local_9: f32;
let _e174 = (*a_1);
let _e175 = (*a_1);
ua = (_e174 / vec3(max(length(_e175), 0.000000000001f)));
let _e180 = (*b);
let _e181 = (*b);
ub = (_e180 / vec3(max(length(_e181), 0.000000000001f)));
let _e186 = ua;
let _e187 = ub;
angle_1 = acos(clamp(dot(_e186, _e187), -1f, 1f));
let _e191 = ua;
let _e192 = ub;
axis = cross(_e191, _e192);
let _e194 = axis;
len = length(_e194);
let _e196 = len;
if (_e196 > 0.000001f) {
let _e198 = angle_1;
let _e199 = axis;
let _e200 = (*n_3);
let _e203 = len;
local_9 = ((_e198 * dot(_e199, _e200)) / _e203);
} else {
local_9 = 0f;
}
let _e205 = local_9;
return _e205;
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var exit: vec3<f32>;
var entry: vec3<f32>;
var i_7: i32;
var a_2: vec3<f32>;
var b_1: vec3<f32>;
var local_10: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_11: f32;
var aAbove: bool;
var bAbove: bool;
var local_12: f32;
var param_67: vec3<f32>;
var param_68: vec3<f32>;
var param_69: vec3<f32>;
var param_70: vec3<f32>;
var param_71: vec3<f32>;
var param_72: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e188 = i_7;
if (_e188 < 4i) {
let _e190 = i_7;
let _e192 = (*corners)[_e190];
a_2 = _e192;
let _e193 = i_7;
if (_e193 == 3i) {
local_10 = 0i;
} else {
let _e195 = i_7;
local_10 = (_e195 + 1i);
}
let _e197 = local_10;
let _e199 = (*corners)[_e197];
b_1 = _e199;
let _e200 = a_2;
let _e201 = (*n_4);
ha = dot(_e200, _e201);
let _e203 = b_1;
let _e204 = (*n_4);
hb = dot(_e203, _e204);
let _e206 = ha;
let _e207 = hb;
d_3 = (_e206 - _e207);
let _e209 = a_2;
let _e210 = b_1;
let _e211 = a_2;
let _e213 = d_3;
if (abs(_e213) > 0.000000000001f) {
let _e216 = ha;
let _e217 = d_3;
local_11 = (_e216 / _e217);
} else {
local_11 = 0f;
}
let _e219 = local_11;
q = (_e209 + ((_e210 - _e211) * _e219));
let _e222 = ha;
aAbove = (_e222 > 0f);
let _e224 = hb;
bAbove = (_e224 > 0f);
let _e226 = aAbove;
let _e227 = bAbove;
if (_e226 || _e227) {
let _e229 = aAbove;
let _e230 = a_2;
let _e231 = q;
let _e234 = bAbove;
let _e235 = b_1;
let _e236 = q;
param_67 = select(_e231, _e230, vec3(_e229));
param_68 = select(_e236, _e235, vec3(_e234));
let _e239 = (*n_4);
param_69 = _e239;
let _e240 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_67), (¶m_68), (¶m_69));
local_12 = _e240;
} else {
local_12 = 0f;
}
let _e241 = local_12;
let _e242 = total;
total = (_e242 + _e241);
let _e244 = aAbove;
let _e245 = bAbove;
let _e248 = q;
let _e249 = exit;
exit = select(_e249, _e248, vec3((_e244 && !(_e245))));
let _e252 = aAbove;
let _e254 = bAbove;
let _e256 = q;
let _e257 = entry;
entry = select(_e257, _e256, vec3((!(_e252) && _e254)));
continue;
} else {
break;
}
continuing {
let _e260 = i_7;
i_7 = (_e260 + 1i);
}
}
let _e262 = exit;
param_70 = _e262;
let _e263 = entry;
param_71 = _e263;
let _e264 = (*n_4);
param_72 = _e264;
let _e265 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_70), (¶m_71), (¶m_72));
let _e266 = total;
total = (_e266 + _e265);
let _e268 = total;
return max((-(_e268) * 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_13: f32;
var local_14: f32;
var local_15: f32;
let _e171 = (*slot_1);
let _e172 = (*slot_1);
lane = (_e171 - ((_e172 / 4i) * 4i));
let _e176 = lane;
if (_e176 == 0i) {
let _e179 = (*four)[0u];
local_13 = _e179;
} else {
let _e180 = lane;
if (_e180 == 1i) {
let _e183 = (*four)[1u];
local_14 = _e183;
} else {
let _e184 = lane;
if (_e184 == 2i) {
let _e187 = (*four)[2u];
local_15 = _e187;
} else {
let _e189 = (*four)[3u];
local_15 = _e189;
}
let _e190 = local_15;
local_14 = _e190;
}
let _e191 = local_14;
local_13 = _e191;
}
let _e192 = local_13;
return _e192;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_73: vec4<f32>;
var param_74: i32;
let _e168 = (*slot_2);
let _e172 = light_list_info.scales[(_e168 / 4i)];
param_73 = _e172;
let _e173 = (*slot_2);
param_74 = _e173;
let _e174 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_73), (¶m_74));
return _e174;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e170 = light_list_info.slot_rows[0i];
let _e171 = (*row);
a_3 = abs((_e170 - vec4(_e171)));
let _e177 = light_list_info.slot_rows[1i];
let _e178 = (*row);
b_2 = abs((_e177 - vec4(_e178)));
let _e183 = a_3[0u];
let _e185 = a_3[1u];
let _e188 = a_3[2u];
let _e190 = a_3[3u];
let _e194 = b_2[0u];
let _e196 = b_2[1u];
let _e199 = b_2[2u];
let _e201 = b_2[3u];
return (min(min(min(_e183, _e185), min(_e188, _e190)), min(min(_e194, _e196), min(_e199, _e201))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_75: vec4<f32>;
var param_76: i32;
let _e168 = (*slot_3);
let _e172 = light_list_info.indices[(_e168 / 4i)];
param_75 = _e172;
let _e173 = (*slot_3);
param_76 = _e173;
let _e174 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_75), (¶m_76));
return _e174;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e167 = (*texel_2);
let _e171 = light_list_info.list[1u];
let _e173 = (*row_1);
let _e177 = light_list_info.list[2u];
let _e180 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e167 + 0.5f) * _e171), ((_e173 + 0.5f) * _e177)), 0f);
return _e180;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_77: f32;
var param_78: f32;
var param_79: vec4<f32>;
var param_80: i32;
let _e175 = g_cluster_offset;
let _e176 = (*slot_4);
entry_1 = (_e175 + f32(_e176));
let _e179 = entry_1;
row_2 = floor((_e179 / 16f));
let _e182 = entry_1;
let _e183 = row_2;
within = (_e182 - (_e183 * 16f));
let _e186 = within;
texel_3 = floor((_e186 / 4f));
let _e191 = light_list_info.cluster_depth[3u];
let _e192 = row_2;
let _e194 = texel_3;
param_77 = _e194;
param_78 = (_e191 + _e192);
let _e195 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_77), (¶m_78));
four_1 = _e195;
let _e196 = within;
let _e197 = texel_3;
let _e202 = four_1;
param_79 = _e202;
param_80 = i32(((_e196 - (_e197 * 4f)) + 0.5f));
let _e203 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_79), (¶m_80));
return _e203;
}
fn Clustered_u0028_() -> bool {
let _e167 = light_list_info.cluster_grid[3u];
return (_e167 > 0.5f);
}
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 light_3: LightSample;
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_5: i32;
var clustered: bool;
var listRow: f32;
var local_16: f32;
var param_81: i32;
var param_82: i32;
var v_1: f32;
var u_1: f32;
var local_17: f32;
var param_83: f32;
var param_84: 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 behind: bool;
var formFactor: f32;
var local_18: f32;
var param_85: array<vec3<f32>, 4>;
var param_86: vec3<f32>;
var area: f32;
var radiance: f32;
var local_19: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
var param_89: vec3<f32>;
var param_90: vec3<f32>;
var param_91: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_20: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_92: f32;
var param_93: f32;
var cosAngle: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e218 = (*index_2);
if (_e218 < 8i) {
let _e220 = (*index_2);
let _e223 = frag_info.light_position[_e220];
position = _e223;
let _e224 = (*index_2);
let _e227 = frag_info.light_color[_e224];
color_1 = _e227;
let _e228 = (*index_2);
let _e231 = frag_info.light_direction[_e228];
direction = _e231;
let _e232 = (*index_2);
let _e235 = frag_info.light_cone[_e232];
cone = _e235;
} else {
let _e236 = (*index_2);
slot_5 = (_e236 - 8i);
let _e238 = Clustered_u0028_();
clustered = _e238;
let _e239 = clustered;
if _e239 {
let _e240 = slot_5;
param_81 = _e240;
let _e241 = ClusterRow_u0028_i1_u003b((¶m_81));
local_16 = _e241;
} else {
let _e242 = slot_5;
param_82 = _e242;
let _e243 = LightListRow_u0028_i1_u003b((¶m_82));
local_16 = _e243;
}
let _e244 = local_16;
listRow = _e244;
let _e245 = listRow;
let _e249 = light_list_info.list[2u];
v_1 = ((_e245 + 0.5f) * _e249);
let _e253 = light_list_info.list[1u];
u_1 = _e253;
let _e254 = u_1;
let _e256 = v_1;
let _e258 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e254), _e256), 0f);
position = _e258;
let _e259 = u_1;
let _e261 = v_1;
let _e263 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e259), _e261), 0f);
color_1 = _e263;
let _e264 = u_1;
let _e266 = v_1;
let _e268 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e264), _e266), 0f);
direction = _e268;
let _e269 = u_1;
let _e271 = v_1;
let _e273 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e269), _e271), 0f);
cone = _e273;
let _e274 = clustered;
if _e274 {
let _e275 = listRow;
param_83 = _e275;
let _e276 = InSlots_u0028_f1_u003b((¶m_83));
local_17 = select(1f, 0f, _e276);
} else {
let _e278 = slot_5;
param_84 = _e278;
let _e279 = LightListScale_u0028_i1_u003b((¶m_84));
local_17 = _e279;
}
let _e280 = local_17;
let _e282 = color_1[3u];
color_1[3u] = (_e282 * _e280);
}
let _e286 = position[3u];
type_39 = _e286;
let _e287 = type_39;
if (_e287 > 2.5f) {
let _e289 = direction;
halfWidth_1 = _e289.xyz;
let _e291 = cone;
halfHeight_1 = _e291.xyz;
let _e293 = position;
let _e295 = v_world_position_1;
toCentre = (_e293.xyz - _e295);
let _e297 = toCentre;
let _e298 = halfWidth_1;
let _e300 = halfHeight_1;
corners_1[0i] = ((_e297 - _e298) - _e300);
let _e303 = toCentre;
let _e304 = halfWidth_1;
let _e306 = halfHeight_1;
corners_1[1i] = ((_e303 + _e304) - _e306);
let _e309 = toCentre;
let _e310 = halfWidth_1;
let _e312 = halfHeight_1;
corners_1[2i] = ((_e309 + _e310) + _e312);
let _e315 = toCentre;
let _e316 = halfWidth_1;
let _e318 = halfHeight_1;
corners_1[3i] = ((_e315 - _e316) + _e318);
let _e321 = toCentre;
let _e322 = halfWidth_1;
let _e323 = halfHeight_1;
behind = (dot(_e321, cross(_e322, _e323)) >= 0f);
let _e327 = behind;
if _e327 {
local_18 = 0f;
} else {
let _e328 = corners_1;
param_85 = _e328;
let _e330 = (*s_3).n;
param_86 = _e330;
let _e331 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_85), (¶m_86));
local_18 = _e331;
}
let _e332 = local_18;
formFactor = _e332;
let _e333 = halfWidth_1;
let _e334 = halfHeight_1;
area = (length(cross(_e333, _e334)) * 4f);
let _e338 = area;
if (_e338 > 0.000000001f) {
let _e340 = area;
local_19 = (1f / _e340);
} else {
local_19 = 0f;
}
let _e342 = local_19;
radiance = _e342;
let _e343 = toCentre;
distance_2 = length(_e343);
let _e346 = direction[3u];
if (_e346 > 0f) {
let _e348 = distance_2;
let _e350 = direction[3u];
ratio_1 = (_e348 / _e350);
let _e352 = ratio_1;
let _e353 = ratio_1;
let _e355 = ratio_1;
let _e357 = ratio_1;
window_1 = clamp((1f - (((_e352 * _e353) * _e355) * _e357)), 0f, 1f);
let _e361 = window_1;
let _e362 = window_1;
let _e364 = radiance;
radiance = (_e364 * (_e361 * _e362));
}
let _e367 = (*s_3).v;
let _e370 = (*s_3).n;
mirror_1 = reflect(-(_e367), _e370);
let _e372 = position;
param_87 = _e372.xyz;
let _e374 = halfWidth_1;
param_88 = _e374;
let _e375 = halfHeight_1;
param_89 = _e375;
let _e376 = v_world_position_1;
param_90 = _e376;
let _e377 = mirror_1;
param_91 = _e377;
let _e378 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_87), (¶m_88), (¶m_89), (¶m_90), (¶m_91));
representative = _e378;
let _e379 = representative;
let _e380 = v_world_position_1;
toPoint = (_e379 - _e380);
let _e382 = toPoint;
pointDistance = length(_e382);
let _e384 = pointDistance;
if (_e384 > 0.000001f) {
let _e386 = toPoint;
let _e387 = pointDistance;
local_20 = (_e386 / vec3(_e387));
} else {
let _e391 = (*s_3).n;
local_20 = _e391;
}
let _e392 = local_20;
light_3.l = _e392;
let _e395 = light_3.l;
let _e397 = (*s_3).v;
light_3.h = normalize((_e395 + _e397));
let _e401 = formFactor;
light_3.n_dot_l = _e401;
let _e404 = (*s_3).n;
let _e406 = light_3.h;
light_3.n_dot_h = max(dot(_e404, _e406), 0f);
let _e411 = (*s_3).v;
let _e413 = light_3.h;
light_3.v_dot_h = max(dot(_e411, _e413), 0f);
let _e417 = color_1;
let _e420 = color_1[3u];
let _e422 = radiance;
light_3.radiance = ((_e417.xyz * _e420) * _e422);
let _e425 = light_3;
return _e425;
}
let _e426 = direction;
aim = normalize(_e426.xyz);
attenuation_1 = 1f;
let _e429 = type_39;
if (_e429 < 0.5f) {
let _e431 = aim;
light_3.l = -(_e431);
} else {
let _e434 = position;
let _e436 = v_world_position_1;
toLight_1 = (_e434.xyz - _e436);
let _e438 = toLight_1;
distance_3 = length(_e438);
let _e440 = distance_3;
if (_e440 < 0.000001f) {
let _e443 = (*s_3).n;
light_3.l = _e443;
let _e446 = (*s_3).n;
light_3.h = _e446;
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 _e452 = light_3;
return _e452;
}
let _e453 = toLight_1;
let _e454 = distance_3;
light_3.l = (_e453 / vec3(_e454));
let _e458 = distance_3;
param_92 = _e458;
let _e460 = direction[3u];
param_93 = _e460;
let _e461 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_92), (¶m_93));
attenuation_1 = _e461;
let _e462 = type_39;
if (_e462 > 1.5f) {
let _e464 = aim;
let _e466 = light_3.l;
cosAngle = dot(_e464, -(_e466));
let _e469 = cosAngle;
let _e471 = cone[1u];
let _e474 = cone[0u];
let _e476 = cone[1u];
let _e480 = attenuation_1;
attenuation_1 = (_e480 * clamp(((_e469 - _e471) / (_e474 - _e476)), 0f, 1f));
}
}
let _e483 = light_3.l;
let _e485 = (*s_3).v;
light_3.h = normalize((_e483 + _e485));
let _e490 = (*s_3).n;
let _e492 = light_3.l;
light_3.n_dot_l = max(dot(_e490, _e492), 0f);
let _e497 = (*s_3).n;
let _e499 = light_3.h;
light_3.n_dot_h = max(dot(_e497, _e499), 0f);
let _e504 = (*s_3).v;
let _e506 = light_3.h;
light_3.v_dot_h = max(dot(_e504, _e506), 0f);
let _e510 = color_1;
let _e513 = color_1[3u];
let _e515 = attenuation_1;
light_3.radiance = ((_e510.xyz * _e513) * _e515);
let _e518 = light_3;
return _e518;
}
fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
var clip_1: vec4<f32>;
var ndc_1: vec2<f32>;
var grid: vec3<f32>;
var near_1: f32;
var tx: f32;
var ty: f32;
var tz: f32;
var local_21: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_94: f32;
var param_95: f32;
let _e180 = light_list_info.cluster_view_projection;
let _e181 = (*world_3);
clip_1 = (_e180 * vec4<f32>(_e181.x, _e181.y, _e181.z, 1f));
let _e187 = clip_1;
let _e190 = clip_1[3u];
ndc_1 = (_e187.xy / vec2(max(_e190, 0.000001f)));
let _e195 = light_list_info.cluster_grid;
grid = _e195.xyz;
let _e199 = light_list_info.cluster_depth[0u];
near_1 = _e199;
let _e201 = ndc_1[0u];
let _e205 = grid[0u];
let _e209 = grid[0u];
tx = clamp(floor((((_e201 * 0.5f) + 0.5f) * _e205)), 0f, (_e209 - 1f));
let _e213 = ndc_1[1u];
let _e217 = grid[1u];
let _e221 = grid[1u];
ty = clamp(floor((((_e213 * 0.5f) + 0.5f) * _e217)), 0f, (_e221 - 1f));
let _e225 = clip_1[3u];
let _e226 = near_1;
if (_e225 <= _e226) {
local_21 = 0f;
} else {
let _e229 = clip_1[3u];
let _e230 = near_1;
let _e235 = light_list_info.cluster_depth[1u];
let _e239 = grid[2u];
local_21 = clamp(floor((log((_e229 / _e230)) * _e235)), 0f, (_e239 - 1f));
}
let _e242 = local_21;
tz = _e242;
let _e243 = tx;
let _e244 = ty;
let _e246 = grid[0u];
let _e249 = tz;
let _e251 = grid[0u];
let _e254 = grid[1u];
cell = ((_e243 + (_e244 * _e246)) + ((_e249 * _e251) * _e254));
let _e257 = cell;
row_3 = floor((_e257 / 4f));
let _e260 = cell;
let _e261 = row_3;
let _e266 = light_list_info.cluster_depth[2u];
let _e267 = row_3;
param_94 = (_e260 - (_e261 * 4f));
param_95 = (_e266 + _e267);
let _e269 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
header = _e269;
let _e271 = header[0u];
g_cluster_offset = _e271;
let _e273 = header[1u];
g_cluster_count = _e273;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_96: vec3<f32>;
let _e169 = light_list_info.list[0u];
tail = _e169;
let _e170 = Clustered_u0028_();
if _e170 {
let _e171 = v_world_position_1;
param_96 = _e171;
FindCluster_u0028_vf3_u003b((¶m_96));
let _e172 = g_cluster_count;
tail = _e172;
}
let _e175 = frag_info.frame_params[1u];
let _e179 = tail;
return (clamp(i32((_e175 + 0.5f)), 0i, 8i) + clamp(i32((_e179 + 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_8: i32;
var light_4: LightSample;
var param_97: i32;
var param_98: Surface;
var visibility: f32;
var param_99: i32;
var local_22: f32;
var param_100: Surface;
var param_101: LightSample;
var param_102: i32;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: i32;
var param_106: Surface;
var param_107: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e183 = LightCount_u0028_();
count_1 = _e183;
i_8 = 0i;
loop {
let _e184 = i_8;
if (_e184 < 32i) {
let _e186 = i_8;
let _e187 = count_1;
if (_e186 >= _e187) {
break;
}
let _e189 = i_8;
param_97 = _e189;
let _e190 = (*s_4);
param_98 = _e190;
let _e191 = 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_97), (¶m_98));
light_4 = _e191;
let _e193 = light_4.n_dot_l;
if (_e193 <= 0f) {
continue;
}
let _e195 = i_8;
param_99 = _e195;
let _e196 = LightHasShadow_u0028_i1_u003b((¶m_99));
if _e196 {
let _e197 = (*s_4);
param_100 = _e197;
let _e198 = light_4;
param_101 = _e198;
let _e199 = i_8;
param_102 = _e199;
let _e200 = 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_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((¶m_100), (¶m_101), (¶m_102));
let _e201 = v_world_position_1;
param_103 = _e201;
let _e203 = (*s_4).n;
param_104 = _e203;
let _e204 = i_8;
param_105 = _e204;
let _e205 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_103), (¶m_104), (¶m_105));
local_22 = (_e200 * _e205);
} else {
local_22 = 1f;
}
let _e207 = local_22;
visibility = _e207;
let _e208 = visibility;
if (_e208 <= 0f) {
continue;
}
let _e210 = (*s_4);
param_106 = _e210;
let _e211 = light_4;
param_107 = _e211;
let _e212 = 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_f1_u002d_f1_u002d_vf31_u003b((¶m_106), (¶m_107));
let _e214 = light_4.radiance;
let _e217 = light_4.n_dot_l;
let _e219 = visibility;
let _e221 = total_1;
total_1 = (_e221 + (((_e212 * _e214) * _e217) * _e219));
continue;
} else {
break;
}
continuing {
let _e223 = i_8;
i_8 = (_e223 + 1i);
}
}
let _e225 = total_1;
return _e225;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e166 = (*srgb);
let _e169 = (*srgb);
let _e174 = (*srgb);
return mix((_e166 / vec3(12.92f)), pow(((_e169 + 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), _e174));
}
fn ImpostorRight_u0028_vf3_u003b(d_4: ptr<function, vec3<f32>>) -> vec3<f32> {
var up: vec3<f32>;
let _e168 = (*d_4)[1u];
up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e168) > 0.999f)));
let _e173 = up;
let _e174 = (*d_4);
return normalize(cross(_e173, _e174));
}
fn ImpostorDecode_u0028_vf2_u003b(uv_5: ptr<function, vec2<f32>>) -> vec3<f32> {
var p_1: vec2<f32>;
var y_1: f32;
var s_5: vec2<f32>;
var folded: vec2<f32>;
var xz: vec2<f32>;
let _e171 = (*uv_5);
p_1 = ((_e171 * 2f) - vec2<f32>(1f, 1f));
let _e175 = p_1[0u];
let _e179 = p_1[1u];
y_1 = ((1f - abs(_e175)) - abs(_e179));
let _e183 = p_1[0u];
let _e187 = p_1[1u];
s_5 = vec2<f32>(select(-1f, 1f, (_e183 >= 0f)), select(-1f, 1f, (_e187 >= 0f)));
let _e191 = p_1;
let _e195 = s_5;
folded = ((vec2<f32>(1f, 1f) - abs(_e191.yx)) * _e195);
let _e197 = y_1;
let _e199 = p_1;
let _e200 = folded;
xz = select(_e200, _e199, vec2((_e197 >= 0f)));
let _e204 = xz[0u];
let _e205 = y_1;
let _e207 = xz[1u];
return normalize(vec3<f32>(_e204, _e205, _e207));
}
fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_1: ptr<function, vec2<f32>>, offset_3: ptr<function, vec3<f32>>) -> vec2<f32> {
var d_5: vec3<f32>;
var param_108: vec2<f32>;
var right: vec3<f32>;
var param_109: vec3<f32>;
var up_1: vec3<f32>;
var local_23: vec2<f32>;
let _e173 = (*cell_1);
param_108 = (_e173 / vec2(7f));
let _e176 = ImpostorDecode_u0028_vf2_u003b((¶m_108));
d_5 = _e176;
let _e177 = d_5;
param_109 = _e177;
let _e178 = ImpostorRight_u0028_vf3_u003b((¶m_109));
right = _e178;
let _e179 = d_5;
let _e180 = right;
up_1 = cross(_e179, _e180);
let _e182 = (*offset_3);
let _e183 = right;
let _e187 = (*offset_3);
let _e188 = up_1;
local_23 = vec2<f32>(((dot(_e182, _e183) * 0.5f) + 0.5f), (0.5f - (dot(_e187, _e188) * 0.5f)));
let _e193 = (*cell_1);
let _e194 = local_23;
return ((_e193 + clamp(_e194, vec2<f32>(0f, 0f), vec2<f32>(1f, 1f))) / vec2(8f));
}
fn ImpostorEncode_u0028_vf3_u003b(d_6: ptr<function, vec3<f32>>) -> vec2<f32> {
var a_4: vec3<f32>;
var p_2: vec2<f32>;
var s_6: vec2<f32>;
var folded_1: vec2<f32>;
let _e170 = (*d_6);
a_4 = abs(_e170);
let _e172 = (*d_6);
let _e175 = a_4[0u];
let _e177 = a_4[1u];
let _e180 = a_4[2u];
p_2 = (_e172.xz / vec2(max(((_e175 + _e177) + _e180), 0.00000001f)));
let _e186 = p_2[0u];
let _e190 = p_2[1u];
s_6 = vec2<f32>(select(-1f, 1f, (_e186 >= 0f)), select(-1f, 1f, (_e190 >= 0f)));
let _e194 = p_2;
let _e198 = s_6;
folded_1 = ((vec2<f32>(1f, 1f) - abs(_e194.yx)) * _e198);
let _e201 = (*d_6)[1u];
let _e203 = p_2;
let _e204 = folded_1;
return ((select(_e204, _e203, vec2((_e201 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e167 = frag_info.target_origin[1u];
return _e167;
}
fn ReadSurface_u0028_() -> Surface {
var texel_4: vec4<f32>;
var s_7: Surface;
var param_110: vec3<f32>;
var param_111: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e172 = v_texcoord_1;
let _e173 = MaterialLodBias_u0028_();
let _e174 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e172, _e173);
texel_4 = _e174;
let _e175 = texel_4;
param_110 = _e175.xyz;
let _e177 = SrgbToLinear_u0028_vf3_u003b((¶m_110));
let _e179 = frag_info.base_color;
param_111 = _e179.xyz;
let _e181 = SrgbToLinear_u0028_vf3_u003b((¶m_111));
let _e183 = v_color_1;
s_7.albedo = ((_e177 * _e181) * _e183.xyz);
let _e188 = texel_4[3u];
let _e191 = frag_info.base_color[3u];
let _e194 = v_color_1[3u];
s_7.alpha = ((_e188 * _e191) * _e194);
let _e198 = s_7.albedo;
g_albedo = _e198;
let _e201 = frag_info.material2_[0u];
cutoff = _e201;
let _e202 = cutoff;
if (_e202 >= 0f) {
let _e205 = s_7.alpha;
let _e206 = cutoff;
if (_e205 < _e206) {
discard;
}
} else {
let _e208 = cutoff;
if (_e208 < -1.5f) {
let _e210 = v_world_position_1;
anchored = floor((_e210 * 16f));
let _e213 = anchored;
noise_1 = fract((sin(dot(_e213, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e219 = s_7.alpha;
let _e220 = noise_1;
if (_e219 < _e220) {
discard;
}
}
}
let _e222 = cutoff;
let _e224 = cutoff;
g_premultiply = ((_e222 < 0f) && (_e224 > -0.75f));
let _e227 = v_normal_1;
s_7.n = normalize(_e227);
let _e230 = gl_FrontFacing_1;
if !(_e230) {
let _e233 = s_7.n;
s_7.n = -(_e233);
}
let _e237 = frag_info.camera_position;
let _e239 = v_world_position_1;
s_7.v = normalize((_e237.xyz - _e239));
let _e244 = s_7.n;
let _e246 = s_7.v;
s_7.n_dot_v = max(dot(_e244, _e246), 0.0001f);
let _e252 = frag_info.material[0u];
s_7.metallic = clamp(_e252, 0f, 1f);
let _e257 = frag_info.material[1u];
s_7.roughness = clamp(_e257, 0.02f, 1f);
let _e261 = frag_info.ambient_ground;
let _e264 = frag_info.ambient_sky;
let _e268 = s_7.n[1u];
let _e275 = frag_info.material[2u];
s_7.ambient = (mix(_e261.xyz, _e264.xyz, vec3(((_e268 * 0.5f) + 0.5f))) * _e275);
let _e280 = frag_info.frame_params[0u];
s_7.exposure = max(_e280, 0f);
s_7.occlusion = 1f;
s_7.emissive = vec3<f32>(0f, 0f, 0f);
let _e285 = s_7;
return _e285;
}
fn main_1() {
var s_8: Surface;
var d_7: vec3<f32>;
var right_1: vec3<f32>;
var param_112: vec3<f32>;
var up_2: vec3<f32>;
var offset_4: vec3<f32>;
var g: vec2<f32>;
var param_113: vec3<f32>;
var base: vec2<f32>;
var f: vec2<f32>;
var lower: bool;
var c0_: vec2<f32>;
var local_24: vec2<f32>;
var c1_: vec2<f32>;
var c2_: vec2<f32>;
var w: vec3<f32>;
var local_25: vec3<f32>;
var uv0_: vec2<f32>;
var param_114: vec2<f32>;
var param_115: vec3<f32>;
var uv1_: vec2<f32>;
var param_116: vec2<f32>;
var param_117: vec3<f32>;
var uv2_: vec2<f32>;
var param_118: vec2<f32>;
var param_119: vec3<f32>;
var a0_: vec4<f32>;
var a1_: vec4<f32>;
var a2_: vec4<f32>;
var n0_: vec4<f32>;
var n1_: vec4<f32>;
var n2_: vec4<f32>;
var wa: vec3<f32>;
var alpha_3: f32;
var srgb_1: vec3<f32>;
var local_26: vec3<f32>;
var worldRight: vec3<f32>;
var worldFacing: vec3<f32>;
var worldUp: vec3<f32>;
var param_120: vec3<f32>;
var param_121: vec3<f32>;
var ambient: vec3<f32>;
var param_122: Surface;
var param_123: vec3<f32>;
var param_124: f32;
var param_125: f32;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e211 = ReadSurface_u0028_();
s_8 = _e211;
let _e212 = v_color_1;
d_7 = normalize(_e212.xyz);
let _e215 = d_7;
param_112 = _e215;
let _e216 = ImpostorRight_u0028_vf3_u003b((¶m_112));
right_1 = _e216;
let _e217 = d_7;
let _e218 = right_1;
up_2 = cross(_e217, _e218);
let _e220 = right_1;
let _e222 = v_texcoord_1[0u];
let _e226 = up_2;
let _e228 = v_texcoord_1[1u];
offset_4 = ((_e220 * ((_e222 * 2f) - 1f)) + (_e226 * (1f - (_e228 * 2f))));
let _e233 = d_7;
param_113 = _e233;
let _e234 = ImpostorEncode_u0028_vf3_u003b((¶m_113));
g = (_e234 * 7f);
let _e236 = g;
base = clamp(floor(_e236), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
let _e239 = g;
let _e240 = base;
f = (_e239 - _e240);
let _e243 = f[0u];
let _e245 = f[1u];
lower = ((_e243 + _e245) < 1f);
let _e248 = lower;
if _e248 {
let _e249 = base;
local_24 = _e249;
} else {
let _e250 = base;
local_24 = (_e250 + vec2<f32>(1f, 1f));
}
let _e252 = local_24;
c0_ = _e252;
let _e253 = base;
c1_ = (_e253 + vec2<f32>(1f, 0f));
let _e255 = base;
c2_ = (_e255 + vec2<f32>(0f, 1f));
let _e257 = lower;
if _e257 {
let _e259 = f[0u];
let _e262 = f[1u];
let _e265 = f[0u];
let _e267 = f[1u];
local_25 = vec3<f32>(((1f - _e259) - _e262), _e265, _e267);
} else {
let _e270 = f[0u];
let _e272 = f[1u];
let _e276 = f[1u];
let _e279 = f[0u];
local_25 = vec3<f32>(((_e270 + _e272) - 1f), (1f - _e276), (1f - _e279));
}
let _e282 = local_25;
w = _e282;
let _e283 = c0_;
param_114 = _e283;
let _e284 = offset_4;
param_115 = _e284;
let _e285 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_114), (¶m_115));
uv0_ = _e285;
let _e286 = c1_;
param_116 = _e286;
let _e287 = offset_4;
param_117 = _e287;
let _e288 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_116), (¶m_117));
uv1_ = _e288;
let _e289 = c2_;
param_118 = _e289;
let _e290 = offset_4;
param_119 = _e290;
let _e291 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_118), (¶m_119));
uv2_ = _e291;
let _e292 = uv0_;
let _e293 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e292, 0f);
a0_ = _e293;
let _e294 = uv1_;
let _e295 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e294, 0f);
a1_ = _e295;
let _e296 = uv2_;
let _e297 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e296, 0f);
a2_ = _e297;
let _e298 = uv0_;
let _e299 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e298, 0f);
n0_ = _e299;
let _e300 = uv1_;
let _e301 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e300, 0f);
n1_ = _e301;
let _e302 = uv2_;
let _e303 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e302, 0f);
n2_ = _e303;
let _e304 = w;
let _e306 = a0_[3u];
let _e308 = a1_[3u];
let _e310 = a2_[3u];
wa = (_e304 * vec3<f32>(_e306, _e308, _e310));
let _e314 = wa[0u];
let _e316 = wa[1u];
let _e319 = wa[2u];
alpha_3 = ((_e314 + _e316) + _e319);
let _e321 = alpha_3;
if (_e321 < 0.5f) {
discard;
}
let _e323 = a0_;
let _e326 = wa[0u];
let _e328 = a1_;
let _e331 = wa[1u];
let _e334 = a2_;
let _e337 = wa[2u];
let _e340 = alpha_3;
srgb_1 = ((((_e323.xyz * _e326) + (_e328.xyz * _e331)) + (_e334.xyz * _e337)) / vec3(_e340));
let _e343 = n0_;
let _e348 = wa[0u];
let _e350 = n1_;
let _e355 = wa[1u];
let _e358 = n2_;
let _e363 = wa[2u];
local_26 = (((((_e343.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e348) + (((_e350.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e355)) + (((_e358.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e363));
let _e366 = local_26;
let _e367 = local_26;
let _e370 = local_26;
let _e371 = d_7;
local_26 = normalize(select(_e371, _e370, vec3((dot(_e366, _e367) > 0.000000000001f))));
let _e375 = v_tangent_1;
worldRight = normalize(_e375.xyz);
let _e378 = v_normal_1;
worldFacing = normalize(_e378);
let _e380 = worldFacing;
let _e381 = worldRight;
worldUp = cross(_e380, _e381);
let _e383 = worldRight;
let _e384 = local_26;
let _e385 = right_1;
let _e388 = worldUp;
let _e389 = local_26;
let _e390 = up_2;
let _e394 = worldFacing;
let _e395 = local_26;
let _e396 = d_7;
s_8.n = normalize((((_e383 * dot(_e384, _e385)) + (_e388 * dot(_e389, _e390))) + (_e394 * dot(_e395, _e396))));
let _e403 = s_8.n;
let _e405 = s_8.v;
s_8.n_dot_v = max(dot(_e403, _e405), 0.0001f);
let _e409 = srgb_1;
param_120 = _e409;
let _e410 = SrgbToLinear_u0028_vf3_u003b((¶m_120));
let _e412 = frag_info.base_color;
param_121 = _e412.xyz;
let _e414 = SrgbToLinear_u0028_vf3_u003b((¶m_121));
s_8.albedo = (_e410 * _e414);
s_8.alpha = 1f;
let _e419 = s_8.albedo;
g_albedo = _e419;
let _e421 = frag_info.ambient_ground;
let _e424 = frag_info.ambient_sky;
let _e428 = s_8.n[1u];
let _e435 = frag_info.material[2u];
s_8.ambient = (mix(_e421.xyz, _e424.xyz, vec3(((_e428 * 0.5f) + 0.5f))) * _e435);
let _e439 = s_8.albedo;
let _e441 = s_8.ambient;
ambient = (_e439 * _e441);
let _e443 = s_8;
param_122 = _e443;
let _e444 = 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_122));
let _e445 = ambient;
param_123 = (_e444 + _e445);
param_124 = 1f;
param_125 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<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;
gl_FrontFacing_1 = gl_FrontFacing;
gl_FragCoord_1 = gl_FragCoord;
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 _e19 = frag_albedo;
let _e20 = frag_surface;
let _e21 = frag_color;
return FragmentOutput(_e19, _e20, _e21);
}
''',
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: 896,
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,
),
WebGpuBlockMember(
name: 'shadow_bias',
offsetInBytes: 864,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'target_origin',
offsetInBytes: 880,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'cluster_view_projection',
offsetInBytes: 208,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'cluster_grid',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'cluster_depth',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slot_rows',
offsetInBytes: 304,
sizeInBytes: 32,
),
],
),
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: 'light_list_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
},
);