webGpuEngineShaders top-level property
Every shader the engine asks for, in WGSL, beside the
reflection a GPUShaderModule cannot be asked for.
Public, and promised with the rest: WebGpuDevice.open takes the
stages it compiles, and uses these when it is given none.
Implementation
final WebGpuSectionStages webGpuEngineShaders = (
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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(5) member_2: vec2<f32>,
@location(4) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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> v_instance: 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 _e42 = (*t);
let _e46 = (*rowStep);
row = ((f32((_e42 * 3i)) + 0.5f) * _e46);
let _e48 = (*column);
let _e49 = row;
let _e51 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e48, _e49), 0f);
let _e53 = (*weight);
let _e55 = (*position_1);
(*position_1) = (_e55 + (_e51.xyz * _e53));
let _e57 = (*column);
let _e58 = row;
let _e59 = (*rowStep);
let _e62 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e57, (_e58 + _e59)), 0f);
let _e64 = (*weight);
let _e66 = (*normal_1);
(*normal_1) = (_e66 + (_e62.xyz * _e64));
let _e68 = (*column);
let _e69 = row;
let _e70 = (*rowStep);
let _e74 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e68, (_e69 + (_e70 * 2f))), 0f);
let _e76 = (*weight);
let _e78 = (*tangent_1);
let _e80 = (_e78.xyz + (_e74.xyz * _e76));
(*tangent_1)[0u] = _e80.x;
(*tangent_1)[1u] = _e80.y;
(*tangent_1)[2u] = _e80.z;
return;
}
fn F3dVertexIndex_u0028_() -> i32 {
let _e34 = gl_VertexIndex_1;
return _e34;
}
fn MorphColumn_u0028_() -> f32 {
let _e34 = F3dVertexIndex_u0028_();
let _e39 = morph_info.morph_params[1u];
return ((f32(_e34) + 0.5f) * _e39);
}
fn MorphCount_u0028_() -> i32 {
let _e36 = morph_info.morph_params[0u];
return i32((_e36 + 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 _e49 = MorphCount_u0028_();
count = _e49;
let _e50 = count;
if (_e50 <= 0i) {
return;
}
let _e52 = MorphColumn_u0028_();
column_1 = _e52;
let _e55 = morph_info.morph_params[2u];
rowStep_1 = _e55;
i = 0i;
loop {
let _e56 = i;
if (_e56 < 8i) {
let _e58 = i;
let _e59 = count;
if (_e58 >= _e59) {
break;
}
let _e61 = i;
let _e63 = i;
let _e74 = morph_info.morph_weights[(_e61 / 4i)][(_e63 - (i32(floor((f32(_e63) / f32(4i)))) * 4i))];
weight_1 = _e74;
let _e75 = weight_1;
if (_e75 == 0f) {
continue;
}
let _e77 = i;
param = _e77;
let _e78 = weight_1;
param_1 = _e78;
let _e79 = column_1;
param_2 = _e79;
let _e80 = rowStep_1;
param_3 = _e80;
let _e81 = (*position_2);
param_4 = _e81;
let _e82 = (*normal_2);
param_5 = _e82;
let _e83 = (*tangent_2);
param_6 = _e83;
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 _e84 = param_4;
(*position_2) = _e84;
let _e85 = param_5;
(*normal_2) = _e85;
let _e86 = param_6;
(*tangent_2) = _e86;
continue;
} else {
break;
}
continuing {
let _e87 = i;
i = (_e87 + 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 _e43 = position_3;
morphed_position = _e43;
let _e44 = normal_3;
morphed_normal = _e44;
let _e45 = tangent_3;
morphed_tangent = _e45;
let _e46 = morphed_position;
param_7 = _e46;
let _e47 = morphed_normal;
param_8 = _e47;
let _e48 = morphed_tangent;
param_9 = _e48;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e49 = param_7;
morphed_position = _e49;
let _e50 = param_8;
morphed_normal = _e50;
let _e51 = param_9;
morphed_tangent = _e51;
let _e53 = frame_info.model;
let _e54 = morphed_position;
world = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, 1f));
let _e60 = world;
v_world_position = _e60.xyz;
let _e63 = frame_info.normal_matrix;
let _e71 = morphed_normal;
v_normal = (mat3x3<f32>(_e63[0].xyz, _e63[1].xyz, _e63[2].xyz) * _e71);
let _e73 = texcoord_1;
v_texcoord = _e73;
let _e75 = frame_info.model;
mirrored = (determinant(mat3x3<f32>(_e75[0].xyz, _e75[1].xyz, _e75[2].xyz)) < 0f);
let _e86 = frame_info.model;
let _e94 = morphed_tangent;
let _e96 = (mat3x3<f32>(_e86[0].xyz, _e86[1].xyz, _e86[2].xyz) * _e94.xyz);
let _e97 = mirrored;
if _e97 {
let _e99 = morphed_tangent[3u];
local = -(_e99);
} else {
let _e102 = morphed_tangent[3u];
local = _e102;
}
let _e103 = local;
v_tangent = vec4<f32>(_e96.x, _e96.y, _e96.z, _e103);
let _e108 = color_1;
v_color = _e108;
v_lightmap_uv = vec2<f32>(0f, 0f);
v_instance = vec4<f32>(0f, 0f, 0f, 0f);
let _e110 = frame_info.mvp;
let _e111 = morphed_position;
unnamed.gl_Position = (_e110 * vec4<f32>(_e111.x, _e111.y, _e111.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 _e22 = v_world_position;
let _e23 = v_normal;
let _e24 = v_texcoord;
let _e25 = v_tangent;
let _e26 = v_color;
let _e27 = v_lightmap_uv;
let _e28 = v_instance;
let _e29 = unnamed.gl_Position;
return VertexOutput(_e22, _e23, _e24, _e25, _e26, _e27, _e28, _e29);
}
''',
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(6) 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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(4) member_2: vec4<f32>,
@location(5) member_3: vec2<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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> v_instance: 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 _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_1);
(*normal_1) = (_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_1);
let _e87 = (_e85.xyz + (_e81.xyz * _e83));
(*tangent_1)[0u] = _e87.x;
(*tangent_1)[1u] = _e87.y;
(*tangent_1)[2u] = _e87.z;
return;
}
fn F3dVertexIndex_u0028_() -> i32 {
let _e41 = gl_VertexIndex_1;
return _e41;
}
fn MorphColumn_u0028_() -> f32 {
let _e41 = F3dVertexIndex_u0028_();
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 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 _e56 = MorphCount_u0028_();
count = _e56;
let _e57 = count;
if (_e57 <= 0i) {
return;
}
let _e59 = MorphColumn_u0028_();
column_1 = _e59;
let _e62 = morph_info.morph_params[2u];
rowStep_1 = _e62;
i = 0i;
loop {
let _e63 = i;
if (_e63 < 8i) {
let _e65 = i;
let _e66 = count;
if (_e65 >= _e66) {
break;
}
let _e68 = i;
let _e70 = i;
let _e81 = morph_info.morph_weights[(_e68 / 4i)][(_e70 - (i32(floor((f32(_e70) / f32(4i)))) * 4i))];
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_2);
param_5 = _e89;
let _e90 = (*tangent_2);
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_2) = _e92;
let _e93 = param_6;
(*tangent_2) = _e93;
continue;
} else {
break;
}
continuing {
let _e94 = i;
i = (_e94 + 1i);
}
}
return;
}
fn JointIndex_u0028_f1_u003b(joint: ptr<function, f32>) -> i32 {
let _e42 = (*joint);
return clamp(i32(_e42), 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 _e49 = weights_1[0u];
let _e51 = weights_1[1u];
let _e54 = weights_1[2u];
let _e57 = weights_1[3u];
total = (((_e49 + _e51) + _e54) + _e57);
let _e59 = total;
if (_e59 > 0.00001f) {
let _e61 = weights_1;
let _e62 = total;
local = (_e61 / vec4(_e62));
} else {
local = vec4<f32>(1f, 0f, 0f, 0f);
}
let _e65 = local;
w = _e65;
let _e67 = w[0u];
let _e69 = joints_1[0u];
param_7 = _e69;
let _e70 = JointIndex_u0028_f1_u003b((¶m_7));
let _e73 = skin_info.joint_matrices[_e70];
let _e74 = (_e73 * _e67);
let _e76 = w[1u];
let _e78 = joints_1[1u];
param_8 = _e78;
let _e79 = JointIndex_u0028_f1_u003b((¶m_8));
let _e82 = skin_info.joint_matrices[_e79];
let _e83 = (_e82 * _e76);
let _e96 = mat4x4<f32>((_e74[0] + _e83[0]), (_e74[1] + _e83[1]), (_e74[2] + _e83[2]), (_e74[3] + _e83[3]));
let _e98 = w[2u];
let _e100 = joints_1[2u];
param_9 = _e100;
let _e101 = JointIndex_u0028_f1_u003b((¶m_9));
let _e104 = skin_info.joint_matrices[_e101];
let _e105 = (_e104 * _e98);
let _e118 = mat4x4<f32>((_e96[0] + _e105[0]), (_e96[1] + _e105[1]), (_e96[2] + _e105[2]), (_e96[3] + _e105[3]));
let _e120 = w[3u];
let _e122 = joints_1[3u];
param_10 = _e122;
let _e123 = JointIndex_u0028_f1_u003b((¶m_10));
let _e126 = skin_info.joint_matrices[_e123];
let _e127 = (_e126 * _e120);
return mat4x4<f32>((_e118[0] + _e127[0]), (_e118[1] + _e127[1]), (_e118[2] + _e127[2]), (_e118[3] + _e127[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 _e53 = SkinMatrix_u0028_();
skin = _e53;
let _e54 = position_3;
morphed_position = _e54;
let _e55 = normal_3;
morphed_normal = _e55;
let _e56 = tangent_3;
morphed_tangent = _e56;
let _e57 = morphed_position;
param_11 = _e57;
let _e58 = morphed_normal;
param_12 = _e58;
let _e59 = morphed_tangent;
param_13 = _e59;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_11), (¶m_12), (¶m_13));
let _e60 = param_11;
morphed_position = _e60;
let _e61 = param_12;
morphed_normal = _e61;
let _e62 = param_13;
morphed_tangent = _e62;
let _e64 = frame_info.model;
let _e65 = skin;
skinnedModel = (_e64 * _e65);
let _e67 = skinnedModel;
let _e68 = morphed_position;
world = (_e67 * vec4<f32>(_e68.x, _e68.y, _e68.z, 1f));
let _e74 = world;
v_world_position = _e74.xyz;
let _e76 = skin;
skinRotation = mat3x3<f32>(_e76[0].xyz, _e76[1].xyz, _e76[2].xyz);
let _e85 = frame_info.normal_matrix;
let _e93 = skinRotation;
let _e94 = morphed_normal;
v_normal = (mat3x3<f32>(_e85[0].xyz, _e85[1].xyz, _e85[2].xyz) * (_e93 * _e94));
let _e98 = frame_info.model;
let _e108 = skinRotation;
mirrored = ((determinant(mat3x3<f32>(_e98[0].xyz, _e98[1].xyz, _e98[2].xyz)) < 0f) != (determinant(_e108) < 0f));
let _e113 = frame_info.model;
let _e121 = skinRotation;
let _e122 = morphed_tangent;
let _e125 = (mat3x3<f32>(_e113[0].xyz, _e113[1].xyz, _e113[2].xyz) * (_e121 * _e122.xyz));
let _e126 = mirrored;
if _e126 {
let _e128 = morphed_tangent[3u];
local_1 = -(_e128);
} else {
let _e131 = morphed_tangent[3u];
local_1 = _e131;
}
let _e132 = local_1;
v_tangent = vec4<f32>(_e125.x, _e125.y, _e125.z, _e132);
let _e137 = texcoord_1;
v_texcoord = _e137;
let _e138 = color_1;
v_color = _e138;
v_lightmap_uv = vec2<f32>(0f, 0f);
v_instance = vec4<f32>(0f, 0f, 0f, 0f);
let _e140 = frame_info.mvp;
let _e141 = skin;
let _e142 = morphed_position;
unnamed.gl_Position = (_e140 * (_e141 * vec4<f32>(_e142.x, _e142.y, _e142.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 _e26 = v_world_position;
let _e27 = v_normal;
let _e28 = v_tangent;
let _e29 = v_texcoord;
let _e30 = v_color;
let _e31 = v_lightmap_uv;
let _e32 = v_instance;
let _e33 = unnamed.gl_Position;
return VertexOutput(_e26, _e27, _e28, _e29, _e30, _e31, _e32, _e33);
}
''',
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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(5) member_2: vec2<f32>,
@location(4) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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> gl_InstanceIndex_1: i32;
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>;
@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> v_instance: vec4<f32>;
var<private> i_data_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 _e50 = (*t);
let _e54 = (*rowStep);
row = ((f32((_e50 * 3i)) + 0.5f) * _e54);
let _e56 = (*column);
let _e57 = row;
let _e59 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e56, _e57), 0f);
let _e61 = (*weight);
let _e63 = (*position_1);
(*position_1) = (_e63 + (_e59.xyz * _e61));
let _e65 = (*column);
let _e66 = row;
let _e67 = (*rowStep);
let _e70 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e65, (_e66 + _e67)), 0f);
let _e72 = (*weight);
let _e74 = (*normal_1);
(*normal_1) = (_e74 + (_e70.xyz * _e72));
let _e76 = (*column);
let _e77 = row;
let _e78 = (*rowStep);
let _e82 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e76, (_e77 + (_e78 * 2f))), 0f);
let _e84 = (*weight);
let _e86 = (*tangent_1);
let _e88 = (_e86.xyz + (_e82.xyz * _e84));
(*tangent_1)[0u] = _e88.x;
(*tangent_1)[1u] = _e88.y;
(*tangent_1)[2u] = _e88.z;
return;
}
fn F3dVertexIndex_u0028_() -> i32 {
let _e42 = gl_VertexIndex_1;
return _e42;
}
fn MorphColumn_u0028_() -> f32 {
let _e42 = F3dVertexIndex_u0028_();
let _e47 = morph_info.morph_params[1u];
return ((f32(_e42) + 0.5f) * _e47);
}
fn MorphCount_u0028_() -> i32 {
let _e44 = morph_info.morph_params[0u];
return i32((_e44 + 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 _e57 = MorphCount_u0028_();
count = _e57;
let _e58 = count;
if (_e58 <= 0i) {
return;
}
let _e60 = MorphColumn_u0028_();
column_1 = _e60;
let _e63 = morph_info.morph_params[2u];
rowStep_1 = _e63;
i = 0i;
loop {
let _e64 = i;
if (_e64 < 8i) {
let _e66 = i;
let _e67 = count;
if (_e66 >= _e67) {
break;
}
let _e69 = i;
let _e71 = i;
let _e82 = morph_info.morph_weights[(_e69 / 4i)][(_e71 - (i32(floor((f32(_e71) / f32(4i)))) * 4i))];
weight_1 = _e82;
let _e83 = weight_1;
if (_e83 == 0f) {
continue;
}
let _e85 = i;
param = _e85;
let _e86 = weight_1;
param_1 = _e86;
let _e87 = column_1;
param_2 = _e87;
let _e88 = rowStep_1;
param_3 = _e88;
let _e89 = (*position_2);
param_4 = _e89;
let _e90 = (*normal_2);
param_5 = _e90;
let _e91 = (*tangent_2);
param_6 = _e91;
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 _e92 = param_4;
(*position_2) = _e92;
let _e93 = param_5;
(*normal_2) = _e93;
let _e94 = param_6;
(*tangent_2) = _e94;
continue;
} else {
break;
}
continuing {
let _e95 = i;
i = (_e95 + 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 _e65 = morph_instance_info.instance_params[0u];
if (_e65 < 0.5f) {
let _e67 = (*position_3);
param_7 = _e67;
let _e68 = (*normal_3);
param_8 = _e68;
let _e69 = (*tangent_3);
param_9 = _e69;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e70 = param_7;
(*position_3) = _e70;
let _e71 = param_8;
(*normal_3) = _e71;
let _e72 = param_9;
(*tangent_3) = _e72;
return;
}
let _e73 = MorphCount_u0028_();
count_1 = _e73;
let _e74 = count_1;
if (_e74 <= 0i) {
return;
}
let _e76 = MorphColumn_u0028_();
deltaColumn = _e76;
let _e79 = morph_info.morph_params[2u];
deltaRowStep = _e79;
let _e80 = (*instance);
let _e85 = morph_instance_info.instance_params[2u];
row_1 = ((f32(_e80) + 0.5f) * _e85);
i_1 = 0i;
loop {
let _e87 = i_1;
if (_e87 < 8i) {
let _e89 = i_1;
let _e90 = count_1;
if (_e89 >= _e90) {
break;
}
let _e92 = i_1;
let _e98 = morph_instance_info.instance_params[1u];
column_2 = ((f32((_e92 / 4i)) + 0.5f) * _e98);
let _e100 = column_2;
let _e101 = row_1;
let _e103 = textureSampleLevel(morph_instance_weights_tex, morph_instance_weights_smp, vec2<f32>(_e100, _e101), 0f);
let _e104 = i_1;
let _e111 = (_e104 - (i32(floor((f32(_e104) / f32(4i)))) * 4i));
weight_2 = select(select(select(_e103[0i], _e103[1i], (1i == _e111)), _e103[2i], (2i == _e111)), _e103[3i], (3i == _e111));
let _e126 = weight_2;
if (_e126 == 0f) {
continue;
}
let _e128 = i_1;
param_10 = _e128;
let _e129 = weight_2;
param_11 = _e129;
let _e130 = deltaColumn;
param_12 = _e130;
let _e131 = deltaRowStep;
param_13 = _e131;
let _e132 = (*position_3);
param_14 = _e132;
let _e133 = (*normal_3);
param_15 = _e133;
let _e134 = (*tangent_3);
param_16 = _e134;
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 _e135 = param_14;
(*position_3) = _e135;
let _e136 = param_15;
(*normal_3) = _e136;
let _e137 = param_16;
(*tangent_3) = _e137;
continue;
} else {
break;
}
continuing {
let _e138 = i_1;
i_1 = (_e138 + 1i);
}
}
return;
}
fn F3dInstanceIndex_u0028_() -> i32 {
let _e42 = gl_InstanceIndex_1;
return _e42;
}
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 _e56 = i_row0_1[0u];
let _e58 = i_row1_1[0u];
let _e60 = i_row2_1[0u];
let _e61 = vec4<f32>(_e56, _e58, _e60, 0f);
let _e63 = i_row0_1[1u];
let _e65 = i_row1_1[1u];
let _e67 = i_row2_1[1u];
let _e68 = vec4<f32>(_e63, _e65, _e67, 0f);
let _e70 = i_row0_1[2u];
let _e72 = i_row1_1[2u];
let _e74 = i_row2_1[2u];
let _e75 = vec4<f32>(_e70, _e72, _e74, 0f);
let _e77 = i_row0_1[3u];
let _e79 = i_row1_1[3u];
let _e81 = i_row2_1[3u];
let _e82 = vec4<f32>(_e77, _e79, _e81, 1f);
instance_1 = mat4x4<f32>(vec4<f32>(_e61.x, _e61.y, _e61.z, _e61.w), vec4<f32>(_e68.x, _e68.y, _e68.z, _e68.w), vec4<f32>(_e75.x, _e75.y, _e75.z, _e75.w), vec4<f32>(_e82.x, _e82.y, _e82.z, _e82.w));
let _e104 = position_4;
morphed_position = _e104;
let _e105 = normal_4;
morphed_normal = _e105;
let _e106 = tangent_4;
morphed_tangent = _e106;
let _e107 = F3dInstanceIndex_u0028_();
param_17 = _e107;
let _e108 = morphed_position;
param_18 = _e108;
let _e109 = morphed_normal;
param_19 = _e109;
let _e110 = morphed_tangent;
param_20 = _e110;
ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e111 = param_18;
morphed_position = _e111;
let _e112 = param_19;
morphed_normal = _e112;
let _e113 = param_20;
morphed_tangent = _e113;
let _e114 = instance_1;
let _e115 = morphed_position;
local = (_e114 * vec4<f32>(_e115.x, _e115.y, _e115.z, 1f));
let _e122 = frame_info.model;
let _e123 = local;
world = (_e122 * _e123);
let _e125 = world;
v_world_position = _e125.xyz;
let _e127 = instance_1;
rotation = mat3x3<f32>(_e127[0].xyz, _e127[1].xyz, _e127[2].xyz);
let _e136 = frame_info.normal_matrix;
let _e144 = rotation;
let _e145 = morphed_normal;
v_normal = (mat3x3<f32>(_e136[0].xyz, _e136[1].xyz, _e136[2].xyz) * normalize((_e144 * _e145)));
let _e149 = texcoord_1;
v_texcoord = _e149;
let _e151 = frame_info.model;
let _e161 = rotation;
mirrored = ((determinant(mat3x3<f32>(_e151[0].xyz, _e151[1].xyz, _e151[2].xyz)) < 0f) != (determinant(_e161) < 0f));
let _e166 = frame_info.model;
let _e174 = rotation;
let _e175 = morphed_tangent;
let _e178 = (mat3x3<f32>(_e166[0].xyz, _e166[1].xyz, _e166[2].xyz) * (_e174 * _e175.xyz));
let _e179 = mirrored;
if _e179 {
let _e181 = morphed_tangent[3u];
local_1 = -(_e181);
} else {
let _e184 = morphed_tangent[3u];
local_1 = _e184;
}
let _e185 = local_1;
v_tangent = vec4<f32>(_e178.x, _e178.y, _e178.z, _e185);
let _e190 = color_1;
let _e191 = i_color_1;
v_color = (_e190 * _e191);
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e193 = i_data_1;
v_instance = _e193;
let _e195 = frame_info.mvp;
let _e196 = local;
unnamed.gl_Position = (_e195 * _e196);
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @builtin(instance_index) gl_InstanceIndex: 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>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>, @location(8) i_color: vec4<f32>, @location(9) i_data: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
gl_InstanceIndex_1 = i32(gl_InstanceIndex);
i_row0_1 = i_row0_;
i_row1_1 = i_row1_;
i_row2_1 = i_row2_;
position_4 = position;
normal_4 = normal;
tangent_4 = tangent;
texcoord_1 = texcoord;
color_1 = color;
i_color_1 = i_color;
i_data_1 = i_data;
main_1();
let _e35 = v_world_position;
let _e36 = v_normal;
let _e37 = v_texcoord;
let _e38 = v_tangent;
let _e39 = v_color;
let _e40 = v_lightmap_uv;
let _e41 = v_instance;
let _e42 = unnamed.gl_Position;
return VertexOutput(_e35, _e36, _e37, _e38, _e39, _e40, _e41, _e42);
}
''',
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,
),
WebGpuAttribute(
name: 'i_data',
location: 9,
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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(5) member_2: vec2<f32>,
@location(4) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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> v_instance: 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 _e42 = (*t);
let _e46 = (*rowStep);
row = ((f32((_e42 * 3i)) + 0.5f) * _e46);
let _e48 = (*column);
let _e49 = row;
let _e51 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e48, _e49), 0f);
let _e53 = (*weight);
let _e55 = (*position_1);
(*position_1) = (_e55 + (_e51.xyz * _e53));
let _e57 = (*column);
let _e58 = row;
let _e59 = (*rowStep);
let _e62 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e57, (_e58 + _e59)), 0f);
let _e64 = (*weight);
let _e66 = (*normal_1);
(*normal_1) = (_e66 + (_e62.xyz * _e64));
let _e68 = (*column);
let _e69 = row;
let _e70 = (*rowStep);
let _e74 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e68, (_e69 + (_e70 * 2f))), 0f);
let _e76 = (*weight);
let _e78 = (*tangent_1);
let _e80 = (_e78.xyz + (_e74.xyz * _e76));
(*tangent_1)[0u] = _e80.x;
(*tangent_1)[1u] = _e80.y;
(*tangent_1)[2u] = _e80.z;
return;
}
fn F3dVertexIndex_u0028_() -> i32 {
let _e34 = gl_VertexIndex_1;
return _e34;
}
fn MorphColumn_u0028_() -> f32 {
let _e34 = F3dVertexIndex_u0028_();
let _e39 = morph_info.morph_params[1u];
return ((f32(_e34) + 0.5f) * _e39);
}
fn MorphCount_u0028_() -> i32 {
let _e36 = morph_info.morph_params[0u];
return i32((_e36 + 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 _e49 = MorphCount_u0028_();
count = _e49;
let _e50 = count;
if (_e50 <= 0i) {
return;
}
let _e52 = MorphColumn_u0028_();
column_1 = _e52;
let _e55 = morph_info.morph_params[2u];
rowStep_1 = _e55;
i = 0i;
loop {
let _e56 = i;
if (_e56 < 8i) {
let _e58 = i;
let _e59 = count;
if (_e58 >= _e59) {
break;
}
let _e61 = i;
let _e63 = i;
let _e74 = morph_info.morph_weights[(_e61 / 4i)][(_e63 - (i32(floor((f32(_e63) / f32(4i)))) * 4i))];
weight_1 = _e74;
let _e75 = weight_1;
if (_e75 == 0f) {
continue;
}
let _e77 = i;
param = _e77;
let _e78 = weight_1;
param_1 = _e78;
let _e79 = column_1;
param_2 = _e79;
let _e80 = rowStep_1;
param_3 = _e80;
let _e81 = (*position_2);
param_4 = _e81;
let _e82 = (*normal_2);
param_5 = _e82;
let _e83 = (*tangent_2);
param_6 = _e83;
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 _e84 = param_4;
(*position_2) = _e84;
let _e85 = param_5;
(*normal_2) = _e85;
let _e86 = param_6;
(*tangent_2) = _e86;
continue;
} else {
break;
}
continuing {
let _e87 = i;
i = (_e87 + 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 _e43 = position_3;
morphed_position = _e43;
let _e44 = normal_3;
morphed_normal = _e44;
let _e45 = tangent_3;
morphed_tangent = _e45;
let _e46 = morphed_position;
param_7 = _e46;
let _e47 = morphed_normal;
param_8 = _e47;
let _e48 = morphed_tangent;
param_9 = _e48;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e49 = param_7;
morphed_position = _e49;
let _e50 = param_8;
morphed_normal = _e50;
let _e51 = param_9;
morphed_tangent = _e51;
let _e53 = frame_info.model;
let _e54 = morphed_position;
world = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, 1f));
let _e60 = world;
v_world_position = _e60.xyz;
let _e63 = frame_info.normal_matrix;
let _e71 = morphed_normal;
v_normal = (mat3x3<f32>(_e63[0].xyz, _e63[1].xyz, _e63[2].xyz) * _e71);
let _e73 = texcoord_1;
v_texcoord = _e73;
let _e75 = frame_info.model;
mirrored = (determinant(mat3x3<f32>(_e75[0].xyz, _e75[1].xyz, _e75[2].xyz)) < 0f);
let _e86 = frame_info.model;
let _e94 = morphed_tangent;
let _e96 = (mat3x3<f32>(_e86[0].xyz, _e86[1].xyz, _e86[2].xyz) * _e94.xyz);
let _e97 = mirrored;
if _e97 {
let _e99 = morphed_tangent[3u];
local = -(_e99);
} else {
let _e102 = morphed_tangent[3u];
local = _e102;
}
let _e103 = local;
v_tangent = vec4<f32>(_e96.x, _e96.y, _e96.z, _e103);
v_color = vec4<f32>(1f, 1f, 1f, 1f);
let _e108 = color_1;
v_lightmap_uv = _e108.xy;
v_instance = vec4<f32>(0f, 0f, 0f, 0f);
let _e111 = frame_info.mvp;
let _e112 = morphed_position;
unnamed.gl_Position = (_e111 * vec4<f32>(_e112.x, _e112.y, _e112.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 _e22 = v_world_position;
let _e23 = v_normal;
let _e24 = v_texcoord;
let _e25 = v_tangent;
let _e26 = v_color;
let _e27 = v_lightmap_uv;
let _e28 = v_instance;
let _e29 = unnamed.gl_Position;
return VertexOutput(_e22, _e23, _e24, _e25, _e26, _e27, _e28, _e29);
}
''',
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>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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 F3dVertexIndex_u0028_() -> i32 {
let _e26 = gl_VertexIndex_1;
return _e26;
}
fn MorphColumn_u0028_() -> f32 {
let _e26 = F3dVertexIndex_u0028_();
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>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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 F3dVertexIndex_u0028_() -> i32 {
let _e41 = gl_VertexIndex_1;
return _e41;
}
fn MorphColumn_u0028_() -> f32 {
let _e41 = F3dVertexIndex_u0028_();
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>,
}
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@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 F3dVertexIndex_u0028_() -> i32 {
let _e33 = gl_VertexIndex_1;
return _e33;
}
fn MorphColumn_u0028_() -> f32 {
let _e33 = F3dVertexIndex_u0028_();
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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(5) member_2: vec2<f32>,
@location(4) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<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>;
var<private> v_instance: vec4<f32>;
fn ToPixels_u0028_vf4_u003b_vf2_u003b(clip: ptr<function, vec4<f32>>, viewport: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e34 = (*clip);
let _e37 = (*clip)[3u];
let _e40 = (*viewport);
return (((_e34.xy / vec2(_e37)) * _e40) * 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 _e36 = (*from_)[3u];
if (_e36 >= 0.0001f) {
let _e38 = (*from_);
return _e38;
}
let _e40 = (*from_)[3u];
let _e43 = (*to)[3u];
let _e45 = (*from_)[3u];
t = ((0.0001f - _e40) / (_e43 - _e45));
let _e48 = (*from_);
let _e49 = (*to);
let _e50 = t;
return mix(_e48, _e49, vec4(clamp(_e50, 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 _e57 = params.viewport;
viewport_1 = _e57.xy;
let _e60 = tangent_1[3u];
halfWidth = abs(_e60);
let _e63 = tangent_1[3u];
side = select(1f, -1f, (_e63 < 0f));
let _e67 = frame_info.mvp;
let _e68 = position_1;
here = (_e67 * vec4<f32>(_e68.x, _e68.y, _e68.z, 1f));
let _e75 = frame_info.mvp;
let _e76 = normal_1;
before = (_e75 * vec4<f32>(_e76.x, _e76.y, _e76.z, 1f));
let _e83 = frame_info.mvp;
let _e84 = tangent_1;
let _e85 = _e84.xyz;
after = (_e83 * vec4<f32>(_e85.x, _e85.y, _e85.z, 1f));
let _e92 = here[3u];
if (_e92 < 0.0001f) {
let _e95 = after[3u];
if (_e95 >= 0.0001f) {
let _e97 = here;
param = _e97;
let _e98 = after;
param_1 = _e98;
let _e99 = InFront_u0028_vf4_u003b_vf4_u003b((¶m), (¶m_1));
local = _e99;
} else {
let _e100 = here;
param_2 = _e100;
let _e101 = before;
param_3 = _e101;
let _e102 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_2), (¶m_3));
local = _e102;
}
let _e103 = local;
here = _e103;
}
let _e104 = before;
param_4 = _e104;
let _e105 = here;
param_5 = _e105;
let _e106 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_4), (¶m_5));
before = _e106;
let _e107 = after;
param_6 = _e107;
let _e108 = here;
param_7 = _e108;
let _e109 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_6), (¶m_7));
after = _e109;
let _e110 = after;
param_8 = _e110;
let _e111 = viewport_1;
param_9 = _e111;
let _e112 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_8), (¶m_9));
let _e113 = before;
param_10 = _e113;
let _e114 = viewport_1;
param_11 = _e114;
let _e115 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_10), (¶m_11));
dir = (_e112 - _e115);
let _e117 = dir;
dirLength = length(_e117);
let _e119 = dirLength;
if (_e119 > 0.000000001f) {
let _e122 = dir[1u];
let _e125 = dir[0u];
let _e127 = dirLength;
local_1 = (vec2<f32>(-(_e122), _e125) / vec2(_e127));
} else {
local_1 = vec2<f32>(1f, 0f);
}
let _e130 = local_1;
segmentNormal = _e130;
let _e131 = segmentNormal;
let _e132 = halfWidth;
let _e134 = side;
offset = ((_e131 * _e132) * _e134);
let _e136 = here;
let _e138 = offset;
let _e139 = viewport_1;
let _e143 = here[3u];
let _e145 = (_e136.xy + ((_e138 / (_e139 * 0.5f)) * _e143));
let _e146 = here;
let _e147 = _e146.zw;
unnamed.gl_Position = vec4<f32>(_e145.x, _e145.y, _e147.x, _e147.y);
let _e155 = frame_info.model;
let _e156 = position_1;
v_world_position = (_e155 * vec4<f32>(_e156.x, _e156.y, _e156.z, 1f)).xyz;
let _e164 = frame_info.normal_matrix;
v_normal = normalize((mat3x3<f32>(_e164[0].xyz, _e164[1].xyz, _e164[2].xyz) * vec3<f32>(0f, 1f, 0f)));
let _e174 = texcoord_1;
v_texcoord = _e174;
v_tangent = vec4<f32>(1f, 0f, 0f, 1f);
let _e175 = color_1;
v_color = _e175;
v_lightmap_uv = vec2<f32>(0f, 0f);
v_instance = vec4<f32>(0f, 0f, 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 _e19 = unnamed.gl_Position;
let _e20 = v_world_position;
let _e21 = v_normal;
let _e22 = v_texcoord;
let _e23 = v_tangent;
let _e24 = v_color;
let _e25 = v_lightmap_uv;
let _e26 = v_instance;
return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25, _e26);
}
''',
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(6) member_1: vec2<f32>,
@location(7) 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(7) member_1: vec3<f32>,
@location(3) 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>[],
),
'CausticPhotonVertex': WebGpuStage(
wgsl: r'''
struct CausticInfo {
map_to_world: mat4x4<f32>,
world_to_map: mat4x4<f32>,
world_to_tile: mat4x4<f32>,
world_to_clip: mat4x4<f32>,
grid: vec4<f32>,
light: vec4<f32>,
optics: vec4<f32>,
tint: vec4<f32>,
attenuation: 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(6) member: vec2<f32>,
@location(0) member_1: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> gl_InstanceIndex_1: i32;
@group(0) @binding(5)
var caustic_front_tex: texture_2d<f32>;
@group(0) @binding(6)
var caustic_front_smp: sampler;
@group(0) @binding(0)
var<uniform> caustic_info: CausticInfo;
@group(0) @binding(1)
var caustic_back_tex: texture_2d<f32>;
@group(0) @binding(2)
var caustic_back_smp: sampler;
@group(0) @binding(3)
var caustic_depth_tex: texture_2d<f32>;
@group(0) @binding(4)
var caustic_depth_smp: sampler;
var<private> v_uv: vec2<f32>;
var<private> corner_1: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b(a: ptr<function, vec2<f32>>, fallback: ptr<function, vec2<f32>>, least: ptr<function, f32>) -> vec2<f32> {
var size: f32;
var local: vec2<f32>;
let _e50 = (*a);
size = length(_e50);
let _e52 = size;
if (_e52 < 0.000000001f) {
let _e54 = (*fallback);
let _e56 = (*least);
return (normalize(_e54) * _e56);
}
let _e58 = size;
let _e59 = (*least);
if (_e58 < _e59) {
let _e61 = (*a);
let _e62 = (*least);
let _e63 = size;
local = (_e61 * (_e62 / _e63));
} else {
let _e66 = (*a);
local = _e66;
}
let _e67 = local;
return _e67;
}
fn Schlick_u0028_f1_u003b_f1_u003b(f0_: ptr<function, f32>, cosine: ptr<function, f32>) -> f32 {
var c: f32;
let _e48 = (*cosine);
c = clamp((1f - _e48), 0f, 1f);
let _e51 = (*f0_);
let _e52 = (*f0_);
let _e54 = c;
let _e56 = c;
let _e58 = c;
let _e60 = c;
let _e62 = c;
return (_e51 + ((((((1f - _e52) * _e54) * _e56) * _e58) * _e60) * _e62));
}
fn MapUv_u0028_vf4_u003b(p: ptr<function, vec4<f32>>) -> vec2<f32> {
let _e47 = (*p)[0u];
let _e51 = (*p)[1u];
return vec2<f32>(((_e47 * 0.5f) + 0.5f), (0.5f - (_e51 * 0.5f)));
}
fn Follow_u0028_vf2_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, energy: ptr<function, vec3<f32>>) -> vec4<f32> {
var front: vec4<f32>;
var ndc: vec2<f32>;
var entry: vec3<f32>;
var range: f32;
var l: vec3<f32>;
var n1_: vec3<f32>;
var index: f32;
var inside: vec3<f32>;
var back: vec4<f32>;
var across: f32;
var exit: vec3<f32>;
var there: vec4<f32>;
var param: vec4<f32>;
var n2_: vec3<f32>;
var local_1: vec3<f32>;
var out_ray: vec3<f32>;
var f0_1: f32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: f32;
var fading: f32;
var p_1: vec3<f32>;
var down: f32;
var k: i32;
var q: vec4<f32>;
var receiver: f32;
var param_5: vec4<f32>;
var advance: f32;
var landed: vec4<f32>;
var under: f32;
var param_6: vec4<f32>;
var clip: vec4<f32>;
var phi_109_: bool;
(*energy) = vec3<f32>(0f, 0f, 0f);
let _e80 = (*uv);
let _e81 = textureSampleLevel(caustic_front_tex, caustic_front_smp, _e80, 0f);
front = _e81;
let _e83 = front[3u];
let _e84 = (_e83 >= 1f);
phi_109_ = _e84;
if !(_e84) {
let _e86 = front;
let _e88 = front;
phi_109_ = (dot(_e86.xyz, _e88.xyz) < 0.25f);
}
let _e93 = phi_109_;
if _e93 {
return vec4<f32>(0f, 0f, 0f, 0f);
}
let _e95 = (*uv)[0u];
let _e99 = (*uv)[1u];
ndc = vec2<f32>(((_e95 * 2f) - 1f), ((0.5f - _e99) * 2f));
let _e104 = caustic_info.map_to_world;
let _e105 = ndc;
let _e107 = front[3u];
entry = (_e104 * vec4<f32>(_e105.x, _e105.y, _e107, 1f)).xyz;
let _e114 = caustic_info.map_to_world;
range = length((_e114 * vec4<f32>(0f, 0f, 1f, 0f)).xyz);
let _e119 = caustic_info.light;
l = normalize(_e119.xyz);
let _e122 = front;
n1_ = normalize(_e122.xyz);
let _e125 = n1_;
let _e126 = l;
if (dot(_e125, _e126) > 0f) {
let _e129 = n1_;
n1_ = -(_e129);
}
let _e133 = caustic_info.optics[0u];
index = max(_e133, 1f);
let _e135 = l;
let _e136 = n1_;
let _e137 = index;
inside = refract(_e135, _e136, (1f / _e137));
let _e140 = (*uv);
let _e141 = textureSampleLevel(caustic_back_tex, caustic_back_smp, _e140, 0f);
back = _e141;
let _e143 = back[3u];
let _e145 = front[3u];
if (_e143 <= _e145) {
return vec4<f32>(0f, 0f, 0f, 0f);
}
let _e148 = back[3u];
let _e150 = front[3u];
let _e152 = range;
across = ((_e148 - _e150) * _e152);
let _e154 = entry;
let _e155 = inside;
let _e156 = across;
let _e157 = inside;
let _e158 = l;
exit = (_e154 + (_e155 * (_e156 / max(dot(_e157, _e158), 0.2f))));
let _e165 = caustic_info.world_to_map;
let _e166 = exit;
param = (_e165 * vec4<f32>(_e166.x, _e166.y, _e166.z, 1f));
let _e172 = MapUv_u0028_vf4_u003b((¶m));
let _e176 = textureSampleLevel(caustic_back_tex, caustic_back_smp, clamp(_e172, vec2(0f), vec2(1f)), 0f);
there = _e176;
let _e177 = there;
let _e179 = there;
if (dot(_e177.xyz, _e179.xyz) > 0.25f) {
let _e183 = there;
local_1 = normalize(_e183.xyz);
} else {
let _e186 = back;
local_1 = normalize(_e186.xyz);
}
let _e189 = local_1;
n2_ = _e189;
let _e190 = n2_;
let _e191 = inside;
if (dot(_e190, _e191) < 0f) {
let _e194 = n2_;
n2_ = -(_e194);
}
let _e196 = inside;
let _e197 = n2_;
let _e199 = index;
out_ray = refract(_e196, -(_e197), _e199);
let _e201 = out_ray;
let _e202 = out_ray;
if (dot(_e201, _e202) < 0.000001f) {
return vec4<f32>(0f, 0f, 0f, 0f);
}
let _e205 = out_ray;
out_ray = normalize(_e205);
let _e207 = out_ray;
let _e208 = l;
if (dot(_e207, _e208) < 0.3f) {
return vec4<f32>(0f, 0f, 0f, 0f);
}
let _e213 = caustic_info.optics[1u];
f0_1 = _e213;
let _e215 = caustic_info.tint;
let _e217 = l;
let _e218 = n1_;
let _e221 = f0_1;
param_1 = _e221;
param_2 = abs(dot(_e217, _e218));
let _e222 = Schlick_u0028_f1_u003b_f1_u003b((¶m_1), (¶m_2));
let _e225 = out_ray;
let _e226 = n2_;
let _e229 = f0_1;
param_3 = _e229;
param_4 = abs(dot(_e225, _e226));
let _e230 = Schlick_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
(*energy) = ((_e215.xyz * (1f - _e222)) * (1f - _e230));
let _e235 = caustic_info.optics[2u];
fading = _e235;
let _e236 = fading;
if (_e236 > 0f) {
let _e239 = caustic_info.attenuation;
let _e242 = exit;
let _e243 = entry;
let _e246 = fading;
let _e250 = (*energy);
(*energy) = (_e250 * pow(max(_e239.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((length((_e242 - _e243)) / _e246))));
}
let _e252 = exit;
p_1 = _e252;
let _e253 = out_ray;
let _e254 = l;
down = max(dot(_e253, _e254), 0.05f);
k = 0i;
loop {
let _e257 = k;
if (_e257 < 4i) {
let _e260 = caustic_info.world_to_tile;
let _e261 = p_1;
q = (_e260 * vec4<f32>(_e261.x, _e261.y, _e261.z, 1f));
let _e267 = q;
param_5 = _e267;
let _e268 = MapUv_u0028_vf4_u003b((¶m_5));
let _e272 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e268, vec2(0f), vec2(1f)), 0f);
receiver = _e272.x;
let _e274 = receiver;
let _e276 = q[2u];
let _e278 = range;
let _e280 = down;
advance = (((_e274 - _e276) * _e278) / _e280);
let _e282 = k;
if (_e282 == 0i) {
let _e284 = advance;
advance = max(_e284, 0f);
}
let _e286 = out_ray;
let _e287 = advance;
let _e289 = p_1;
p_1 = (_e289 + (_e286 * _e287));
continue;
} else {
break;
}
continuing {
let _e291 = k;
k = (_e291 + 1i);
}
}
let _e294 = caustic_info.world_to_tile;
let _e295 = p_1;
landed = (_e294 * vec4<f32>(_e295.x, _e295.y, _e295.z, 1f));
let _e301 = landed;
param_6 = _e301;
let _e302 = MapUv_u0028_vf4_u003b((¶m_6));
let _e306 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e302, vec2(0f), vec2(1f)), 0f);
under = _e306.x;
let _e308 = under;
let _e310 = landed[2u];
let _e313 = range;
if ((abs((_e308 - _e310)) * _e313) > 0.02f) {
return vec4<f32>(0f, 0f, 0f, 0f);
}
let _e317 = caustic_info.world_to_clip;
let _e318 = p_1;
clip = (_e317 * vec4<f32>(_e318.x, _e318.y, _e318.z, 1f));
let _e324 = clip;
let _e327 = clip[3u];
let _e329 = (_e324.xy / vec2(_e327));
return vec4<f32>(_e329.x, _e329.y, 0f, 1f);
}
fn F3dInstanceIndex_u0028_() -> i32 {
let _e45 = gl_InstanceIndex_1;
return _e45;
}
fn main_1() {
var n: f32;
var id: f32;
var column: f32;
var row: f32;
var uv_1: vec2<f32>;
var texel: f32;
var here: vec4<f32>;
var energy_1: vec3<f32>;
var param_7: vec2<f32>;
var param_8: vec3<f32>;
var spacing_x: vec2<f32>;
var spacing_y: vec2<f32>;
var next_x: vec4<f32>;
var unused: vec3<f32>;
var param_9: vec2<f32>;
var param_10: vec3<f32>;
var a_1: vec2<f32>;
var local_2: vec2<f32>;
var prev_x: vec4<f32>;
var param_11: vec2<f32>;
var param_12: vec3<f32>;
var next_y: vec4<f32>;
var param_13: vec2<f32>;
var param_14: vec3<f32>;
var b: vec2<f32>;
var local_3: vec2<f32>;
var prev_y: vec4<f32>;
var param_15: vec2<f32>;
var param_16: vec3<f32>;
var least_1: f32;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var area: f32;
var share: f32;
let _e83 = corner_1;
v_uv = _e83;
v_color = vec4<f32>(0f, 0f, 0f, 0f);
unnamed.gl_Position = vec4<f32>(4f, 4f, 0.5f, 1f);
let _e87 = caustic_info.grid[0u];
n = _e87;
let _e88 = F3dInstanceIndex_u0028_();
id = f32(_e88);
let _e90 = id;
let _e91 = n;
column = (_e90 - (floor((_e90 / _e91)) * _e91));
let _e96 = id;
let _e97 = n;
row = floor((_e96 / _e97));
let _e100 = column;
let _e102 = n;
let _e104 = row;
let _e106 = n;
uv_1 = vec2<f32>(((_e100 + 0.5f) / _e102), ((_e104 + 0.5f) / _e106));
let _e109 = n;
texel = (1f / _e109);
let _e111 = uv_1;
param_7 = _e111;
let _e112 = Follow_u0028_vf2_u003b_vf3_u003b((¶m_7), (¶m_8));
let _e113 = param_8;
energy_1 = _e113;
here = _e112;
let _e115 = here[3u];
if (_e115 < 0.5f) {
return;
}
let _e119 = caustic_info.grid[2u];
spacing_x = vec2<f32>(_e119, 0f);
let _e123 = caustic_info.grid[3u];
spacing_y = vec2<f32>(0f, _e123);
let _e125 = uv_1;
let _e126 = texel;
param_9 = (_e125 + vec2<f32>(_e126, 0f));
let _e129 = Follow_u0028_vf2_u003b_vf3_u003b((¶m_9), (¶m_10));
let _e130 = param_10;
unused = _e130;
next_x = _e129;
let _e132 = next_x[3u];
if (_e132 > 0.5f) {
let _e134 = next_x;
let _e136 = here;
local_2 = (_e134.xy - _e136.xy);
} else {
let _e139 = spacing_x;
local_2 = _e139;
}
let _e140 = local_2;
a_1 = _e140;
let _e142 = next_x[3u];
if (_e142 < 0.5f) {
let _e144 = uv_1;
let _e145 = texel;
param_11 = (_e144 - vec2<f32>(_e145, 0f));
let _e148 = Follow_u0028_vf2_u003b_vf3_u003b((¶m_11), (¶m_12));
let _e149 = param_12;
unused = _e149;
prev_x = _e148;
let _e151 = prev_x[3u];
if (_e151 > 0.5f) {
let _e153 = here;
let _e155 = prev_x;
a_1 = (_e153.xy - _e155.xy);
}
}
let _e158 = uv_1;
let _e159 = texel;
param_13 = (_e158 + vec2<f32>(0f, _e159));
let _e162 = Follow_u0028_vf2_u003b_vf3_u003b((¶m_13), (¶m_14));
let _e163 = param_14;
unused = _e163;
next_y = _e162;
let _e165 = next_y[3u];
if (_e165 > 0.5f) {
let _e167 = next_y;
let _e169 = here;
local_3 = (_e167.xy - _e169.xy);
} else {
let _e172 = spacing_y;
local_3 = _e172;
}
let _e173 = local_3;
b = _e173;
let _e175 = next_y[3u];
if (_e175 < 0.5f) {
let _e177 = uv_1;
let _e178 = texel;
param_15 = (_e177 - vec2<f32>(0f, _e178));
let _e181 = Follow_u0028_vf2_u003b_vf3_u003b((¶m_15), (¶m_16));
let _e182 = param_16;
unused = _e182;
prev_y = _e181;
let _e184 = prev_y[3u];
if (_e184 > 0.5f) {
let _e186 = here;
let _e188 = prev_y;
b = (_e186.xy - _e188.xy);
}
}
let _e193 = caustic_info.grid[1u];
least_1 = _e193;
let _e194 = a_1;
param_17 = (_e194 * 1.5f);
let _e196 = spacing_x;
param_18 = _e196;
let _e197 = least_1;
param_19 = _e197;
let _e198 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((¶m_17), (¶m_18), (¶m_19));
a_1 = _e198;
let _e199 = b;
param_20 = (_e199 * 1.5f);
let _e201 = spacing_y;
param_21 = _e201;
let _e202 = least_1;
param_22 = _e202;
let _e203 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22));
b = _e203;
let _e205 = a_1[0u];
let _e207 = b[1u];
let _e210 = a_1[1u];
let _e212 = b[0u];
let _e216 = least_1;
let _e217 = least_1;
area = max(abs(((_e205 * _e207) - (_e210 * _e212))), (_e216 * _e217));
let _e220 = here;
let _e223 = corner_1[0u];
let _e224 = a_1;
let _e228 = corner_1[1u];
let _e229 = b;
let _e231 = ((_e220.xy + (_e224 * _e223)) + (_e229 * _e228));
unnamed.gl_Position = vec4<f32>(_e231.x, _e231.y, 0.5f, 1f);
let _e238 = caustic_info.grid[2u];
let _e241 = caustic_info.grid[3u];
share = (_e238 * _e241);
let _e243 = energy_1;
let _e244 = share;
let _e246 = area;
let _e249 = ((_e243 * _e244) / vec3((1.0471976f * _e246)));
v_color = vec4<f32>(_e249.x, _e249.y, _e249.z, 0f);
return;
}
@vertex
fn main(@builtin(instance_index) gl_InstanceIndex: u32, @location(0) corner: vec2<f32>) -> VertexOutput {
gl_InstanceIndex_1 = i32(gl_InstanceIndex);
corner_1 = corner;
main_1();
let _e9 = v_uv;
let _e10 = v_color;
let _e11 = unnamed.gl_Position;
return VertexOutput(_e9, _e10, _e11);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'corner',
location: 0,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'CausticInfo',
group: 0,
binding: 0,
sizeInBytes: 336,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'map_to_world',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'world_to_map',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'world_to_tile',
offsetInBytes: 128,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'world_to_clip',
offsetInBytes: 192,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'grid',
offsetInBytes: 256,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'light',
offsetInBytes: 272,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'optics',
offsetInBytes: 288,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'tint',
offsetInBytes: 304,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'attenuation',
offsetInBytes: 320,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'caustic_back',
group: 0,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'caustic_depth',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'caustic_front',
group: 0,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'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(6) 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(6) member: vec3<f32>,
@location(11) member_1: vec4<f32>,
@location(2) member_2: vec4<f32>,
@location(4) member_3: vec4<f32>,
@location(9) 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: vec3<f32>;
fn main_1() {
let _e19 = corner_ray_1;
v_ray = _e19;
let _e20 = zenith_1;
v_zenith = _e20;
let _e21 = horizon_1;
v_horizon = _e21;
let _e22 = nadir_1;
v_nadir = _e22;
let _e23 = sun_1;
v_sun = _e23;
let _e24 = glow_1;
v_glow = _e24;
let _e25 = disc_1;
v_disc = _e25;
let _e26 = position_1;
unnamed.gl_Position = vec4<f32>(_e26.x, _e26.y, _e26.z, 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: vec3<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.float32x3,
),
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(6) member: vec3<f32>,
@location(10) 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: vec3<f32>;
fn main_1() {
let _e9 = corner_ray_1;
v_ray = _e9;
let _e10 = tint_1;
v_tint = _e10;
let _e11 = position_1;
unnamed.gl_Position = vec4<f32>(_e11.x, _e11.y, _e11.z, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) tint: vec4<f32>, @location(0) position: vec3<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.float32x3,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'tint',
location: 2,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyPhysicalVertex': 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(6) member: vec3<f32>,
@location(7) member_1: vec4<f32>,
@location(3) member_2: vec4<f32>,
@location(9) member_3: vec4<f32>,
@location(5) member_4: vec4<f32>,
@location(8) 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_rayleigh: vec4<f32>;
var<private> rayleigh_1: vec4<f32>;
var<private> v_mie: vec4<f32>;
var<private> mie_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_planet: vec4<f32>;
var<private> planet_1: vec4<f32>;
var<private> v_stars: vec4<f32>;
var<private> stars_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: vec3<f32>;
fn main_1() {
let _e19 = corner_ray_1;
v_ray = _e19;
let _e20 = rayleigh_1;
v_rayleigh = _e20;
let _e21 = mie_1;
v_mie = _e21;
let _e22 = sun_1;
v_sun = _e22;
let _e23 = planet_1;
v_planet = _e23;
let _e24 = stars_1;
v_stars = _e24;
let _e25 = disc_1;
v_disc = _e25;
let _e26 = position_1;
unnamed.gl_Position = vec4<f32>(_e26.x, _e26.y, _e26.z, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) rayleigh: vec4<f32>, @location(3) mie: vec4<f32>, @location(4) sun: vec4<f32>, @location(5) planet: vec4<f32>, @location(6) stars: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
rayleigh_1 = rayleigh;
mie_1 = mie;
sun_1 = sun;
planet_1 = planet;
stars_1 = stars;
disc_1 = disc;
position_1 = position;
main_1();
let _e25 = v_ray;
let _e26 = v_rayleigh;
let _e27 = v_mie;
let _e28 = v_sun;
let _e29 = v_planet;
let _e30 = v_stars;
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.float32x3,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'rayleigh',
location: 2,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'mie',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'sun',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'planet',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'stars',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'disc',
location: 7,
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(7) member: vec3<f32>,
@location(3) member_1: vec3<f32>,
@location(4) member_2: vec4<f32>,
@location(5) member_3: vec2<f32>,
@location(0) member_4: vec4<f32>,
@location(2) member_5: vec2<f32>,
@location(1) member_6: vec4<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> v_instance: vec4<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 _e34 = (*d)[1u];
up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e34) > 0.999f)));
let _e39 = up;
let _e40 = (*d);
return normalize(cross(_e39, _e40));
}
fn MvpRow_u0028_i1_u003b(r: ptr<function, i32>) -> vec4<f32> {
let _e32 = (*r);
let _e36 = frame_info.mvp[0][_e32];
let _e37 = (*r);
let _e41 = frame_info.mvp[1][_e37];
let _e42 = (*r);
let _e46 = frame_info.mvp[2][_e42];
let _e47 = (*r);
let _e51 = frame_info.mvp[3][_e47];
return vec4<f32>(_e36, _e41, _e46, _e51);
}
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 _e54 = tangent_1[3u];
radius = _e54;
let _e55 = position_1;
let _e57 = texcoord_1[0u];
let _e61 = texcoord_1[1u];
let _e65 = radius;
centre = (_e55 - (vec3<f32>(((_e57 * 2f) - 1f), (1f - (_e61 * 2f)), 0f) * _e65));
param = 0i;
let _e68 = MvpRow_u0028_i1_u003b((¶m));
rx = _e68;
param_1 = 1i;
let _e69 = MvpRow_u0028_i1_u003b((¶m_1));
ry = _e69;
param_2 = 2i;
let _e70 = MvpRow_u0028_i1_u003b((¶m_2));
rz = _e70;
param_3 = 3i;
let _e71 = MvpRow_u0028_i1_u003b((¶m_3));
rw = _e71;
let _e72 = ry;
let _e74 = rw;
yw = cross(_e72.xyz, _e74.xyz);
let _e77 = rw;
let _e79 = rx;
wx = cross(_e77.xyz, _e79.xyz);
let _e82 = rx;
let _e84 = ry;
xy = cross(_e82.xyz, _e84.xyz);
let _e87 = rx;
let _e89 = yw;
det = dot(_e87.xyz, _e89);
let _e92 = rx[3u];
let _e93 = yw;
let _e96 = ry[3u];
let _e97 = wx;
let _e101 = rw[3u];
let _e102 = xy;
let _e106 = det;
let _e109 = det;
eye = (-((((_e93 * _e92) + (_e97 * _e96)) + (_e102 * _e101))) / vec3(select(1f, _e109, (abs(_e106) > 0.00000000000000000001f))));
let _e113 = det;
if (abs(_e113) > 0.00000000000000000001f) {
let _e116 = eye;
let _e117 = centre;
local = (_e116 - _e117);
} else {
let _e119 = rz;
local = -(_e119.xyz);
}
let _e122 = local;
toEye = _e122;
let _e123 = toEye;
let _e124 = toEye;
let _e127 = toEye;
let _e128 = normal_1;
d_1 = normalize(select(_e128, _e127, vec3((dot(_e123, _e124) > 0.00000000000000000001f))));
let _e132 = d_1;
param_4 = _e132;
let _e133 = ImpostorRight_u0028_vf3_u003b((¶m_4));
right = _e133;
let _e134 = d_1;
let _e135 = right;
up_1 = cross(_e134, _e135);
let _e137 = centre;
let _e138 = right;
let _e140 = texcoord_1[0u];
let _e144 = up_1;
let _e146 = texcoord_1[1u];
let _e151 = radius;
corner = (_e137 + (((_e138 * ((_e140 * 2f) - 1f)) + (_e144 * (1f - (_e146 * 2f)))) * _e151));
let _e155 = frame_info.model;
let _e156 = corner;
v_world_position = (_e155 * vec4<f32>(_e156.x, _e156.y, _e156.z, 1f)).xyz;
let _e164 = frame_info.normal_matrix;
let _e172 = d_1;
v_normal = normalize((mat3x3<f32>(_e164[0].xyz, _e164[1].xyz, _e164[2].xyz) * _e172));
let _e176 = frame_info.model;
let _e184 = right;
let _e186 = normalize((mat3x3<f32>(_e176[0].xyz, _e176[1].xyz, _e176[2].xyz) * _e184));
v_tangent = vec4<f32>(_e186.x, _e186.y, _e186.z, 1f);
let _e191 = texcoord_1;
v_texcoord = _e191;
let _e192 = d_1;
let _e194 = color_1[3u];
v_color = vec4<f32>(_e192.x, _e192.y, _e192.z, _e194);
v_lightmap_uv = vec2<f32>(0f, 0f);
v_instance = vec4<f32>(0f, 0f, 0f, 0f);
let _e200 = frame_info.mvp;
let _e201 = corner;
unnamed.gl_Position = (_e200 * vec4<f32>(_e201.x, _e201.y, _e201.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 _e19 = v_world_position;
let _e20 = v_normal;
let _e21 = v_tangent;
let _e22 = v_texcoord;
let _e23 = v_color;
let _e24 = v_lightmap_uv;
let _e25 = v_instance;
let _e26 = unnamed.gl_Position;
return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25, _e26);
}
''',
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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> gl_FragCoord_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e131 = v_world_position_1;
let _e133 = fog_info.eye;
let _e137 = fog_info.forward;
return dot((_e131 - _e133.xyz), _e137.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e136 = ViewDepth_u0028_();
z = abs(_e136);
let _e138 = z;
near = (_e138 / 5f);
let _e140 = z;
far = (_e140 / 200f);
let _e142 = far;
let _e143 = far;
let _e145 = far;
far3_ = ((_e142 * _e143) * _e145);
let _e147 = (*alpha);
let _e148 = near;
let _e149 = near;
let _e152 = far3_;
let _e153 = far3_;
return (_e147 * clamp((10f / ((0.00001f + (_e148 * _e149)) + (_e152 * _e153))), 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 _e140 = fog_info.forward[3u];
mode = _e140;
let _e141 = mode;
if (_e141 > 0.5f) {
let _e144 = frag_color[3u];
alpha_1 = _e144;
let _e145 = alpha_1;
param = _e145;
let _e146 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e146;
let _e147 = frag_color;
let _e149 = weight;
let _e150 = (_e147.xyz * _e149);
let _e151 = alpha_1;
let _e152 = weight;
accumulate = vec4<f32>(_e150.x, _e150.y, _e150.z, (_e151 * _e152));
let _e158 = mode;
let _e160 = mode;
revealage = ((_e158 > 1.5f) && (_e160 < 2.5f));
let _e163 = revealage;
if _e163 {
let _e164 = alpha_1;
local = vec4(_e164);
} else {
let _e166 = accumulate;
local = _e166;
}
let _e167 = local;
frag_color = _e167;
let _e168 = mode;
if (_e168 > 2.5f) {
let _e170 = alpha_1;
frag_surface = vec4(_e170);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e134 = (*n)[0u];
let _e137 = (*n)[1u];
let _e141 = (*n)[2u];
let _e144 = (*n);
(*n) = (_e144 / vec3(((abs(_e134) + abs(_e137)) + abs(_e141))));
let _e147 = (*n);
e = _e147.xy;
let _e150 = (*n)[2u];
if (_e150 < 0f) {
let _e152 = (*n);
let _e158 = (*n)[0u];
let _e162 = (*n)[1u];
e = ((vec2(1f) - abs(_e152.yx)) * vec2<f32>(select(-1f, 1f, (_e158 >= 0f)), select(-1f, 1f, (_e162 >= 0f))));
}
let _e167 = e;
return ((_e167 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e132 = (*linear);
let _e134 = (*linear);
let _e138 = (*linear);
return mix((_e132 * 12.92f), ((pow(_e134, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e138));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e135 = g_albedo;
param_1 = clamp(_e135, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e137 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e137.x, _e137.y, _e137.z, 1f);
let _e142 = g_debug_surface_on;
if _e142 {
let _e143 = g_debug_surface;
let _e144 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e143.x, _e143.y, _e143.z, _e144);
return;
}
let _e149 = v_normal_1;
geometric = normalize(_e149);
let _e151 = gl_FrontFacing_1;
if !(_e151) {
let _e153 = geometric;
geometric = -(_e153);
}
let _e155 = geometric;
param_2 = _e155;
let _e156 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e157 = (*roughness);
let _e159 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e156.x, _e156.y, clamp(_e157, 0f, 1f), _e159);
return;
}
fn Orthographic_u0028_() -> bool {
let _e133 = fog_info.projection[0u];
return (_e133 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e132 = Orthographic_u0028_();
if _e132 {
let _e133 = ViewDepth_u0028_();
local_1 = max(_e133, 0f);
} else {
let _e135 = v_world_position_1;
let _e137 = fog_info.eye;
local_1 = distance(_e135, _e137.xyz);
}
let _e140 = local_1;
return _e140;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e139 = fog_info.fog[3u];
density = _e139;
let _e140 = density;
if (_e140 <= 0f) {
let _e142 = (*color);
return _e142;
}
let _e143 = EyeDistance_u0028_();
d = _e143;
let _e146 = fog_info.eye[3u];
falloff = _e146;
let _e147 = falloff;
if (_e147 > 0f) {
let _e149 = falloff;
let _e151 = v_world_position_1[1u];
let _e154 = fog_info.eye[1u];
k = (_e149 * (_e151 - _e154));
let _e157 = k;
if (abs(_e157) > 0.001f) {
let _e160 = k;
let _e164 = k;
local_2 = ((1f - exp(-(_e160))) / _e164);
} else {
let _e166 = k;
local_2 = (1f - (0.5f * _e166));
}
let _e169 = local_2;
let _e170 = density;
density = (_e170 * _e169);
}
let _e173 = fog_info.fog;
let _e175 = (*color);
let _e176 = density;
let _e178 = d;
return mix(_e173.xyz, _e175, vec3(clamp(exp((-(_e176) * _e178)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var weight_1: f32;
var param_3: vec3<f32>;
var param_4: f32;
let _e137 = g_premultiply;
let _e138 = (*alpha_2);
weight_1 = select(1f, _e138, _e137);
let _e140 = (*linearColor);
param_3 = _e140;
let _e141 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e142 = weight_1;
let _e143 = (_e141 * _e142);
let _e144 = (*alpha_2);
let _e145 = g_pass_through;
frag_color = vec4<f32>(_e143.x, _e143.y, _e143.z, (_e144 * (1f - _e145)));
let _e152 = (*roughness_1);
param_4 = _e152;
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 _e136 = (*linearColor_1);
param_5 = _e136;
let _e137 = (*alpha_3);
param_6 = _e137;
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 _e132 = (*srgb);
let _e135 = (*srgb);
let _e140 = (*srgb);
return mix((_e132 / vec3(12.92f)), pow(((_e135 + 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), _e140));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e134 = (*key);
hue = fract(((_e134 * 0.618034f) + 0.13f));
let _e138 = hue;
k_1 = clamp((abs(((fract((vec3(_e138) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e151 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e151, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_710_: bool;
let _e132 = (*c);
let _e133 = (*c);
let _e135 = any((_e132 != _e133));
phi_710_ = _e135;
if !(_e135) {
let _e137 = (*c);
phi_710_ = any((abs(_e137) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e142 = phi_710_;
return _e142;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var grey: f32;
var param_10: vec3<f32>;
var param_11: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_12: vec3<f32>;
var key_1: f32;
var param_13: f32;
var srgb_1: vec3<f32>;
var param_14: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_15: vec3<f32>;
var param_16: f32;
var phi_803_: bool;
var phi_1074_: bool;
let _e174 = gl_FragCoord_1[0u];
let _e177 = frag_info.debug_view[1u];
if (_e174 < _e177) {
let _e181 = frag_info.debug_view[2u];
local_3 = _e181;
} else {
let _e184 = frag_info.debug_view[0u];
local_3 = _e184;
}
let _e185 = local_3;
view = _e185;
let _e186 = view;
if (_e186 < 0.5f) {
return false;
}
let _e188 = view;
code = i32((_e188 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e191 = v_normal_1;
geometric_n = normalize(_e191);
let _e193 = v_tangent_1;
let _e195 = geometric_n;
let _e196 = geometric_n;
let _e197 = v_tangent_1;
tangent = (_e193.xyz - (_e195 * dot(_e196, _e197.xyz)));
let _e202 = tangent;
let _e203 = tangent;
let _e205 = (dot(_e202, _e203) > 0.000000000001f);
phi_803_ = _e205;
if _e205 {
let _e207 = v_tangent_1[3u];
phi_803_ = (abs((abs(_e207) - 1f)) < 0.01f);
}
let _e213 = phi_803_;
tangent_usable = _e213;
let _e216 = frag_info.debug_view[3u];
identity = _e216;
let _e217 = identity;
identity_object = floor((_e217 / 8192f));
let _e220 = identity;
let _e221 = identity_object;
identity_rest = (_e220 - (_e221 * 8192f));
let _e224 = identity_rest;
identity_material = floor((_e224 / 2f));
let _e227 = identity_rest;
let _e228 = identity_material;
normal_mapped = ((_e227 - (_e228 * 2f)) > 0.5f);
let _e232 = code;
if (_e232 == 1i) {
let _e235 = (*s).albedo;
param_8 = clamp(_e235, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e237 = LinearToSrgb_u0028_vf3_u003b((¶m_8));
shown = _e237;
} else {
let _e238 = code;
if (_e238 == 2i) {
let _e241 = (*s).n;
shown = ((_e241 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e244 = code;
if (_e244 == 3i) {
let _e247 = (*s).roughness;
shown = vec3(clamp(_e247, 0f, 1f));
} else {
let _e250 = code;
if (_e250 == 4i) {
let _e253 = (*s).metallic;
shown = vec3(clamp(_e253, 0f, 1f));
} else {
let _e256 = code;
if (_e256 == 5i) {
let _e259 = (*s).occlusion;
shown = vec3(clamp(_e259, 0f, 1f));
} else {
let _e262 = code;
if (_e262 == 6i) {
let _e265 = (*s).emissive;
param_9 = clamp(_e265, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e267 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e267;
} else {
let _e268 = code;
if (_e268 == 7i) {
let _e270 = v_texcoord_1;
let _e271 = fract(_e270);
shown = vec3<f32>(_e271.x, _e271.y, 0f);
} else {
let _e275 = code;
if (_e275 == 8i) {
let _e277 = (*lit);
param_10 = clamp(_e277, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e279 = LinearToSrgb_u0028_vf3_u003b((¶m_10));
grey = dot(_e279, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e281 = (*lit);
param_11 = _e281;
let _e282 = NonFinite_u0028_vf3_u003b((¶m_11));
if _e282 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e283 = grey;
local_4 = vec3((_e283 * 0.5f));
}
let _e286 = local_4;
shown = _e286;
} else {
let _e287 = code;
if (_e287 == 9i) {
let _e289 = tangent_usable;
if _e289 {
let _e290 = tangent;
local_5 = ((normalize(_e290) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e294 = local_5;
shown = _e294;
} else {
let _e295 = code;
if (_e295 == 10i) {
let _e297 = v_texcoord_1;
uv = _e297;
let _e298 = uv;
cell = floor((_e298 * 8f));
let _e302 = cell[0u];
let _e304 = cell[1u];
odd = (fract(((_e302 + _e304) * 0.5f)) * 2f);
let _e309 = uv;
within = fract(_e309);
let _e311 = odd;
let _e315 = within[0u];
let _e319 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e311)) * vec3<f32>((0.55f + (0.45f * _e315)), (0.55f + (0.45f * _e319)), 0.85f));
} else {
let _e324 = code;
if (_e324 == 11i) {
let _e326 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e326));
} else {
let _e329 = code;
if (_e329 == 12i) {
let _e331 = v_color_1;
param_12 = clamp(_e331.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e334 = LinearToSrgb_u0028_vf3_u003b((¶m_12));
shown = _e334;
} else {
let _e335 = code;
let _e337 = code;
if ((_e335 == 13i) || (_e337 == 14i)) {
let _e340 = code;
let _e342 = identity_object;
let _e343 = identity_material;
key_1 = select(_e343, _e342, (_e340 == 13i));
let _e345 = key_1;
param_13 = _e345;
let _e346 = DebugIdentityColour_u0028_f1_u003b((¶m_13));
let _e348 = (*s).n_dot_v;
shown = (_e346 * (0.55f + (0.45f * _e348)));
} else {
let _e352 = code;
if (_e352 == 15i) {
let _e355 = (*s).albedo;
param_14 = clamp(_e355, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e357 = LinearToSrgb_u0028_vf3_u003b((¶m_14));
srgb_1 = _e357;
let _e358 = srgb_1;
luma = dot(_e358, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e361 = (*s).metallic;
metal = (_e361 > 0.5f);
let _e363 = metal;
let _e365 = luma;
if (!(_e363) && (_e365 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e368 = metal;
let _e369 = !(_e368);
phi_1074_ = _e369;
if _e369 {
let _e371 = srgb_1[0u];
let _e373 = srgb_1[1u];
let _e375 = srgb_1[2u];
phi_1074_ = (max(_e371, max(_e373, _e375)) > 0.9411765f);
}
let _e380 = phi_1074_;
if _e380 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e381 = metal;
let _e382 = luma;
if (_e381 && (_e382 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e385 = luma;
local_8 = vec3(_e385);
}
let _e387 = local_8;
local_7 = _e387;
}
let _e388 = local_7;
local_6 = _e388;
}
let _e389 = local_6;
shown = _e389;
} else {
let _e390 = code;
if (_e390 == 16i) {
let _e393 = (*s).metallic;
m = _e393;
let _e394 = m;
let _e396 = m;
if ((_e394 > 0.05f) && (_e396 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e399 = m;
local_9 = vec3(select(0.15f, 1f, (_e399 > 0.5f)));
}
let _e403 = local_9;
shown = _e403;
} else {
let _e404 = code;
if (_e404 == 17i) {
let _e406 = normal_mapped;
if !(_e406) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e408 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e408));
}
let _e411 = local_10;
shown = _e411;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e412 = g_premultiply;
if _e412 {
let _e414 = (*s).alpha;
local_11 = _e414;
} else {
local_11 = 1f;
}
let _e415 = local_11;
weight_2 = _e415;
let _e416 = shown;
param_15 = _e416;
let _e417 = SrgbToLinear_u0028_vf3_u003b((¶m_15));
let _e418 = weight_2;
let _e419 = (_e417 * _e418);
let _e421 = (*s).alpha;
frag_color = vec4<f32>(_e419.x, _e419.y, _e419.z, _e421);
let _e427 = (*s).roughness;
param_16 = _e427;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_16));
WriteWeightedBlended_u0028_();
return true;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_12: vec3<f32>;
let _e132 = Orthographic_u0028_();
if _e132 {
let _e134 = fog_info.forward;
local_12 = -(_e134.xyz);
} else {
let _e138 = fog_info.eye;
let _e140 = v_world_position_1;
local_12 = normalize((_e138.xyz - _e140));
}
let _e143 = local_12;
return _e143;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin: vec3<f32>;
var cell_1: vec3<f32>;
var p3_: vec3<f32>;
let _e137 = (*cutoff);
key_2 = (-2f - _e137);
let _e139 = key_2;
let _e142 = key_2;
let _e144 = floor((_e142 / 128f));
let _e149 = key_2;
origin = vec3<f32>(floor((_e139 / 16384f)), (_e144 - (floor((_e144 / 128f)) * 128f)), (_e149 - (floor((_e149 / 128f)) * 128f)));
let _e155 = (*scenePosition);
let _e158 = origin;
let _e159 = (floor((_e155 * 16f)) + _e158);
let _e160 = vec3(128f);
cell_1 = (_e159 - (floor((_e159 / _e160)) * _e160));
let _e165 = cell_1;
p3_ = fract((_e165 * 0.1031f));
let _e168 = p3_;
let _e169 = p3_;
let _e174 = p3_;
p3_ = (_e174 + vec3(dot(_e168, (_e169.zyx + vec3(31.32f)))));
let _e178 = p3_[0u];
let _e180 = p3_[1u];
let _e183 = p3_[2u];
return fract(((_e178 + _e180) * _e183));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e133 = frag_info.target_origin[1u];
return _e133;
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s_1: Surface;
var param_17: vec3<f32>;
var param_18: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_19: vec3<f32>;
var param_20: f32;
let _e139 = v_texcoord_1;
let _e140 = MaterialLodBias_u0028_();
let _e141 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e139, _e140);
texel = _e141;
let _e142 = texel;
param_17 = _e142.xyz;
let _e144 = SrgbToLinear_u0028_vf3_u003b((¶m_17));
let _e146 = frag_info.base_color;
param_18 = _e146.xyz;
let _e148 = SrgbToLinear_u0028_vf3_u003b((¶m_18));
let _e150 = v_color_1;
s_1.albedo = ((_e144 * _e148) * _e150.xyz);
let _e155 = texel[3u];
let _e158 = frag_info.base_color[3u];
let _e161 = v_color_1[3u];
s_1.alpha = ((_e155 * _e158) * _e161);
let _e165 = s_1.albedo;
g_albedo = _e165;
let _e168 = frag_info.material2_[0u];
cutoff_1 = _e168;
let _e169 = cutoff_1;
if (_e169 > 1f) {
let _e171 = cutoff_1;
edge = (_e171 - 1f);
let _e174 = s_1.alpha;
let _e175 = edge;
let _e178 = s_1.alpha;
let _e179 = fwidth(_e178);
s_1.alpha = clamp((((_e174 - _e175) / max(_e179, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e185 = cutoff_1;
if (_e185 >= 0f) {
let _e188 = s_1.alpha;
let _e189 = cutoff_1;
if (_e188 < _e189) {
discard;
}
s_1.alpha = 1f;
} else {
let _e192 = cutoff_1;
if (_e192 < -1.5f) {
let _e195 = s_1.alpha;
let _e196 = v_world_position_1;
param_19 = _e196;
let _e197 = cutoff_1;
param_20 = _e197;
let _e198 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_19), (¶m_20));
if (_e195 < _e198) {
discard;
}
}
}
}
let _e200 = cutoff_1;
let _e202 = cutoff_1;
g_premultiply = ((_e200 < 0f) && (_e202 > -0.75f));
let _e205 = v_normal_1;
s_1.n = normalize(_e205);
let _e208 = gl_FrontFacing_1;
if !(_e208) {
let _e211 = s_1.n;
s_1.n = -(_e211);
}
let _e214 = TowardsEye_u0028_();
s_1.v = _e214;
let _e217 = s_1.n;
let _e219 = s_1.v;
s_1.n_dot_v = max(dot(_e217, _e219), 0.0001f);
let _e225 = frag_info.material[0u];
s_1.metallic = clamp(_e225, 0f, 1f);
let _e230 = frag_info.material[1u];
s_1.roughness = clamp(_e230, 0.02f, 1f);
let _e234 = frag_info.ambient_ground;
let _e237 = frag_info.ambient_sky;
let _e241 = s_1.n[1u];
let _e248 = frag_info.material[2u];
s_1.ambient = (mix(_e234.xyz, _e237.xyz, vec3(((_e241 * 0.5f) + 0.5f))) * _e248);
let _e253 = frag_info.frame_params[0u];
s_1.exposure = max(_e253, 0f);
s_1.occlusion = 1f;
s_1.emissive = vec3<f32>(0f, 0f, 0f);
let _e258 = s_1;
return _e258;
}
fn main_1() {
var s_2: Surface;
var param_21: Surface;
var param_22: vec3<f32>;
var param_23: vec3<f32>;
var param_24: 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_pass_through = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e136 = ReadSurface_u0028_();
s_2 = _e136;
g_albedo = vec3<f32>(0f, 0f, 0f);
let _e137 = s_2;
param_21 = _e137;
let _e139 = s_2.albedo;
param_22 = _e139;
let _e140 = WriteDebugView_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_vf3_u003b((¶m_21), (¶m_22));
if _e140 {
return;
}
let _e142 = s_2.albedo;
param_23 = _e142;
let _e144 = s_2.alpha;
param_24 = _e144;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_23), (¶m_24));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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;
gl_FragCoord_1 = gl_FragCoord;
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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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 _e71 = v_world_position_1;
let _e73 = fog_info.eye;
let _e77 = fog_info.forward;
return dot((_e71 - _e73.xyz), _e77.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e76 = ViewDepth_u0028_();
z = abs(_e76);
let _e78 = z;
near = (_e78 / 5f);
let _e80 = z;
far = (_e80 / 200f);
let _e82 = far;
let _e83 = far;
let _e85 = far;
far3_ = ((_e82 * _e83) * _e85);
let _e87 = (*alpha);
let _e88 = near;
let _e89 = near;
let _e92 = far3_;
let _e93 = far3_;
return (_e87 * clamp((10f / ((0.00001f + (_e88 * _e89)) + (_e92 * _e93))), 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 _e80 = fog_info.forward[3u];
mode = _e80;
let _e81 = mode;
if (_e81 > 0.5f) {
let _e84 = frag_color[3u];
alpha_1 = _e84;
let _e85 = alpha_1;
param = _e85;
let _e86 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e86;
let _e87 = frag_color;
let _e89 = weight;
let _e90 = (_e87.xyz * _e89);
let _e91 = alpha_1;
let _e92 = weight;
accumulate = vec4<f32>(_e90.x, _e90.y, _e90.z, (_e91 * _e92));
let _e98 = mode;
let _e100 = mode;
revealage = ((_e98 > 1.5f) && (_e100 < 2.5f));
let _e103 = revealage;
if _e103 {
let _e104 = alpha_1;
local = vec4(_e104);
} else {
let _e106 = accumulate;
local = _e106;
}
let _e107 = local;
frag_color = _e107;
}
return;
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
return;
}
fn Orthographic_u0028_() -> bool {
let _e73 = fog_info.projection[0u];
return (_e73 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e72 = Orthographic_u0028_();
if _e72 {
let _e73 = ViewDepth_u0028_();
local_1 = max(_e73, 0f);
} else {
let _e75 = v_world_position_1;
let _e77 = fog_info.eye;
local_1 = distance(_e75, _e77.xyz);
}
let _e80 = local_1;
return _e80;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e79 = fog_info.fog[3u];
density = _e79;
let _e80 = density;
if (_e80 <= 0f) {
let _e82 = (*color);
return _e82;
}
let _e83 = EyeDistance_u0028_();
d = _e83;
let _e86 = fog_info.eye[3u];
falloff = _e86;
let _e87 = falloff;
if (_e87 > 0f) {
let _e89 = falloff;
let _e91 = v_world_position_1[1u];
let _e94 = fog_info.eye[1u];
k = (_e89 * (_e91 - _e94));
let _e97 = k;
if (abs(_e97) > 0.001f) {
let _e100 = k;
let _e104 = k;
local_2 = ((1f - exp(-(_e100))) / _e104);
} else {
let _e106 = k;
local_2 = (1f - (0.5f * _e106));
}
let _e109 = local_2;
let _e110 = density;
density = (_e110 * _e109);
}
let _e113 = fog_info.fog;
let _e115 = (*color);
let _e116 = density;
let _e118 = d;
return mix(_e113.xyz, _e115, vec3(clamp(exp((-(_e116) * _e118)), 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 _e77 = g_premultiply;
let _e78 = (*alpha_2);
weight_1 = select(1f, _e78, _e77);
let _e80 = (*linearColor);
param_1 = _e80;
let _e81 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e82 = weight_1;
let _e83 = (_e81 * _e82);
let _e84 = (*alpha_2);
let _e85 = g_pass_through;
frag_color = vec4<f32>(_e83.x, _e83.y, _e83.z, (_e84 * (1f - _e85)));
let _e92 = (*roughness_1);
param_2 = _e92;
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 _e76 = (*linearColor_1);
param_3 = _e76;
let _e77 = (*alpha_3);
param_4 = _e77;
param_5 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_3), (¶m_4), (¶m_5));
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_3: vec3<f32>;
let _e72 = Orthographic_u0028_();
if _e72 {
let _e74 = fog_info.forward;
local_3 = -(_e74.xyz);
} else {
let _e78 = fog_info.eye;
let _e80 = v_world_position_1;
local_3 = normalize((_e78.xyz - _e80));
}
let _e83 = local_3;
return _e83;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key: f32;
var origin: vec3<f32>;
var cell: vec3<f32>;
var p3_: vec3<f32>;
let _e77 = (*cutoff);
key = (-2f - _e77);
let _e79 = key;
let _e82 = key;
let _e84 = floor((_e82 / 128f));
let _e89 = key;
origin = vec3<f32>(floor((_e79 / 16384f)), (_e84 - (floor((_e84 / 128f)) * 128f)), (_e89 - (floor((_e89 / 128f)) * 128f)));
let _e95 = (*scenePosition);
let _e98 = origin;
let _e99 = (floor((_e95 * 16f)) + _e98);
let _e100 = vec3(128f);
cell = (_e99 - (floor((_e99 / _e100)) * _e100));
let _e105 = cell;
p3_ = fract((_e105 * 0.1031f));
let _e108 = p3_;
let _e109 = p3_;
let _e114 = p3_;
p3_ = (_e114 + vec3(dot(_e108, (_e109.zyx + vec3(31.32f)))));
let _e118 = p3_[0u];
let _e120 = p3_[1u];
let _e123 = p3_[2u];
return fract(((_e118 + _e120) * _e123));
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e72 = (*srgb);
let _e75 = (*srgb);
let _e80 = (*srgb);
return mix((_e72 / vec3(12.92f)), pow(((_e75 + 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), _e80));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e73 = frag_info.target_origin[1u];
return _e73;
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_8: vec3<f32>;
var param_9: f32;
let _e79 = v_texcoord_1;
let _e80 = MaterialLodBias_u0028_();
let _e81 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e79, _e80);
texel = _e81;
let _e82 = texel;
param_6 = _e82.xyz;
let _e84 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e86 = frag_info.base_color;
param_7 = _e86.xyz;
let _e88 = SrgbToLinear_u0028_vf3_u003b((¶m_7));
let _e90 = v_color_1;
s.albedo = ((_e84 * _e88) * _e90.xyz);
let _e95 = texel[3u];
let _e98 = frag_info.base_color[3u];
let _e101 = v_color_1[3u];
s.alpha = ((_e95 * _e98) * _e101);
let _e105 = s.albedo;
g_albedo = _e105;
let _e108 = frag_info.material2_[0u];
cutoff_1 = _e108;
let _e109 = cutoff_1;
if (_e109 > 1f) {
let _e111 = cutoff_1;
edge = (_e111 - 1f);
let _e114 = s.alpha;
let _e115 = edge;
let _e118 = s.alpha;
let _e119 = fwidth(_e118);
s.alpha = clamp((((_e114 - _e115) / max(_e119, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e125 = cutoff_1;
if (_e125 >= 0f) {
let _e128 = s.alpha;
let _e129 = cutoff_1;
if (_e128 < _e129) {
discard;
}
s.alpha = 1f;
} else {
let _e132 = cutoff_1;
if (_e132 < -1.5f) {
let _e135 = s.alpha;
let _e136 = v_world_position_1;
param_8 = _e136;
let _e137 = cutoff_1;
param_9 = _e137;
let _e138 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
if (_e135 < _e138) {
discard;
}
}
}
}
let _e140 = cutoff_1;
let _e142 = cutoff_1;
g_premultiply = ((_e140 < 0f) && (_e142 > -0.75f));
let _e145 = v_normal_1;
s.n = normalize(_e145);
let _e148 = gl_FrontFacing_1;
if !(_e148) {
let _e151 = s.n;
s.n = -(_e151);
}
let _e154 = TowardsEye_u0028_();
s.v = _e154;
let _e157 = s.n;
let _e159 = s.v;
s.n_dot_v = max(dot(_e157, _e159), 0.0001f);
let _e165 = frag_info.material[0u];
s.metallic = clamp(_e165, 0f, 1f);
let _e170 = frag_info.material[1u];
s.roughness = clamp(_e170, 0.02f, 1f);
let _e174 = frag_info.ambient_ground;
let _e177 = frag_info.ambient_sky;
let _e181 = s.n[1u];
let _e188 = frag_info.material[2u];
s.ambient = (mix(_e174.xyz, _e177.xyz, vec3(((_e181 * 0.5f) + 0.5f))) * _e188);
let _e193 = frag_info.frame_params[0u];
s.exposure = max(_e193, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e198 = s;
return _e198;
}
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;
g_pass_through = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e74 = ReadSurface_u0028_();
s_1 = _e74;
let _e76 = s_1.albedo;
param_10 = _e76;
let _e78 = s_1.alpha;
param_11 = _e78;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_10), (¶m_11));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'PlanarReflection': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: vec4<f32>,
}
struct PlanarReflectionInfo {
view: vec4<f32>,
params: vec4<f32>,
tint: 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_pass_through: f32;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> planar_info: PlanarReflectionInfo;
@group(1) @binding(2)
var reflection_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var reflection_texture_smp: sampler;
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 ViewDepth_u0028_() -> f32 {
let _e33 = v_world_position_1;
let _e35 = fog_info.eye;
let _e39 = fog_info.forward;
return dot((_e33 - _e35.xyz), _e39.xyz);
}
fn Orthographic_u0028_() -> bool {
let _e35 = fog_info.projection[0u];
return (_e35 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local: f32;
let _e34 = Orthographic_u0028_();
if _e34 {
let _e35 = ViewDepth_u0028_();
local = max(_e35, 0f);
} else {
let _e37 = v_world_position_1;
let _e39 = fog_info.eye;
local = distance(_e37, _e39.xyz);
}
let _e42 = local;
return _e42;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_1: f32;
let _e41 = fog_info.fog[3u];
density = _e41;
let _e42 = density;
if (_e42 <= 0f) {
let _e44 = (*color);
return _e44;
}
let _e45 = EyeDistance_u0028_();
d = _e45;
let _e48 = fog_info.eye[3u];
falloff = _e48;
let _e49 = falloff;
if (_e49 > 0f) {
let _e51 = falloff;
let _e53 = v_world_position_1[1u];
let _e56 = fog_info.eye[1u];
k = (_e51 * (_e53 - _e56));
let _e59 = k;
if (abs(_e59) > 0.001f) {
let _e62 = k;
let _e66 = k;
local_1 = ((1f - exp(-(_e62))) / _e66);
} else {
let _e68 = k;
local_1 = (1f - (0.5f * _e68));
}
let _e71 = local_1;
let _e72 = density;
density = (_e72 * _e71);
}
let _e75 = fog_info.fog;
let _e77 = (*color);
let _e78 = density;
let _e80 = d;
return mix(_e75.xyz, _e77, vec3(clamp(exp((-(_e78) * _e80)), 0f, 1f)));
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_2: vec3<f32>;
let _e34 = Orthographic_u0028_();
if _e34 {
let _e36 = fog_info.forward;
local_2 = -(_e36.xyz);
} else {
let _e40 = fog_info.eye;
let _e42 = v_world_position_1;
local_2 = normalize((_e40.xyz - _e42));
}
let _e45 = local_2;
return _e45;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_3: vec2<f32>;
let _e35 = (*rows);
if (_e35 > 0f) {
let _e38 = gl_FragCoord_1[0u];
let _e39 = (*rows);
let _e41 = gl_FragCoord_1[1u];
local_3 = vec2<f32>(_e38, (_e39 - _e41));
} else {
let _e44 = gl_FragCoord_1;
local_3 = _e44.xy;
}
let _e46 = local_3;
return _e46;
}
fn main_1() {
var rows_1: f32;
var pixel: vec2<f32>;
var param: f32;
var uv: vec2<f32>;
var reflected: vec3<f32>;
var n: vec3<f32>;
var v: vec3<f32>;
var cosine: f32;
var f0_: f32;
var grazing: f32;
var grazing2_: f32;
var fresnel: f32;
var alpha: f32;
var param_1: vec3<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_pass_through = 0f;
let _e49 = planar_info.params[2u];
rows_1 = _e49;
let _e50 = rows_1;
param = _e50;
let _e51 = FragCoordFromTop_u0028_f1_u003b((¶m));
pixel = _e51;
let _e52 = pixel;
let _e54 = planar_info.view;
let _e58 = planar_info.view;
uv = ((_e52 - _e54.xy) / _e58.zw);
let _e61 = rows_1;
if (_e61 > 0f) {
let _e64 = uv[1u];
uv[1u] = (1f - _e64);
}
let _e67 = uv;
let _e68 = textureSampleLevel(reflection_texture_tex, reflection_texture_smp, _e67, 0f);
let _e71 = planar_info.tint;
reflected = (_e68.xyz * _e71.xyz);
let _e74 = v_normal_1;
n = normalize(_e74);
let _e76 = gl_FrontFacing_1;
if !(_e76) {
let _e78 = n;
n = -(_e78);
}
let _e80 = TowardsEye_u0028_();
v = _e80;
let _e81 = n;
let _e82 = v;
cosine = clamp(dot(_e81, _e82), 0f, 1f);
let _e87 = planar_info.params[0u];
f0_ = _e87;
let _e88 = cosine;
grazing = (1f - _e88);
let _e90 = grazing;
let _e91 = grazing;
grazing2_ = (_e90 * _e91);
let _e93 = f0_;
let _e94 = f0_;
let _e96 = grazing2_;
let _e98 = grazing2_;
let _e100 = grazing;
fresnel = (_e93 + ((((1f - _e94) * _e96) * _e98) * _e100));
let _e103 = fresnel;
let _e106 = planar_info.params[1u];
alpha = clamp((_e103 * _e106), 0f, 1f);
let _e109 = reflected;
param_1 = _e109;
let _e110 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e111 = alpha;
let _e112 = (_e110 * _e111);
let _e113 = alpha;
frag_color = vec4<f32>(_e112.x, _e112.y, _e112.z, _e113);
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
gl_FragCoord_1 = gl_FragCoord;
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_color;
return _e17;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'PlanarReflectionInfo',
group: 1,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'view', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'tint', offsetInBytes: 32, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'reflection_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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e216 = v_world_position_1;
let _e218 = fog_info.eye;
let _e222 = fog_info.forward;
return dot((_e216 - _e218.xyz), _e222.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e221 = ViewDepth_u0028_();
z = abs(_e221);
let _e223 = z;
near = (_e223 / 5f);
let _e225 = z;
far = (_e225 / 200f);
let _e227 = far;
let _e228 = far;
let _e230 = far;
far3_ = ((_e227 * _e228) * _e230);
let _e232 = (*alpha);
let _e233 = near;
let _e234 = near;
let _e237 = far3_;
let _e238 = far3_;
return (_e232 * clamp((10f / ((0.00001f + (_e233 * _e234)) + (_e237 * _e238))), 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 _e225 = fog_info.forward[3u];
mode = _e225;
let _e226 = mode;
if (_e226 > 0.5f) {
let _e229 = frag_color[3u];
alpha_1 = _e229;
let _e230 = alpha_1;
param = _e230;
let _e231 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e231;
let _e232 = frag_color;
let _e234 = weight;
let _e235 = (_e232.xyz * _e234);
let _e236 = alpha_1;
let _e237 = weight;
accumulate = vec4<f32>(_e235.x, _e235.y, _e235.z, (_e236 * _e237));
let _e243 = mode;
let _e245 = mode;
revealage = ((_e243 > 1.5f) && (_e245 < 2.5f));
let _e248 = revealage;
if _e248 {
let _e249 = alpha_1;
local = vec4(_e249);
} else {
let _e251 = accumulate;
local = _e251;
}
let _e252 = local;
frag_color = _e252;
let _e253 = mode;
if (_e253 > 2.5f) {
let _e255 = alpha_1;
frag_surface = vec4(_e255);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e219 = (*n)[0u];
let _e222 = (*n)[1u];
let _e226 = (*n)[2u];
let _e229 = (*n);
(*n) = (_e229 / vec3(((abs(_e219) + abs(_e222)) + abs(_e226))));
let _e232 = (*n);
e = _e232.xy;
let _e235 = (*n)[2u];
if (_e235 < 0f) {
let _e237 = (*n);
let _e243 = (*n)[0u];
let _e247 = (*n)[1u];
e = ((vec2(1f) - abs(_e237.yx)) * vec2<f32>(select(-1f, 1f, (_e243 >= 0f)), select(-1f, 1f, (_e247 >= 0f))));
}
let _e252 = e;
return ((_e252 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e217 = (*linear);
let _e219 = (*linear);
let _e223 = (*linear);
return mix((_e217 * 12.92f), ((pow(_e219, 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), _e223));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e220 = g_albedo;
param_1 = clamp(_e220, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e222 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e222.x, _e222.y, _e222.z, 1f);
let _e227 = g_debug_surface_on;
if _e227 {
let _e228 = g_debug_surface;
let _e229 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e228.x, _e228.y, _e228.z, _e229);
return;
}
let _e234 = v_normal_1;
geometric = normalize(_e234);
let _e236 = gl_FrontFacing_1;
if !(_e236) {
let _e238 = geometric;
geometric = -(_e238);
}
let _e240 = geometric;
param_2 = _e240;
let _e241 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e242 = (*roughness);
let _e244 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e241.x, _e241.y, clamp(_e242, 0f, 1f), _e244);
return;
}
fn Orthographic_u0028_() -> bool {
let _e218 = fog_info.projection[0u];
return (_e218 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e217 = Orthographic_u0028_();
if _e217 {
let _e218 = ViewDepth_u0028_();
local_1 = max(_e218, 0f);
} else {
let _e220 = v_world_position_1;
let _e222 = fog_info.eye;
local_1 = distance(_e220, _e222.xyz);
}
let _e225 = local_1;
return _e225;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e224 = fog_info.fog[3u];
density = _e224;
let _e225 = density;
if (_e225 <= 0f) {
let _e227 = (*color);
return _e227;
}
let _e228 = EyeDistance_u0028_();
d = _e228;
let _e231 = fog_info.eye[3u];
falloff = _e231;
let _e232 = falloff;
if (_e232 > 0f) {
let _e234 = falloff;
let _e236 = v_world_position_1[1u];
let _e239 = fog_info.eye[1u];
k = (_e234 * (_e236 - _e239));
let _e242 = k;
if (abs(_e242) > 0.001f) {
let _e245 = k;
let _e249 = k;
local_2 = ((1f - exp(-(_e245))) / _e249);
} else {
let _e251 = k;
local_2 = (1f - (0.5f * _e251));
}
let _e254 = local_2;
let _e255 = density;
density = (_e255 * _e254);
}
let _e258 = fog_info.fog;
let _e260 = (*color);
let _e261 = density;
let _e263 = d;
return mix(_e258.xyz, _e260, vec3(clamp(exp((-(_e261) * _e263)), 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 _e222 = g_premultiply;
let _e223 = (*alpha_2);
weight_1 = select(1f, _e223, _e222);
let _e225 = (*linearColor);
param_3 = _e225;
let _e226 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e227 = weight_1;
let _e228 = (_e226 * _e227);
let _e229 = (*alpha_2);
let _e230 = g_pass_through;
frag_color = vec4<f32>(_e228.x, _e228.y, _e228.z, (_e229 * (1f - _e230)));
let _e237 = (*roughness_1);
param_4 = _e237;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e217 = (*srgb);
let _e220 = (*srgb);
let _e225 = (*srgb);
return mix((_e217 / vec3(12.92f)), pow(((_e220 + 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), _e225));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e219 = (*key);
hue = fract(((_e219 * 0.618034f) + 0.13f));
let _e223 = hue;
k_1 = clamp((abs(((fract((vec3(_e223) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e236 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e236, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2636_: bool;
let _e217 = (*c);
let _e218 = (*c);
let _e220 = any((_e217 != _e218));
phi_2636_ = _e220;
if !(_e220) {
let _e222 = (*c);
phi_2636_ = any((abs(_e222) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e227 = phi_2636_;
return _e227;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2726_: bool;
var phi_2994_: bool;
let _e259 = gl_FragCoord_1[0u];
let _e262 = frag_info.debug_view[1u];
if (_e259 < _e262) {
let _e266 = frag_info.debug_view[2u];
local_3 = _e266;
} else {
let _e269 = frag_info.debug_view[0u];
local_3 = _e269;
}
let _e270 = local_3;
view = _e270;
let _e271 = view;
if (_e271 < 0.5f) {
return false;
}
let _e273 = view;
code = i32((_e273 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e276 = v_normal_1;
geometric_n = normalize(_e276);
let _e278 = v_tangent_1;
let _e280 = geometric_n;
let _e281 = geometric_n;
let _e282 = v_tangent_1;
tangent = (_e278.xyz - (_e280 * dot(_e281, _e282.xyz)));
let _e287 = tangent;
let _e288 = tangent;
let _e290 = (dot(_e287, _e288) > 0.000000000001f);
phi_2726_ = _e290;
if _e290 {
let _e292 = v_tangent_1[3u];
phi_2726_ = (abs((abs(_e292) - 1f)) < 0.01f);
}
let _e298 = phi_2726_;
tangent_usable = _e298;
let _e301 = frag_info.debug_view[3u];
identity = _e301;
let _e302 = identity;
identity_object = floor((_e302 / 8192f));
let _e305 = identity;
let _e306 = identity_object;
identity_rest = (_e305 - (_e306 * 8192f));
let _e309 = identity_rest;
identity_material = floor((_e309 / 2f));
let _e312 = identity_rest;
let _e313 = identity_material;
normal_mapped = ((_e312 - (_e313 * 2f)) > 0.5f);
let _e317 = code;
if (_e317 == 1i) {
let _e320 = (*s).albedo;
param_5 = clamp(_e320, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e322 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e322;
} else {
let _e323 = code;
if (_e323 == 2i) {
let _e326 = (*s).n;
shown = ((_e326 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e329 = code;
if (_e329 == 3i) {
let _e332 = (*s).roughness;
shown = vec3(clamp(_e332, 0f, 1f));
} else {
let _e335 = code;
if (_e335 == 4i) {
let _e338 = (*s).metallic;
shown = vec3(clamp(_e338, 0f, 1f));
} else {
let _e341 = code;
if (_e341 == 5i) {
let _e344 = (*s).occlusion;
shown = vec3(clamp(_e344, 0f, 1f));
} else {
let _e347 = code;
if (_e347 == 6i) {
let _e350 = (*s).emissive;
param_6 = clamp(_e350, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e352 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e352;
} else {
let _e353 = code;
if (_e353 == 7i) {
let _e355 = v_texcoord_1;
let _e356 = fract(_e355);
shown = vec3<f32>(_e356.x, _e356.y, 0f);
} else {
let _e360 = code;
if (_e360 == 8i) {
let _e362 = (*lit);
param_7 = clamp(_e362, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e364 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e364, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e366 = (*lit);
param_8 = _e366;
let _e367 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e367 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e368 = grey;
local_4 = vec3((_e368 * 0.5f));
}
let _e371 = local_4;
shown = _e371;
} else {
let _e372 = code;
if (_e372 == 9i) {
let _e374 = tangent_usable;
if _e374 {
let _e375 = tangent;
local_5 = ((normalize(_e375) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e379 = local_5;
shown = _e379;
} else {
let _e380 = code;
if (_e380 == 10i) {
let _e382 = v_texcoord_1;
uv = _e382;
let _e383 = uv;
cell = floor((_e383 * 8f));
let _e387 = cell[0u];
let _e389 = cell[1u];
odd = (fract(((_e387 + _e389) * 0.5f)) * 2f);
let _e394 = uv;
within = fract(_e394);
let _e396 = odd;
let _e400 = within[0u];
let _e404 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e396)) * vec3<f32>((0.55f + (0.45f * _e400)), (0.55f + (0.45f * _e404)), 0.85f));
} else {
let _e409 = code;
if (_e409 == 11i) {
let _e411 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e411));
} else {
let _e414 = code;
if (_e414 == 12i) {
let _e416 = v_color_1;
param_9 = clamp(_e416.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e419 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e419;
} else {
let _e420 = code;
let _e422 = code;
if ((_e420 == 13i) || (_e422 == 14i)) {
let _e425 = code;
let _e427 = identity_object;
let _e428 = identity_material;
key_1 = select(_e428, _e427, (_e425 == 13i));
let _e430 = key_1;
param_10 = _e430;
let _e431 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e433 = (*s).n_dot_v;
shown = (_e431 * (0.55f + (0.45f * _e433)));
} else {
let _e437 = code;
if (_e437 == 15i) {
let _e440 = (*s).albedo;
param_11 = clamp(_e440, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e442 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e442;
let _e443 = srgb_1;
luma = dot(_e443, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e446 = (*s).metallic;
metal = (_e446 > 0.5f);
let _e448 = metal;
let _e450 = luma;
if (!(_e448) && (_e450 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e453 = metal;
let _e454 = !(_e453);
phi_2994_ = _e454;
if _e454 {
let _e456 = srgb_1[0u];
let _e458 = srgb_1[1u];
let _e460 = srgb_1[2u];
phi_2994_ = (max(_e456, max(_e458, _e460)) > 0.9411765f);
}
let _e465 = phi_2994_;
if _e465 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e466 = metal;
let _e467 = luma;
if (_e466 && (_e467 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e470 = luma;
local_8 = vec3(_e470);
}
let _e472 = local_8;
local_7 = _e472;
}
let _e473 = local_7;
local_6 = _e473;
}
let _e474 = local_6;
shown = _e474;
} else {
let _e475 = code;
if (_e475 == 16i) {
let _e478 = (*s).metallic;
m = _e478;
let _e479 = m;
let _e481 = m;
if ((_e479 > 0.05f) && (_e481 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e484 = m;
local_9 = vec3(select(0.15f, 1f, (_e484 > 0.5f)));
}
let _e488 = local_9;
shown = _e488;
} else {
let _e489 = code;
if (_e489 == 17i) {
let _e491 = normal_mapped;
if !(_e491) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e493 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e493));
}
let _e496 = local_10;
shown = _e496;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e497 = g_premultiply;
if _e497 {
let _e499 = (*s).alpha;
local_11 = _e499;
} else {
local_11 = 1f;
}
let _e500 = local_11;
weight_2 = _e500;
let _e501 = shown;
param_12 = _e501;
let _e502 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e503 = weight_2;
let _e504 = (_e502 * _e503);
let _e506 = (*s).alpha;
frag_color = vec4<f32>(_e504.x, _e504.y, _e504.z, _e506);
let _e512 = (*s).roughness;
param_13 = _e512;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e219 = (*s_1).albedo;
return _e219;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e217 = (*i);
if (_e217 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e219 = (*i);
if (_e219 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e221 = (*i);
if (_e221 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e223 = (*i);
if (_e223 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e225 = (*i);
if (_e225 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e227 = (*i);
if (_e227 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e229 = (*i);
if (_e229 == 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_14: i32;
let _e222 = (*i_1);
param_14 = _e222;
let _e223 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e223;
let _e225 = p[0u];
let _e226 = (*ca);
let _e229 = p[1u];
let _e230 = (*sa);
let _e234 = p[0u];
let _e235 = (*sa);
let _e238 = p[1u];
let _e239 = (*ca);
let _e243 = (*radius);
return (vec2<f32>(((_e225 * _e226) - (_e229 * _e230)), ((_e234 * _e235) + (_e238 * _e239))) * _e243);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e225 = point_shadow.params[0u];
inset = _e225;
let _e226 = (*uv_1);
let _e227 = (*offset);
let _e229 = inset;
let _e230 = inset;
local_12 = clamp((_e226 + _e227), vec2(_e229), vec2((1f - _e230)));
let _e235 = local_12;
let _e236 = (*tile);
atlas = ((_e235 + _e236) * vec2<f32>(0.16666667f, 0.16666667f));
let _e241 = point_shadow.params3_[0u];
if (_e241 > 0.5f) {
let _e244 = atlas[1u];
atlas[1u] = (1f - _e244);
}
let _e247 = atlas;
let _e248 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e247, 0f);
let _e250 = atlas;
let _e251 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e250, 0f);
let _e254 = (*range);
return (min(_e248.x, _e251.x) * _e254);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e226 = (*uv_2);
param_15 = _e226;
let _e227 = (*offset_1);
param_16 = _e227;
let _e228 = (*tile_1);
param_17 = _e228;
let _e229 = (*range_1);
param_18 = _e229;
let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e230;
let _e231 = stored;
let _e232 = (*range_1);
if (_e231 >= (_e232 * 0.999f)) {
return 1f;
}
let _e235 = (*receiver);
let _e236 = stored;
return select(1f, 0f, (_e235 > _e236));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e247 = point_shadow.params2_[1u];
lightRadius = _e247;
let _e250 = point_shadow.params2_[0u];
minRadius = _e250;
let _e253 = point_shadow.params2_[2u];
maxRadius = _e253;
let _e254 = lightRadius;
if (_e254 <= 0f) {
let _e256 = (*uv_3);
param_19 = _e256;
param_20 = vec2<f32>(0f, 0f);
let _e257 = (*tile_2);
param_21 = _e257;
let _e258 = (*range_2);
param_22 = _e258;
let _e259 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e259;
let _e260 = minRadius;
return _e260;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e261 = i_2;
if (_e261 < 8i) {
let _e263 = i_2;
param_23 = _e263;
let _e264 = (*ca_1);
param_24 = _e264;
let _e265 = (*sa_1);
param_25 = _e265;
let _e266 = maxRadius;
param_26 = _e266;
let _e267 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e268 = (*uv_3);
param_27 = _e268;
param_28 = _e267;
let _e269 = (*tile_2);
param_29 = _e269;
let _e270 = (*range_2);
param_30 = _e270;
let _e271 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e271;
let _e272 = stored_1;
let _e273 = (*range_2);
if (_e272 >= (_e273 * 0.999f)) {
continue;
}
let _e276 = stored_1;
let _e277 = (*receiver_1);
if (_e276 >= _e277) {
continue;
}
let _e279 = stored_1;
let _e280 = sum;
sum = (_e280 + _e279);
let _e282 = count;
count = (_e282 + 1f);
continue;
} else {
break;
}
continuing {
let _e284 = i_2;
i_2 = (_e284 + 1i);
}
}
let _e286 = count;
if (_e286 < 0.5f) {
return -1f;
}
let _e288 = sum;
let _e289 = count;
blocker = max((_e288 / _e289), 0.0001f);
let _e292 = blocker;
(*blockerOut) = _e292;
let _e293 = lightRadius;
let _e294 = (*receiver_1);
let _e295 = blocker;
let _e299 = blocker;
world = ((_e293 * max((_e294 - _e295), 0f)) / _e299);
let _e301 = world;
let _e302 = (*receiver_1);
let _e304 = (*tanHalf);
let _e307 = minRadius;
let _e308 = maxRadius;
return clamp((_e301 / ((2f * _e302) * _e304)), _e307, _e308);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e218 = (*rows);
if (_e218 > 0f) {
let _e221 = gl_FragCoord_1[0u];
let _e222 = (*rows);
let _e224 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e221, (_e222 - _e224));
} else {
let _e227 = gl_FragCoord_1;
local_13 = _e227.xy;
}
let _e229 = local_13;
return _e229;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2323_: bool;
var phi_2384_: bool;
let _e270 = (*lightIndex);
let _e274 = point_shadow.slots[_e270][0u];
slot = i32((_e274 + 0.5f));
let _e277 = (*lightIndex);
let _e281 = point_shadow.slots[_e277][0u];
if (_e281 < 0f) {
return 1f;
}
let _e285 = point_shadow.params[2u];
strength = _e285;
let _e286 = strength;
if (_e286 <= 0f) {
return 1f;
}
let _e288 = slot;
let _e291 = point_shadow.lights[_e288];
let _e293 = (*world_1);
toLight = (_e291.xyz - _e293);
let _e295 = toLight;
toLightLength = max(length(_e295), 0.000001f);
let _e298 = (*normal);
let _e299 = toLight;
let _e300 = toLightLength;
nDotL = max(dot(_e298, (_e299 / vec3(_e300))), 0.15f);
let _e305 = nDotL;
let _e306 = nDotL;
let _e311 = nDotL;
let _e312 = nDotL;
slope = min((sqrt(max((1f - (_e305 * _e306)), 0f)) / (_e311 * _e312)), 8f);
let _e316 = toLightLength;
let _e318 = (*lightIndex);
let _e322 = point_shadow.slots[_e318][2u];
let _e327 = point_shadow.params3_[1u];
texel = (((2f * _e316) * max(_e322, 0.0001f)) * _e327);
let _e329 = (*world_1);
let _e330 = (*normal);
let _e331 = texel;
let _e335 = point_shadow.params[3u];
let _e337 = slope;
origin = (_e329 + (((_e330 * _e331) * _e335) * (1f + _e337)));
let _e341 = origin;
let _e342 = slot;
let _e345 = point_shadow.lights[_e342];
toFragment = (_e341 - _e345.xyz);
let _e348 = toFragment;
distance_ = length(_e348);
let _e350 = slot;
let _e354 = point_shadow.lights[_e350][3u];
range_3 = max(_e354, 0.0001f);
let _e356 = distance_;
let _e357 = range_3;
if (_e356 >= _e357) {
return 1f;
}
face = 0i;
let _e359 = (*lightIndex);
let _e363 = point_shadow.slots[_e359][1u];
if (_e363 < 0.5f) {
let _e365 = toFragment;
a = abs(_e365);
let _e368 = a[0u];
let _e370 = a[1u];
let _e371 = (_e368 >= _e370);
phi_2323_ = _e371;
if _e371 {
let _e373 = a[0u];
let _e375 = a[2u];
phi_2323_ = (_e373 >= _e375);
}
let _e378 = phi_2323_;
if _e378 {
let _e380 = toFragment[0u];
face = select(1i, 0i, (_e380 > 0f));
} else {
let _e384 = a[1u];
let _e386 = a[2u];
if (_e384 >= _e386) {
let _e389 = toFragment[1u];
face = select(3i, 2i, (_e389 > 0f));
} else {
let _e393 = toFragment[2u];
face = select(5i, 4i, (_e393 > 0f));
}
}
}
let _e396 = slot;
let _e398 = face;
let _e402 = point_shadow.faces[((_e396 * 6i) + _e398)];
let _e403 = origin;
clip = (_e402 * vec4<f32>(_e403.x, _e403.y, _e403.z, 1f));
let _e410 = clip[3u];
if (_e410 <= 0f) {
return 1f;
}
let _e412 = clip;
let _e415 = clip[3u];
ndc = (_e412.xy / vec2(_e415));
let _e419 = ndc[0u];
let _e421 = (abs(_e419) > 1f);
phi_2384_ = _e421;
if !(_e421) {
let _e424 = ndc[1u];
phi_2384_ = (abs(_e424) > 1f);
}
let _e428 = phi_2384_;
if _e428 {
return 1f;
}
let _e430 = ndc[0u];
let _e434 = ndc[1u];
uv_4 = vec2<f32>(((_e430 * 0.5f) + 0.5f), (0.5f - (_e434 * 0.5f)));
let _e438 = face;
let _e440 = slot;
tile_3 = vec2<f32>(f32(_e438), f32(_e440));
let _e443 = distance_;
let _e446 = point_shadow.params[1u];
receiver_2 = (_e443 - _e446);
let _e450 = frag_info.target_origin[0u];
param_31 = _e450;
let _e451 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e451, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e456 = noise;
angle = (_e456 * 6.2831855f);
let _e458 = angle;
ca_2 = cos(_e458);
let _e460 = angle;
sa_2 = sin(_e460);
let _e462 = (*lightIndex);
let _e466 = point_shadow.slots[_e462][2u];
tanHalf_1 = max(_e466, 0.0001f);
blocker_1 = -1f;
let _e468 = uv_4;
param_32 = _e468;
let _e469 = tile_3;
param_33 = _e469;
let _e470 = range_3;
param_34 = _e470;
let _e471 = receiver_2;
param_35 = _e471;
let _e472 = ca_2;
param_36 = _e472;
let _e473 = sa_2;
param_37 = _e473;
let _e474 = tanHalf_1;
param_38 = _e474;
let _e475 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e476 = param_39;
blocker_1 = _e476;
radius_1 = _e475;
let _e479 = point_shadow.params2_[3u];
if (_e479 > 0.5f) {
g_debug_surface_on = true;
let _e481 = radius_1;
if (_e481 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e483 = radius_1;
let _e486 = point_shadow.params2_[2u];
let _e490 = blocker_1;
let _e491 = range_3;
local_14 = vec3<f32>(clamp((_e483 / max(_e486, 0.000001f)), 0f, 1f), clamp((_e490 / _e491), 0f, 1f), 0f);
}
let _e495 = local_14;
g_debug_surface = _e495;
}
let _e496 = radius_1;
if (_e496 < 0f) {
return 1f;
}
let _e498 = uv_4;
param_40 = _e498;
param_41 = vec2<f32>(0f, 0f);
let _e499 = tile_3;
param_42 = _e499;
let _e500 = range_3;
param_43 = _e500;
let _e501 = receiver_2;
param_44 = _e501;
let _e502 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e502;
let _e503 = radius_1;
if (_e503 > 0f) {
i_3 = 0i;
loop {
let _e505 = i_3;
if (_e505 < 8i) {
let _e507 = i_3;
param_45 = _e507;
let _e508 = ca_2;
param_46 = _e508;
let _e509 = sa_2;
param_47 = _e509;
let _e510 = radius_1;
param_48 = _e510;
let _e511 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e512 = uv_4;
param_49 = _e512;
param_50 = _e511;
let _e513 = tile_3;
param_51 = _e513;
let _e514 = range_3;
param_52 = _e514;
let _e515 = receiver_2;
param_53 = _e515;
let _e516 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e517 = lit_1;
lit_1 = (_e517 + _e516);
continue;
} else {
break;
}
continuing {
let _e519 = i_3;
i_3 = (_e519 + 1i);
}
}
let _e521 = lit_1;
lit_1 = (_e521 * 0.11111111f);
}
let _e523 = lit_1;
let _e524 = strength;
return mix(1f, _e523, clamp(_e524, 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 _e221 = (*i_4);
let _e224 = (*n_1);
r = sqrt(((f32(_e221) + 0.5f) / f32(_e224)));
let _e228 = (*i_4);
let _e231 = (*turn);
theta = ((f32(_e228) * 2.3999631f) + _e231);
let _e233 = r;
let _e234 = theta;
let _e236 = theta;
return (vec2<f32>(cos(_e234), sin(_e236)) * _e233);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e220 = frag_info.target_origin[0u];
param_54 = _e220;
let _e221 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e224 = frag_info.target_origin[3u];
at = (_e221 + vec2((5.588238f * max(_e224, 0f))));
let _e229 = at;
return fract((52.982918f * fract(dot(_e229, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e219 = (*mode_1);
if (_e219 > 0.5f) {
let _e221 = (*stored_2);
local_15 = (1f - _e221);
} else {
let _e223 = (*stored_2);
local_15 = _e223;
}
let _e224 = local_15;
return _e224;
}
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 _e225 = (*moments)[1u];
let _e227 = (*moments)[0u];
let _e229 = (*moments)[0u];
let _e232 = (*minVariance);
variance = max((_e225 - (_e227 * _e229)), _e232);
let _e234 = (*t);
let _e236 = (*moments)[0u];
d_1 = (_e234 - _e236);
let _e238 = variance;
let _e239 = variance;
let _e240 = d_1;
let _e241 = d_1;
pMax = (_e238 / (_e239 + (_e240 * _e241)));
let _e245 = pMax;
let _e246 = (*bleed);
let _e248 = (*bleed);
reduced = clamp(((_e245 - _e246) / max((1f - _e248), 0.0001f)), 0f, 1f);
let _e253 = (*t);
let _e255 = (*moments)[0u];
let _e257 = reduced;
return select(_e257, 1f, (_e253 <= _e255));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e218 = (*depth);
d_2 = ((2f * clamp(_e218, 0f, 1f)) - 1f);
let _e222 = d_2;
let _e225 = d_2;
return vec2<f32>(exp((40f * _e222)), -(exp((-5f * _e225))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e232 = (*depth_1);
param_55 = _e232;
let _e233 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e233;
let _e234 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e234);
let _e237 = scale[0u];
let _e239 = scale[0u];
let _e241 = (*moments_1);
param_56 = _e241.xy;
let _e244 = warped[0u];
param_57 = _e244;
param_58 = (_e237 * _e239);
let _e245 = (*bleed_1);
param_59 = _e245;
let _e246 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e246;
let _e248 = scale[1u];
let _e250 = scale[1u];
let _e252 = (*moments_1);
param_60 = _e252.zw;
let _e255 = warped[1u];
param_61 = _e255;
param_62 = (_e248 * _e250);
let _e256 = (*bleed_1);
param_63 = _e256;
let _e257 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e257;
let _e258 = positive;
let _e259 = negative;
return min(_e258, _e259);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e218 = (*depth_2);
stored_3 = max((1f - _e218), 0.000061035156f);
let _e221 = stored_3;
return exp2((floor(log2(_e221)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3909_: bool;
var phi_3920_: bool;
var phi_4077_: bool;
var phi_4084_: bool;
var phi_4091_: bool;
let _e295 = frag_info.shadow_params[3u];
strength_1 = _e295;
let _e296 = strength_1;
if (_e296 <= 0f) {
return 1f;
}
let _e298 = (*lightIndex_1);
let _e301 = frag_info.frame_params[2u];
if (_e298 != i32(floor((_e301 + 0.5f)))) {
return 1f;
}
let _e308 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e308 + 0.5f));
let _e311 = Orthographic_u0028_();
if _e311 {
let _e312 = ViewDepth_u0028_();
local_16 = _e312;
} else {
let _e313 = v_world_position_1;
let _e315 = frag_info.camera_position;
local_16 = length((_e313 - _e315.xyz));
}
let _e319 = local_16;
viewDistance = _e319;
cascade = 0i;
let _e320 = cascadeCount;
let _e321 = (_e320 > 1i);
phi_3909_ = _e321;
if _e321 {
let _e322 = viewDistance;
let _e325 = frag_info.shadow_cascades[0u];
phi_3909_ = (_e322 > _e325);
}
let _e328 = phi_3909_;
if _e328 {
cascade = 1i;
}
let _e329 = cascadeCount;
let _e330 = (_e329 > 2i);
phi_3920_ = _e330;
if _e330 {
let _e331 = viewDistance;
let _e334 = frag_info.shadow_cascades[1u];
phi_3920_ = (_e331 > _e334);
}
let _e337 = phi_3920_;
if _e337 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e338 = attempt;
if (_e338 < 3i) {
let _e340 = cascade;
let _e341 = attempt;
which = (_e340 + _e341);
let _e343 = which;
let _e344 = cascadeCount;
if (_e343 >= _e344) {
break;
}
let _e346 = which;
if (_e346 == 0i) {
let _e349 = frag_info.shadow_matrix;
local_17 = _e349;
} else {
let _e350 = which;
if (_e350 == 1i) {
let _e353 = frag_info.shadow_matrix_far;
local_18 = _e353;
} else {
let _e355 = frag_info.shadow_matrix_farthest;
local_18 = _e355;
}
let _e356 = local_18;
local_17 = _e356;
}
let _e357 = local_17;
matrix = _e357;
let _e360 = matrix[0][0u];
let _e363 = matrix[1][0u];
let _e366 = matrix[2][0u];
axisX = vec3<f32>(_e360, _e363, _e366);
let _e370 = matrix[0][1u];
let _e373 = matrix[1][1u];
let _e376 = matrix[2][1u];
axisY = vec3<f32>(_e370, _e373, _e376);
let _e378 = axisX;
rowX = max(length(_e378), 0.000001f);
let _e381 = axisY;
rowY = max(length(_e381), 0.000001f);
let _e386 = frag_info.shadow_cascades[3u];
let _e388 = rowX;
texelMetres = ((2f * _e386) / _e388);
let _e392 = frag_info.shadow_cascades[3u];
let _e395 = (*s_2).n;
let _e396 = axisX;
let _e399 = rowX;
let _e400 = rowX;
let _e404 = (*s_2).n;
let _e405 = axisY;
let _e408 = rowY;
let _e409 = rowY;
reach = ((3f * _e392) * ((abs(dot(_e395, _e396)) / (_e399 * _e400)) + (abs(dot(_e404, _e405)) / (_e408 * _e409))));
let _e416 = frag_info.shadow_params[2u];
let _e417 = texelMetres;
flatOffset = min(_e416, _e417);
let _e419 = v_world_position_1;
let _e421 = (*s_2).n;
let _e422 = flatOffset;
let _e423 = reach;
origin_1 = (_e419 + (_e421 * (_e422 + _e423)));
let _e427 = matrix;
let _e428 = origin_1;
lightSpace = (_e427 * vec4<f32>(_e428.x, _e428.y, _e428.z, 1f));
let _e435 = lightSpace[3u];
if (_e435 <= 0f) {
continue;
}
let _e437 = lightSpace;
let _e440 = lightSpace[3u];
candidate = (_e437.xyz / vec3(_e440));
let _e444 = candidate[0u];
let _e448 = candidate[1u];
inTile = vec2<f32>(((_e444 * 0.5f) + 0.5f), (0.5f - (_e448 * 0.5f)));
let _e453 = inTile[0u];
let _e454 = (_e453 < 0f);
phi_4077_ = _e454;
if !(_e454) {
let _e457 = inTile[0u];
phi_4077_ = (_e457 > 1f);
}
let _e460 = phi_4077_;
phi_4084_ = _e460;
if !(_e460) {
let _e463 = inTile[1u];
phi_4084_ = (_e463 < 0f);
}
let _e466 = phi_4084_;
phi_4091_ = _e466;
if !(_e466) {
let _e469 = inTile[1u];
phi_4091_ = (_e469 > 1f);
}
let _e472 = phi_4091_;
if _e472 {
continue;
}
let _e474 = candidate[2u];
if (_e474 > 1f) {
let _e476 = which;
let _e477 = cascadeCount;
if (_e476 < (_e477 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e482 = inTile[0u];
let _e483 = which;
let _e486 = cascadeCount;
let _e490 = inTile[1u];
uv_5 = vec2<f32>(((_e482 + f32(_e483)) / f32(_e486)), _e490);
let _e492 = candidate;
projected = _e492;
let _e493 = which;
cascade = _e493;
let _e494 = texelMetres;
cascadeTexel = _e494;
let _e497 = matrix[0][2u];
let _e500 = matrix[1][2u];
let _e503 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e497, _e500, _e503)), 0.000001f));
let _e509 = (*s_2).n;
let _e512 = matrix[0][2u];
let _e515 = matrix[1][2u];
let _e518 = matrix[2][2u];
let _e522 = cascadeDepth;
cosSlope = clamp((abs(dot(_e509, vec3<f32>(_e512, _e515, _e518))) * _e522), 0.1f, 1f);
let _e525 = texelMetres;
let _e526 = cosSlope;
let _e527 = cosSlope;
let _e533 = cosSlope;
let _e535 = cascadeDepth;
receiverSlope = (((_e525 * sqrt(max((1f - (_e526 * _e527)), 0f))) / _e533) / _e535);
found = true;
break;
} else {
break;
}
continuing {
let _e537 = attempt;
attempt = (_e537 + 1i);
}
}
let _e539 = found;
if !(_e539) {
return 1f;
}
let _e541 = cascade;
if (_e541 == 0i) {
let _e545 = frag_info.shadow_bias[0u];
local_19 = _e545;
} else {
let _e546 = cascade;
if (_e546 == 1i) {
let _e550 = frag_info.shadow_bias[1u];
local_20 = _e550;
} else {
let _e553 = frag_info.shadow_bias[2u];
local_20 = _e553;
}
let _e554 = local_20;
local_19 = _e554;
}
let _e555 = local_19;
bias = _e555;
let _e558 = frag_info.shadow_params[1u];
storage_ = _e558;
let _e559 = storage_;
let _e561 = storage_;
if ((_e559 > 0.5f) && (_e561 < 1.5f)) {
let _e564 = bias;
let _e566 = projected[2u];
param_64 = _e566;
let _e567 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e564, _e567);
}
let _e571 = frag_info.shadow_params[0u];
let _e574 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e571, _e574);
let _e576 = cascade;
let _e578 = cascadeCount;
let _e582 = texel_1;
tileLo = (vec2<f32>((f32(_e576) / f32(_e578)), 0f) + (_e582 * 0.5f));
let _e585 = cascade;
let _e588 = cascadeCount;
let _e592 = texel_1;
tileHi = (vec2<f32>((f32((_e585 + 1i)) / f32(_e588)), 1f) - (_e592 * 0.5f));
let _e597 = frag_info.shadow_bias[3u];
if (_e597 > 0.5f) {
let _e599 = uv_5;
let _e600 = tileLo;
let _e601 = tileHi;
let _e603 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e599, _e600, _e601), 0f);
stored_4 = _e603;
let _e605 = stored_4[1u];
let _e608 = stored_4[2u];
let _e611 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e605), (1f - _e608), _e611), vec3(0f), vec3(4f));
let _e616 = through;
let _e617 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e616, vec3(clamp(_e617, 0f, 1f)));
}
let _e623 = frag_info.ambient_ground[3u];
softness = _e623;
lit_2 = 0f;
let _e624 = softness;
if (_e624 < 0f) {
let _e626 = uv_5;
let _e627 = tileLo;
let _e628 = tileHi;
let _e630 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e626, _e627, _e628), 0f);
moments_2 = _e630;
let _e632 = projected[2u];
let _e633 = bias;
let _e635 = softness;
let _e639 = moments_2;
param_65 = _e639;
param_66 = (_e632 - _e633);
param_67 = clamp((-(_e635) - 1f), 0f, 0.95f);
let _e640 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e640;
} else {
let _e641 = softness;
if (_e641 <= 0f) {
y = -1i;
loop {
let _e643 = y;
if (_e643 <= 1i) {
x = -1i;
loop {
let _e645 = x;
if (_e645 <= 1i) {
let _e647 = uv_5;
let _e648 = x;
let _e650 = y;
let _e653 = texel_1;
let _e656 = tileLo;
let _e657 = tileHi;
let _e659 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e647 + (vec2<f32>(f32(_e648), f32(_e650)) * _e653)), _e656, _e657), 0f);
param_68 = _e659.x;
let _e661 = storage_;
param_69 = _e661;
let _e662 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e662;
let _e664 = projected[2u];
let _e665 = bias;
let _e667 = occluder;
let _e670 = lit_2;
lit_2 = (_e670 + select(1f, 0f, ((_e664 - _e665) > _e667)));
continue;
} else {
break;
}
continuing {
let _e672 = x;
x = (_e672 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e674 = y;
y = (_e674 + 1i);
}
}
let _e676 = lit_2;
lit_2 = (_e676 * 0.11111111f);
} else {
let _e678 = softness;
spread = tan(min(_e678, 0.5f));
let _e681 = ShadowNoise_u0028_();
turn_1 = (_e681 * 6.2831855f);
let _e683 = spread;
let _e685 = projected[2u];
let _e687 = cascadeDepth;
let _e689 = cascadeTexel;
searchRadius = clamp((((_e683 * _e685) * _e687) / _e689), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e692 = i_5;
if (_e692 < 16i) {
let _e694 = i_5;
param_70 = _e694;
param_71 = 16i;
let _e695 = turn_1;
param_72 = _e695;
let _e696 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e696;
let _e697 = bias;
let _e698 = disc;
let _e700 = searchRadius;
let _e704 = receiverSlope;
tapBias = (_e697 + (max(((length(_e698) * _e700) - 1.5f), 0f) * _e704));
let _e707 = uv_5;
let _e708 = disc;
let _e709 = texel_1;
let _e711 = searchRadius;
let _e714 = tileLo;
let _e715 = tileHi;
let _e717 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e707 + ((_e708 * _e709) * _e711)), _e714, _e715), 0f);
param_73 = _e717.x;
let _e719 = storage_;
param_74 = _e719;
let _e720 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e720;
let _e722 = projected[2u];
let _e723 = tapBias;
let _e725 = occluder_1;
if ((_e722 - _e723) > _e725) {
let _e727 = occluder_1;
let _e728 = blockerSum;
blockerSum = (_e728 + _e727);
let _e730 = blockerCount;
blockerCount = (_e730 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e732 = i_5;
i_5 = (_e732 + 1i);
}
}
let _e734 = blockerCount;
if (_e734 <= 0f) {
return 1f;
}
let _e737 = projected[2u];
let _e738 = blockerSum;
let _e739 = blockerCount;
let _e743 = cascadeDepth;
gap = (max((_e737 - (_e738 / _e739)), 0f) * _e743);
let _e745 = spread;
let _e746 = gap;
let _e748 = cascadeTexel;
radius_2 = clamp(((_e745 * _e746) / _e748), 1f, 16f);
i_6 = 0i;
loop {
let _e751 = i_6;
if (_e751 < 16i) {
let _e753 = turn_1;
let _e755 = i_6;
param_75 = _e755;
param_76 = 16i;
param_77 = (_e753 + 1f);
let _e756 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e756;
let _e757 = bias;
let _e758 = disc_1;
let _e760 = radius_2;
let _e764 = receiverSlope;
tapBias_1 = (_e757 + (max(((length(_e758) * _e760) - 1.5f), 0f) * _e764));
let _e767 = uv_5;
let _e768 = disc_1;
let _e769 = texel_1;
let _e771 = radius_2;
let _e774 = tileLo;
let _e775 = tileHi;
let _e777 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e767 + ((_e768 * _e769) * _e771)), _e774, _e775), 0f);
param_78 = _e777.x;
let _e779 = storage_;
param_79 = _e779;
let _e780 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e780;
let _e782 = projected[2u];
let _e783 = tapBias_1;
let _e785 = occluder_2;
let _e788 = lit_2;
lit_2 = (_e788 + select(1f, 0f, ((_e782 - _e783) > _e785)));
continue;
} else {
break;
}
continuing {
let _e790 = i_6;
i_6 = (_e790 + 1i);
}
}
let _e792 = lit_2;
lit_2 = (_e792 * 0.0625f);
}
}
let _e794 = lit_2;
let _e795 = strength_1;
return mix(1f, _e794, clamp(_e795, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e222 = (*s_3);
param_80 = _e222;
let _e223 = (*light_2);
param_81 = _e223;
let _e224 = (*index);
param_82 = _e224;
let _e225 = 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_80), (¶m_81), (¶m_82));
return _e225;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e217 = (*index_1);
return (_e217 < 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 _e221 = (*distance_1);
let _e222 = (*distance_1);
attenuation = (1f / max((_e221 * _e222), 0.0001f));
let _e226 = (*range_4);
if (_e226 > 0f) {
let _e228 = (*distance_1);
let _e229 = (*range_4);
ratio = (_e228 / _e229);
let _e231 = ratio;
let _e232 = ratio;
let _e234 = ratio;
let _e236 = ratio;
window = clamp((1f - (((_e231 * _e232) * _e234) * _e236)), 0f, 1f);
let _e240 = window;
let _e241 = window;
let _e243 = attenuation;
attenuation = (_e243 * (_e240 * _e241));
}
let _e245 = attenuation;
return _e245;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e233 = (*halfWidth);
let _e234 = (*halfHeight);
n_2 = cross(_e233, _e234);
let _e236 = n_2;
nLen = length(_e236);
let _e238 = nLen;
if (_e238 < 0.000000000001f) {
let _e240 = (*centre);
return _e240;
}
let _e241 = nLen;
let _e242 = n_2;
n_2 = (_e242 / vec3(_e241));
let _e245 = (*centre);
let _e246 = (*world_2);
toPlane = (_e245 - _e246);
let _e248 = (*mirror);
let _e249 = n_2;
denom = dot(_e248, _e249);
let _e251 = denom;
if (abs(_e251) < 0.00001f) {
let _e254 = toPlane;
let _e255 = n_2;
let _e256 = toPlane;
let _e257 = n_2;
onPlane = (_e254 - (_e255 * dot(_e256, _e257)));
} else {
let _e261 = toPlane;
let _e262 = n_2;
let _e264 = denom;
t_1 = (dot(_e261, _e262) / _e264);
let _e266 = t_1;
if (_e266 > 0f) {
let _e268 = (*mirror);
let _e269 = t_1;
local_21 = (_e268 * _e269);
} else {
let _e271 = toPlane;
let _e272 = n_2;
let _e273 = toPlane;
let _e274 = n_2;
local_21 = (_e271 - (_e272 * dot(_e273, _e274)));
}
let _e278 = local_21;
onPlane = _e278;
}
let _e279 = onPlane;
let _e280 = toPlane;
offset_2 = (_e279 - _e280);
let _e282 = (*halfWidth);
let _e283 = (*halfWidth);
wLen2_ = max(dot(_e282, _e283), 0.000000000001f);
let _e286 = (*halfHeight);
let _e287 = (*halfHeight);
hLen2_ = max(dot(_e286, _e287), 0.000000000001f);
let _e290 = offset_2;
let _e291 = (*halfWidth);
let _e293 = wLen2_;
u = clamp((dot(_e290, _e291) / _e293), -1f, 1f);
let _e296 = offset_2;
let _e297 = (*halfHeight);
let _e299 = hLen2_;
v = clamp((dot(_e296, _e297) / _e299), -1f, 1f);
let _e302 = (*centre);
let _e303 = (*halfWidth);
let _e304 = u;
let _e307 = (*halfHeight);
let _e308 = v;
return ((_e302 + (_e303 * _e304)) + (_e307 * _e308));
}
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_22: f32;
let _e225 = (*a_1);
let _e226 = (*a_1);
ua = (_e225 / vec3(max(length(_e226), 0.000000000001f)));
let _e231 = (*b);
let _e232 = (*b);
ub = (_e231 / vec3(max(length(_e232), 0.000000000001f)));
let _e237 = ua;
let _e238 = ub;
angle_1 = acos(clamp(dot(_e237, _e238), -1f, 1f));
let _e242 = ua;
let _e243 = ub;
axis = cross(_e242, _e243);
let _e245 = axis;
len = length(_e245);
let _e247 = len;
if (_e247 > 0.000001f) {
let _e249 = angle_1;
let _e250 = axis;
let _e251 = (*n_3);
let _e254 = len;
local_22 = ((_e249 * dot(_e250, _e251)) / _e254);
} else {
local_22 = 0f;
}
let _e256 = local_22;
return _e256;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e239 = i_7;
if (_e239 < 4i) {
let _e241 = i_7;
let _e243 = (*corners)[_e241];
a_2 = _e243;
let _e244 = i_7;
if (_e244 == 3i) {
local_23 = 0i;
} else {
let _e246 = i_7;
local_23 = (_e246 + 1i);
}
let _e248 = local_23;
let _e250 = (*corners)[_e248];
b_1 = _e250;
let _e251 = a_2;
let _e252 = (*n_4);
ha = dot(_e251, _e252);
let _e254 = b_1;
let _e255 = (*n_4);
hb = dot(_e254, _e255);
let _e257 = ha;
let _e258 = hb;
d_3 = (_e257 - _e258);
let _e260 = a_2;
let _e261 = b_1;
let _e262 = a_2;
let _e264 = d_3;
if (abs(_e264) > 0.000000000001f) {
let _e267 = ha;
let _e268 = d_3;
local_24 = (_e267 / _e268);
} else {
local_24 = 0f;
}
let _e270 = local_24;
q = (_e260 + ((_e261 - _e262) * _e270));
let _e273 = ha;
aAbove = (_e273 > 0f);
let _e275 = hb;
bAbove = (_e275 > 0f);
let _e277 = aAbove;
let _e278 = bAbove;
if (_e277 || _e278) {
let _e280 = aAbove;
let _e281 = a_2;
let _e282 = q;
let _e285 = bAbove;
let _e286 = b_1;
let _e287 = q;
param_83 = select(_e282, _e281, vec3(_e280));
param_84 = select(_e287, _e286, vec3(_e285));
let _e290 = (*n_4);
param_85 = _e290;
let _e291 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e291;
} else {
local_25 = 0f;
}
let _e292 = local_25;
let _e293 = total;
total = (_e293 + _e292);
let _e295 = aAbove;
let _e296 = bAbove;
let _e299 = q;
let _e300 = exit;
exit = select(_e300, _e299, vec3((_e295 && !(_e296))));
let _e303 = aAbove;
let _e305 = bAbove;
let _e307 = q;
let _e308 = entry;
entry = select(_e308, _e307, vec3((!(_e303) && _e305)));
continue;
} else {
break;
}
continuing {
let _e311 = i_7;
i_7 = (_e311 + 1i);
}
}
let _e313 = exit;
param_86 = _e313;
let _e314 = entry;
param_87 = _e314;
let _e315 = (*n_4);
param_88 = _e315;
let _e316 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e317 = total;
total = (_e317 + _e316);
let _e319 = total;
return max((-(_e319) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e222 = (*slot_1);
let _e223 = (*slot_1);
lane = (_e222 - ((_e223 / 4i) * 4i));
let _e227 = lane;
if (_e227 == 0i) {
let _e230 = (*four)[0u];
local_26 = _e230;
} else {
let _e231 = lane;
if (_e231 == 1i) {
let _e234 = (*four)[1u];
local_27 = _e234;
} else {
let _e235 = lane;
if (_e235 == 2i) {
let _e238 = (*four)[2u];
local_28 = _e238;
} else {
let _e240 = (*four)[3u];
local_28 = _e240;
}
let _e241 = local_28;
local_27 = _e241;
}
let _e242 = local_27;
local_26 = _e242;
}
let _e243 = local_26;
return _e243;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e219 = (*slot_2);
let _e223 = light_list_info.scales[(_e219 / 4i)];
param_89 = _e223;
let _e224 = (*slot_2);
param_90 = _e224;
let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e225;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e221 = light_list_info.slot_rows[0i];
let _e222 = (*row);
a_3 = abs((_e221 - vec4(_e222)));
let _e228 = light_list_info.slot_rows[1i];
let _e229 = (*row);
b_2 = abs((_e228 - vec4(_e229)));
let _e234 = a_3[0u];
let _e236 = a_3[1u];
let _e239 = a_3[2u];
let _e241 = a_3[3u];
let _e245 = b_2[0u];
let _e247 = b_2[1u];
let _e250 = b_2[2u];
let _e252 = b_2[3u];
return (min(min(min(_e234, _e236), min(_e239, _e241)), min(min(_e245, _e247), min(_e250, _e252))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e219 = (*slot_3);
let _e223 = light_list_info.indices[(_e219 / 4i)];
param_91 = _e223;
let _e224 = (*slot_3);
param_92 = _e224;
let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e225;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e218 = (*texel_2);
let _e222 = light_list_info.list[1u];
let _e224 = (*row_1);
let _e228 = light_list_info.list[2u];
let _e231 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e218 + 0.5f) * _e222), ((_e224 + 0.5f) * _e228)), 0f);
return _e231;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e226 = g_cluster_offset;
let _e227 = (*slot_4);
entry_1 = (_e226 + f32(_e227));
let _e230 = entry_1;
row_2 = floor((_e230 / 16f));
let _e233 = entry_1;
let _e234 = row_2;
within_1 = (_e233 - (_e234 * 16f));
let _e237 = within_1;
texel_3 = floor((_e237 / 4f));
let _e242 = light_list_info.cluster_depth[3u];
let _e243 = row_2;
let _e245 = texel_3;
param_93 = _e245;
param_94 = (_e242 + _e243);
let _e246 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e246;
let _e247 = within_1;
let _e248 = texel_3;
let _e253 = four_1;
param_95 = _e253;
param_96 = i32(((_e247 - (_e248 * 4f)) + 0.5f));
let _e254 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e254;
}
fn Clustered_u0028_() -> bool {
let _e218 = light_list_info.cluster_grid[3u];
return (_e218 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e270 = (*index_2);
if (_e270 < 8i) {
let _e272 = (*index_2);
let _e275 = frag_info.light_position[_e272];
position = _e275;
let _e276 = (*index_2);
let _e279 = frag_info.light_color[_e276];
color_1 = _e279;
let _e280 = (*index_2);
let _e283 = frag_info.light_direction[_e280];
direction = _e283;
let _e284 = (*index_2);
let _e287 = frag_info.light_cone[_e284];
cone = _e287;
} else {
let _e288 = (*index_2);
slot_5 = (_e288 - 8i);
let _e290 = Clustered_u0028_();
clustered = _e290;
let _e291 = clustered;
if _e291 {
let _e292 = slot_5;
param_97 = _e292;
let _e293 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e293;
} else {
let _e294 = slot_5;
param_98 = _e294;
let _e295 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e295;
}
let _e296 = local_29;
listRow = _e296;
let _e297 = listRow;
let _e301 = light_list_info.list[2u];
v_1 = ((_e297 + 0.5f) * _e301);
let _e305 = light_list_info.list[1u];
u_1 = _e305;
let _e306 = u_1;
let _e308 = v_1;
let _e310 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e306), _e308), 0f);
position = _e310;
let _e311 = u_1;
let _e313 = v_1;
let _e315 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e311), _e313), 0f);
color_1 = _e315;
let _e316 = u_1;
let _e318 = v_1;
let _e320 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e316), _e318), 0f);
direction = _e320;
let _e321 = u_1;
let _e323 = v_1;
let _e325 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e321), _e323), 0f);
cone = _e325;
let _e326 = clustered;
if _e326 {
let _e327 = listRow;
param_99 = _e327;
let _e328 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e328);
} else {
let _e330 = slot_5;
param_100 = _e330;
let _e331 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e331;
}
let _e332 = local_30;
let _e334 = color_1[3u];
color_1[3u] = (_e334 * _e332);
}
let _e338 = position[3u];
type_39 = _e338;
let _e339 = type_39;
if (_e339 > 15.5f) {
let _e342 = (*s_4).n;
light_3.l = _e342;
let _e345 = (*s_4).n;
light_3.h = _e345;
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 _e351 = light_3;
return _e351;
}
let _e352 = type_39;
if (_e352 > 2.5f) {
let _e354 = direction;
halfWidth_1 = _e354.xyz;
let _e356 = cone;
halfHeight_1 = _e356.xyz;
let _e358 = position;
let _e360 = v_world_position_1;
toCentre = (_e358.xyz - _e360);
let _e362 = toCentre;
let _e363 = halfWidth_1;
let _e365 = halfHeight_1;
corners_1[0i] = ((_e362 - _e363) - _e365);
let _e368 = toCentre;
let _e369 = halfWidth_1;
let _e371 = halfHeight_1;
corners_1[1i] = ((_e368 + _e369) - _e371);
let _e374 = toCentre;
let _e375 = halfWidth_1;
let _e377 = halfHeight_1;
corners_1[2i] = ((_e374 + _e375) + _e377);
let _e380 = toCentre;
let _e381 = halfWidth_1;
let _e383 = halfHeight_1;
corners_1[3i] = ((_e380 - _e381) + _e383);
let _e386 = toCentre;
let _e387 = halfWidth_1;
let _e388 = halfHeight_1;
behind = (dot(_e386, cross(_e387, _e388)) >= 0f);
let _e392 = behind;
if _e392 {
local_31 = 0f;
} else {
let _e393 = corners_1;
param_101 = _e393;
let _e395 = (*s_4).n;
param_102 = _e395;
let _e396 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e396;
}
let _e397 = local_31;
formFactor = _e397;
let _e398 = halfWidth_1;
let _e399 = halfHeight_1;
area = (length(cross(_e398, _e399)) * 4f);
let _e403 = area;
if (_e403 > 0.000000001f) {
let _e405 = area;
local_32 = (1f / _e405);
} else {
local_32 = 0f;
}
let _e407 = local_32;
radiance = _e407;
let _e408 = toCentre;
distance_2 = length(_e408);
let _e411 = direction[3u];
if (_e411 > 0f) {
let _e413 = distance_2;
let _e415 = direction[3u];
ratio_1 = (_e413 / _e415);
let _e417 = ratio_1;
let _e418 = ratio_1;
let _e420 = ratio_1;
let _e422 = ratio_1;
window_1 = clamp((1f - (((_e417 * _e418) * _e420) * _e422)), 0f, 1f);
let _e426 = window_1;
let _e427 = window_1;
let _e429 = radiance;
radiance = (_e429 * (_e426 * _e427));
}
let _e432 = (*s_4).v;
let _e435 = (*s_4).n;
mirror_1 = reflect(-(_e432), _e435);
let _e437 = position;
param_103 = _e437.xyz;
let _e439 = halfWidth_1;
param_104 = _e439;
let _e440 = halfHeight_1;
param_105 = _e440;
let _e441 = v_world_position_1;
param_106 = _e441;
let _e442 = mirror_1;
param_107 = _e442;
let _e443 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e443;
let _e444 = representative;
let _e445 = v_world_position_1;
toPoint = (_e444 - _e445);
let _e447 = toPoint;
pointDistance = length(_e447);
let _e449 = pointDistance;
if (_e449 > 0.000001f) {
let _e451 = toPoint;
let _e452 = pointDistance;
local_33 = (_e451 / vec3(_e452));
} else {
let _e456 = (*s_4).n;
local_33 = _e456;
}
let _e457 = local_33;
light_3.l = _e457;
let _e460 = light_3.l;
let _e462 = (*s_4).v;
light_3.h = normalize((_e460 + _e462));
let _e466 = formFactor;
light_3.n_dot_l = _e466;
let _e469 = (*s_4).n;
let _e471 = light_3.h;
light_3.n_dot_h = max(dot(_e469, _e471), 0f);
let _e476 = (*s_4).v;
let _e478 = light_3.h;
light_3.v_dot_h = max(dot(_e476, _e478), 0f);
let _e482 = color_1;
let _e485 = color_1[3u];
let _e487 = radiance;
light_3.radiance = ((_e482.xyz * _e485) * _e487);
let _e490 = light_3;
return _e490;
}
let _e491 = direction;
aim = normalize(_e491.xyz);
attenuation_1 = 1f;
let _e494 = type_39;
if (_e494 < 0.5f) {
let _e496 = aim;
light_3.l = -(_e496);
} else {
let _e499 = position;
let _e501 = v_world_position_1;
toLight_1 = (_e499.xyz - _e501);
let _e503 = toLight_1;
distance_3 = length(_e503);
let _e505 = distance_3;
if (_e505 < 0.000001f) {
let _e508 = (*s_4).n;
light_3.l = _e508;
let _e511 = (*s_4).n;
light_3.h = _e511;
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 _e517 = light_3;
return _e517;
}
let _e518 = toLight_1;
let _e519 = distance_3;
light_3.l = (_e518 / vec3(_e519));
let _e523 = distance_3;
param_108 = _e523;
let _e525 = direction[3u];
param_109 = _e525;
let _e526 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e526;
let _e527 = type_39;
if (_e527 > 1.5f) {
let _e529 = aim;
let _e531 = light_3.l;
cosAngle = dot(_e529, -(_e531));
let _e534 = cosAngle;
let _e536 = cone[1u];
let _e539 = cone[0u];
let _e541 = cone[1u];
ramp = clamp(((_e534 - _e536) / (_e539 - _e541)), 0f, 1f);
let _e545 = ramp;
let _e546 = ramp;
let _e548 = attenuation_1;
attenuation_1 = (_e548 * (_e545 * _e546));
}
}
let _e551 = light_3.l;
let _e553 = (*s_4).v;
light_3.h = normalize((_e551 + _e553));
let _e558 = (*s_4).n;
let _e560 = light_3.l;
light_3.n_dot_l = max(dot(_e558, _e560), 0f);
let _e565 = (*s_4).n;
let _e567 = light_3.h;
light_3.n_dot_h = max(dot(_e565, _e567), 0f);
let _e572 = (*s_4).v;
let _e574 = light_3.h;
light_3.v_dot_h = max(dot(_e572, _e574), 0f);
let _e578 = color_1;
let _e581 = color_1[3u];
let _e583 = attenuation_1;
light_3.radiance = ((_e578.xyz * _e581) * _e583);
let _e586 = light_3;
return _e586;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e231 = light_list_info.cluster_view_projection;
let _e232 = (*world_3);
clip_1 = (_e231 * vec4<f32>(_e232.x, _e232.y, _e232.z, 1f));
let _e238 = clip_1;
let _e241 = clip_1[3u];
ndc_1 = (_e238.xy / vec2(max(_e241, 0.000001f)));
let _e246 = light_list_info.cluster_grid;
grid = _e246.xyz;
let _e250 = light_list_info.cluster_depth[0u];
near_1 = _e250;
let _e252 = ndc_1[0u];
let _e256 = grid[0u];
let _e260 = grid[0u];
tx = clamp(floor((((_e252 * 0.5f) + 0.5f) * _e256)), 0f, (_e260 - 1f));
let _e264 = ndc_1[1u];
let _e268 = grid[1u];
let _e272 = grid[1u];
ty = clamp(floor((((_e264 * 0.5f) + 0.5f) * _e268)), 0f, (_e272 - 1f));
let _e276 = clip_1[3u];
let _e277 = near_1;
if (_e276 <= _e277) {
local_34 = 0f;
} else {
let _e280 = clip_1[3u];
let _e281 = near_1;
let _e286 = light_list_info.cluster_depth[1u];
let _e290 = grid[2u];
local_34 = clamp(floor((log((_e280 / _e281)) * _e286)), 0f, (_e290 - 1f));
}
let _e293 = local_34;
tz = _e293;
let _e294 = tx;
let _e295 = ty;
let _e297 = grid[0u];
let _e300 = tz;
let _e302 = grid[0u];
let _e305 = grid[1u];
cell_1 = ((_e294 + (_e295 * _e297)) + ((_e300 * _e302) * _e305));
let _e308 = cell_1;
row_3 = floor((_e308 / 4f));
let _e311 = cell_1;
let _e312 = row_3;
let _e317 = light_list_info.cluster_depth[2u];
let _e318 = row_3;
param_110 = (_e311 - (_e312 * 4f));
param_111 = (_e317 + _e318);
let _e320 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e320;
let _e322 = header[0u];
g_cluster_offset = _e322;
let _e324 = header[1u];
g_cluster_count = _e324;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e220 = light_list_info.list[0u];
tail = _e220;
let _e221 = Clustered_u0028_();
if _e221 {
let _e222 = v_world_position_1;
param_112 = _e222;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e223 = g_cluster_count;
tail = _e223;
}
let _e226 = frag_info.frame_params[1u];
let _e230 = tail;
return (clamp(i32((_e226 + 0.5f)), 0i, 8i) + clamp(i32((_e230 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e234 = LightCount_u0028_();
count_1 = _e234;
i_8 = 0i;
loop {
let _e235 = i_8;
if (_e235 < 32i) {
let _e237 = i_8;
let _e238 = count_1;
if (_e237 >= _e238) {
break;
}
let _e240 = i_8;
param_113 = _e240;
let _e241 = (*s_5);
param_114 = _e241;
let _e242 = 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_113), (¶m_114));
light_4 = _e242;
let _e244 = light_4.n_dot_l;
if (_e244 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e246 = i_8;
param_115 = _e246;
let _e247 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e247 {
let _e248 = (*s_5);
param_116 = _e248;
let _e249 = light_4;
param_117 = _e249;
let _e250 = i_8;
param_118 = _e250;
let _e251 = 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_116), (¶m_117), (¶m_118));
let _e252 = v_world_position_1;
param_119 = _e252;
let _e254 = (*s_5).n;
param_120 = _e254;
let _e255 = i_8;
param_121 = _e255;
let _e256 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e251 * _e256);
} else {
local_35 = 1f;
}
let _e258 = local_35;
visibility = _e258;
let _e259 = visibility;
if (_e259 <= 0f) {
continue;
}
let _e261 = (*s_5);
param_122 = _e261;
let _e262 = light_4;
param_123 = _e262;
let _e263 = 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_122), (¶m_123));
let _e265 = light_4.radiance;
let _e268 = light_4.n_dot_l;
let _e270 = visibility;
let _e272 = light_transmittance;
let _e274 = total_1;
total_1 = (_e274 + ((((_e263 * _e265) * _e268) * _e270) * _e272));
continue;
} else {
break;
}
continuing {
let _e276 = i_8;
i_8 = (_e276 + 1i);
}
}
let _e278 = total_1;
return _e278;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e217 = v_lightmap_uv_1;
let _e218 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e217);
texel_4 = _e218;
let _e219 = texel_4;
let _e222 = texel_4[3u];
return ((_e219.xyz * _e222) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e218 = frag_info.target_origin[1u];
return _e218;
}
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_124: vec3<f32>;
let _e219 = v_texcoord_1;
let _e220 = MaterialLodBias_u0028_();
let _e221 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e219, _e220);
param_124 = _e221.xyz;
let _e223 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e223;
let _e224 = emissive;
let _e226 = frag_info.emissive;
let _e231 = frag_info.material2_[3u];
(*s_6).emissive = ((_e224 * _e226.xyz) * _e231);
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 _e218 = v_texcoord_1;
let _e219 = MaterialLodBias_u0028_();
let _e220 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e218, _e219);
occlusion = _e220.x;
let _e222 = occlusion;
let _e225 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e222, clamp(_e225, 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 _e221 = v_texcoord_1;
let _e222 = MaterialLodBias_u0028_();
let _e223 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e221, _e222);
sampledTexel = _e223;
let _e224 = v_tangent_1;
t_2 = _e224.xyz;
let _e226 = t_2;
let _e228 = (*s_8).n;
let _e230 = (*s_8).n;
let _e231 = t_2;
t_2 = (_e226 - (_e228 * dot(_e230, _e231)));
let _e235 = t_2;
let _e236 = t_2;
if (dot(_e235, _e236) < 0.000000000001f) {
return;
}
let _e239 = t_2;
t_2 = normalize(_e239);
let _e242 = (*s_8).n;
let _e243 = t_2;
let _e246 = v_tangent_1[3u];
b_3 = (cross(_e242, _e243) * _e246);
let _e248 = gl_FrontFacing_1;
if !(_e248) {
let _e250 = t_2;
t_2 = -(_e250);
}
let _e252 = sampledTexel;
sampled = ((_e252.xyz * 2f) - vec3(1f));
let _e259 = frag_info.emissive[3u];
if (_e259 > 0.5f) {
let _e261 = sampled;
let _e263 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e261.xy, _e263.xy)), 0f));
}
let _e272 = frag_info.material2_[1u];
let _e273 = sampled;
let _e275 = (_e273.xy * _e272);
sampled[0u] = _e275.x;
sampled[1u] = _e275.y;
let _e280 = t_2;
let _e282 = sampled[0u];
let _e284 = b_3;
let _e286 = sampled[1u];
let _e290 = (*s_8).n;
let _e292 = sampled[2u];
(*s_8).n = normalize((((_e280 * _e282) + (_e284 * _e286)) + (_e290 * _e292)));
let _e298 = (*s_8).n;
let _e300 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e298, _e300), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e217 = (*texel_5);
let _e221 = irradiance_info.atlas;
let _e224 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e217 + vec2(0.5f)) * _e221.xy), 0f);
return _e224;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e230 = (*uv_6);
let _e231 = (*interior);
at_1 = ((vec2(1f) + (_e230 * _e231)) - vec2(0.5f));
let _e237 = at_1;
low = floor(_e237);
let _e239 = at_1;
let _e240 = low;
f = (_e239 - _e240);
let _e242 = (*corner);
let _e243 = low;
param_125 = (_e242 + _e243);
let _e245 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e245;
let _e246 = (*corner);
let _e247 = low;
param_126 = ((_e246 + _e247) + vec2<f32>(1f, 0f));
let _e250 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e250;
let _e251 = (*corner);
let _e252 = low;
param_127 = ((_e251 + _e252) + vec2<f32>(0f, 1f));
let _e255 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e255;
let _e256 = (*corner);
let _e257 = low;
param_128 = ((_e256 + _e257) + vec2<f32>(1f, 1f));
let _e260 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e260;
let _e261 = a_4;
let _e262 = b_4;
let _e264 = f[0u];
let _e267 = c_1;
let _e268 = d_4;
let _e270 = f[0u];
let _e274 = f[1u];
return mix(mix(_e261, _e262, vec4(_e264)), mix(_e267, _e268, vec4(_e270)), vec4(_e274));
}
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 _e221 = (*direction_1)[0u];
let _e224 = (*direction_1)[1u];
let _e228 = (*direction_1)[2u];
sum_1 = ((abs(_e221) + abs(_e224)) + abs(_e228));
let _e231 = sum_1;
if (_e231 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e233 = (*direction_1);
let _e234 = sum_1;
n_5 = (_e233 / vec3(_e234));
let _e237 = n_5;
xy = _e237.xy;
let _e240 = n_5[2u];
if (_e240 < 0f) {
let _e243 = n_5[1u];
let _e247 = n_5[0u];
let _e252 = n_5[0u];
let _e256 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e243)) * select(-1f, 1f, (_e247 >= 0f))), ((1f - abs(_e252)) * select(-1f, 1f, (_e256 >= 0f))));
}
let _e261 = xy;
return ((_e261 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e263 = irradiance_info.origin;
origin_2 = _e263.xyz;
let _e266 = irradiance_info.spacing;
spacing = _e266.xyz;
let _e269 = irradiance_info.counts;
counts = _e269.xyz;
let _e273 = irradiance_info.tiles[0u];
irradianceTile = _e273;
let _e276 = irradiance_info.tiles[1u];
depthTile = _e276;
let _e279 = irradiance_info.tiles[2u];
columns = _e279;
let _e282 = irradiance_info.tiles[3u];
momentsTop = _e282;
let _e283 = (*normal_1);
unit = normalize(_e283);
let _e285 = (*world_4);
let _e286 = unit;
let _e289 = irradiance_info.spacing[3u];
let _e292 = (*view_1);
let _e295 = irradiance_info.counts[3u];
biased = ((_e285 + (_e286 * _e289)) + (_e292 * _e295));
let _e298 = biased;
let _e299 = origin_2;
let _e301 = spacing;
grid_1 = ((_e298 - _e299) / _e301);
let _e303 = grid_1;
let _e305 = counts;
base = clamp(floor(_e303), vec3<f32>(0f, 0f, 0f), (_e305 - vec3(2f)));
let _e309 = grid_1;
let _e310 = base;
f_1 = clamp((_e309 - _e310), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e313 = corner_1;
if (_e313 < 8i) {
let _e315 = corner_1;
let _e318 = corner_1;
let _e323 = corner_1;
offset_3 = vec3<f32>(f32((_e315 & 1i)), f32(((_e318 >> bitcast<u32>(1i)) & 1i)), f32(((_e323 >> bitcast<u32>(2i)) & 1i)));
let _e329 = base;
let _e330 = offset_3;
cell_2 = (_e329 + _e330);
let _e333 = cell_2[2u];
let _e335 = counts[1u];
let _e338 = cell_2[1u];
let _e341 = counts[0u];
let _e344 = cell_2[0u];
probe = ((((_e333 * _e335) + _e338) * _e341) + _e344);
let _e346 = probe;
let _e347 = columns;
let _e352 = probe;
let _e353 = columns;
tile_4 = vec2<f32>((_e346 - (floor((_e346 / _e347)) * _e347)), floor((_e352 / _e353)));
let _e357 = tile_4;
let _e358 = irradianceTile;
irradianceCorner = (_e357 * (_e358 + 2f));
let _e362 = tile_4[0u];
let _e363 = depthTile;
let _e366 = momentsTop;
let _e368 = tile_4[1u];
let _e369 = depthTile;
momentCorner = vec2<f32>((_e362 * (_e363 + 2f)), (_e366 + (_e368 * (_e369 + 2f))));
let _e374 = irradianceCorner;
param_129 = (_e374 + vec2(1f));
let _e377 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e377.w < 0.5f) {
continue;
}
let _e380 = f_1;
let _e382 = f_1;
let _e383 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e380), _e382, _e383);
let _e386 = trilinear[0u];
let _e388 = trilinear[1u];
let _e391 = trilinear[2u];
weight_3 = max(((_e386 * _e388) * _e391), 0.001f);
let _e394 = origin_2;
let _e395 = spacing;
let _e396 = cell_2;
probePosition = (_e394 + (_e395 * _e396));
let _e399 = probePosition;
let _e400 = biased;
toProbe = (_e399 - _e400);
let _e402 = toProbe;
distance_4 = length(_e402);
let _e404 = distance_4;
if (_e404 > 0.000001f) {
let _e406 = toProbe;
let _e407 = distance_4;
direction_2 = (_e406 / vec3(_e407));
let _e410 = unit;
let _e411 = probePosition;
let _e412 = (*world_4);
facing = ((dot(_e410, normalize((_e411 - _e412))) * 0.5f) + 0.5f);
let _e418 = facing;
let _e419 = facing;
probeWeight = ((_e418 * _e419) + 0.2f);
let _e422 = direction_2;
param_130 = -(_e422);
let _e424 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e425 = momentCorner;
param_131 = _e425;
let _e426 = depthTile;
param_132 = _e426;
param_133 = _e424;
let _e427 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e427.xy;
chebyshev = 1f;
let _e429 = distance_4;
let _e431 = moments_3[0u];
if (_e429 > _e431) {
let _e434 = moments_3[1u];
let _e436 = moments_3[0u];
let _e438 = moments_3[0u];
variance_1 = max((_e434 - (_e436 * _e438)), 0.000001f);
let _e442 = distance_4;
let _e444 = moments_3[0u];
difference = (_e442 - _e444);
let _e446 = variance_1;
let _e447 = variance_1;
let _e448 = difference;
let _e449 = difference;
chebyshev = (_e446 / (_e447 + (_e448 * _e449)));
let _e453 = chebyshev;
let _e454 = chebyshev;
let _e456 = chebyshev;
chebyshev = ((_e453 * _e454) * _e456);
}
let _e458 = probeWeight;
let _e459 = chebyshev;
probeWeight = max((_e458 * max(_e459, 0.05f)), 0.000001f);
let _e463 = probeWeight;
if (_e463 < 0.2f) {
let _e465 = probeWeight;
let _e466 = probeWeight;
let _e469 = probeWeight;
probeWeight = (_e469 * ((_e465 * _e466) * 25f));
}
let _e471 = probeWeight;
let _e472 = weight_3;
weight_3 = (_e472 * _e471);
}
let _e474 = unit;
param_134 = _e474;
let _e475 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e476 = irradianceCorner;
param_135 = _e476;
let _e477 = irradianceTile;
param_136 = _e477;
param_137 = _e475;
let _e478 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e480 = weight_3;
let _e482 = total_2;
total_2 = (_e482 + (_e478.xyz * _e480));
let _e484 = weight_3;
let _e485 = weights;
weights = (_e485 + _e484);
continue;
} else {
break;
}
continuing {
let _e487 = corner_1;
corner_1 = (_e487 + 1i);
}
}
let _e489 = weights;
if (_e489 > 0f) {
let _e491 = total_2;
let _e492 = weights;
local_36 = (_e491 / vec3(_e492));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e495 = local_36;
return _e495;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e218 = irradiance_info.origin[3u];
return (_e218 > 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_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e223 = IrradianceEnabled_u0028_();
if _e223 {
let _e224 = v_world_position_1;
param_138 = _e224;
let _e226 = (*s_9).n;
param_139 = _e226;
let _e228 = (*s_9).v;
param_140 = _e228;
let _e229 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e232 = frag_info.material[2u];
(*s_9).ambient = (_e229 * _e232);
}
let _e235 = (*s_9);
param_141 = _e235;
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_141));
let _e236 = param_141;
(*s_9) = _e236;
let _e237 = (*s_9);
param_142 = _e237;
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_142));
let _e238 = param_142;
(*s_9) = _e238;
let _e239 = (*s_9);
param_143 = _e239;
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_143));
let _e240 = param_143;
(*s_9) = _e240;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e217 = Orthographic_u0028_();
if _e217 {
let _e219 = fog_info.forward;
local_37 = -(_e219.xyz);
} else {
let _e223 = fog_info.eye;
let _e225 = v_world_position_1;
local_37 = normalize((_e223.xyz - _e225));
}
let _e228 = local_37;
return _e228;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_3: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e222 = (*cutoff);
key_2 = (-2f - _e222);
let _e224 = key_2;
let _e227 = key_2;
let _e229 = floor((_e227 / 128f));
let _e234 = key_2;
origin_3 = vec3<f32>(floor((_e224 / 16384f)), (_e229 - (floor((_e229 / 128f)) * 128f)), (_e234 - (floor((_e234 / 128f)) * 128f)));
let _e240 = (*scenePosition);
let _e243 = origin_3;
let _e244 = (floor((_e240 * 16f)) + _e243);
let _e245 = vec3(128f);
cell_3 = (_e244 - (floor((_e244 / _e245)) * _e245));
let _e250 = cell_3;
p3_ = fract((_e250 * 0.1031f));
let _e253 = p3_;
let _e254 = p3_;
let _e259 = p3_;
p3_ = (_e259 + vec3(dot(_e253, (_e254.zyx + vec3(31.32f)))));
let _e263 = p3_[0u];
let _e265 = p3_[1u];
let _e268 = p3_[2u];
return fract(((_e263 + _e265) * _e268));
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_10: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_146: vec3<f32>;
var param_147: f32;
let _e224 = v_texcoord_1;
let _e225 = MaterialLodBias_u0028_();
let _e226 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e224, _e225);
texel_6 = _e226;
let _e227 = texel_6;
param_144 = _e227.xyz;
let _e229 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e231 = frag_info.base_color;
param_145 = _e231.xyz;
let _e233 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e235 = v_color_1;
s_10.albedo = ((_e229 * _e233) * _e235.xyz);
let _e240 = texel_6[3u];
let _e243 = frag_info.base_color[3u];
let _e246 = v_color_1[3u];
s_10.alpha = ((_e240 * _e243) * _e246);
let _e250 = s_10.albedo;
g_albedo = _e250;
let _e253 = frag_info.material2_[0u];
cutoff_1 = _e253;
let _e254 = cutoff_1;
if (_e254 > 1f) {
let _e256 = cutoff_1;
edge = (_e256 - 1f);
let _e259 = s_10.alpha;
let _e260 = edge;
let _e263 = s_10.alpha;
let _e264 = fwidth(_e263);
s_10.alpha = clamp((((_e259 - _e260) / max(_e264, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e270 = cutoff_1;
if (_e270 >= 0f) {
let _e273 = s_10.alpha;
let _e274 = cutoff_1;
if (_e273 < _e274) {
discard;
}
s_10.alpha = 1f;
} else {
let _e277 = cutoff_1;
if (_e277 < -1.5f) {
let _e280 = s_10.alpha;
let _e281 = v_world_position_1;
param_146 = _e281;
let _e282 = cutoff_1;
param_147 = _e282;
let _e283 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_146), (¶m_147));
if (_e280 < _e283) {
discard;
}
}
}
}
let _e285 = cutoff_1;
let _e287 = cutoff_1;
g_premultiply = ((_e285 < 0f) && (_e287 > -0.75f));
let _e290 = v_normal_1;
s_10.n = normalize(_e290);
let _e293 = gl_FrontFacing_1;
if !(_e293) {
let _e296 = s_10.n;
s_10.n = -(_e296);
}
let _e299 = TowardsEye_u0028_();
s_10.v = _e299;
let _e302 = s_10.n;
let _e304 = s_10.v;
s_10.n_dot_v = max(dot(_e302, _e304), 0.0001f);
let _e310 = frag_info.material[0u];
s_10.metallic = clamp(_e310, 0f, 1f);
let _e315 = frag_info.material[1u];
s_10.roughness = clamp(_e315, 0.02f, 1f);
let _e319 = frag_info.ambient_ground;
let _e322 = frag_info.ambient_sky;
let _e326 = s_10.n[1u];
let _e333 = frag_info.material[2u];
s_10.ambient = (mix(_e319.xyz, _e322.xyz, vec3(((_e326 * 0.5f) + 0.5f))) * _e333);
let _e338 = frag_info.frame_params[0u];
s_10.exposure = max(_e338, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e343 = s_10;
return _e343;
}
fn main_1() {
var s_11: Surface;
var param_148: Surface;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_149: Surface;
var param_150: Surface;
var param_151: vec3<f32>;
var param_152: vec3<f32>;
var param_153: f32;
var param_154: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e226 = ReadSurface_u0028_();
s_11 = _e226;
let _e227 = s_11;
param_148 = _e227;
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_148));
let _e228 = param_148;
s_11 = _e228;
let _e230 = s_11.albedo;
let _e232 = s_11.ambient;
let _e233 = SampleLightmap_u0028_();
let _e237 = s_11.occlusion;
ambient = ((_e230 * (_e232 + _e233)) * _e237);
let _e239 = s_11;
param_149 = _e239;
let _e240 = 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_149));
let _e242 = s_11.occlusion;
let _e244 = ambient;
let _e247 = s_11.emissive;
lit_3 = (((_e240 * _e242) + _e244) + _e247);
let _e249 = s_11;
param_150 = _e249;
let _e250 = lit_3;
param_151 = _e250;
let _e251 = WriteDebugView_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_vf3_u003b((¶m_150), (¶m_151));
if _e251 {
return;
}
let _e252 = lit_3;
param_152 = _e252;
let _e254 = s_11.alpha;
param_153 = _e254;
let _e256 = s_11.roughness;
param_154 = _e256;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_152), (¶m_153), (¶m_154));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e217 = v_world_position_1;
let _e219 = fog_info.eye;
let _e223 = fog_info.forward;
return dot((_e217 - _e219.xyz), _e223.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e222 = ViewDepth_u0028_();
z = abs(_e222);
let _e224 = z;
near = (_e224 / 5f);
let _e226 = z;
far = (_e226 / 200f);
let _e228 = far;
let _e229 = far;
let _e231 = far;
far3_ = ((_e228 * _e229) * _e231);
let _e233 = (*alpha);
let _e234 = near;
let _e235 = near;
let _e238 = far3_;
let _e239 = far3_;
return (_e233 * clamp((10f / ((0.00001f + (_e234 * _e235)) + (_e238 * _e239))), 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 _e226 = fog_info.forward[3u];
mode = _e226;
let _e227 = mode;
if (_e227 > 0.5f) {
let _e230 = frag_color[3u];
alpha_1 = _e230;
let _e231 = alpha_1;
param = _e231;
let _e232 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e232;
let _e233 = frag_color;
let _e235 = weight;
let _e236 = (_e233.xyz * _e235);
let _e237 = alpha_1;
let _e238 = weight;
accumulate = vec4<f32>(_e236.x, _e236.y, _e236.z, (_e237 * _e238));
let _e244 = mode;
let _e246 = mode;
revealage = ((_e244 > 1.5f) && (_e246 < 2.5f));
let _e249 = revealage;
if _e249 {
let _e250 = alpha_1;
local = vec4(_e250);
} else {
let _e252 = accumulate;
local = _e252;
}
let _e253 = local;
frag_color = _e253;
let _e254 = mode;
if (_e254 > 2.5f) {
let _e256 = alpha_1;
frag_surface = vec4(_e256);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e220 = (*n)[0u];
let _e223 = (*n)[1u];
let _e227 = (*n)[2u];
let _e230 = (*n);
(*n) = (_e230 / vec3(((abs(_e220) + abs(_e223)) + abs(_e227))));
let _e233 = (*n);
e = _e233.xy;
let _e236 = (*n)[2u];
if (_e236 < 0f) {
let _e238 = (*n);
let _e244 = (*n)[0u];
let _e248 = (*n)[1u];
e = ((vec2(1f) - abs(_e238.yx)) * vec2<f32>(select(-1f, 1f, (_e244 >= 0f)), select(-1f, 1f, (_e248 >= 0f))));
}
let _e253 = e;
return ((_e253 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e218 = (*linear);
let _e220 = (*linear);
let _e224 = (*linear);
return mix((_e218 * 12.92f), ((pow(_e220, 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), _e224));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e221 = g_albedo;
param_1 = clamp(_e221, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e223 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e223.x, _e223.y, _e223.z, 1f);
let _e228 = g_debug_surface_on;
if _e228 {
let _e229 = g_debug_surface;
let _e230 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e229.x, _e229.y, _e229.z, _e230);
return;
}
let _e235 = v_normal_1;
geometric = normalize(_e235);
let _e237 = gl_FrontFacing_1;
if !(_e237) {
let _e239 = geometric;
geometric = -(_e239);
}
let _e241 = geometric;
param_2 = _e241;
let _e242 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e243 = (*roughness);
let _e245 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e242.x, _e242.y, clamp(_e243, 0f, 1f), _e245);
return;
}
fn Orthographic_u0028_() -> bool {
let _e219 = fog_info.projection[0u];
return (_e219 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e218 = Orthographic_u0028_();
if _e218 {
let _e219 = ViewDepth_u0028_();
local_1 = max(_e219, 0f);
} else {
let _e221 = v_world_position_1;
let _e223 = fog_info.eye;
local_1 = distance(_e221, _e223.xyz);
}
let _e226 = local_1;
return _e226;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e225 = fog_info.fog[3u];
density = _e225;
let _e226 = density;
if (_e226 <= 0f) {
let _e228 = (*color);
return _e228;
}
let _e229 = EyeDistance_u0028_();
d = _e229;
let _e232 = fog_info.eye[3u];
falloff = _e232;
let _e233 = falloff;
if (_e233 > 0f) {
let _e235 = falloff;
let _e237 = v_world_position_1[1u];
let _e240 = fog_info.eye[1u];
k = (_e235 * (_e237 - _e240));
let _e243 = k;
if (abs(_e243) > 0.001f) {
let _e246 = k;
let _e250 = k;
local_2 = ((1f - exp(-(_e246))) / _e250);
} else {
let _e252 = k;
local_2 = (1f - (0.5f * _e252));
}
let _e255 = local_2;
let _e256 = density;
density = (_e256 * _e255);
}
let _e259 = fog_info.fog;
let _e261 = (*color);
let _e262 = density;
let _e264 = d;
return mix(_e259.xyz, _e261, vec3(clamp(exp((-(_e262) * _e264)), 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 _e223 = g_premultiply;
let _e224 = (*alpha_2);
weight_1 = select(1f, _e224, _e223);
let _e226 = (*linearColor);
param_3 = _e226;
let _e227 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e228 = weight_1;
let _e229 = (_e227 * _e228);
let _e230 = (*alpha_2);
let _e231 = g_pass_through;
frag_color = vec4<f32>(_e229.x, _e229.y, _e229.z, (_e230 * (1f - _e231)));
let _e238 = (*roughness_1);
param_4 = _e238;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e218 = (*srgb);
let _e221 = (*srgb);
let _e226 = (*srgb);
return mix((_e218 / vec3(12.92f)), pow(((_e221 + 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), _e226));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e220 = (*key);
hue = fract(((_e220 * 0.618034f) + 0.13f));
let _e224 = hue;
k_1 = clamp((abs(((fract((vec3(_e224) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e237 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e237, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2639_: bool;
let _e218 = (*c);
let _e219 = (*c);
let _e221 = any((_e218 != _e219));
phi_2639_ = _e221;
if !(_e221) {
let _e223 = (*c);
phi_2639_ = any((abs(_e223) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e228 = phi_2639_;
return _e228;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2729_: bool;
var phi_2997_: bool;
let _e260 = gl_FragCoord_1[0u];
let _e263 = frag_info.debug_view[1u];
if (_e260 < _e263) {
let _e267 = frag_info.debug_view[2u];
local_3 = _e267;
} else {
let _e270 = frag_info.debug_view[0u];
local_3 = _e270;
}
let _e271 = local_3;
view = _e271;
let _e272 = view;
if (_e272 < 0.5f) {
return false;
}
let _e274 = view;
code = i32((_e274 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e277 = v_normal_1;
geometric_n = normalize(_e277);
let _e279 = v_tangent_1;
let _e281 = geometric_n;
let _e282 = geometric_n;
let _e283 = v_tangent_1;
tangent = (_e279.xyz - (_e281 * dot(_e282, _e283.xyz)));
let _e288 = tangent;
let _e289 = tangent;
let _e291 = (dot(_e288, _e289) > 0.000000000001f);
phi_2729_ = _e291;
if _e291 {
let _e293 = v_tangent_1[3u];
phi_2729_ = (abs((abs(_e293) - 1f)) < 0.01f);
}
let _e299 = phi_2729_;
tangent_usable = _e299;
let _e302 = frag_info.debug_view[3u];
identity = _e302;
let _e303 = identity;
identity_object = floor((_e303 / 8192f));
let _e306 = identity;
let _e307 = identity_object;
identity_rest = (_e306 - (_e307 * 8192f));
let _e310 = identity_rest;
identity_material = floor((_e310 / 2f));
let _e313 = identity_rest;
let _e314 = identity_material;
normal_mapped = ((_e313 - (_e314 * 2f)) > 0.5f);
let _e318 = code;
if (_e318 == 1i) {
let _e321 = (*s).albedo;
param_5 = clamp(_e321, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e323 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e323;
} else {
let _e324 = code;
if (_e324 == 2i) {
let _e327 = (*s).n;
shown = ((_e327 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e330 = code;
if (_e330 == 3i) {
let _e333 = (*s).roughness;
shown = vec3(clamp(_e333, 0f, 1f));
} else {
let _e336 = code;
if (_e336 == 4i) {
let _e339 = (*s).metallic;
shown = vec3(clamp(_e339, 0f, 1f));
} else {
let _e342 = code;
if (_e342 == 5i) {
let _e345 = (*s).occlusion;
shown = vec3(clamp(_e345, 0f, 1f));
} else {
let _e348 = code;
if (_e348 == 6i) {
let _e351 = (*s).emissive;
param_6 = clamp(_e351, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e353 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e353;
} else {
let _e354 = code;
if (_e354 == 7i) {
let _e356 = v_texcoord_1;
let _e357 = fract(_e356);
shown = vec3<f32>(_e357.x, _e357.y, 0f);
} else {
let _e361 = code;
if (_e361 == 8i) {
let _e363 = (*lit);
param_7 = clamp(_e363, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e365 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e365, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e367 = (*lit);
param_8 = _e367;
let _e368 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e368 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e369 = grey;
local_4 = vec3((_e369 * 0.5f));
}
let _e372 = local_4;
shown = _e372;
} else {
let _e373 = code;
if (_e373 == 9i) {
let _e375 = tangent_usable;
if _e375 {
let _e376 = tangent;
local_5 = ((normalize(_e376) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e380 = local_5;
shown = _e380;
} else {
let _e381 = code;
if (_e381 == 10i) {
let _e383 = v_texcoord_1;
uv = _e383;
let _e384 = uv;
cell = floor((_e384 * 8f));
let _e388 = cell[0u];
let _e390 = cell[1u];
odd = (fract(((_e388 + _e390) * 0.5f)) * 2f);
let _e395 = uv;
within = fract(_e395);
let _e397 = odd;
let _e401 = within[0u];
let _e405 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e397)) * vec3<f32>((0.55f + (0.45f * _e401)), (0.55f + (0.45f * _e405)), 0.85f));
} else {
let _e410 = code;
if (_e410 == 11i) {
let _e412 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e412));
} else {
let _e415 = code;
if (_e415 == 12i) {
let _e417 = v_color_1;
param_9 = clamp(_e417.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e420 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e420;
} else {
let _e421 = code;
let _e423 = code;
if ((_e421 == 13i) || (_e423 == 14i)) {
let _e426 = code;
let _e428 = identity_object;
let _e429 = identity_material;
key_1 = select(_e429, _e428, (_e426 == 13i));
let _e431 = key_1;
param_10 = _e431;
let _e432 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e434 = (*s).n_dot_v;
shown = (_e432 * (0.55f + (0.45f * _e434)));
} else {
let _e438 = code;
if (_e438 == 15i) {
let _e441 = (*s).albedo;
param_11 = clamp(_e441, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e443 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e443;
let _e444 = srgb_1;
luma = dot(_e444, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e447 = (*s).metallic;
metal = (_e447 > 0.5f);
let _e449 = metal;
let _e451 = luma;
if (!(_e449) && (_e451 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e454 = metal;
let _e455 = !(_e454);
phi_2997_ = _e455;
if _e455 {
let _e457 = srgb_1[0u];
let _e459 = srgb_1[1u];
let _e461 = srgb_1[2u];
phi_2997_ = (max(_e457, max(_e459, _e461)) > 0.9411765f);
}
let _e466 = phi_2997_;
if _e466 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e467 = metal;
let _e468 = luma;
if (_e467 && (_e468 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e471 = luma;
local_8 = vec3(_e471);
}
let _e473 = local_8;
local_7 = _e473;
}
let _e474 = local_7;
local_6 = _e474;
}
let _e475 = local_6;
shown = _e475;
} else {
let _e476 = code;
if (_e476 == 16i) {
let _e479 = (*s).metallic;
m = _e479;
let _e480 = m;
let _e482 = m;
if ((_e480 > 0.05f) && (_e482 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e485 = m;
local_9 = vec3(select(0.15f, 1f, (_e485 > 0.5f)));
}
let _e489 = local_9;
shown = _e489;
} else {
let _e490 = code;
if (_e490 == 17i) {
let _e492 = normal_mapped;
if !(_e492) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e494 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e494));
}
let _e497 = local_10;
shown = _e497;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e498 = g_premultiply;
if _e498 {
let _e500 = (*s).alpha;
local_11 = _e500;
} else {
local_11 = 1f;
}
let _e501 = local_11;
weight_2 = _e501;
let _e502 = shown;
param_12 = _e502;
let _e503 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e504 = weight_2;
let _e505 = (_e503 * _e504);
let _e507 = (*s).alpha;
frag_color = vec4<f32>(_e505.x, _e505.y, _e505.z, _e507);
let _e513 = (*s).roughness;
param_13 = _e513;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var shininess: f32;
var specular: f32;
let _e222 = (*s_1).roughness;
shininess = mix(256f, 4f, _e222);
let _e225 = (*light).n_dot_h;
let _e226 = shininess;
let _e230 = frag_info.material[3u];
specular = (pow(_e225, _e226) * _e230);
let _e233 = (*s_1).albedo;
let _e234 = specular;
return (_e233 + vec3(_e234));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e218 = (*i);
if (_e218 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e220 = (*i);
if (_e220 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e222 = (*i);
if (_e222 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e224 = (*i);
if (_e224 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e226 = (*i);
if (_e226 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e228 = (*i);
if (_e228 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e230 = (*i);
if (_e230 == 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_14: i32;
let _e223 = (*i_1);
param_14 = _e223;
let _e224 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e224;
let _e226 = p[0u];
let _e227 = (*ca);
let _e230 = p[1u];
let _e231 = (*sa);
let _e235 = p[0u];
let _e236 = (*sa);
let _e239 = p[1u];
let _e240 = (*ca);
let _e244 = (*radius);
return (vec2<f32>(((_e226 * _e227) - (_e230 * _e231)), ((_e235 * _e236) + (_e239 * _e240))) * _e244);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e226 = point_shadow.params[0u];
inset = _e226;
let _e227 = (*uv_1);
let _e228 = (*offset);
let _e230 = inset;
let _e231 = inset;
local_12 = clamp((_e227 + _e228), vec2(_e230), vec2((1f - _e231)));
let _e236 = local_12;
let _e237 = (*tile);
atlas = ((_e236 + _e237) * vec2<f32>(0.16666667f, 0.16666667f));
let _e242 = point_shadow.params3_[0u];
if (_e242 > 0.5f) {
let _e245 = atlas[1u];
atlas[1u] = (1f - _e245);
}
let _e248 = atlas;
let _e249 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e248, 0f);
let _e251 = atlas;
let _e252 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e251, 0f);
let _e255 = (*range);
return (min(_e249.x, _e252.x) * _e255);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e227 = (*uv_2);
param_15 = _e227;
let _e228 = (*offset_1);
param_16 = _e228;
let _e229 = (*tile_1);
param_17 = _e229;
let _e230 = (*range_1);
param_18 = _e230;
let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e231;
let _e232 = stored;
let _e233 = (*range_1);
if (_e232 >= (_e233 * 0.999f)) {
return 1f;
}
let _e236 = (*receiver);
let _e237 = stored;
return select(1f, 0f, (_e236 > _e237));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e248 = point_shadow.params2_[1u];
lightRadius = _e248;
let _e251 = point_shadow.params2_[0u];
minRadius = _e251;
let _e254 = point_shadow.params2_[2u];
maxRadius = _e254;
let _e255 = lightRadius;
if (_e255 <= 0f) {
let _e257 = (*uv_3);
param_19 = _e257;
param_20 = vec2<f32>(0f, 0f);
let _e258 = (*tile_2);
param_21 = _e258;
let _e259 = (*range_2);
param_22 = _e259;
let _e260 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e260;
let _e261 = minRadius;
return _e261;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e262 = i_2;
if (_e262 < 8i) {
let _e264 = i_2;
param_23 = _e264;
let _e265 = (*ca_1);
param_24 = _e265;
let _e266 = (*sa_1);
param_25 = _e266;
let _e267 = maxRadius;
param_26 = _e267;
let _e268 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e269 = (*uv_3);
param_27 = _e269;
param_28 = _e268;
let _e270 = (*tile_2);
param_29 = _e270;
let _e271 = (*range_2);
param_30 = _e271;
let _e272 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e272;
let _e273 = stored_1;
let _e274 = (*range_2);
if (_e273 >= (_e274 * 0.999f)) {
continue;
}
let _e277 = stored_1;
let _e278 = (*receiver_1);
if (_e277 >= _e278) {
continue;
}
let _e280 = stored_1;
let _e281 = sum;
sum = (_e281 + _e280);
let _e283 = count;
count = (_e283 + 1f);
continue;
} else {
break;
}
continuing {
let _e285 = i_2;
i_2 = (_e285 + 1i);
}
}
let _e287 = count;
if (_e287 < 0.5f) {
return -1f;
}
let _e289 = sum;
let _e290 = count;
blocker = max((_e289 / _e290), 0.0001f);
let _e293 = blocker;
(*blockerOut) = _e293;
let _e294 = lightRadius;
let _e295 = (*receiver_1);
let _e296 = blocker;
let _e300 = blocker;
world = ((_e294 * max((_e295 - _e296), 0f)) / _e300);
let _e302 = world;
let _e303 = (*receiver_1);
let _e305 = (*tanHalf);
let _e308 = minRadius;
let _e309 = maxRadius;
return clamp((_e302 / ((2f * _e303) * _e305)), _e308, _e309);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e219 = (*rows);
if (_e219 > 0f) {
let _e222 = gl_FragCoord_1[0u];
let _e223 = (*rows);
let _e225 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e222, (_e223 - _e225));
} else {
let _e228 = gl_FragCoord_1;
local_13 = _e228.xy;
}
let _e230 = local_13;
return _e230;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2326_: bool;
var phi_2387_: bool;
let _e271 = (*lightIndex);
let _e275 = point_shadow.slots[_e271][0u];
slot = i32((_e275 + 0.5f));
let _e278 = (*lightIndex);
let _e282 = point_shadow.slots[_e278][0u];
if (_e282 < 0f) {
return 1f;
}
let _e286 = point_shadow.params[2u];
strength = _e286;
let _e287 = strength;
if (_e287 <= 0f) {
return 1f;
}
let _e289 = slot;
let _e292 = point_shadow.lights[_e289];
let _e294 = (*world_1);
toLight = (_e292.xyz - _e294);
let _e296 = toLight;
toLightLength = max(length(_e296), 0.000001f);
let _e299 = (*normal);
let _e300 = toLight;
let _e301 = toLightLength;
nDotL = max(dot(_e299, (_e300 / vec3(_e301))), 0.15f);
let _e306 = nDotL;
let _e307 = nDotL;
let _e312 = nDotL;
let _e313 = nDotL;
slope = min((sqrt(max((1f - (_e306 * _e307)), 0f)) / (_e312 * _e313)), 8f);
let _e317 = toLightLength;
let _e319 = (*lightIndex);
let _e323 = point_shadow.slots[_e319][2u];
let _e328 = point_shadow.params3_[1u];
texel = (((2f * _e317) * max(_e323, 0.0001f)) * _e328);
let _e330 = (*world_1);
let _e331 = (*normal);
let _e332 = texel;
let _e336 = point_shadow.params[3u];
let _e338 = slope;
origin = (_e330 + (((_e331 * _e332) * _e336) * (1f + _e338)));
let _e342 = origin;
let _e343 = slot;
let _e346 = point_shadow.lights[_e343];
toFragment = (_e342 - _e346.xyz);
let _e349 = toFragment;
distance_ = length(_e349);
let _e351 = slot;
let _e355 = point_shadow.lights[_e351][3u];
range_3 = max(_e355, 0.0001f);
let _e357 = distance_;
let _e358 = range_3;
if (_e357 >= _e358) {
return 1f;
}
face = 0i;
let _e360 = (*lightIndex);
let _e364 = point_shadow.slots[_e360][1u];
if (_e364 < 0.5f) {
let _e366 = toFragment;
a = abs(_e366);
let _e369 = a[0u];
let _e371 = a[1u];
let _e372 = (_e369 >= _e371);
phi_2326_ = _e372;
if _e372 {
let _e374 = a[0u];
let _e376 = a[2u];
phi_2326_ = (_e374 >= _e376);
}
let _e379 = phi_2326_;
if _e379 {
let _e381 = toFragment[0u];
face = select(1i, 0i, (_e381 > 0f));
} else {
let _e385 = a[1u];
let _e387 = a[2u];
if (_e385 >= _e387) {
let _e390 = toFragment[1u];
face = select(3i, 2i, (_e390 > 0f));
} else {
let _e394 = toFragment[2u];
face = select(5i, 4i, (_e394 > 0f));
}
}
}
let _e397 = slot;
let _e399 = face;
let _e403 = point_shadow.faces[((_e397 * 6i) + _e399)];
let _e404 = origin;
clip = (_e403 * vec4<f32>(_e404.x, _e404.y, _e404.z, 1f));
let _e411 = clip[3u];
if (_e411 <= 0f) {
return 1f;
}
let _e413 = clip;
let _e416 = clip[3u];
ndc = (_e413.xy / vec2(_e416));
let _e420 = ndc[0u];
let _e422 = (abs(_e420) > 1f);
phi_2387_ = _e422;
if !(_e422) {
let _e425 = ndc[1u];
phi_2387_ = (abs(_e425) > 1f);
}
let _e429 = phi_2387_;
if _e429 {
return 1f;
}
let _e431 = ndc[0u];
let _e435 = ndc[1u];
uv_4 = vec2<f32>(((_e431 * 0.5f) + 0.5f), (0.5f - (_e435 * 0.5f)));
let _e439 = face;
let _e441 = slot;
tile_3 = vec2<f32>(f32(_e439), f32(_e441));
let _e444 = distance_;
let _e447 = point_shadow.params[1u];
receiver_2 = (_e444 - _e447);
let _e451 = frag_info.target_origin[0u];
param_31 = _e451;
let _e452 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e452, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e457 = noise;
angle = (_e457 * 6.2831855f);
let _e459 = angle;
ca_2 = cos(_e459);
let _e461 = angle;
sa_2 = sin(_e461);
let _e463 = (*lightIndex);
let _e467 = point_shadow.slots[_e463][2u];
tanHalf_1 = max(_e467, 0.0001f);
blocker_1 = -1f;
let _e469 = uv_4;
param_32 = _e469;
let _e470 = tile_3;
param_33 = _e470;
let _e471 = range_3;
param_34 = _e471;
let _e472 = receiver_2;
param_35 = _e472;
let _e473 = ca_2;
param_36 = _e473;
let _e474 = sa_2;
param_37 = _e474;
let _e475 = tanHalf_1;
param_38 = _e475;
let _e476 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e477 = param_39;
blocker_1 = _e477;
radius_1 = _e476;
let _e480 = point_shadow.params2_[3u];
if (_e480 > 0.5f) {
g_debug_surface_on = true;
let _e482 = radius_1;
if (_e482 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e484 = radius_1;
let _e487 = point_shadow.params2_[2u];
let _e491 = blocker_1;
let _e492 = range_3;
local_14 = vec3<f32>(clamp((_e484 / max(_e487, 0.000001f)), 0f, 1f), clamp((_e491 / _e492), 0f, 1f), 0f);
}
let _e496 = local_14;
g_debug_surface = _e496;
}
let _e497 = radius_1;
if (_e497 < 0f) {
return 1f;
}
let _e499 = uv_4;
param_40 = _e499;
param_41 = vec2<f32>(0f, 0f);
let _e500 = tile_3;
param_42 = _e500;
let _e501 = range_3;
param_43 = _e501;
let _e502 = receiver_2;
param_44 = _e502;
let _e503 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e503;
let _e504 = radius_1;
if (_e504 > 0f) {
i_3 = 0i;
loop {
let _e506 = i_3;
if (_e506 < 8i) {
let _e508 = i_3;
param_45 = _e508;
let _e509 = ca_2;
param_46 = _e509;
let _e510 = sa_2;
param_47 = _e510;
let _e511 = radius_1;
param_48 = _e511;
let _e512 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e513 = uv_4;
param_49 = _e513;
param_50 = _e512;
let _e514 = tile_3;
param_51 = _e514;
let _e515 = range_3;
param_52 = _e515;
let _e516 = receiver_2;
param_53 = _e516;
let _e517 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e518 = lit_1;
lit_1 = (_e518 + _e517);
continue;
} else {
break;
}
continuing {
let _e520 = i_3;
i_3 = (_e520 + 1i);
}
}
let _e522 = lit_1;
lit_1 = (_e522 * 0.11111111f);
}
let _e524 = lit_1;
let _e525 = strength;
return mix(1f, _e524, clamp(_e525, 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 _e222 = (*i_4);
let _e225 = (*n_1);
r = sqrt(((f32(_e222) + 0.5f) / f32(_e225)));
let _e229 = (*i_4);
let _e232 = (*turn);
theta = ((f32(_e229) * 2.3999631f) + _e232);
let _e234 = r;
let _e235 = theta;
let _e237 = theta;
return (vec2<f32>(cos(_e235), sin(_e237)) * _e234);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e221 = frag_info.target_origin[0u];
param_54 = _e221;
let _e222 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e225 = frag_info.target_origin[3u];
at = (_e222 + vec2((5.588238f * max(_e225, 0f))));
let _e230 = at;
return fract((52.982918f * fract(dot(_e230, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e220 = (*mode_1);
if (_e220 > 0.5f) {
let _e222 = (*stored_2);
local_15 = (1f - _e222);
} else {
let _e224 = (*stored_2);
local_15 = _e224;
}
let _e225 = local_15;
return _e225;
}
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 _e226 = (*moments)[1u];
let _e228 = (*moments)[0u];
let _e230 = (*moments)[0u];
let _e233 = (*minVariance);
variance = max((_e226 - (_e228 * _e230)), _e233);
let _e235 = (*t);
let _e237 = (*moments)[0u];
d_1 = (_e235 - _e237);
let _e239 = variance;
let _e240 = variance;
let _e241 = d_1;
let _e242 = d_1;
pMax = (_e239 / (_e240 + (_e241 * _e242)));
let _e246 = pMax;
let _e247 = (*bleed);
let _e249 = (*bleed);
reduced = clamp(((_e246 - _e247) / max((1f - _e249), 0.0001f)), 0f, 1f);
let _e254 = (*t);
let _e256 = (*moments)[0u];
let _e258 = reduced;
return select(_e258, 1f, (_e254 <= _e256));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e219 = (*depth);
d_2 = ((2f * clamp(_e219, 0f, 1f)) - 1f);
let _e223 = d_2;
let _e226 = d_2;
return vec2<f32>(exp((40f * _e223)), -(exp((-5f * _e226))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e233 = (*depth_1);
param_55 = _e233;
let _e234 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e234;
let _e235 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e235);
let _e238 = scale[0u];
let _e240 = scale[0u];
let _e242 = (*moments_1);
param_56 = _e242.xy;
let _e245 = warped[0u];
param_57 = _e245;
param_58 = (_e238 * _e240);
let _e246 = (*bleed_1);
param_59 = _e246;
let _e247 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e247;
let _e249 = scale[1u];
let _e251 = scale[1u];
let _e253 = (*moments_1);
param_60 = _e253.zw;
let _e256 = warped[1u];
param_61 = _e256;
param_62 = (_e249 * _e251);
let _e257 = (*bleed_1);
param_63 = _e257;
let _e258 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e258;
let _e259 = positive;
let _e260 = negative;
return min(_e259, _e260);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e219 = (*depth_2);
stored_3 = max((1f - _e219), 0.000061035156f);
let _e222 = stored_3;
return exp2((floor(log2(_e222)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3936_: bool;
var phi_3947_: bool;
var phi_4104_: bool;
var phi_4111_: bool;
var phi_4118_: bool;
let _e296 = frag_info.shadow_params[3u];
strength_1 = _e296;
let _e297 = strength_1;
if (_e297 <= 0f) {
return 1f;
}
let _e299 = (*lightIndex_1);
let _e302 = frag_info.frame_params[2u];
if (_e299 != i32(floor((_e302 + 0.5f)))) {
return 1f;
}
let _e309 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e309 + 0.5f));
let _e312 = Orthographic_u0028_();
if _e312 {
let _e313 = ViewDepth_u0028_();
local_16 = _e313;
} else {
let _e314 = v_world_position_1;
let _e316 = frag_info.camera_position;
local_16 = length((_e314 - _e316.xyz));
}
let _e320 = local_16;
viewDistance = _e320;
cascade = 0i;
let _e321 = cascadeCount;
let _e322 = (_e321 > 1i);
phi_3936_ = _e322;
if _e322 {
let _e323 = viewDistance;
let _e326 = frag_info.shadow_cascades[0u];
phi_3936_ = (_e323 > _e326);
}
let _e329 = phi_3936_;
if _e329 {
cascade = 1i;
}
let _e330 = cascadeCount;
let _e331 = (_e330 > 2i);
phi_3947_ = _e331;
if _e331 {
let _e332 = viewDistance;
let _e335 = frag_info.shadow_cascades[1u];
phi_3947_ = (_e332 > _e335);
}
let _e338 = phi_3947_;
if _e338 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e339 = attempt;
if (_e339 < 3i) {
let _e341 = cascade;
let _e342 = attempt;
which = (_e341 + _e342);
let _e344 = which;
let _e345 = cascadeCount;
if (_e344 >= _e345) {
break;
}
let _e347 = which;
if (_e347 == 0i) {
let _e350 = frag_info.shadow_matrix;
local_17 = _e350;
} else {
let _e351 = which;
if (_e351 == 1i) {
let _e354 = frag_info.shadow_matrix_far;
local_18 = _e354;
} else {
let _e356 = frag_info.shadow_matrix_farthest;
local_18 = _e356;
}
let _e357 = local_18;
local_17 = _e357;
}
let _e358 = local_17;
matrix = _e358;
let _e361 = matrix[0][0u];
let _e364 = matrix[1][0u];
let _e367 = matrix[2][0u];
axisX = vec3<f32>(_e361, _e364, _e367);
let _e371 = matrix[0][1u];
let _e374 = matrix[1][1u];
let _e377 = matrix[2][1u];
axisY = vec3<f32>(_e371, _e374, _e377);
let _e379 = axisX;
rowX = max(length(_e379), 0.000001f);
let _e382 = axisY;
rowY = max(length(_e382), 0.000001f);
let _e387 = frag_info.shadow_cascades[3u];
let _e389 = rowX;
texelMetres = ((2f * _e387) / _e389);
let _e393 = frag_info.shadow_cascades[3u];
let _e396 = (*s_2).n;
let _e397 = axisX;
let _e400 = rowX;
let _e401 = rowX;
let _e405 = (*s_2).n;
let _e406 = axisY;
let _e409 = rowY;
let _e410 = rowY;
reach = ((3f * _e393) * ((abs(dot(_e396, _e397)) / (_e400 * _e401)) + (abs(dot(_e405, _e406)) / (_e409 * _e410))));
let _e417 = frag_info.shadow_params[2u];
let _e418 = texelMetres;
flatOffset = min(_e417, _e418);
let _e420 = v_world_position_1;
let _e422 = (*s_2).n;
let _e423 = flatOffset;
let _e424 = reach;
origin_1 = (_e420 + (_e422 * (_e423 + _e424)));
let _e428 = matrix;
let _e429 = origin_1;
lightSpace = (_e428 * vec4<f32>(_e429.x, _e429.y, _e429.z, 1f));
let _e436 = lightSpace[3u];
if (_e436 <= 0f) {
continue;
}
let _e438 = lightSpace;
let _e441 = lightSpace[3u];
candidate = (_e438.xyz / vec3(_e441));
let _e445 = candidate[0u];
let _e449 = candidate[1u];
inTile = vec2<f32>(((_e445 * 0.5f) + 0.5f), (0.5f - (_e449 * 0.5f)));
let _e454 = inTile[0u];
let _e455 = (_e454 < 0f);
phi_4104_ = _e455;
if !(_e455) {
let _e458 = inTile[0u];
phi_4104_ = (_e458 > 1f);
}
let _e461 = phi_4104_;
phi_4111_ = _e461;
if !(_e461) {
let _e464 = inTile[1u];
phi_4111_ = (_e464 < 0f);
}
let _e467 = phi_4111_;
phi_4118_ = _e467;
if !(_e467) {
let _e470 = inTile[1u];
phi_4118_ = (_e470 > 1f);
}
let _e473 = phi_4118_;
if _e473 {
continue;
}
let _e475 = candidate[2u];
if (_e475 > 1f) {
let _e477 = which;
let _e478 = cascadeCount;
if (_e477 < (_e478 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e483 = inTile[0u];
let _e484 = which;
let _e487 = cascadeCount;
let _e491 = inTile[1u];
uv_5 = vec2<f32>(((_e483 + f32(_e484)) / f32(_e487)), _e491);
let _e493 = candidate;
projected = _e493;
let _e494 = which;
cascade = _e494;
let _e495 = texelMetres;
cascadeTexel = _e495;
let _e498 = matrix[0][2u];
let _e501 = matrix[1][2u];
let _e504 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e498, _e501, _e504)), 0.000001f));
let _e510 = (*s_2).n;
let _e513 = matrix[0][2u];
let _e516 = matrix[1][2u];
let _e519 = matrix[2][2u];
let _e523 = cascadeDepth;
cosSlope = clamp((abs(dot(_e510, vec3<f32>(_e513, _e516, _e519))) * _e523), 0.1f, 1f);
let _e526 = texelMetres;
let _e527 = cosSlope;
let _e528 = cosSlope;
let _e534 = cosSlope;
let _e536 = cascadeDepth;
receiverSlope = (((_e526 * sqrt(max((1f - (_e527 * _e528)), 0f))) / _e534) / _e536);
found = true;
break;
} else {
break;
}
continuing {
let _e538 = attempt;
attempt = (_e538 + 1i);
}
}
let _e540 = found;
if !(_e540) {
return 1f;
}
let _e542 = cascade;
if (_e542 == 0i) {
let _e546 = frag_info.shadow_bias[0u];
local_19 = _e546;
} else {
let _e547 = cascade;
if (_e547 == 1i) {
let _e551 = frag_info.shadow_bias[1u];
local_20 = _e551;
} else {
let _e554 = frag_info.shadow_bias[2u];
local_20 = _e554;
}
let _e555 = local_20;
local_19 = _e555;
}
let _e556 = local_19;
bias = _e556;
let _e559 = frag_info.shadow_params[1u];
storage_ = _e559;
let _e560 = storage_;
let _e562 = storage_;
if ((_e560 > 0.5f) && (_e562 < 1.5f)) {
let _e565 = bias;
let _e567 = projected[2u];
param_64 = _e567;
let _e568 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e565, _e568);
}
let _e572 = frag_info.shadow_params[0u];
let _e575 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e572, _e575);
let _e577 = cascade;
let _e579 = cascadeCount;
let _e583 = texel_1;
tileLo = (vec2<f32>((f32(_e577) / f32(_e579)), 0f) + (_e583 * 0.5f));
let _e586 = cascade;
let _e589 = cascadeCount;
let _e593 = texel_1;
tileHi = (vec2<f32>((f32((_e586 + 1i)) / f32(_e589)), 1f) - (_e593 * 0.5f));
let _e598 = frag_info.shadow_bias[3u];
if (_e598 > 0.5f) {
let _e600 = uv_5;
let _e601 = tileLo;
let _e602 = tileHi;
let _e604 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e600, _e601, _e602), 0f);
stored_4 = _e604;
let _e606 = stored_4[1u];
let _e609 = stored_4[2u];
let _e612 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e606), (1f - _e609), _e612), vec3(0f), vec3(4f));
let _e617 = through;
let _e618 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e617, vec3(clamp(_e618, 0f, 1f)));
}
let _e624 = frag_info.ambient_ground[3u];
softness = _e624;
lit_2 = 0f;
let _e625 = softness;
if (_e625 < 0f) {
let _e627 = uv_5;
let _e628 = tileLo;
let _e629 = tileHi;
let _e631 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e627, _e628, _e629), 0f);
moments_2 = _e631;
let _e633 = projected[2u];
let _e634 = bias;
let _e636 = softness;
let _e640 = moments_2;
param_65 = _e640;
param_66 = (_e633 - _e634);
param_67 = clamp((-(_e636) - 1f), 0f, 0.95f);
let _e641 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e641;
} else {
let _e642 = softness;
if (_e642 <= 0f) {
y = -1i;
loop {
let _e644 = y;
if (_e644 <= 1i) {
x = -1i;
loop {
let _e646 = x;
if (_e646 <= 1i) {
let _e648 = uv_5;
let _e649 = x;
let _e651 = y;
let _e654 = texel_1;
let _e657 = tileLo;
let _e658 = tileHi;
let _e660 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e648 + (vec2<f32>(f32(_e649), f32(_e651)) * _e654)), _e657, _e658), 0f);
param_68 = _e660.x;
let _e662 = storage_;
param_69 = _e662;
let _e663 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e663;
let _e665 = projected[2u];
let _e666 = bias;
let _e668 = occluder;
let _e671 = lit_2;
lit_2 = (_e671 + select(1f, 0f, ((_e665 - _e666) > _e668)));
continue;
} else {
break;
}
continuing {
let _e673 = x;
x = (_e673 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e675 = y;
y = (_e675 + 1i);
}
}
let _e677 = lit_2;
lit_2 = (_e677 * 0.11111111f);
} else {
let _e679 = softness;
spread = tan(min(_e679, 0.5f));
let _e682 = ShadowNoise_u0028_();
turn_1 = (_e682 * 6.2831855f);
let _e684 = spread;
let _e686 = projected[2u];
let _e688 = cascadeDepth;
let _e690 = cascadeTexel;
searchRadius = clamp((((_e684 * _e686) * _e688) / _e690), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e693 = i_5;
if (_e693 < 16i) {
let _e695 = i_5;
param_70 = _e695;
param_71 = 16i;
let _e696 = turn_1;
param_72 = _e696;
let _e697 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e697;
let _e698 = bias;
let _e699 = disc;
let _e701 = searchRadius;
let _e705 = receiverSlope;
tapBias = (_e698 + (max(((length(_e699) * _e701) - 1.5f), 0f) * _e705));
let _e708 = uv_5;
let _e709 = disc;
let _e710 = texel_1;
let _e712 = searchRadius;
let _e715 = tileLo;
let _e716 = tileHi;
let _e718 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e708 + ((_e709 * _e710) * _e712)), _e715, _e716), 0f);
param_73 = _e718.x;
let _e720 = storage_;
param_74 = _e720;
let _e721 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e721;
let _e723 = projected[2u];
let _e724 = tapBias;
let _e726 = occluder_1;
if ((_e723 - _e724) > _e726) {
let _e728 = occluder_1;
let _e729 = blockerSum;
blockerSum = (_e729 + _e728);
let _e731 = blockerCount;
blockerCount = (_e731 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e733 = i_5;
i_5 = (_e733 + 1i);
}
}
let _e735 = blockerCount;
if (_e735 <= 0f) {
return 1f;
}
let _e738 = projected[2u];
let _e739 = blockerSum;
let _e740 = blockerCount;
let _e744 = cascadeDepth;
gap = (max((_e738 - (_e739 / _e740)), 0f) * _e744);
let _e746 = spread;
let _e747 = gap;
let _e749 = cascadeTexel;
radius_2 = clamp(((_e746 * _e747) / _e749), 1f, 16f);
i_6 = 0i;
loop {
let _e752 = i_6;
if (_e752 < 16i) {
let _e754 = turn_1;
let _e756 = i_6;
param_75 = _e756;
param_76 = 16i;
param_77 = (_e754 + 1f);
let _e757 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e757;
let _e758 = bias;
let _e759 = disc_1;
let _e761 = radius_2;
let _e765 = receiverSlope;
tapBias_1 = (_e758 + (max(((length(_e759) * _e761) - 1.5f), 0f) * _e765));
let _e768 = uv_5;
let _e769 = disc_1;
let _e770 = texel_1;
let _e772 = radius_2;
let _e775 = tileLo;
let _e776 = tileHi;
let _e778 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e768 + ((_e769 * _e770) * _e772)), _e775, _e776), 0f);
param_78 = _e778.x;
let _e780 = storage_;
param_79 = _e780;
let _e781 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e781;
let _e783 = projected[2u];
let _e784 = tapBias_1;
let _e786 = occluder_2;
let _e789 = lit_2;
lit_2 = (_e789 + select(1f, 0f, ((_e783 - _e784) > _e786)));
continue;
} else {
break;
}
continuing {
let _e791 = i_6;
i_6 = (_e791 + 1i);
}
}
let _e793 = lit_2;
lit_2 = (_e793 * 0.0625f);
}
}
let _e795 = lit_2;
let _e796 = strength_1;
return mix(1f, _e795, clamp(_e796, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e223 = (*s_3);
param_80 = _e223;
let _e224 = (*light_2);
param_81 = _e224;
let _e225 = (*index);
param_82 = _e225;
let _e226 = 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_80), (¶m_81), (¶m_82));
return _e226;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e218 = (*index_1);
return (_e218 < 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 _e222 = (*distance_1);
let _e223 = (*distance_1);
attenuation = (1f / max((_e222 * _e223), 0.0001f));
let _e227 = (*range_4);
if (_e227 > 0f) {
let _e229 = (*distance_1);
let _e230 = (*range_4);
ratio = (_e229 / _e230);
let _e232 = ratio;
let _e233 = ratio;
let _e235 = ratio;
let _e237 = ratio;
window = clamp((1f - (((_e232 * _e233) * _e235) * _e237)), 0f, 1f);
let _e241 = window;
let _e242 = window;
let _e244 = attenuation;
attenuation = (_e244 * (_e241 * _e242));
}
let _e246 = attenuation;
return _e246;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e234 = (*halfWidth);
let _e235 = (*halfHeight);
n_2 = cross(_e234, _e235);
let _e237 = n_2;
nLen = length(_e237);
let _e239 = nLen;
if (_e239 < 0.000000000001f) {
let _e241 = (*centre);
return _e241;
}
let _e242 = nLen;
let _e243 = n_2;
n_2 = (_e243 / vec3(_e242));
let _e246 = (*centre);
let _e247 = (*world_2);
toPlane = (_e246 - _e247);
let _e249 = (*mirror);
let _e250 = n_2;
denom = dot(_e249, _e250);
let _e252 = denom;
if (abs(_e252) < 0.00001f) {
let _e255 = toPlane;
let _e256 = n_2;
let _e257 = toPlane;
let _e258 = n_2;
onPlane = (_e255 - (_e256 * dot(_e257, _e258)));
} else {
let _e262 = toPlane;
let _e263 = n_2;
let _e265 = denom;
t_1 = (dot(_e262, _e263) / _e265);
let _e267 = t_1;
if (_e267 > 0f) {
let _e269 = (*mirror);
let _e270 = t_1;
local_21 = (_e269 * _e270);
} else {
let _e272 = toPlane;
let _e273 = n_2;
let _e274 = toPlane;
let _e275 = n_2;
local_21 = (_e272 - (_e273 * dot(_e274, _e275)));
}
let _e279 = local_21;
onPlane = _e279;
}
let _e280 = onPlane;
let _e281 = toPlane;
offset_2 = (_e280 - _e281);
let _e283 = (*halfWidth);
let _e284 = (*halfWidth);
wLen2_ = max(dot(_e283, _e284), 0.000000000001f);
let _e287 = (*halfHeight);
let _e288 = (*halfHeight);
hLen2_ = max(dot(_e287, _e288), 0.000000000001f);
let _e291 = offset_2;
let _e292 = (*halfWidth);
let _e294 = wLen2_;
u = clamp((dot(_e291, _e292) / _e294), -1f, 1f);
let _e297 = offset_2;
let _e298 = (*halfHeight);
let _e300 = hLen2_;
v = clamp((dot(_e297, _e298) / _e300), -1f, 1f);
let _e303 = (*centre);
let _e304 = (*halfWidth);
let _e305 = u;
let _e308 = (*halfHeight);
let _e309 = v;
return ((_e303 + (_e304 * _e305)) + (_e308 * _e309));
}
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_22: f32;
let _e226 = (*a_1);
let _e227 = (*a_1);
ua = (_e226 / vec3(max(length(_e227), 0.000000000001f)));
let _e232 = (*b);
let _e233 = (*b);
ub = (_e232 / vec3(max(length(_e233), 0.000000000001f)));
let _e238 = ua;
let _e239 = ub;
angle_1 = acos(clamp(dot(_e238, _e239), -1f, 1f));
let _e243 = ua;
let _e244 = ub;
axis = cross(_e243, _e244);
let _e246 = axis;
len = length(_e246);
let _e248 = len;
if (_e248 > 0.000001f) {
let _e250 = angle_1;
let _e251 = axis;
let _e252 = (*n_3);
let _e255 = len;
local_22 = ((_e250 * dot(_e251, _e252)) / _e255);
} else {
local_22 = 0f;
}
let _e257 = local_22;
return _e257;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e240 = i_7;
if (_e240 < 4i) {
let _e242 = i_7;
let _e244 = (*corners)[_e242];
a_2 = _e244;
let _e245 = i_7;
if (_e245 == 3i) {
local_23 = 0i;
} else {
let _e247 = i_7;
local_23 = (_e247 + 1i);
}
let _e249 = local_23;
let _e251 = (*corners)[_e249];
b_1 = _e251;
let _e252 = a_2;
let _e253 = (*n_4);
ha = dot(_e252, _e253);
let _e255 = b_1;
let _e256 = (*n_4);
hb = dot(_e255, _e256);
let _e258 = ha;
let _e259 = hb;
d_3 = (_e258 - _e259);
let _e261 = a_2;
let _e262 = b_1;
let _e263 = a_2;
let _e265 = d_3;
if (abs(_e265) > 0.000000000001f) {
let _e268 = ha;
let _e269 = d_3;
local_24 = (_e268 / _e269);
} else {
local_24 = 0f;
}
let _e271 = local_24;
q = (_e261 + ((_e262 - _e263) * _e271));
let _e274 = ha;
aAbove = (_e274 > 0f);
let _e276 = hb;
bAbove = (_e276 > 0f);
let _e278 = aAbove;
let _e279 = bAbove;
if (_e278 || _e279) {
let _e281 = aAbove;
let _e282 = a_2;
let _e283 = q;
let _e286 = bAbove;
let _e287 = b_1;
let _e288 = q;
param_83 = select(_e283, _e282, vec3(_e281));
param_84 = select(_e288, _e287, vec3(_e286));
let _e291 = (*n_4);
param_85 = _e291;
let _e292 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e292;
} else {
local_25 = 0f;
}
let _e293 = local_25;
let _e294 = total;
total = (_e294 + _e293);
let _e296 = aAbove;
let _e297 = bAbove;
let _e300 = q;
let _e301 = exit;
exit = select(_e301, _e300, vec3((_e296 && !(_e297))));
let _e304 = aAbove;
let _e306 = bAbove;
let _e308 = q;
let _e309 = entry;
entry = select(_e309, _e308, vec3((!(_e304) && _e306)));
continue;
} else {
break;
}
continuing {
let _e312 = i_7;
i_7 = (_e312 + 1i);
}
}
let _e314 = exit;
param_86 = _e314;
let _e315 = entry;
param_87 = _e315;
let _e316 = (*n_4);
param_88 = _e316;
let _e317 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e318 = total;
total = (_e318 + _e317);
let _e320 = total;
return max((-(_e320) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e223 = (*slot_1);
let _e224 = (*slot_1);
lane = (_e223 - ((_e224 / 4i) * 4i));
let _e228 = lane;
if (_e228 == 0i) {
let _e231 = (*four)[0u];
local_26 = _e231;
} else {
let _e232 = lane;
if (_e232 == 1i) {
let _e235 = (*four)[1u];
local_27 = _e235;
} else {
let _e236 = lane;
if (_e236 == 2i) {
let _e239 = (*four)[2u];
local_28 = _e239;
} else {
let _e241 = (*four)[3u];
local_28 = _e241;
}
let _e242 = local_28;
local_27 = _e242;
}
let _e243 = local_27;
local_26 = _e243;
}
let _e244 = local_26;
return _e244;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e220 = (*slot_2);
let _e224 = light_list_info.scales[(_e220 / 4i)];
param_89 = _e224;
let _e225 = (*slot_2);
param_90 = _e225;
let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e226;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e222 = light_list_info.slot_rows[0i];
let _e223 = (*row);
a_3 = abs((_e222 - vec4(_e223)));
let _e229 = light_list_info.slot_rows[1i];
let _e230 = (*row);
b_2 = abs((_e229 - vec4(_e230)));
let _e235 = a_3[0u];
let _e237 = a_3[1u];
let _e240 = a_3[2u];
let _e242 = a_3[3u];
let _e246 = b_2[0u];
let _e248 = b_2[1u];
let _e251 = b_2[2u];
let _e253 = b_2[3u];
return (min(min(min(_e235, _e237), min(_e240, _e242)), min(min(_e246, _e248), min(_e251, _e253))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e220 = (*slot_3);
let _e224 = light_list_info.indices[(_e220 / 4i)];
param_91 = _e224;
let _e225 = (*slot_3);
param_92 = _e225;
let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e226;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e219 = (*texel_2);
let _e223 = light_list_info.list[1u];
let _e225 = (*row_1);
let _e229 = light_list_info.list[2u];
let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e219 + 0.5f) * _e223), ((_e225 + 0.5f) * _e229)), 0f);
return _e232;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e227 = g_cluster_offset;
let _e228 = (*slot_4);
entry_1 = (_e227 + f32(_e228));
let _e231 = entry_1;
row_2 = floor((_e231 / 16f));
let _e234 = entry_1;
let _e235 = row_2;
within_1 = (_e234 - (_e235 * 16f));
let _e238 = within_1;
texel_3 = floor((_e238 / 4f));
let _e243 = light_list_info.cluster_depth[3u];
let _e244 = row_2;
let _e246 = texel_3;
param_93 = _e246;
param_94 = (_e243 + _e244);
let _e247 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e247;
let _e248 = within_1;
let _e249 = texel_3;
let _e254 = four_1;
param_95 = _e254;
param_96 = i32(((_e248 - (_e249 * 4f)) + 0.5f));
let _e255 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e255;
}
fn Clustered_u0028_() -> bool {
let _e219 = light_list_info.cluster_grid[3u];
return (_e219 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e271 = (*index_2);
if (_e271 < 8i) {
let _e273 = (*index_2);
let _e276 = frag_info.light_position[_e273];
position = _e276;
let _e277 = (*index_2);
let _e280 = frag_info.light_color[_e277];
color_1 = _e280;
let _e281 = (*index_2);
let _e284 = frag_info.light_direction[_e281];
direction = _e284;
let _e285 = (*index_2);
let _e288 = frag_info.light_cone[_e285];
cone = _e288;
} else {
let _e289 = (*index_2);
slot_5 = (_e289 - 8i);
let _e291 = Clustered_u0028_();
clustered = _e291;
let _e292 = clustered;
if _e292 {
let _e293 = slot_5;
param_97 = _e293;
let _e294 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e294;
} else {
let _e295 = slot_5;
param_98 = _e295;
let _e296 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e296;
}
let _e297 = local_29;
listRow = _e297;
let _e298 = listRow;
let _e302 = light_list_info.list[2u];
v_1 = ((_e298 + 0.5f) * _e302);
let _e306 = light_list_info.list[1u];
u_1 = _e306;
let _e307 = u_1;
let _e309 = v_1;
let _e311 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e307), _e309), 0f);
position = _e311;
let _e312 = u_1;
let _e314 = v_1;
let _e316 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e312), _e314), 0f);
color_1 = _e316;
let _e317 = u_1;
let _e319 = v_1;
let _e321 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e317), _e319), 0f);
direction = _e321;
let _e322 = u_1;
let _e324 = v_1;
let _e326 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e322), _e324), 0f);
cone = _e326;
let _e327 = clustered;
if _e327 {
let _e328 = listRow;
param_99 = _e328;
let _e329 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e329);
} else {
let _e331 = slot_5;
param_100 = _e331;
let _e332 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e332;
}
let _e333 = local_30;
let _e335 = color_1[3u];
color_1[3u] = (_e335 * _e333);
}
let _e339 = position[3u];
type_39 = _e339;
let _e340 = type_39;
if (_e340 > 15.5f) {
let _e343 = (*s_4).n;
light_3.l = _e343;
let _e346 = (*s_4).n;
light_3.h = _e346;
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 _e352 = light_3;
return _e352;
}
let _e353 = type_39;
if (_e353 > 2.5f) {
let _e355 = direction;
halfWidth_1 = _e355.xyz;
let _e357 = cone;
halfHeight_1 = _e357.xyz;
let _e359 = position;
let _e361 = v_world_position_1;
toCentre = (_e359.xyz - _e361);
let _e363 = toCentre;
let _e364 = halfWidth_1;
let _e366 = halfHeight_1;
corners_1[0i] = ((_e363 - _e364) - _e366);
let _e369 = toCentre;
let _e370 = halfWidth_1;
let _e372 = halfHeight_1;
corners_1[1i] = ((_e369 + _e370) - _e372);
let _e375 = toCentre;
let _e376 = halfWidth_1;
let _e378 = halfHeight_1;
corners_1[2i] = ((_e375 + _e376) + _e378);
let _e381 = toCentre;
let _e382 = halfWidth_1;
let _e384 = halfHeight_1;
corners_1[3i] = ((_e381 - _e382) + _e384);
let _e387 = toCentre;
let _e388 = halfWidth_1;
let _e389 = halfHeight_1;
behind = (dot(_e387, cross(_e388, _e389)) >= 0f);
let _e393 = behind;
if _e393 {
local_31 = 0f;
} else {
let _e394 = corners_1;
param_101 = _e394;
let _e396 = (*s_4).n;
param_102 = _e396;
let _e397 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e397;
}
let _e398 = local_31;
formFactor = _e398;
let _e399 = halfWidth_1;
let _e400 = halfHeight_1;
area = (length(cross(_e399, _e400)) * 4f);
let _e404 = area;
if (_e404 > 0.000000001f) {
let _e406 = area;
local_32 = (1f / _e406);
} else {
local_32 = 0f;
}
let _e408 = local_32;
radiance = _e408;
let _e409 = toCentre;
distance_2 = length(_e409);
let _e412 = direction[3u];
if (_e412 > 0f) {
let _e414 = distance_2;
let _e416 = direction[3u];
ratio_1 = (_e414 / _e416);
let _e418 = ratio_1;
let _e419 = ratio_1;
let _e421 = ratio_1;
let _e423 = ratio_1;
window_1 = clamp((1f - (((_e418 * _e419) * _e421) * _e423)), 0f, 1f);
let _e427 = window_1;
let _e428 = window_1;
let _e430 = radiance;
radiance = (_e430 * (_e427 * _e428));
}
let _e433 = (*s_4).v;
let _e436 = (*s_4).n;
mirror_1 = reflect(-(_e433), _e436);
let _e438 = position;
param_103 = _e438.xyz;
let _e440 = halfWidth_1;
param_104 = _e440;
let _e441 = halfHeight_1;
param_105 = _e441;
let _e442 = v_world_position_1;
param_106 = _e442;
let _e443 = mirror_1;
param_107 = _e443;
let _e444 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e444;
let _e445 = representative;
let _e446 = v_world_position_1;
toPoint = (_e445 - _e446);
let _e448 = toPoint;
pointDistance = length(_e448);
let _e450 = pointDistance;
if (_e450 > 0.000001f) {
let _e452 = toPoint;
let _e453 = pointDistance;
local_33 = (_e452 / vec3(_e453));
} else {
let _e457 = (*s_4).n;
local_33 = _e457;
}
let _e458 = local_33;
light_3.l = _e458;
let _e461 = light_3.l;
let _e463 = (*s_4).v;
light_3.h = normalize((_e461 + _e463));
let _e467 = formFactor;
light_3.n_dot_l = _e467;
let _e470 = (*s_4).n;
let _e472 = light_3.h;
light_3.n_dot_h = max(dot(_e470, _e472), 0f);
let _e477 = (*s_4).v;
let _e479 = light_3.h;
light_3.v_dot_h = max(dot(_e477, _e479), 0f);
let _e483 = color_1;
let _e486 = color_1[3u];
let _e488 = radiance;
light_3.radiance = ((_e483.xyz * _e486) * _e488);
let _e491 = light_3;
return _e491;
}
let _e492 = direction;
aim = normalize(_e492.xyz);
attenuation_1 = 1f;
let _e495 = type_39;
if (_e495 < 0.5f) {
let _e497 = aim;
light_3.l = -(_e497);
} else {
let _e500 = position;
let _e502 = v_world_position_1;
toLight_1 = (_e500.xyz - _e502);
let _e504 = toLight_1;
distance_3 = length(_e504);
let _e506 = distance_3;
if (_e506 < 0.000001f) {
let _e509 = (*s_4).n;
light_3.l = _e509;
let _e512 = (*s_4).n;
light_3.h = _e512;
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 _e518 = light_3;
return _e518;
}
let _e519 = toLight_1;
let _e520 = distance_3;
light_3.l = (_e519 / vec3(_e520));
let _e524 = distance_3;
param_108 = _e524;
let _e526 = direction[3u];
param_109 = _e526;
let _e527 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e527;
let _e528 = type_39;
if (_e528 > 1.5f) {
let _e530 = aim;
let _e532 = light_3.l;
cosAngle = dot(_e530, -(_e532));
let _e535 = cosAngle;
let _e537 = cone[1u];
let _e540 = cone[0u];
let _e542 = cone[1u];
ramp = clamp(((_e535 - _e537) / (_e540 - _e542)), 0f, 1f);
let _e546 = ramp;
let _e547 = ramp;
let _e549 = attenuation_1;
attenuation_1 = (_e549 * (_e546 * _e547));
}
}
let _e552 = light_3.l;
let _e554 = (*s_4).v;
light_3.h = normalize((_e552 + _e554));
let _e559 = (*s_4).n;
let _e561 = light_3.l;
light_3.n_dot_l = max(dot(_e559, _e561), 0f);
let _e566 = (*s_4).n;
let _e568 = light_3.h;
light_3.n_dot_h = max(dot(_e566, _e568), 0f);
let _e573 = (*s_4).v;
let _e575 = light_3.h;
light_3.v_dot_h = max(dot(_e573, _e575), 0f);
let _e579 = color_1;
let _e582 = color_1[3u];
let _e584 = attenuation_1;
light_3.radiance = ((_e579.xyz * _e582) * _e584);
let _e587 = light_3;
return _e587;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e232 = light_list_info.cluster_view_projection;
let _e233 = (*world_3);
clip_1 = (_e232 * vec4<f32>(_e233.x, _e233.y, _e233.z, 1f));
let _e239 = clip_1;
let _e242 = clip_1[3u];
ndc_1 = (_e239.xy / vec2(max(_e242, 0.000001f)));
let _e247 = light_list_info.cluster_grid;
grid = _e247.xyz;
let _e251 = light_list_info.cluster_depth[0u];
near_1 = _e251;
let _e253 = ndc_1[0u];
let _e257 = grid[0u];
let _e261 = grid[0u];
tx = clamp(floor((((_e253 * 0.5f) + 0.5f) * _e257)), 0f, (_e261 - 1f));
let _e265 = ndc_1[1u];
let _e269 = grid[1u];
let _e273 = grid[1u];
ty = clamp(floor((((_e265 * 0.5f) + 0.5f) * _e269)), 0f, (_e273 - 1f));
let _e277 = clip_1[3u];
let _e278 = near_1;
if (_e277 <= _e278) {
local_34 = 0f;
} else {
let _e281 = clip_1[3u];
let _e282 = near_1;
let _e287 = light_list_info.cluster_depth[1u];
let _e291 = grid[2u];
local_34 = clamp(floor((log((_e281 / _e282)) * _e287)), 0f, (_e291 - 1f));
}
let _e294 = local_34;
tz = _e294;
let _e295 = tx;
let _e296 = ty;
let _e298 = grid[0u];
let _e301 = tz;
let _e303 = grid[0u];
let _e306 = grid[1u];
cell_1 = ((_e295 + (_e296 * _e298)) + ((_e301 * _e303) * _e306));
let _e309 = cell_1;
row_3 = floor((_e309 / 4f));
let _e312 = cell_1;
let _e313 = row_3;
let _e318 = light_list_info.cluster_depth[2u];
let _e319 = row_3;
param_110 = (_e312 - (_e313 * 4f));
param_111 = (_e318 + _e319);
let _e321 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e321;
let _e323 = header[0u];
g_cluster_offset = _e323;
let _e325 = header[1u];
g_cluster_count = _e325;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e221 = light_list_info.list[0u];
tail = _e221;
let _e222 = Clustered_u0028_();
if _e222 {
let _e223 = v_world_position_1;
param_112 = _e223;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e224 = g_cluster_count;
tail = _e224;
}
let _e227 = frag_info.frame_params[1u];
let _e231 = tail;
return (clamp(i32((_e227 + 0.5f)), 0i, 8i) + clamp(i32((_e231 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e235 = LightCount_u0028_();
count_1 = _e235;
i_8 = 0i;
loop {
let _e236 = i_8;
if (_e236 < 32i) {
let _e238 = i_8;
let _e239 = count_1;
if (_e238 >= _e239) {
break;
}
let _e241 = i_8;
param_113 = _e241;
let _e242 = (*s_5);
param_114 = _e242;
let _e243 = 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_113), (¶m_114));
light_4 = _e243;
let _e245 = light_4.n_dot_l;
if (_e245 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e247 = i_8;
param_115 = _e247;
let _e248 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e248 {
let _e249 = (*s_5);
param_116 = _e249;
let _e250 = light_4;
param_117 = _e250;
let _e251 = i_8;
param_118 = _e251;
let _e252 = 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_116), (¶m_117), (¶m_118));
let _e253 = v_world_position_1;
param_119 = _e253;
let _e255 = (*s_5).n;
param_120 = _e255;
let _e256 = i_8;
param_121 = _e256;
let _e257 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e252 * _e257);
} else {
local_35 = 1f;
}
let _e259 = local_35;
visibility = _e259;
let _e260 = visibility;
if (_e260 <= 0f) {
continue;
}
let _e262 = (*s_5);
param_122 = _e262;
let _e263 = light_4;
param_123 = _e263;
let _e264 = 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_122), (¶m_123));
let _e266 = light_4.radiance;
let _e269 = light_4.n_dot_l;
let _e271 = visibility;
let _e273 = light_transmittance;
let _e275 = total_1;
total_1 = (_e275 + ((((_e264 * _e266) * _e269) * _e271) * _e273));
continue;
} else {
break;
}
continuing {
let _e277 = i_8;
i_8 = (_e277 + 1i);
}
}
let _e279 = total_1;
return _e279;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e218 = v_lightmap_uv_1;
let _e219 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e218);
texel_4 = _e219;
let _e220 = texel_4;
let _e223 = texel_4[3u];
return ((_e220.xyz * _e223) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e219 = frag_info.target_origin[1u];
return _e219;
}
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_6: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e219 = v_texcoord_1;
let _e220 = MaterialLodBias_u0028_();
let _e221 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e219, _e220);
orm = _e221.xyz;
let _e224 = (*s_6).metallic;
let _e226 = orm[2u];
(*s_6).metallic = clamp((_e224 * _e226), 0f, 1f);
let _e231 = (*s_6).roughness;
let _e233 = orm[1u];
(*s_6).roughness = clamp((_e231 * _e233), 0.02f, 1f);
return;
}
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_7: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_124: vec3<f32>;
let _e220 = v_texcoord_1;
let _e221 = MaterialLodBias_u0028_();
let _e222 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e220, _e221);
param_124 = _e222.xyz;
let _e224 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e224;
let _e225 = emissive;
let _e227 = frag_info.emissive;
let _e232 = frag_info.material2_[3u];
(*s_7).emissive = ((_e225 * _e227.xyz) * _e232);
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_8: ptr<function, Surface>) {
var occlusion: f32;
let _e219 = v_texcoord_1;
let _e220 = MaterialLodBias_u0028_();
let _e221 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e219, _e220);
occlusion = _e221.x;
let _e223 = occlusion;
let _e226 = frag_info.material2_[2u];
(*s_8).occlusion = mix(1f, _e223, clamp(_e226, 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_9: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e222 = v_texcoord_1;
let _e223 = MaterialLodBias_u0028_();
let _e224 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e222, _e223);
sampledTexel = _e224;
let _e225 = v_tangent_1;
t_2 = _e225.xyz;
let _e227 = t_2;
let _e229 = (*s_9).n;
let _e231 = (*s_9).n;
let _e232 = t_2;
t_2 = (_e227 - (_e229 * dot(_e231, _e232)));
let _e236 = t_2;
let _e237 = t_2;
if (dot(_e236, _e237) < 0.000000000001f) {
return;
}
let _e240 = t_2;
t_2 = normalize(_e240);
let _e243 = (*s_9).n;
let _e244 = t_2;
let _e247 = v_tangent_1[3u];
b_3 = (cross(_e243, _e244) * _e247);
let _e249 = gl_FrontFacing_1;
if !(_e249) {
let _e251 = t_2;
t_2 = -(_e251);
}
let _e253 = sampledTexel;
sampled = ((_e253.xyz * 2f) - vec3(1f));
let _e260 = frag_info.emissive[3u];
if (_e260 > 0.5f) {
let _e262 = sampled;
let _e264 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e262.xy, _e264.xy)), 0f));
}
let _e273 = frag_info.material2_[1u];
let _e274 = sampled;
let _e276 = (_e274.xy * _e273);
sampled[0u] = _e276.x;
sampled[1u] = _e276.y;
let _e281 = t_2;
let _e283 = sampled[0u];
let _e285 = b_3;
let _e287 = sampled[1u];
let _e291 = (*s_9).n;
let _e293 = sampled[2u];
(*s_9).n = normalize((((_e281 * _e283) + (_e285 * _e287)) + (_e291 * _e293)));
let _e299 = (*s_9).n;
let _e301 = (*s_9).v;
(*s_9).n_dot_v = max(dot(_e299, _e301), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e218 = (*texel_5);
let _e222 = irradiance_info.atlas;
let _e225 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e218 + vec2(0.5f)) * _e222.xy), 0f);
return _e225;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e231 = (*uv_6);
let _e232 = (*interior);
at_1 = ((vec2(1f) + (_e231 * _e232)) - vec2(0.5f));
let _e238 = at_1;
low = floor(_e238);
let _e240 = at_1;
let _e241 = low;
f = (_e240 - _e241);
let _e243 = (*corner);
let _e244 = low;
param_125 = (_e243 + _e244);
let _e246 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e246;
let _e247 = (*corner);
let _e248 = low;
param_126 = ((_e247 + _e248) + vec2<f32>(1f, 0f));
let _e251 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e251;
let _e252 = (*corner);
let _e253 = low;
param_127 = ((_e252 + _e253) + vec2<f32>(0f, 1f));
let _e256 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e256;
let _e257 = (*corner);
let _e258 = low;
param_128 = ((_e257 + _e258) + vec2<f32>(1f, 1f));
let _e261 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e261;
let _e262 = a_4;
let _e263 = b_4;
let _e265 = f[0u];
let _e268 = c_1;
let _e269 = d_4;
let _e271 = f[0u];
let _e275 = f[1u];
return mix(mix(_e262, _e263, vec4(_e265)), mix(_e268, _e269, vec4(_e271)), vec4(_e275));
}
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 _e222 = (*direction_1)[0u];
let _e225 = (*direction_1)[1u];
let _e229 = (*direction_1)[2u];
sum_1 = ((abs(_e222) + abs(_e225)) + abs(_e229));
let _e232 = sum_1;
if (_e232 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e234 = (*direction_1);
let _e235 = sum_1;
n_5 = (_e234 / vec3(_e235));
let _e238 = n_5;
xy = _e238.xy;
let _e241 = n_5[2u];
if (_e241 < 0f) {
let _e244 = n_5[1u];
let _e248 = n_5[0u];
let _e253 = n_5[0u];
let _e257 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e244)) * select(-1f, 1f, (_e248 >= 0f))), ((1f - abs(_e253)) * select(-1f, 1f, (_e257 >= 0f))));
}
let _e262 = xy;
return ((_e262 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e264 = irradiance_info.origin;
origin_2 = _e264.xyz;
let _e267 = irradiance_info.spacing;
spacing = _e267.xyz;
let _e270 = irradiance_info.counts;
counts = _e270.xyz;
let _e274 = irradiance_info.tiles[0u];
irradianceTile = _e274;
let _e277 = irradiance_info.tiles[1u];
depthTile = _e277;
let _e280 = irradiance_info.tiles[2u];
columns = _e280;
let _e283 = irradiance_info.tiles[3u];
momentsTop = _e283;
let _e284 = (*normal_1);
unit = normalize(_e284);
let _e286 = (*world_4);
let _e287 = unit;
let _e290 = irradiance_info.spacing[3u];
let _e293 = (*view_1);
let _e296 = irradiance_info.counts[3u];
biased = ((_e286 + (_e287 * _e290)) + (_e293 * _e296));
let _e299 = biased;
let _e300 = origin_2;
let _e302 = spacing;
grid_1 = ((_e299 - _e300) / _e302);
let _e304 = grid_1;
let _e306 = counts;
base = clamp(floor(_e304), vec3<f32>(0f, 0f, 0f), (_e306 - vec3(2f)));
let _e310 = grid_1;
let _e311 = base;
f_1 = clamp((_e310 - _e311), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e314 = corner_1;
if (_e314 < 8i) {
let _e316 = corner_1;
let _e319 = corner_1;
let _e324 = corner_1;
offset_3 = vec3<f32>(f32((_e316 & 1i)), f32(((_e319 >> bitcast<u32>(1i)) & 1i)), f32(((_e324 >> bitcast<u32>(2i)) & 1i)));
let _e330 = base;
let _e331 = offset_3;
cell_2 = (_e330 + _e331);
let _e334 = cell_2[2u];
let _e336 = counts[1u];
let _e339 = cell_2[1u];
let _e342 = counts[0u];
let _e345 = cell_2[0u];
probe = ((((_e334 * _e336) + _e339) * _e342) + _e345);
let _e347 = probe;
let _e348 = columns;
let _e353 = probe;
let _e354 = columns;
tile_4 = vec2<f32>((_e347 - (floor((_e347 / _e348)) * _e348)), floor((_e353 / _e354)));
let _e358 = tile_4;
let _e359 = irradianceTile;
irradianceCorner = (_e358 * (_e359 + 2f));
let _e363 = tile_4[0u];
let _e364 = depthTile;
let _e367 = momentsTop;
let _e369 = tile_4[1u];
let _e370 = depthTile;
momentCorner = vec2<f32>((_e363 * (_e364 + 2f)), (_e367 + (_e369 * (_e370 + 2f))));
let _e375 = irradianceCorner;
param_129 = (_e375 + vec2(1f));
let _e378 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e378.w < 0.5f) {
continue;
}
let _e381 = f_1;
let _e383 = f_1;
let _e384 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e381), _e383, _e384);
let _e387 = trilinear[0u];
let _e389 = trilinear[1u];
let _e392 = trilinear[2u];
weight_3 = max(((_e387 * _e389) * _e392), 0.001f);
let _e395 = origin_2;
let _e396 = spacing;
let _e397 = cell_2;
probePosition = (_e395 + (_e396 * _e397));
let _e400 = probePosition;
let _e401 = biased;
toProbe = (_e400 - _e401);
let _e403 = toProbe;
distance_4 = length(_e403);
let _e405 = distance_4;
if (_e405 > 0.000001f) {
let _e407 = toProbe;
let _e408 = distance_4;
direction_2 = (_e407 / vec3(_e408));
let _e411 = unit;
let _e412 = probePosition;
let _e413 = (*world_4);
facing = ((dot(_e411, normalize((_e412 - _e413))) * 0.5f) + 0.5f);
let _e419 = facing;
let _e420 = facing;
probeWeight = ((_e419 * _e420) + 0.2f);
let _e423 = direction_2;
param_130 = -(_e423);
let _e425 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e426 = momentCorner;
param_131 = _e426;
let _e427 = depthTile;
param_132 = _e427;
param_133 = _e425;
let _e428 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e428.xy;
chebyshev = 1f;
let _e430 = distance_4;
let _e432 = moments_3[0u];
if (_e430 > _e432) {
let _e435 = moments_3[1u];
let _e437 = moments_3[0u];
let _e439 = moments_3[0u];
variance_1 = max((_e435 - (_e437 * _e439)), 0.000001f);
let _e443 = distance_4;
let _e445 = moments_3[0u];
difference = (_e443 - _e445);
let _e447 = variance_1;
let _e448 = variance_1;
let _e449 = difference;
let _e450 = difference;
chebyshev = (_e447 / (_e448 + (_e449 * _e450)));
let _e454 = chebyshev;
let _e455 = chebyshev;
let _e457 = chebyshev;
chebyshev = ((_e454 * _e455) * _e457);
}
let _e459 = probeWeight;
let _e460 = chebyshev;
probeWeight = max((_e459 * max(_e460, 0.05f)), 0.000001f);
let _e464 = probeWeight;
if (_e464 < 0.2f) {
let _e466 = probeWeight;
let _e467 = probeWeight;
let _e470 = probeWeight;
probeWeight = (_e470 * ((_e466 * _e467) * 25f));
}
let _e472 = probeWeight;
let _e473 = weight_3;
weight_3 = (_e473 * _e472);
}
let _e475 = unit;
param_134 = _e475;
let _e476 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e477 = irradianceCorner;
param_135 = _e477;
let _e478 = irradianceTile;
param_136 = _e478;
param_137 = _e476;
let _e479 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e481 = weight_3;
let _e483 = total_2;
total_2 = (_e483 + (_e479.xyz * _e481));
let _e485 = weight_3;
let _e486 = weights;
weights = (_e486 + _e485);
continue;
} else {
break;
}
continuing {
let _e488 = corner_1;
corner_1 = (_e488 + 1i);
}
}
let _e490 = weights;
if (_e490 > 0f) {
let _e492 = total_2;
let _e493 = weights;
local_36 = (_e492 / vec3(_e493));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e496 = local_36;
return _e496;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e219 = irradiance_info.origin[3u];
return (_e219 > 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_10: ptr<function, Surface>) {
var param_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e224 = IrradianceEnabled_u0028_();
if _e224 {
let _e225 = v_world_position_1;
param_138 = _e225;
let _e227 = (*s_10).n;
param_139 = _e227;
let _e229 = (*s_10).v;
param_140 = _e229;
let _e230 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e233 = frag_info.material[2u];
(*s_10).ambient = (_e230 * _e233);
}
let _e236 = (*s_10);
param_141 = _e236;
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_141));
let _e237 = param_141;
(*s_10) = _e237;
let _e238 = (*s_10);
param_142 = _e238;
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_142));
let _e239 = param_142;
(*s_10) = _e239;
let _e240 = (*s_10);
param_143 = _e240;
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_143));
let _e241 = param_143;
(*s_10) = _e241;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e218 = Orthographic_u0028_();
if _e218 {
let _e220 = fog_info.forward;
local_37 = -(_e220.xyz);
} else {
let _e224 = fog_info.eye;
let _e226 = v_world_position_1;
local_37 = normalize((_e224.xyz - _e226));
}
let _e229 = local_37;
return _e229;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_3: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e223 = (*cutoff);
key_2 = (-2f - _e223);
let _e225 = key_2;
let _e228 = key_2;
let _e230 = floor((_e228 / 128f));
let _e235 = key_2;
origin_3 = vec3<f32>(floor((_e225 / 16384f)), (_e230 - (floor((_e230 / 128f)) * 128f)), (_e235 - (floor((_e235 / 128f)) * 128f)));
let _e241 = (*scenePosition);
let _e244 = origin_3;
let _e245 = (floor((_e241 * 16f)) + _e244);
let _e246 = vec3(128f);
cell_3 = (_e245 - (floor((_e245 / _e246)) * _e246));
let _e251 = cell_3;
p3_ = fract((_e251 * 0.1031f));
let _e254 = p3_;
let _e255 = p3_;
let _e260 = p3_;
p3_ = (_e260 + vec3(dot(_e254, (_e255.zyx + vec3(31.32f)))));
let _e264 = p3_[0u];
let _e266 = p3_[1u];
let _e269 = p3_[2u];
return fract(((_e264 + _e266) * _e269));
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_11: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_146: vec3<f32>;
var param_147: f32;
let _e225 = v_texcoord_1;
let _e226 = MaterialLodBias_u0028_();
let _e227 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e225, _e226);
texel_6 = _e227;
let _e228 = texel_6;
param_144 = _e228.xyz;
let _e230 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e232 = frag_info.base_color;
param_145 = _e232.xyz;
let _e234 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e236 = v_color_1;
s_11.albedo = ((_e230 * _e234) * _e236.xyz);
let _e241 = texel_6[3u];
let _e244 = frag_info.base_color[3u];
let _e247 = v_color_1[3u];
s_11.alpha = ((_e241 * _e244) * _e247);
let _e251 = s_11.albedo;
g_albedo = _e251;
let _e254 = frag_info.material2_[0u];
cutoff_1 = _e254;
let _e255 = cutoff_1;
if (_e255 > 1f) {
let _e257 = cutoff_1;
edge = (_e257 - 1f);
let _e260 = s_11.alpha;
let _e261 = edge;
let _e264 = s_11.alpha;
let _e265 = fwidth(_e264);
s_11.alpha = clamp((((_e260 - _e261) / max(_e265, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e271 = cutoff_1;
if (_e271 >= 0f) {
let _e274 = s_11.alpha;
let _e275 = cutoff_1;
if (_e274 < _e275) {
discard;
}
s_11.alpha = 1f;
} else {
let _e278 = cutoff_1;
if (_e278 < -1.5f) {
let _e281 = s_11.alpha;
let _e282 = v_world_position_1;
param_146 = _e282;
let _e283 = cutoff_1;
param_147 = _e283;
let _e284 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_146), (¶m_147));
if (_e281 < _e284) {
discard;
}
}
}
}
let _e286 = cutoff_1;
let _e288 = cutoff_1;
g_premultiply = ((_e286 < 0f) && (_e288 > -0.75f));
let _e291 = v_normal_1;
s_11.n = normalize(_e291);
let _e294 = gl_FrontFacing_1;
if !(_e294) {
let _e297 = s_11.n;
s_11.n = -(_e297);
}
let _e300 = TowardsEye_u0028_();
s_11.v = _e300;
let _e303 = s_11.n;
let _e305 = s_11.v;
s_11.n_dot_v = max(dot(_e303, _e305), 0.0001f);
let _e311 = frag_info.material[0u];
s_11.metallic = clamp(_e311, 0f, 1f);
let _e316 = frag_info.material[1u];
s_11.roughness = clamp(_e316, 0.02f, 1f);
let _e320 = frag_info.ambient_ground;
let _e323 = frag_info.ambient_sky;
let _e327 = s_11.n[1u];
let _e334 = frag_info.material[2u];
s_11.ambient = (mix(_e320.xyz, _e323.xyz, vec3(((_e327 * 0.5f) + 0.5f))) * _e334);
let _e339 = frag_info.frame_params[0u];
s_11.exposure = max(_e339, 0f);
s_11.occlusion = 1f;
s_11.emissive = vec3<f32>(0f, 0f, 0f);
let _e344 = s_11;
return _e344;
}
fn main_1() {
var s_12: Surface;
var param_148: Surface;
var param_149: Surface;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_150: Surface;
var param_151: Surface;
var param_152: vec3<f32>;
var param_153: vec3<f32>;
var param_154: f32;
var param_155: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e228 = ReadSurface_u0028_();
s_12 = _e228;
let _e229 = s_12;
param_148 = _e229;
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_148));
let _e230 = param_148;
s_12 = _e230;
let _e231 = s_12;
param_149 = _e231;
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_149));
let _e232 = param_149;
s_12 = _e232;
let _e234 = s_12.albedo;
let _e236 = s_12.ambient;
let _e237 = SampleLightmap_u0028_();
let _e241 = s_12.occlusion;
ambient = ((_e234 * (_e236 + _e237)) * _e241);
let _e243 = s_12;
param_150 = _e243;
let _e244 = 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_150));
let _e246 = s_12.occlusion;
let _e248 = ambient;
let _e251 = s_12.emissive;
lit_3 = (((_e244 * _e246) + _e248) + _e251);
let _e253 = s_12;
param_151 = _e253;
let _e254 = lit_3;
param_152 = _e254;
let _e255 = WriteDebugView_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_vf3_u003b((¶m_151), (¶m_152));
if _e255 {
return;
}
let _e256 = lit_3;
param_153 = _e256;
let _e258 = s_12.alpha;
param_154 = _e258;
let _e260 = s_12.roughness;
param_155 = _e260;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_153), (¶m_154), (¶m_155));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e236 = v_world_position_1;
let _e238 = fog_info.eye;
let _e242 = fog_info.forward;
return dot((_e236 - _e238.xyz), _e242.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e241 = ViewDepth_u0028_();
z = abs(_e241);
let _e243 = z;
near = (_e243 / 5f);
let _e245 = z;
far = (_e245 / 200f);
let _e247 = far;
let _e248 = far;
let _e250 = far;
far3_ = ((_e247 * _e248) * _e250);
let _e252 = (*alpha);
let _e253 = near;
let _e254 = near;
let _e257 = far3_;
let _e258 = far3_;
return (_e252 * clamp((10f / ((0.00001f + (_e253 * _e254)) + (_e257 * _e258))), 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 _e245 = fog_info.forward[3u];
mode = _e245;
let _e246 = mode;
if (_e246 > 0.5f) {
let _e249 = frag_color[3u];
alpha_1 = _e249;
let _e250 = alpha_1;
param = _e250;
let _e251 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e251;
let _e252 = frag_color;
let _e254 = weight;
let _e255 = (_e252.xyz * _e254);
let _e256 = alpha_1;
let _e257 = weight;
accumulate = vec4<f32>(_e255.x, _e255.y, _e255.z, (_e256 * _e257));
let _e263 = mode;
let _e265 = mode;
revealage = ((_e263 > 1.5f) && (_e265 < 2.5f));
let _e268 = revealage;
if _e268 {
let _e269 = alpha_1;
local = vec4(_e269);
} else {
let _e271 = accumulate;
local = _e271;
}
let _e272 = local;
frag_color = _e272;
let _e273 = mode;
if (_e273 > 2.5f) {
let _e275 = alpha_1;
frag_surface = vec4(_e275);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e239 = (*n)[0u];
let _e242 = (*n)[1u];
let _e246 = (*n)[2u];
let _e249 = (*n);
(*n) = (_e249 / vec3(((abs(_e239) + abs(_e242)) + abs(_e246))));
let _e252 = (*n);
e = _e252.xy;
let _e255 = (*n)[2u];
if (_e255 < 0f) {
let _e257 = (*n);
let _e263 = (*n)[0u];
let _e267 = (*n)[1u];
e = ((vec2(1f) - abs(_e257.yx)) * vec2<f32>(select(-1f, 1f, (_e263 >= 0f)), select(-1f, 1f, (_e267 >= 0f))));
}
let _e272 = e;
return ((_e272 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e237 = (*linear);
let _e239 = (*linear);
let _e243 = (*linear);
return mix((_e237 * 12.92f), ((pow(_e239, 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), _e243));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e240 = g_albedo;
param_1 = clamp(_e240, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e242 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e242.x, _e242.y, _e242.z, 1f);
let _e247 = g_debug_surface_on;
if _e247 {
let _e248 = g_debug_surface;
let _e249 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e248.x, _e248.y, _e248.z, _e249);
return;
}
let _e254 = v_normal_1;
geometric = normalize(_e254);
let _e256 = gl_FrontFacing_1;
if !(_e256) {
let _e258 = geometric;
geometric = -(_e258);
}
let _e260 = geometric;
param_2 = _e260;
let _e261 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e262 = (*roughness);
let _e264 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e261.x, _e261.y, clamp(_e262, 0f, 1f), _e264);
return;
}
fn Orthographic_u0028_() -> bool {
let _e238 = fog_info.projection[0u];
return (_e238 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e237 = Orthographic_u0028_();
if _e237 {
let _e238 = ViewDepth_u0028_();
local_1 = max(_e238, 0f);
} else {
let _e240 = v_world_position_1;
let _e242 = fog_info.eye;
local_1 = distance(_e240, _e242.xyz);
}
let _e245 = local_1;
return _e245;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e244 = fog_info.fog[3u];
density = _e244;
let _e245 = density;
if (_e245 <= 0f) {
let _e247 = (*color);
return _e247;
}
let _e248 = EyeDistance_u0028_();
d = _e248;
let _e251 = fog_info.eye[3u];
falloff = _e251;
let _e252 = falloff;
if (_e252 > 0f) {
let _e254 = falloff;
let _e256 = v_world_position_1[1u];
let _e259 = fog_info.eye[1u];
k = (_e254 * (_e256 - _e259));
let _e262 = k;
if (abs(_e262) > 0.001f) {
let _e265 = k;
let _e269 = k;
local_2 = ((1f - exp(-(_e265))) / _e269);
} else {
let _e271 = k;
local_2 = (1f - (0.5f * _e271));
}
let _e274 = local_2;
let _e275 = density;
density = (_e275 * _e274);
}
let _e278 = fog_info.fog;
let _e280 = (*color);
let _e281 = density;
let _e283 = d;
return mix(_e278.xyz, _e280, vec3(clamp(exp((-(_e281) * _e283)), 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 _e242 = g_premultiply;
let _e243 = (*alpha_2);
weight_1 = select(1f, _e243, _e242);
let _e245 = (*linearColor);
param_3 = _e245;
let _e246 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e247 = weight_1;
let _e248 = (_e246 * _e247);
let _e249 = (*alpha_2);
let _e250 = g_pass_through;
frag_color = vec4<f32>(_e248.x, _e248.y, _e248.z, (_e249 * (1f - _e250)));
let _e257 = (*roughness_1);
param_4 = _e257;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e237 = (*srgb);
let _e240 = (*srgb);
let _e245 = (*srgb);
return mix((_e237 / vec3(12.92f)), pow(((_e240 + 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), _e245));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e239 = (*key);
hue = fract(((_e239 * 0.618034f) + 0.13f));
let _e243 = hue;
k_1 = clamp((abs(((fract((vec3(_e243) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e256 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e256, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2978_: bool;
let _e237 = (*c);
let _e238 = (*c);
let _e240 = any((_e237 != _e238));
phi_2978_ = _e240;
if !(_e240) {
let _e242 = (*c);
phi_2978_ = any((abs(_e242) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e247 = phi_2978_;
return _e247;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_3068_: bool;
var phi_3336_: bool;
let _e279 = gl_FragCoord_1[0u];
let _e282 = frag_info.debug_view[1u];
if (_e279 < _e282) {
let _e286 = frag_info.debug_view[2u];
local_3 = _e286;
} else {
let _e289 = frag_info.debug_view[0u];
local_3 = _e289;
}
let _e290 = local_3;
view = _e290;
let _e291 = view;
if (_e291 < 0.5f) {
return false;
}
let _e293 = view;
code = i32((_e293 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e296 = v_normal_1;
geometric_n = normalize(_e296);
let _e298 = v_tangent_1;
let _e300 = geometric_n;
let _e301 = geometric_n;
let _e302 = v_tangent_1;
tangent = (_e298.xyz - (_e300 * dot(_e301, _e302.xyz)));
let _e307 = tangent;
let _e308 = tangent;
let _e310 = (dot(_e307, _e308) > 0.000000000001f);
phi_3068_ = _e310;
if _e310 {
let _e312 = v_tangent_1[3u];
phi_3068_ = (abs((abs(_e312) - 1f)) < 0.01f);
}
let _e318 = phi_3068_;
tangent_usable = _e318;
let _e321 = frag_info.debug_view[3u];
identity = _e321;
let _e322 = identity;
identity_object = floor((_e322 / 8192f));
let _e325 = identity;
let _e326 = identity_object;
identity_rest = (_e325 - (_e326 * 8192f));
let _e329 = identity_rest;
identity_material = floor((_e329 / 2f));
let _e332 = identity_rest;
let _e333 = identity_material;
normal_mapped = ((_e332 - (_e333 * 2f)) > 0.5f);
let _e337 = code;
if (_e337 == 1i) {
let _e340 = (*s).albedo;
param_5 = clamp(_e340, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e342 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e342;
} else {
let _e343 = code;
if (_e343 == 2i) {
let _e346 = (*s).n;
shown = ((_e346 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e349 = code;
if (_e349 == 3i) {
let _e352 = (*s).roughness;
shown = vec3(clamp(_e352, 0f, 1f));
} else {
let _e355 = code;
if (_e355 == 4i) {
let _e358 = (*s).metallic;
shown = vec3(clamp(_e358, 0f, 1f));
} else {
let _e361 = code;
if (_e361 == 5i) {
let _e364 = (*s).occlusion;
shown = vec3(clamp(_e364, 0f, 1f));
} else {
let _e367 = code;
if (_e367 == 6i) {
let _e370 = (*s).emissive;
param_6 = clamp(_e370, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e372 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e372;
} else {
let _e373 = code;
if (_e373 == 7i) {
let _e375 = v_texcoord_1;
let _e376 = fract(_e375);
shown = vec3<f32>(_e376.x, _e376.y, 0f);
} else {
let _e380 = code;
if (_e380 == 8i) {
let _e382 = (*lit);
param_7 = clamp(_e382, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e384 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e384, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e386 = (*lit);
param_8 = _e386;
let _e387 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e387 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e388 = grey;
local_4 = vec3((_e388 * 0.5f));
}
let _e391 = local_4;
shown = _e391;
} else {
let _e392 = code;
if (_e392 == 9i) {
let _e394 = tangent_usable;
if _e394 {
let _e395 = tangent;
local_5 = ((normalize(_e395) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e399 = local_5;
shown = _e399;
} else {
let _e400 = code;
if (_e400 == 10i) {
let _e402 = v_texcoord_1;
uv = _e402;
let _e403 = uv;
cell = floor((_e403 * 8f));
let _e407 = cell[0u];
let _e409 = cell[1u];
odd = (fract(((_e407 + _e409) * 0.5f)) * 2f);
let _e414 = uv;
within = fract(_e414);
let _e416 = odd;
let _e420 = within[0u];
let _e424 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e416)) * vec3<f32>((0.55f + (0.45f * _e420)), (0.55f + (0.45f * _e424)), 0.85f));
} else {
let _e429 = code;
if (_e429 == 11i) {
let _e431 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e431));
} else {
let _e434 = code;
if (_e434 == 12i) {
let _e436 = v_color_1;
param_9 = clamp(_e436.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e439 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e439;
} else {
let _e440 = code;
let _e442 = code;
if ((_e440 == 13i) || (_e442 == 14i)) {
let _e445 = code;
let _e447 = identity_object;
let _e448 = identity_material;
key_1 = select(_e448, _e447, (_e445 == 13i));
let _e450 = key_1;
param_10 = _e450;
let _e451 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e453 = (*s).n_dot_v;
shown = (_e451 * (0.55f + (0.45f * _e453)));
} else {
let _e457 = code;
if (_e457 == 15i) {
let _e460 = (*s).albedo;
param_11 = clamp(_e460, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e462 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e462;
let _e463 = srgb_1;
luma = dot(_e463, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e466 = (*s).metallic;
metal = (_e466 > 0.5f);
let _e468 = metal;
let _e470 = luma;
if (!(_e468) && (_e470 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e473 = metal;
let _e474 = !(_e473);
phi_3336_ = _e474;
if _e474 {
let _e476 = srgb_1[0u];
let _e478 = srgb_1[1u];
let _e480 = srgb_1[2u];
phi_3336_ = (max(_e476, max(_e478, _e480)) > 0.9411765f);
}
let _e485 = phi_3336_;
if _e485 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e486 = metal;
let _e487 = luma;
if (_e486 && (_e487 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e490 = luma;
local_8 = vec3(_e490);
}
let _e492 = local_8;
local_7 = _e492;
}
let _e493 = local_7;
local_6 = _e493;
}
let _e494 = local_6;
shown = _e494;
} else {
let _e495 = code;
if (_e495 == 16i) {
let _e498 = (*s).metallic;
m = _e498;
let _e499 = m;
let _e501 = m;
if ((_e499 > 0.05f) && (_e501 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e504 = m;
local_9 = vec3(select(0.15f, 1f, (_e504 > 0.5f)));
}
let _e508 = local_9;
shown = _e508;
} else {
let _e509 = code;
if (_e509 == 17i) {
let _e511 = normal_mapped;
if !(_e511) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e513 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e513));
}
let _e516 = local_10;
shown = _e516;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e517 = g_premultiply;
if _e517 {
let _e519 = (*s).alpha;
local_11 = _e519;
} else {
local_11 = 1f;
}
let _e520 = local_11;
weight_2 = _e520;
let _e521 = shown;
param_12 = _e521;
let _e522 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e523 = weight_2;
let _e524 = (_e522 * _e523);
let _e526 = (*s).alpha;
frag_color = vec4<f32>(_e524.x, _e524.y, _e524.z, _e526);
let _e532 = (*s).roughness;
param_13 = _e532;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m_1: f32;
var g: f32;
let _e240 = (*mu);
m_1 = (1f - _e240);
let _e242 = m_1;
let _e243 = m_1;
let _e244 = m_1;
let _e245 = m_1;
g = (_e242 * (0.05710853f + (_e243 * (0.49188188f + (_e244 * (-0.33218145f + (_e245 * 0.071443f)))))));
let _e253 = (*r);
let _e254 = g;
let _e257 = (*r);
return ((1f + (_e253 * _e254)) / (1f + (0.2877934f * _e257)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e238 = (*rho);
let _e239 = (*rho);
let _e241 = (*average);
let _e243 = (*rho);
let _e244 = (*average);
return (((_e238 * _e239) * _e241) / (vec3<f32>(1f, 1f, 1f) - (_e243 * (1f - _e244))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e237 = (*r_1);
let _e240 = (*r_1);
return ((1f + (0.07248821f * _e237)) / (1f + (0.2877934f * _e240)));
}
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_12: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_14: f32;
var multi: vec3<f32>;
var param_15: vec3<f32>;
var param_16: f32;
var param_17: f32;
var param_18: f32;
var param_19: f32;
var param_20: f32;
let _e255 = (*l_dot_v);
let _e256 = (*mu_i);
let _e257 = (*mu_o);
s_1 = (_e255 - (_e256 * _e257));
let _e260 = s_1;
if (_e260 > 0f) {
let _e262 = s_1;
let _e263 = (*mu_i);
let _e264 = (*mu_o);
local_12 = (_e262 / max(_e263, _e264));
} else {
let _e267 = s_1;
local_12 = _e267;
}
let _e268 = local_12;
s_over_t = _e268;
let _e269 = (*r_2);
af = (1f / (1f + (0.2877934f * _e269)));
let _e273 = (*rho_1);
let _e274 = af;
let _e275 = (*r_2);
let _e276 = s_over_t;
single = (_e273 * (_e274 * (1f + (_e275 * _e276))));
let _e281 = (*r_2);
param_14 = _e281;
let _e282 = FonAverage_u0028_f1_u003b((¶m_14));
average_1 = _e282;
let _e283 = (*rho_1);
param_15 = _e283;
let _e284 = average_1;
param_16 = _e284;
let _e285 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_15), (¶m_16));
let _e286 = (*mu_o);
param_17 = _e286;
let _e287 = (*r_2);
param_18 = _e287;
let _e288 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_17), (¶m_18));
let _e291 = (*mu_i);
param_19 = _e291;
let _e292 = (*r_2);
param_20 = _e292;
let _e293 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_19), (¶m_20));
let _e297 = average_1;
multi = (_e285 * ((max((1f - _e288), 0.0000001f) * max((1f - _e293), 0.0000001f)) / max((1f - _e297), 0.0000001f)));
let _e302 = single;
let _e303 = multi;
return ((_e302 + _e303) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e238 = frag_info.ambient_sky[3u];
return (_e238 > 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 _e240 = (*x);
let _e241 = (*y);
inTable = ((vec2<f32>(_e240, _e241) * 0.984375f) + vec2(0.0078125f));
let _e247 = inTable[0u];
let _e249 = inTable[1u];
let _e250 = (*table);
return vec2<f32>(_e247, ((_e249 + _e250) * 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_21: f32;
var param_22: f32;
var param_23: f32;
let _e242 = (*roughness_2);
let _e244 = (*n_dot_v);
param_21 = clamp(_e242, 0f, 1f);
param_22 = sqrt(clamp((1f - _e244), 0f, 1f));
param_23 = 1f;
let _e248 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_21), (¶m_22), (¶m_23));
let _e249 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e248, 0f);
dfg = _e249.xy;
let _e252 = dfg[0u];
let _e254 = dfg[1u];
let _e257 = dfg[1u];
return vec2<f32>((_e252 - _e254), _e257);
}
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_24: f32;
var param_25: f32;
var ess: f32;
let _e243 = (*s_2).roughness;
param_24 = max(_e243, 0.045f);
let _e246 = (*s_2).n_dot_v;
param_25 = _e246;
let _e247 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_24), (¶m_25));
ab = _e247;
let _e249 = ab[0u];
let _e251 = ab[1u];
ess = max((_e249 + _e251), 0.0001f);
let _e254 = (*f0_);
let _e255 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e254 * ((1f / _e255) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e238 = frag_info.target_origin[2u];
return (_e238 > 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 _e239 = (*v_dot_h);
f = pow((1f - _e239), 5f);
let _e242 = (*f0_1);
let _e243 = (*f0_1);
let _e245 = f;
return (_e242 + ((vec3<f32>(1f, 1f, 1f) - _e243) * _e245));
}
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 _e242 = (*alpha_3);
let _e243 = (*alpha_3);
a2_ = (_e242 * _e243);
let _e245 = (*n_dot_l);
let _e246 = (*n_dot_v_1);
let _e247 = (*n_dot_v_1);
let _e249 = a2_;
let _e252 = a2_;
lambda_v = (_e245 * sqrt((((_e246 * _e247) * (1f - _e249)) + _e252)));
let _e256 = (*n_dot_v_1);
let _e257 = (*n_dot_l);
let _e258 = (*n_dot_l);
let _e260 = a2_;
let _e263 = a2_;
lambda_l = (_e256 * sqrt((((_e257 * _e258) * (1f - _e260)) + _e263)));
let _e267 = lambda_v;
let _e268 = lambda_l;
return (0.5f / max((_e267 + _e268), 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_2: f32;
let _e240 = (*n_dot_h);
let _e241 = (*alpha_4);
a = (_e240 * _e241);
let _e243 = (*alpha_4);
let _e244 = (*n_dot_h);
let _e245 = (*n_dot_h);
let _e248 = a;
let _e249 = a;
k_2 = (_e243 / max(((1f - (_e244 * _e245)) + (_e248 * _e249)), 0.0000001f));
let _e254 = k_2;
let _e255 = k_2;
return ((_e254 * _e255) * 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_3: 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_26: f32;
var param_27: f32;
var vis: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var f_1: vec3<f32>;
var param_31: vec3<f32>;
var param_32: f32;
var specular: vec3<f32>;
var param_33: vec3<f32>;
var param_34: Surface;
var diffuse: vec3<f32>;
var param_35: vec3<f32>;
var param_36: f32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
let _e262 = (*s_3).roughness;
lobe = max(_e262, 0.045f);
let _e264 = lobe;
let _e265 = lobe;
alpha_5 = (_e264 * _e265);
let _e268 = (*s_3).albedo;
let _e270 = (*s_3).metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e268, vec3(_e270));
let _e274 = (*s_3).albedo;
let _e276 = (*s_3).metallic;
diffuseColor = (_e274 * (1f - _e276));
let _e280 = (*light).n_dot_h;
param_26 = _e280;
let _e281 = alpha_5;
param_27 = _e281;
let _e282 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_26), (¶m_27));
d_1 = _e282;
let _e284 = (*s_3).n_dot_v;
param_28 = _e284;
let _e286 = (*light).n_dot_l;
param_29 = _e286;
let _e287 = alpha_5;
param_30 = _e287;
let _e288 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30));
vis = _e288;
let _e289 = f0_2;
param_31 = _e289;
let _e291 = (*light).v_dot_h;
param_32 = _e291;
let _e292 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_31), (¶m_32));
f_1 = _e292;
let _e293 = d_1;
let _e294 = vis;
let _e296 = f_1;
let _e300 = frag_info.material[3u];
specular = ((_e296 * (_e293 * _e294)) * _e300);
let _e303 = (*light).integrated;
if (_e303 > 0.5f) {
let _e307 = (*light).ltc[0u];
let _e308 = f0_2;
let _e311 = (*light).ltc[1u];
let _e313 = f0_2;
let _e318 = (*light).ltc[2u];
let _e324 = frag_info.material[3u];
let _e327 = (*light).n_dot_l;
specular = (((((_e308 * _e311) + ((vec3(1f) - _e313) * _e318)) * _e307) * _e324) / vec3(max(_e327, 0.000001f)));
}
let _e331 = EnergyCompensation_u0028_();
if _e331 {
let _e332 = f0_2;
param_33 = _e332;
let _e333 = (*s_3);
param_34 = _e333;
let _e334 = 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_33), (¶m_34));
let _e335 = specular;
specular = (_e335 * _e334);
}
let _e337 = diffuseColor;
let _e338 = f_1;
diffuse = ((_e337 * (vec3<f32>(1f, 1f, 1f) - _e338)) / vec3(3.1415927f));
let _e343 = EonDiffuse_u0028_();
if _e343 {
let _e345 = (*s_3).n;
let _e347 = (*light).l;
let _e351 = (*light).l;
let _e353 = (*s_3).v;
let _e355 = diffuseColor;
param_35 = _e355;
let _e357 = (*s_3).roughness;
param_36 = _e357;
param_37 = clamp(dot(_e345, _e347), 0.0001f, 1f);
let _e359 = (*s_3).n_dot_v;
param_38 = _e359;
param_39 = dot(_e351, _e353);
let _e360 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e361 = f_1;
diffuse = (_e360 * (vec3<f32>(1f, 1f, 1f) - _e361));
}
let _e364 = diffuse;
let _e365 = specular;
return ((_e364 + _e365) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e237 = (*i);
if (_e237 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e239 = (*i);
if (_e239 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e241 = (*i);
if (_e241 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e243 = (*i);
if (_e243 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e245 = (*i);
if (_e245 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e247 = (*i);
if (_e247 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e249 = (*i);
if (_e249 == 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_40: i32;
let _e242 = (*i_1);
param_40 = _e242;
let _e243 = PointShadowDiskTap_u0028_i1_u003b((¶m_40));
p = _e243;
let _e245 = p[0u];
let _e246 = (*ca);
let _e249 = p[1u];
let _e250 = (*sa);
let _e254 = p[0u];
let _e255 = (*sa);
let _e258 = p[1u];
let _e259 = (*ca);
let _e263 = (*radius);
return (vec2<f32>(((_e245 * _e246) - (_e249 * _e250)), ((_e254 * _e255) + (_e258 * _e259))) * _e263);
}
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_13: vec2<f32>;
var atlas: vec2<f32>;
let _e245 = point_shadow.params[0u];
inset = _e245;
let _e246 = (*uv_1);
let _e247 = (*offset);
let _e249 = inset;
let _e250 = inset;
local_13 = clamp((_e246 + _e247), vec2(_e249), vec2((1f - _e250)));
let _e255 = local_13;
let _e256 = (*tile);
atlas = ((_e255 + _e256) * vec2<f32>(0.16666667f, 0.16666667f));
let _e261 = point_shadow.params3_[0u];
if (_e261 > 0.5f) {
let _e264 = atlas[1u];
atlas[1u] = (1f - _e264);
}
let _e267 = atlas;
let _e268 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e267, 0f);
let _e270 = atlas;
let _e271 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e270, 0f);
let _e274 = (*range);
return (min(_e268.x, _e271.x) * _e274);
}
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_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: vec2<f32>;
var param_44: f32;
let _e246 = (*uv_2);
param_41 = _e246;
let _e247 = (*offset_1);
param_42 = _e247;
let _e248 = (*tile_1);
param_43 = _e248;
let _e249 = (*range_1);
param_44 = _e249;
let _e250 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_41), (¶m_42), (¶m_43), (¶m_44));
stored = _e250;
let _e251 = stored;
let _e252 = (*range_1);
if (_e251 >= (_e252 * 0.999f)) {
return 1f;
}
let _e255 = (*receiver);
let _e256 = stored;
return select(1f, 0f, (_e255 > _e256));
}
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_45: vec2<f32>;
var param_46: vec2<f32>;
var param_47: vec2<f32>;
var param_48: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_49: i32;
var param_50: f32;
var param_51: f32;
var param_52: f32;
var param_53: vec2<f32>;
var param_54: vec2<f32>;
var param_55: vec2<f32>;
var param_56: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e267 = point_shadow.params2_[1u];
lightRadius = _e267;
let _e270 = point_shadow.params2_[0u];
minRadius = _e270;
let _e273 = point_shadow.params2_[2u];
maxRadius = _e273;
let _e274 = lightRadius;
if (_e274 <= 0f) {
let _e276 = (*uv_3);
param_45 = _e276;
param_46 = vec2<f32>(0f, 0f);
let _e277 = (*tile_2);
param_47 = _e277;
let _e278 = (*range_2);
param_48 = _e278;
let _e279 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
(*blockerOut) = _e279;
let _e280 = minRadius;
return _e280;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e281 = i_2;
if (_e281 < 8i) {
let _e283 = i_2;
param_49 = _e283;
let _e284 = (*ca_1);
param_50 = _e284;
let _e285 = (*sa_1);
param_51 = _e285;
let _e286 = maxRadius;
param_52 = _e286;
let _e287 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52));
let _e288 = (*uv_3);
param_53 = _e288;
param_54 = _e287;
let _e289 = (*tile_2);
param_55 = _e289;
let _e290 = (*range_2);
param_56 = _e290;
let _e291 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56));
stored_1 = _e291;
let _e292 = stored_1;
let _e293 = (*range_2);
if (_e292 >= (_e293 * 0.999f)) {
continue;
}
let _e296 = stored_1;
let _e297 = (*receiver_1);
if (_e296 >= _e297) {
continue;
}
let _e299 = stored_1;
let _e300 = sum;
sum = (_e300 + _e299);
let _e302 = count;
count = (_e302 + 1f);
continue;
} else {
break;
}
continuing {
let _e304 = i_2;
i_2 = (_e304 + 1i);
}
}
let _e306 = count;
if (_e306 < 0.5f) {
return -1f;
}
let _e308 = sum;
let _e309 = count;
blocker = max((_e308 / _e309), 0.0001f);
let _e312 = blocker;
(*blockerOut) = _e312;
let _e313 = lightRadius;
let _e314 = (*receiver_1);
let _e315 = blocker;
let _e319 = blocker;
world = ((_e313 * max((_e314 - _e315), 0f)) / _e319);
let _e321 = world;
let _e322 = (*receiver_1);
let _e324 = (*tanHalf);
let _e327 = minRadius;
let _e328 = maxRadius;
return clamp((_e321 / ((2f * _e322) * _e324)), _e327, _e328);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_14: vec2<f32>;
let _e238 = (*rows);
if (_e238 > 0f) {
let _e241 = gl_FragCoord_1[0u];
let _e242 = (*rows);
let _e244 = gl_FragCoord_1[1u];
local_14 = vec2<f32>(_e241, (_e242 - _e244));
} else {
let _e247 = gl_FragCoord_1;
local_14 = _e247.xy;
}
let _e249 = local_14;
return _e249;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_57: 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_58: vec2<f32>;
var param_59: vec2<f32>;
var param_60: f32;
var param_61: f32;
var param_62: f32;
var param_63: f32;
var param_64: f32;
var param_65: f32;
var local_15: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_71: i32;
var param_72: f32;
var param_73: f32;
var param_74: f32;
var param_75: vec2<f32>;
var param_76: vec2<f32>;
var param_77: vec2<f32>;
var param_78: f32;
var param_79: f32;
var phi_2667_: bool;
var phi_2728_: bool;
let _e290 = (*lightIndex);
let _e294 = point_shadow.slots[_e290][0u];
slot = i32((_e294 + 0.5f));
let _e297 = (*lightIndex);
let _e301 = point_shadow.slots[_e297][0u];
if (_e301 < 0f) {
return 1f;
}
let _e305 = point_shadow.params[2u];
strength = _e305;
let _e306 = strength;
if (_e306 <= 0f) {
return 1f;
}
let _e308 = slot;
let _e311 = point_shadow.lights[_e308];
let _e313 = (*world_1);
toLight = (_e311.xyz - _e313);
let _e315 = toLight;
toLightLength = max(length(_e315), 0.000001f);
let _e318 = (*normal);
let _e319 = toLight;
let _e320 = toLightLength;
nDotL = max(dot(_e318, (_e319 / vec3(_e320))), 0.15f);
let _e325 = nDotL;
let _e326 = nDotL;
let _e331 = nDotL;
let _e332 = nDotL;
slope = min((sqrt(max((1f - (_e325 * _e326)), 0f)) / (_e331 * _e332)), 8f);
let _e336 = toLightLength;
let _e338 = (*lightIndex);
let _e342 = point_shadow.slots[_e338][2u];
let _e347 = point_shadow.params3_[1u];
texel = (((2f * _e336) * max(_e342, 0.0001f)) * _e347);
let _e349 = (*world_1);
let _e350 = (*normal);
let _e351 = texel;
let _e355 = point_shadow.params[3u];
let _e357 = slope;
origin = (_e349 + (((_e350 * _e351) * _e355) * (1f + _e357)));
let _e361 = origin;
let _e362 = slot;
let _e365 = point_shadow.lights[_e362];
toFragment = (_e361 - _e365.xyz);
let _e368 = toFragment;
distance_ = length(_e368);
let _e370 = slot;
let _e374 = point_shadow.lights[_e370][3u];
range_3 = max(_e374, 0.0001f);
let _e376 = distance_;
let _e377 = range_3;
if (_e376 >= _e377) {
return 1f;
}
face = 0i;
let _e379 = (*lightIndex);
let _e383 = point_shadow.slots[_e379][1u];
if (_e383 < 0.5f) {
let _e385 = toFragment;
a_1 = abs(_e385);
let _e388 = a_1[0u];
let _e390 = a_1[1u];
let _e391 = (_e388 >= _e390);
phi_2667_ = _e391;
if _e391 {
let _e393 = a_1[0u];
let _e395 = a_1[2u];
phi_2667_ = (_e393 >= _e395);
}
let _e398 = phi_2667_;
if _e398 {
let _e400 = toFragment[0u];
face = select(1i, 0i, (_e400 > 0f));
} else {
let _e404 = a_1[1u];
let _e406 = a_1[2u];
if (_e404 >= _e406) {
let _e409 = toFragment[1u];
face = select(3i, 2i, (_e409 > 0f));
} else {
let _e413 = toFragment[2u];
face = select(5i, 4i, (_e413 > 0f));
}
}
}
let _e416 = slot;
let _e418 = face;
let _e422 = point_shadow.faces[((_e416 * 6i) + _e418)];
let _e423 = origin;
clip = (_e422 * vec4<f32>(_e423.x, _e423.y, _e423.z, 1f));
let _e430 = clip[3u];
if (_e430 <= 0f) {
return 1f;
}
let _e432 = clip;
let _e435 = clip[3u];
ndc = (_e432.xy / vec2(_e435));
let _e439 = ndc[0u];
let _e441 = (abs(_e439) > 1f);
phi_2728_ = _e441;
if !(_e441) {
let _e444 = ndc[1u];
phi_2728_ = (abs(_e444) > 1f);
}
let _e448 = phi_2728_;
if _e448 {
return 1f;
}
let _e450 = ndc[0u];
let _e454 = ndc[1u];
uv_4 = vec2<f32>(((_e450 * 0.5f) + 0.5f), (0.5f - (_e454 * 0.5f)));
let _e458 = face;
let _e460 = slot;
tile_3 = vec2<f32>(f32(_e458), f32(_e460));
let _e463 = distance_;
let _e466 = point_shadow.params[1u];
receiver_2 = (_e463 - _e466);
let _e470 = frag_info.target_origin[0u];
param_57 = _e470;
let _e471 = FragCoordFromTop_u0028_f1_u003b((¶m_57));
noise = fract((52.982918f * fract(dot(_e471, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e476 = noise;
angle = (_e476 * 6.2831855f);
let _e478 = angle;
ca_2 = cos(_e478);
let _e480 = angle;
sa_2 = sin(_e480);
let _e482 = (*lightIndex);
let _e486 = point_shadow.slots[_e482][2u];
tanHalf_1 = max(_e486, 0.0001f);
blocker_1 = -1f;
let _e488 = uv_4;
param_58 = _e488;
let _e489 = tile_3;
param_59 = _e489;
let _e490 = range_3;
param_60 = _e490;
let _e491 = receiver_2;
param_61 = _e491;
let _e492 = ca_2;
param_62 = _e492;
let _e493 = sa_2;
param_63 = _e493;
let _e494 = tanHalf_1;
param_64 = _e494;
let _e495 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60), (¶m_61), (¶m_62), (¶m_63), (¶m_64), (¶m_65));
let _e496 = param_65;
blocker_1 = _e496;
radius_1 = _e495;
let _e499 = point_shadow.params2_[3u];
if (_e499 > 0.5f) {
g_debug_surface_on = true;
let _e501 = radius_1;
if (_e501 < 0f) {
local_15 = vec3<f32>(0f, 0f, 1f);
} else {
let _e503 = radius_1;
let _e506 = point_shadow.params2_[2u];
let _e510 = blocker_1;
let _e511 = range_3;
local_15 = vec3<f32>(clamp((_e503 / max(_e506, 0.000001f)), 0f, 1f), clamp((_e510 / _e511), 0f, 1f), 0f);
}
let _e515 = local_15;
g_debug_surface = _e515;
}
let _e516 = radius_1;
if (_e516 < 0f) {
return 1f;
}
let _e518 = uv_4;
param_66 = _e518;
param_67 = vec2<f32>(0f, 0f);
let _e519 = tile_3;
param_68 = _e519;
let _e520 = range_3;
param_69 = _e520;
let _e521 = receiver_2;
param_70 = _e521;
let _e522 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70));
lit_1 = _e522;
let _e523 = radius_1;
if (_e523 > 0f) {
i_3 = 0i;
loop {
let _e525 = i_3;
if (_e525 < 8i) {
let _e527 = i_3;
param_71 = _e527;
let _e528 = ca_2;
param_72 = _e528;
let _e529 = sa_2;
param_73 = _e529;
let _e530 = radius_1;
param_74 = _e530;
let _e531 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_71), (¶m_72), (¶m_73), (¶m_74));
let _e532 = uv_4;
param_75 = _e532;
param_76 = _e531;
let _e533 = tile_3;
param_77 = _e533;
let _e534 = range_3;
param_78 = _e534;
let _e535 = receiver_2;
param_79 = _e535;
let _e536 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77), (¶m_78), (¶m_79));
let _e537 = lit_1;
lit_1 = (_e537 + _e536);
continue;
} else {
break;
}
continuing {
let _e539 = i_3;
i_3 = (_e539 + 1i);
}
}
let _e541 = lit_1;
lit_1 = (_e541 * 0.11111111f);
}
let _e543 = lit_1;
let _e544 = strength;
return mix(1f, _e543, clamp(_e544, 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 _e241 = (*i_4);
let _e244 = (*n_1);
r_3 = sqrt(((f32(_e241) + 0.5f) / f32(_e244)));
let _e248 = (*i_4);
let _e251 = (*turn);
theta = ((f32(_e248) * 2.3999631f) + _e251);
let _e253 = r_3;
let _e254 = theta;
let _e256 = theta;
return (vec2<f32>(cos(_e254), sin(_e256)) * _e253);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_80: f32;
let _e240 = frag_info.target_origin[0u];
param_80 = _e240;
let _e241 = FragCoordFromTop_u0028_f1_u003b((¶m_80));
let _e244 = frag_info.target_origin[3u];
at = (_e241 + vec2((5.588238f * max(_e244, 0f))));
let _e249 = at;
return fract((52.982918f * fract(dot(_e249, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_16: f32;
let _e239 = (*mode_1);
if (_e239 > 0.5f) {
let _e241 = (*stored_2);
local_16 = (1f - _e241);
} else {
let _e243 = (*stored_2);
local_16 = _e243;
}
let _e244 = local_16;
return _e244;
}
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 _e245 = (*moments)[1u];
let _e247 = (*moments)[0u];
let _e249 = (*moments)[0u];
let _e252 = (*minVariance);
variance = max((_e245 - (_e247 * _e249)), _e252);
let _e254 = (*t);
let _e256 = (*moments)[0u];
d_2 = (_e254 - _e256);
let _e258 = variance;
let _e259 = variance;
let _e260 = d_2;
let _e261 = d_2;
pMax = (_e258 / (_e259 + (_e260 * _e261)));
let _e265 = pMax;
let _e266 = (*bleed);
let _e268 = (*bleed);
reduced = clamp(((_e265 - _e266) / max((1f - _e268), 0.0001f)), 0f, 1f);
let _e273 = (*t);
let _e275 = (*moments)[0u];
let _e277 = reduced;
return select(_e277, 1f, (_e273 <= _e275));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_3: f32;
let _e238 = (*depth);
d_3 = ((2f * clamp(_e238, 0f, 1f)) - 1f);
let _e242 = d_3;
let _e245 = d_3;
return vec2<f32>(exp((40f * _e242)), -(exp((-5f * _e245))));
}
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_81: f32;
var scale: vec2<f32>;
var positive: f32;
var param_82: vec2<f32>;
var param_83: f32;
var param_84: f32;
var param_85: f32;
var negative: f32;
var param_86: vec2<f32>;
var param_87: f32;
var param_88: f32;
var param_89: f32;
let _e252 = (*depth_1);
param_81 = _e252;
let _e253 = EvsmWarp_u0028_f1_u003b((¶m_81));
warped = _e253;
let _e254 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e254);
let _e257 = scale[0u];
let _e259 = scale[0u];
let _e261 = (*moments_1);
param_82 = _e261.xy;
let _e264 = warped[0u];
param_83 = _e264;
param_84 = (_e257 * _e259);
let _e265 = (*bleed_1);
param_85 = _e265;
let _e266 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_82), (¶m_83), (¶m_84), (¶m_85));
positive = _e266;
let _e268 = scale[1u];
let _e270 = scale[1u];
let _e272 = (*moments_1);
param_86 = _e272.zw;
let _e275 = warped[1u];
param_87 = _e275;
param_88 = (_e268 * _e270);
let _e276 = (*bleed_1);
param_89 = _e276;
let _e277 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_86), (¶m_87), (¶m_88), (¶m_89));
negative = _e277;
let _e278 = positive;
let _e279 = negative;
return min(_e278, _e279);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e238 = (*depth_2);
stored_3 = max((1f - _e238), 0.000061035156f);
let _e241 = stored_3;
return exp2((floor(log2(_e241)) - 10f));
}
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_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var local_17: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_18: mat4x4<f32>;
var local_19: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_20: f32;
var local_21: f32;
var storage_: f32;
var param_90: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_91: vec4<f32>;
var param_92: f32;
var param_93: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var param_94: f32;
var param_95: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_96: i32;
var param_97: i32;
var param_98: f32;
var tapBias: f32;
var occluder_1: f32;
var param_99: f32;
var param_100: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_101: i32;
var param_102: i32;
var param_103: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_104: f32;
var param_105: f32;
var phi_4275_: bool;
var phi_4286_: bool;
var phi_4443_: bool;
var phi_4450_: bool;
var phi_4457_: bool;
let _e315 = frag_info.shadow_params[3u];
strength_1 = _e315;
let _e316 = strength_1;
if (_e316 <= 0f) {
return 1f;
}
let _e318 = (*lightIndex_1);
let _e321 = frag_info.frame_params[2u];
if (_e318 != i32(floor((_e321 + 0.5f)))) {
return 1f;
}
let _e328 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e328 + 0.5f));
let _e331 = Orthographic_u0028_();
if _e331 {
let _e332 = ViewDepth_u0028_();
local_17 = _e332;
} else {
let _e333 = v_world_position_1;
let _e335 = frag_info.camera_position;
local_17 = length((_e333 - _e335.xyz));
}
let _e339 = local_17;
viewDistance = _e339;
cascade = 0i;
let _e340 = cascadeCount;
let _e341 = (_e340 > 1i);
phi_4275_ = _e341;
if _e341 {
let _e342 = viewDistance;
let _e345 = frag_info.shadow_cascades[0u];
phi_4275_ = (_e342 > _e345);
}
let _e348 = phi_4275_;
if _e348 {
cascade = 1i;
}
let _e349 = cascadeCount;
let _e350 = (_e349 > 2i);
phi_4286_ = _e350;
if _e350 {
let _e351 = viewDistance;
let _e354 = frag_info.shadow_cascades[1u];
phi_4286_ = (_e351 > _e354);
}
let _e357 = phi_4286_;
if _e357 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e358 = attempt;
if (_e358 < 3i) {
let _e360 = cascade;
let _e361 = attempt;
which = (_e360 + _e361);
let _e363 = which;
let _e364 = cascadeCount;
if (_e363 >= _e364) {
break;
}
let _e366 = which;
if (_e366 == 0i) {
let _e369 = frag_info.shadow_matrix;
local_18 = _e369;
} else {
let _e370 = which;
if (_e370 == 1i) {
let _e373 = frag_info.shadow_matrix_far;
local_19 = _e373;
} else {
let _e375 = frag_info.shadow_matrix_farthest;
local_19 = _e375;
}
let _e376 = local_19;
local_18 = _e376;
}
let _e377 = local_18;
matrix = _e377;
let _e380 = matrix[0][0u];
let _e383 = matrix[1][0u];
let _e386 = matrix[2][0u];
axisX = vec3<f32>(_e380, _e383, _e386);
let _e390 = matrix[0][1u];
let _e393 = matrix[1][1u];
let _e396 = matrix[2][1u];
axisY = vec3<f32>(_e390, _e393, _e396);
let _e398 = axisX;
rowX = max(length(_e398), 0.000001f);
let _e401 = axisY;
rowY = max(length(_e401), 0.000001f);
let _e406 = frag_info.shadow_cascades[3u];
let _e408 = rowX;
texelMetres = ((2f * _e406) / _e408);
let _e412 = frag_info.shadow_cascades[3u];
let _e415 = (*s_4).n;
let _e416 = axisX;
let _e419 = rowX;
let _e420 = rowX;
let _e424 = (*s_4).n;
let _e425 = axisY;
let _e428 = rowY;
let _e429 = rowY;
reach = ((3f * _e412) * ((abs(dot(_e415, _e416)) / (_e419 * _e420)) + (abs(dot(_e424, _e425)) / (_e428 * _e429))));
let _e436 = frag_info.shadow_params[2u];
let _e437 = texelMetres;
flatOffset = min(_e436, _e437);
let _e439 = v_world_position_1;
let _e441 = (*s_4).n;
let _e442 = flatOffset;
let _e443 = reach;
origin_1 = (_e439 + (_e441 * (_e442 + _e443)));
let _e447 = matrix;
let _e448 = origin_1;
lightSpace = (_e447 * vec4<f32>(_e448.x, _e448.y, _e448.z, 1f));
let _e455 = lightSpace[3u];
if (_e455 <= 0f) {
continue;
}
let _e457 = lightSpace;
let _e460 = lightSpace[3u];
candidate = (_e457.xyz / vec3(_e460));
let _e464 = candidate[0u];
let _e468 = candidate[1u];
inTile = vec2<f32>(((_e464 * 0.5f) + 0.5f), (0.5f - (_e468 * 0.5f)));
let _e473 = inTile[0u];
let _e474 = (_e473 < 0f);
phi_4443_ = _e474;
if !(_e474) {
let _e477 = inTile[0u];
phi_4443_ = (_e477 > 1f);
}
let _e480 = phi_4443_;
phi_4450_ = _e480;
if !(_e480) {
let _e483 = inTile[1u];
phi_4450_ = (_e483 < 0f);
}
let _e486 = phi_4450_;
phi_4457_ = _e486;
if !(_e486) {
let _e489 = inTile[1u];
phi_4457_ = (_e489 > 1f);
}
let _e492 = phi_4457_;
if _e492 {
continue;
}
let _e494 = candidate[2u];
if (_e494 > 1f) {
let _e496 = which;
let _e497 = cascadeCount;
if (_e496 < (_e497 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e502 = inTile[0u];
let _e503 = which;
let _e506 = cascadeCount;
let _e510 = inTile[1u];
uv_5 = vec2<f32>(((_e502 + f32(_e503)) / f32(_e506)), _e510);
let _e512 = candidate;
projected = _e512;
let _e513 = which;
cascade = _e513;
let _e514 = texelMetres;
cascadeTexel = _e514;
let _e517 = matrix[0][2u];
let _e520 = matrix[1][2u];
let _e523 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e517, _e520, _e523)), 0.000001f));
let _e529 = (*s_4).n;
let _e532 = matrix[0][2u];
let _e535 = matrix[1][2u];
let _e538 = matrix[2][2u];
let _e542 = cascadeDepth;
cosSlope = clamp((abs(dot(_e529, vec3<f32>(_e532, _e535, _e538))) * _e542), 0.1f, 1f);
let _e545 = texelMetres;
let _e546 = cosSlope;
let _e547 = cosSlope;
let _e553 = cosSlope;
let _e555 = cascadeDepth;
receiverSlope = (((_e545 * sqrt(max((1f - (_e546 * _e547)), 0f))) / _e553) / _e555);
found = true;
break;
} else {
break;
}
continuing {
let _e557 = attempt;
attempt = (_e557 + 1i);
}
}
let _e559 = found;
if !(_e559) {
return 1f;
}
let _e561 = cascade;
if (_e561 == 0i) {
let _e565 = frag_info.shadow_bias[0u];
local_20 = _e565;
} else {
let _e566 = cascade;
if (_e566 == 1i) {
let _e570 = frag_info.shadow_bias[1u];
local_21 = _e570;
} else {
let _e573 = frag_info.shadow_bias[2u];
local_21 = _e573;
}
let _e574 = local_21;
local_20 = _e574;
}
let _e575 = local_20;
bias = _e575;
let _e578 = frag_info.shadow_params[1u];
storage_ = _e578;
let _e579 = storage_;
let _e581 = storage_;
if ((_e579 > 0.5f) && (_e581 < 1.5f)) {
let _e584 = bias;
let _e586 = projected[2u];
param_90 = _e586;
let _e587 = ShadowStoredStep_u0028_f1_u003b((¶m_90));
bias = max(_e584, _e587);
}
let _e591 = frag_info.shadow_params[0u];
let _e594 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e591, _e594);
let _e596 = cascade;
let _e598 = cascadeCount;
let _e602 = texel_1;
tileLo = (vec2<f32>((f32(_e596) / f32(_e598)), 0f) + (_e602 * 0.5f));
let _e605 = cascade;
let _e608 = cascadeCount;
let _e612 = texel_1;
tileHi = (vec2<f32>((f32((_e605 + 1i)) / f32(_e608)), 1f) - (_e612 * 0.5f));
let _e617 = frag_info.shadow_bias[3u];
if (_e617 > 0.5f) {
let _e619 = uv_5;
let _e620 = tileLo;
let _e621 = tileHi;
let _e623 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e619, _e620, _e621), 0f);
stored_4 = _e623;
let _e625 = stored_4[1u];
let _e628 = stored_4[2u];
let _e631 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e625), (1f - _e628), _e631), vec3(0f), vec3(4f));
let _e636 = through;
let _e637 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e636, vec3(clamp(_e637, 0f, 1f)));
}
let _e643 = frag_info.ambient_ground[3u];
softness = _e643;
lit_2 = 0f;
let _e644 = softness;
if (_e644 < 0f) {
let _e646 = uv_5;
let _e647 = tileLo;
let _e648 = tileHi;
let _e650 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e646, _e647, _e648), 0f);
moments_2 = _e650;
let _e652 = projected[2u];
let _e653 = bias;
let _e655 = softness;
let _e659 = moments_2;
param_91 = _e659;
param_92 = (_e652 - _e653);
param_93 = clamp((-(_e655) - 1f), 0f, 0.95f);
let _e660 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_91), (¶m_92), (¶m_93));
lit_2 = _e660;
} else {
let _e661 = softness;
if (_e661 <= 0f) {
y_1 = -1i;
loop {
let _e663 = y_1;
if (_e663 <= 1i) {
x_1 = -1i;
loop {
let _e665 = x_1;
if (_e665 <= 1i) {
let _e667 = uv_5;
let _e668 = x_1;
let _e670 = y_1;
let _e673 = texel_1;
let _e676 = tileLo;
let _e677 = tileHi;
let _e679 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e667 + (vec2<f32>(f32(_e668), f32(_e670)) * _e673)), _e676, _e677), 0f);
param_94 = _e679.x;
let _e681 = storage_;
param_95 = _e681;
let _e682 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
occluder = _e682;
let _e684 = projected[2u];
let _e685 = bias;
let _e687 = occluder;
let _e690 = lit_2;
lit_2 = (_e690 + select(1f, 0f, ((_e684 - _e685) > _e687)));
continue;
} else {
break;
}
continuing {
let _e692 = x_1;
x_1 = (_e692 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e694 = y_1;
y_1 = (_e694 + 1i);
}
}
let _e696 = lit_2;
lit_2 = (_e696 * 0.11111111f);
} else {
let _e698 = softness;
spread = tan(min(_e698, 0.5f));
let _e701 = ShadowNoise_u0028_();
turn_1 = (_e701 * 6.2831855f);
let _e703 = spread;
let _e705 = projected[2u];
let _e707 = cascadeDepth;
let _e709 = cascadeTexel;
searchRadius = clamp((((_e703 * _e705) * _e707) / _e709), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e712 = i_5;
if (_e712 < 16i) {
let _e714 = i_5;
param_96 = _e714;
param_97 = 16i;
let _e715 = turn_1;
param_98 = _e715;
let _e716 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_96), (¶m_97), (¶m_98));
disc = _e716;
let _e717 = bias;
let _e718 = disc;
let _e720 = searchRadius;
let _e724 = receiverSlope;
tapBias = (_e717 + (max(((length(_e718) * _e720) - 1.5f), 0f) * _e724));
let _e727 = uv_5;
let _e728 = disc;
let _e729 = texel_1;
let _e731 = searchRadius;
let _e734 = tileLo;
let _e735 = tileHi;
let _e737 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e727 + ((_e728 * _e729) * _e731)), _e734, _e735), 0f);
param_99 = _e737.x;
let _e739 = storage_;
param_100 = _e739;
let _e740 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_99), (¶m_100));
occluder_1 = _e740;
let _e742 = projected[2u];
let _e743 = tapBias;
let _e745 = occluder_1;
if ((_e742 - _e743) > _e745) {
let _e747 = occluder_1;
let _e748 = blockerSum;
blockerSum = (_e748 + _e747);
let _e750 = blockerCount;
blockerCount = (_e750 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e752 = i_5;
i_5 = (_e752 + 1i);
}
}
let _e754 = blockerCount;
if (_e754 <= 0f) {
return 1f;
}
let _e757 = projected[2u];
let _e758 = blockerSum;
let _e759 = blockerCount;
let _e763 = cascadeDepth;
gap = (max((_e757 - (_e758 / _e759)), 0f) * _e763);
let _e765 = spread;
let _e766 = gap;
let _e768 = cascadeTexel;
radius_2 = clamp(((_e765 * _e766) / _e768), 1f, 16f);
i_6 = 0i;
loop {
let _e771 = i_6;
if (_e771 < 16i) {
let _e773 = turn_1;
let _e775 = i_6;
param_101 = _e775;
param_102 = 16i;
param_103 = (_e773 + 1f);
let _e776 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_101), (¶m_102), (¶m_103));
disc_1 = _e776;
let _e777 = bias;
let _e778 = disc_1;
let _e780 = radius_2;
let _e784 = receiverSlope;
tapBias_1 = (_e777 + (max(((length(_e778) * _e780) - 1.5f), 0f) * _e784));
let _e787 = uv_5;
let _e788 = disc_1;
let _e789 = texel_1;
let _e791 = radius_2;
let _e794 = tileLo;
let _e795 = tileHi;
let _e797 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e787 + ((_e788 * _e789) * _e791)), _e794, _e795), 0f);
param_104 = _e797.x;
let _e799 = storage_;
param_105 = _e799;
let _e800 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_104), (¶m_105));
occluder_2 = _e800;
let _e802 = projected[2u];
let _e803 = tapBias_1;
let _e805 = occluder_2;
let _e808 = lit_2;
lit_2 = (_e808 + select(1f, 0f, ((_e802 - _e803) > _e805)));
continue;
} else {
break;
}
continuing {
let _e810 = i_6;
i_6 = (_e810 + 1i);
}
}
let _e812 = lit_2;
lit_2 = (_e812 * 0.0625f);
}
}
let _e814 = lit_2;
let _e815 = strength_1;
return mix(1f, _e814, clamp(_e815, 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_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_106: Surface;
var param_107: LightSample;
var param_108: i32;
let _e242 = (*s_5);
param_106 = _e242;
let _e243 = (*light_2);
param_107 = _e243;
let _e244 = (*index);
param_108 = _e244;
let _e245 = 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_106), (¶m_107), (¶m_108));
return _e245;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e237 = (*index_1);
return (_e237 < 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 _e241 = (*distance_1);
let _e242 = (*distance_1);
attenuation = (1f / max((_e241 * _e242), 0.0001f));
let _e246 = (*range_4);
if (_e246 > 0f) {
let _e248 = (*distance_1);
let _e249 = (*range_4);
ratio = (_e248 / _e249);
let _e251 = ratio;
let _e252 = ratio;
let _e254 = ratio;
let _e256 = ratio;
window = clamp((1f - (((_e251 * _e252) * _e254) * _e256)), 0f, 1f);
let _e260 = window;
let _e261 = window;
let _e263 = attenuation;
attenuation = (_e263 * (_e260 * _e261));
}
let _e265 = attenuation;
return _e265;
}
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_22: vec3<f32>;
let _e242 = (*a_2);
let _e243 = (*b);
axis = cross(_e242, _e243);
let _e245 = axis;
len = length(_e245);
let _e247 = (*a_2);
let _e248 = (*b);
angle_1 = acos(clamp(dot(_e247, _e248), -1f, 1f));
let _e252 = len;
if (_e252 > 0.000001f) {
let _e254 = axis;
let _e255 = angle_1;
let _e256 = len;
local_22 = (_e254 * (_e255 / (_e256 * 6.2831855f)));
} else {
local_22 = vec3<f32>(0f, 0f, 0f);
}
let _e260 = local_22;
return _e260;
}
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_6: vec2<f32>;
var inverse: vec4<f32>;
var param_109: f32;
var param_110: f32;
var param_111: f32;
var fit: vec4<f32>;
var param_112: f32;
var param_113: f32;
var param_114: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_23: 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_115: vec3<f32>;
var param_116: vec3<f32>;
var param_117: vec3<f32>;
var param_118: vec3<f32>;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: vec3<f32>;
var param_122: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_24: f32;
var sphere: f32;
var param_123: f32;
var param_124: f32;
var param_125: f32;
let _e274 = (*roughness_3);
let _e276 = (*n_2);
let _e277 = (*v);
uv_6 = vec2<f32>(clamp(_e274, 0f, 1f), sqrt(clamp((1f - dot(_e276, _e277)), 0f, 1f)));
let _e284 = uv_6[0u];
param_109 = _e284;
let _e286 = uv_6[1u];
param_110 = _e286;
param_111 = 0f;
let _e287 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_109), (¶m_110), (¶m_111));
let _e288 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e287, 0f);
inverse = _e288;
let _e290 = uv_6[0u];
param_112 = _e290;
let _e292 = uv_6[1u];
param_113 = _e292;
param_114 = 1f;
let _e293 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_112), (¶m_113), (¶m_114));
let _e294 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e293, 0f);
fit = _e294;
let _e295 = (*v);
let _e296 = (*n_2);
let _e297 = (*v);
let _e298 = (*n_2);
along = (_e295 - (_e296 * dot(_e297, _e298)));
let _e302 = along;
alongLength = length(_e302);
let _e304 = alongLength;
if (_e304 > 0.00001f) {
let _e306 = along;
let _e307 = alongLength;
local_23 = (_e306 / vec3(_e307));
} else {
let _e310 = (*n_2);
let _e312 = (*n_2)[2u];
local_23 = normalize(cross(_e310, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e312) < 0.999f)))));
}
let _e319 = local_23;
t1_ = _e319;
let _e320 = (*n_2);
let _e321 = t1_;
t2_ = cross(_e320, _e321);
let _e324 = inverse[0u];
let _e326 = inverse[1u];
let _e327 = vec3<f32>(_e324, 0f, _e326);
let _e329 = inverse[2u];
let _e331 = inverse[3u];
let _e332 = vec3<f32>(_e329, 0f, _e331);
minv = mat3x3<f32>(vec3<f32>(_e327.x, _e327.y, _e327.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e332.x, _e332.y, _e332.z));
i_7 = 0i;
loop {
let _e346 = i_7;
if (_e346 < 4i) {
let _e348 = i_7;
let _e350 = (*corners)[_e348];
p_1 = _e350;
let _e351 = i_7;
let _e352 = minv;
let _e353 = p_1;
let _e354 = t1_;
let _e356 = p_1;
let _e357 = t2_;
let _e359 = p_1;
let _e360 = (*n_2);
l[_e351] = normalize((_e352 * vec3<f32>(dot(_e353, _e354), dot(_e356, _e357), dot(_e359, _e360))));
continue;
} else {
break;
}
continuing {
let _e366 = i_7;
i_7 = (_e366 + 1i);
}
}
let _e369 = l[0i];
param_115 = _e369;
let _e371 = l[1i];
param_116 = _e371;
let _e372 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_115), (¶m_116));
let _e374 = l[1i];
param_117 = _e374;
let _e376 = l[2i];
param_118 = _e376;
let _e377 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_117), (¶m_118));
let _e380 = l[2i];
param_119 = _e380;
let _e382 = l[3i];
param_120 = _e382;
let _e383 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_119), (¶m_120));
let _e386 = l[3i];
param_121 = _e386;
let _e388 = l[0i];
param_122 = _e388;
let _e389 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_121), (¶m_122));
f_2 = -((((_e372 + _e377) + _e383) + _e389));
let _e392 = f_2;
len_1 = length(_e392);
let _e394 = len_1;
if (_e394 > 0.000000001f) {
let _e397 = f_2[2u];
let _e398 = len_1;
local_24 = (_e397 / _e398);
} else {
local_24 = 0f;
}
let _e400 = local_24;
z_1 = _e400;
let _e401 = z_1;
let _e404 = len_1;
param_123 = ((_e401 * 0.5f) + 0.5f);
param_124 = clamp(_e404, 0f, 1f);
param_125 = 1f;
let _e406 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125));
let _e407 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e406, 0f);
sphere = _e407.w;
let _e409 = len_1;
let _e410 = sphere;
let _e414 = fit[0u];
let _e416 = fit[1u];
return vec3<f32>(max((_e409 * _e410), 0f), _e414, _e416);
}
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_25: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e253 = (*halfWidth);
let _e254 = (*halfHeight);
n_3 = cross(_e253, _e254);
let _e256 = n_3;
nLen = length(_e256);
let _e258 = nLen;
if (_e258 < 0.000000000001f) {
let _e260 = (*centre);
return _e260;
}
let _e261 = nLen;
let _e262 = n_3;
n_3 = (_e262 / vec3(_e261));
let _e265 = (*centre);
let _e266 = (*world_2);
toPlane = (_e265 - _e266);
let _e268 = (*mirror);
let _e269 = n_3;
denom = dot(_e268, _e269);
let _e271 = denom;
if (abs(_e271) < 0.00001f) {
let _e274 = toPlane;
let _e275 = n_3;
let _e276 = toPlane;
let _e277 = n_3;
onPlane = (_e274 - (_e275 * dot(_e276, _e277)));
} else {
let _e281 = toPlane;
let _e282 = n_3;
let _e284 = denom;
t_1 = (dot(_e281, _e282) / _e284);
let _e286 = t_1;
if (_e286 > 0f) {
let _e288 = (*mirror);
let _e289 = t_1;
local_25 = (_e288 * _e289);
} else {
let _e291 = toPlane;
let _e292 = n_3;
let _e293 = toPlane;
let _e294 = n_3;
local_25 = (_e291 - (_e292 * dot(_e293, _e294)));
}
let _e298 = local_25;
onPlane = _e298;
}
let _e299 = onPlane;
let _e300 = toPlane;
offset_2 = (_e299 - _e300);
let _e302 = (*halfWidth);
let _e303 = (*halfWidth);
wLen2_ = max(dot(_e302, _e303), 0.000000000001f);
let _e306 = (*halfHeight);
let _e307 = (*halfHeight);
hLen2_ = max(dot(_e306, _e307), 0.000000000001f);
let _e310 = offset_2;
let _e311 = (*halfWidth);
let _e313 = wLen2_;
u = clamp((dot(_e310, _e311) / _e313), -1f, 1f);
let _e316 = offset_2;
let _e317 = (*halfHeight);
let _e319 = hLen2_;
v_1 = clamp((dot(_e316, _e317) / _e319), -1f, 1f);
let _e322 = (*centre);
let _e323 = (*halfWidth);
let _e324 = u;
let _e327 = (*halfHeight);
let _e328 = v_1;
return ((_e322 + (_e323 * _e324)) + (_e327 * _e328));
}
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_26: f32;
let _e245 = (*a_3);
let _e246 = (*a_3);
ua = (_e245 / vec3(max(length(_e246), 0.000000000001f)));
let _e251 = (*b_1);
let _e252 = (*b_1);
ub = (_e251 / vec3(max(length(_e252), 0.000000000001f)));
let _e257 = ua;
let _e258 = ub;
angle_2 = acos(clamp(dot(_e257, _e258), -1f, 1f));
let _e262 = ua;
let _e263 = ub;
axis_1 = cross(_e262, _e263);
let _e265 = axis_1;
len_2 = length(_e265);
let _e267 = len_2;
if (_e267 > 0.000001f) {
let _e269 = angle_2;
let _e270 = axis_1;
let _e271 = (*n_4);
let _e274 = len_2;
local_26 = ((_e269 * dot(_e270, _e271)) / _e274);
} else {
local_26 = 0f;
}
let _e276 = local_26;
return _e276;
}
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_27: i32;
var ha: f32;
var hb: f32;
var d_4: f32;
var q: vec3<f32>;
var local_28: f32;
var aAbove: bool;
var bAbove: bool;
var local_29: f32;
var param_126: vec3<f32>;
var param_127: vec3<f32>;
var param_128: vec3<f32>;
var param_129: vec3<f32>;
var param_130: vec3<f32>;
var param_131: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e259 = i_8;
if (_e259 < 4i) {
let _e261 = i_8;
let _e263 = (*corners_1)[_e261];
a_4 = _e263;
let _e264 = i_8;
if (_e264 == 3i) {
local_27 = 0i;
} else {
let _e266 = i_8;
local_27 = (_e266 + 1i);
}
let _e268 = local_27;
let _e270 = (*corners_1)[_e268];
b_2 = _e270;
let _e271 = a_4;
let _e272 = (*n_5);
ha = dot(_e271, _e272);
let _e274 = b_2;
let _e275 = (*n_5);
hb = dot(_e274, _e275);
let _e277 = ha;
let _e278 = hb;
d_4 = (_e277 - _e278);
let _e280 = a_4;
let _e281 = b_2;
let _e282 = a_4;
let _e284 = d_4;
if (abs(_e284) > 0.000000000001f) {
let _e287 = ha;
let _e288 = d_4;
local_28 = (_e287 / _e288);
} else {
local_28 = 0f;
}
let _e290 = local_28;
q = (_e280 + ((_e281 - _e282) * _e290));
let _e293 = ha;
aAbove = (_e293 > 0f);
let _e295 = hb;
bAbove = (_e295 > 0f);
let _e297 = aAbove;
let _e298 = bAbove;
if (_e297 || _e298) {
let _e300 = aAbove;
let _e301 = a_4;
let _e302 = q;
let _e305 = bAbove;
let _e306 = b_2;
let _e307 = q;
param_126 = select(_e302, _e301, vec3(_e300));
param_127 = select(_e307, _e306, vec3(_e305));
let _e310 = (*n_5);
param_128 = _e310;
let _e311 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_126), (¶m_127), (¶m_128));
local_29 = _e311;
} else {
local_29 = 0f;
}
let _e312 = local_29;
let _e313 = total;
total = (_e313 + _e312);
let _e315 = aAbove;
let _e316 = bAbove;
let _e319 = q;
let _e320 = exit;
exit = select(_e320, _e319, vec3((_e315 && !(_e316))));
let _e323 = aAbove;
let _e325 = bAbove;
let _e327 = q;
let _e328 = entry;
entry = select(_e328, _e327, vec3((!(_e323) && _e325)));
continue;
} else {
break;
}
continuing {
let _e331 = i_8;
i_8 = (_e331 + 1i);
}
}
let _e333 = exit;
param_129 = _e333;
let _e334 = entry;
param_130 = _e334;
let _e335 = (*n_5);
param_131 = _e335;
let _e336 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_129), (¶m_130), (¶m_131));
let _e337 = total;
total = (_e337 + _e336);
let _e339 = total;
return max((-(_e339) * 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_30: f32;
var local_31: f32;
var local_32: f32;
let _e242 = (*slot_1);
let _e243 = (*slot_1);
lane = (_e242 - ((_e243 / 4i) * 4i));
let _e247 = lane;
if (_e247 == 0i) {
let _e250 = (*four)[0u];
local_30 = _e250;
} else {
let _e251 = lane;
if (_e251 == 1i) {
let _e254 = (*four)[1u];
local_31 = _e254;
} else {
let _e255 = lane;
if (_e255 == 2i) {
let _e258 = (*four)[2u];
local_32 = _e258;
} else {
let _e260 = (*four)[3u];
local_32 = _e260;
}
let _e261 = local_32;
local_31 = _e261;
}
let _e262 = local_31;
local_30 = _e262;
}
let _e263 = local_30;
return _e263;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_132: vec4<f32>;
var param_133: i32;
let _e239 = (*slot_2);
let _e243 = light_list_info.scales[(_e239 / 4i)];
param_132 = _e243;
let _e244 = (*slot_2);
param_133 = _e244;
let _e245 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_132), (¶m_133));
return _e245;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e241 = light_list_info.slot_rows[0i];
let _e242 = (*row);
a_5 = abs((_e241 - vec4(_e242)));
let _e248 = light_list_info.slot_rows[1i];
let _e249 = (*row);
b_3 = abs((_e248 - vec4(_e249)));
let _e254 = a_5[0u];
let _e256 = a_5[1u];
let _e259 = a_5[2u];
let _e261 = a_5[3u];
let _e265 = b_3[0u];
let _e267 = b_3[1u];
let _e270 = b_3[2u];
let _e272 = b_3[3u];
return (min(min(min(_e254, _e256), min(_e259, _e261)), min(min(_e265, _e267), min(_e270, _e272))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_134: vec4<f32>;
var param_135: i32;
let _e239 = (*slot_3);
let _e243 = light_list_info.indices[(_e239 / 4i)];
param_134 = _e243;
let _e244 = (*slot_3);
param_135 = _e244;
let _e245 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_134), (¶m_135));
return _e245;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e238 = (*texel_2);
let _e242 = light_list_info.list[1u];
let _e244 = (*row_1);
let _e248 = light_list_info.list[2u];
let _e251 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e238 + 0.5f) * _e242), ((_e244 + 0.5f) * _e248)), 0f);
return _e251;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_136: f32;
var param_137: f32;
var param_138: vec4<f32>;
var param_139: i32;
let _e246 = g_cluster_offset;
let _e247 = (*slot_4);
entry_1 = (_e246 + f32(_e247));
let _e250 = entry_1;
row_2 = floor((_e250 / 16f));
let _e253 = entry_1;
let _e254 = row_2;
within_1 = (_e253 - (_e254 * 16f));
let _e257 = within_1;
texel_3 = floor((_e257 / 4f));
let _e262 = light_list_info.cluster_depth[3u];
let _e263 = row_2;
let _e265 = texel_3;
param_136 = _e265;
param_137 = (_e262 + _e263);
let _e266 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_136), (¶m_137));
four_1 = _e266;
let _e267 = within_1;
let _e268 = texel_3;
let _e273 = four_1;
param_138 = _e273;
param_139 = i32(((_e267 - (_e268 * 4f)) + 0.5f));
let _e274 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_138), (¶m_139));
return _e274;
}
fn Clustered_u0028_() -> bool {
let _e238 = light_list_info.cluster_grid[3u];
return (_e238 > 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_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_33: f32;
var param_140: i32;
var param_141: i32;
var v_2: f32;
var u_1: f32;
var local_34: f32;
var param_142: f32;
var param_143: 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_35: f32;
var param_144: array<vec3<f32>, 4>;
var param_145: vec3<f32>;
var area: f32;
var radiance: f32;
var local_36: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_146: vec3<f32>;
var param_147: vec3<f32>;
var param_148: vec3<f32>;
var param_149: vec3<f32>;
var param_150: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_37: vec3<f32>;
var param_151: vec3<f32>;
var param_152: vec3<f32>;
var param_153: f32;
var param_154: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_155: f32;
var param_156: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e294 = (*index_2);
if (_e294 < 8i) {
let _e296 = (*index_2);
let _e299 = frag_info.light_position[_e296];
position = _e299;
let _e300 = (*index_2);
let _e303 = frag_info.light_color[_e300];
color_1 = _e303;
let _e304 = (*index_2);
let _e307 = frag_info.light_direction[_e304];
direction = _e307;
let _e308 = (*index_2);
let _e311 = frag_info.light_cone[_e308];
cone = _e311;
} else {
let _e312 = (*index_2);
slot_5 = (_e312 - 8i);
let _e314 = Clustered_u0028_();
clustered = _e314;
let _e315 = clustered;
if _e315 {
let _e316 = slot_5;
param_140 = _e316;
let _e317 = ClusterRow_u0028_i1_u003b((¶m_140));
local_33 = _e317;
} else {
let _e318 = slot_5;
param_141 = _e318;
let _e319 = LightListRow_u0028_i1_u003b((¶m_141));
local_33 = _e319;
}
let _e320 = local_33;
listRow = _e320;
let _e321 = listRow;
let _e325 = light_list_info.list[2u];
v_2 = ((_e321 + 0.5f) * _e325);
let _e329 = light_list_info.list[1u];
u_1 = _e329;
let _e330 = u_1;
let _e332 = v_2;
let _e334 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e330), _e332), 0f);
position = _e334;
let _e335 = u_1;
let _e337 = v_2;
let _e339 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e335), _e337), 0f);
color_1 = _e339;
let _e340 = u_1;
let _e342 = v_2;
let _e344 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e340), _e342), 0f);
direction = _e344;
let _e345 = u_1;
let _e347 = v_2;
let _e349 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e345), _e347), 0f);
cone = _e349;
let _e350 = clustered;
if _e350 {
let _e351 = listRow;
param_142 = _e351;
let _e352 = InSlots_u0028_f1_u003b((¶m_142));
local_34 = select(1f, 0f, _e352);
} else {
let _e354 = slot_5;
param_143 = _e354;
let _e355 = LightListScale_u0028_i1_u003b((¶m_143));
local_34 = _e355;
}
let _e356 = local_34;
let _e358 = color_1[3u];
color_1[3u] = (_e358 * _e356);
}
let _e362 = position[3u];
type_42 = _e362;
let _e363 = type_42;
if (_e363 > 15.5f) {
let _e366 = (*s_6).n;
light_3.l = _e366;
let _e369 = (*s_6).n;
light_3.h = _e369;
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 _e375 = light_3;
return _e375;
}
let _e376 = type_42;
if (_e376 > 2.5f) {
let _e378 = direction;
halfWidth_1 = _e378.xyz;
let _e380 = cone;
halfHeight_1 = _e380.xyz;
let _e382 = position;
let _e384 = v_world_position_1;
toCentre = (_e382.xyz - _e384);
let _e386 = toCentre;
let _e387 = halfWidth_1;
let _e389 = halfHeight_1;
corners_2[0i] = ((_e386 - _e387) - _e389);
let _e392 = toCentre;
let _e393 = halfWidth_1;
let _e395 = halfHeight_1;
corners_2[1i] = ((_e392 + _e393) - _e395);
let _e398 = toCentre;
let _e399 = halfWidth_1;
let _e401 = halfHeight_1;
corners_2[2i] = ((_e398 + _e399) + _e401);
let _e404 = toCentre;
let _e405 = halfWidth_1;
let _e407 = halfHeight_1;
corners_2[3i] = ((_e404 - _e405) + _e407);
let _e410 = toCentre;
let _e411 = halfWidth_1;
let _e412 = halfHeight_1;
behind = (dot(_e410, cross(_e411, _e412)) >= 0f);
let _e416 = behind;
if _e416 {
local_35 = 0f;
} else {
let _e417 = corners_2;
param_144 = _e417;
let _e419 = (*s_6).n;
param_145 = _e419;
let _e420 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_144), (¶m_145));
local_35 = _e420;
}
let _e421 = local_35;
formFactor = _e421;
let _e422 = halfWidth_1;
let _e423 = halfHeight_1;
area = (length(cross(_e422, _e423)) * 4f);
let _e427 = area;
if (_e427 > 0.000000001f) {
let _e429 = area;
local_36 = (1f / _e429);
} else {
local_36 = 0f;
}
let _e431 = local_36;
radiance = _e431;
let _e432 = toCentre;
distance_2 = length(_e432);
let _e435 = direction[3u];
if (_e435 > 0f) {
let _e437 = distance_2;
let _e439 = direction[3u];
ratio_1 = (_e437 / _e439);
let _e441 = ratio_1;
let _e442 = ratio_1;
let _e444 = ratio_1;
let _e446 = ratio_1;
window_1 = clamp((1f - (((_e441 * _e442) * _e444) * _e446)), 0f, 1f);
let _e450 = window_1;
let _e451 = window_1;
let _e453 = radiance;
radiance = (_e453 * (_e450 * _e451));
}
let _e456 = (*s_6).v;
let _e459 = (*s_6).n;
mirror_1 = reflect(-(_e456), _e459);
let _e461 = position;
param_146 = _e461.xyz;
let _e463 = halfWidth_1;
param_147 = _e463;
let _e464 = halfHeight_1;
param_148 = _e464;
let _e465 = v_world_position_1;
param_149 = _e465;
let _e466 = mirror_1;
param_150 = _e466;
let _e467 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_146), (¶m_147), (¶m_148), (¶m_149), (¶m_150));
representative = _e467;
let _e468 = representative;
let _e469 = v_world_position_1;
toPoint = (_e468 - _e469);
let _e471 = toPoint;
pointDistance = length(_e471);
let _e473 = pointDistance;
if (_e473 > 0.000001f) {
let _e475 = toPoint;
let _e476 = pointDistance;
local_37 = (_e475 / vec3(_e476));
} else {
let _e480 = (*s_6).n;
local_37 = _e480;
}
let _e481 = local_37;
light_3.l = _e481;
let _e484 = light_3.l;
let _e486 = (*s_6).v;
light_3.h = normalize((_e484 + _e486));
let _e490 = formFactor;
light_3.n_dot_l = _e490;
let _e493 = (*s_6).n;
let _e495 = light_3.h;
light_3.n_dot_h = max(dot(_e493, _e495), 0f);
let _e500 = (*s_6).v;
let _e502 = light_3.h;
light_3.v_dot_h = max(dot(_e500, _e502), 0f);
let _e506 = color_1;
let _e509 = color_1[3u];
let _e511 = radiance;
light_3.radiance = ((_e506.xyz * _e509) * _e511);
light_3.integrated = 1f;
let _e516 = (*s_6).n;
param_151 = _e516;
let _e518 = (*s_6).v;
param_152 = _e518;
let _e520 = (*s_6).roughness;
param_153 = _e520;
let _e521 = corners_2;
param_154 = _e521;
let _e522 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_151), (¶m_152), (¶m_153), (¶m_154));
light_3.ltc = _e522;
let _e524 = light_3;
return _e524;
}
let _e525 = direction;
aim = normalize(_e525.xyz);
attenuation_1 = 1f;
let _e528 = type_42;
if (_e528 < 0.5f) {
let _e530 = aim;
light_3.l = -(_e530);
} else {
let _e533 = position;
let _e535 = v_world_position_1;
toLight_1 = (_e533.xyz - _e535);
let _e537 = toLight_1;
distance_3 = length(_e537);
let _e539 = distance_3;
if (_e539 < 0.000001f) {
let _e542 = (*s_6).n;
light_3.l = _e542;
let _e545 = (*s_6).n;
light_3.h = _e545;
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 _e551 = light_3;
return _e551;
}
let _e552 = toLight_1;
let _e553 = distance_3;
light_3.l = (_e552 / vec3(_e553));
let _e557 = distance_3;
param_155 = _e557;
let _e559 = direction[3u];
param_156 = _e559;
let _e560 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_155), (¶m_156));
attenuation_1 = _e560;
let _e561 = type_42;
if (_e561 > 1.5f) {
let _e563 = aim;
let _e565 = light_3.l;
cosAngle = dot(_e563, -(_e565));
let _e568 = cosAngle;
let _e570 = cone[1u];
let _e573 = cone[0u];
let _e575 = cone[1u];
ramp = clamp(((_e568 - _e570) / (_e573 - _e575)), 0f, 1f);
let _e579 = ramp;
let _e580 = ramp;
let _e582 = attenuation_1;
attenuation_1 = (_e582 * (_e579 * _e580));
}
}
let _e585 = light_3.l;
let _e587 = (*s_6).v;
light_3.h = normalize((_e585 + _e587));
let _e592 = (*s_6).n;
let _e594 = light_3.l;
light_3.n_dot_l = max(dot(_e592, _e594), 0f);
let _e599 = (*s_6).n;
let _e601 = light_3.h;
light_3.n_dot_h = max(dot(_e599, _e601), 0f);
let _e606 = (*s_6).v;
let _e608 = light_3.h;
light_3.v_dot_h = max(dot(_e606, _e608), 0f);
let _e612 = color_1;
let _e615 = color_1[3u];
let _e617 = attenuation_1;
light_3.radiance = ((_e612.xyz * _e615) * _e617);
let _e620 = light_3;
return _e620;
}
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_38: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_157: f32;
var param_158: f32;
let _e251 = light_list_info.cluster_view_projection;
let _e252 = (*world_3);
clip_1 = (_e251 * vec4<f32>(_e252.x, _e252.y, _e252.z, 1f));
let _e258 = clip_1;
let _e261 = clip_1[3u];
ndc_1 = (_e258.xy / vec2(max(_e261, 0.000001f)));
let _e266 = light_list_info.cluster_grid;
grid = _e266.xyz;
let _e270 = light_list_info.cluster_depth[0u];
near_1 = _e270;
let _e272 = ndc_1[0u];
let _e276 = grid[0u];
let _e280 = grid[0u];
tx = clamp(floor((((_e272 * 0.5f) + 0.5f) * _e276)), 0f, (_e280 - 1f));
let _e284 = ndc_1[1u];
let _e288 = grid[1u];
let _e292 = grid[1u];
ty = clamp(floor((((_e284 * 0.5f) + 0.5f) * _e288)), 0f, (_e292 - 1f));
let _e296 = clip_1[3u];
let _e297 = near_1;
if (_e296 <= _e297) {
local_38 = 0f;
} else {
let _e300 = clip_1[3u];
let _e301 = near_1;
let _e306 = light_list_info.cluster_depth[1u];
let _e310 = grid[2u];
local_38 = clamp(floor((log((_e300 / _e301)) * _e306)), 0f, (_e310 - 1f));
}
let _e313 = local_38;
tz = _e313;
let _e314 = tx;
let _e315 = ty;
let _e317 = grid[0u];
let _e320 = tz;
let _e322 = grid[0u];
let _e325 = grid[1u];
cell_1 = ((_e314 + (_e315 * _e317)) + ((_e320 * _e322) * _e325));
let _e328 = cell_1;
row_3 = floor((_e328 / 4f));
let _e331 = cell_1;
let _e332 = row_3;
let _e337 = light_list_info.cluster_depth[2u];
let _e338 = row_3;
param_157 = (_e331 - (_e332 * 4f));
param_158 = (_e337 + _e338);
let _e340 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_157), (¶m_158));
header = _e340;
let _e342 = header[0u];
g_cluster_offset = _e342;
let _e344 = header[1u];
g_cluster_count = _e344;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_159: vec3<f32>;
let _e240 = light_list_info.list[0u];
tail = _e240;
let _e241 = Clustered_u0028_();
if _e241 {
let _e242 = v_world_position_1;
param_159 = _e242;
FindCluster_u0028_vf3_u003b((¶m_159));
let _e243 = g_cluster_count;
tail = _e243;
}
let _e246 = frag_info.frame_params[1u];
let _e250 = tail;
return (clamp(i32((_e246 + 0.5f)), 0i, 8i) + clamp(i32((_e250 + 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_4: LightSample;
var param_160: i32;
var param_161: Surface;
var visibility: f32;
var param_162: i32;
var local_39: f32;
var param_163: Surface;
var param_164: LightSample;
var param_165: i32;
var param_166: vec3<f32>;
var param_167: vec3<f32>;
var param_168: i32;
var param_169: Surface;
var param_170: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e254 = LightCount_u0028_();
count_1 = _e254;
i_9 = 0i;
loop {
let _e255 = i_9;
if (_e255 < 32i) {
let _e257 = i_9;
let _e258 = count_1;
if (_e257 >= _e258) {
break;
}
let _e260 = i_9;
param_160 = _e260;
let _e261 = (*s_7);
param_161 = _e261;
let _e262 = 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_160), (¶m_161));
light_4 = _e262;
let _e264 = light_4.n_dot_l;
if (_e264 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e266 = i_9;
param_162 = _e266;
let _e267 = LightHasShadow_u0028_i1_u003b((¶m_162));
if _e267 {
let _e268 = (*s_7);
param_163 = _e268;
let _e269 = light_4;
param_164 = _e269;
let _e270 = i_9;
param_165 = _e270;
let _e271 = 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_163), (¶m_164), (¶m_165));
let _e272 = v_world_position_1;
param_166 = _e272;
let _e274 = (*s_7).n;
param_167 = _e274;
let _e275 = i_9;
param_168 = _e275;
let _e276 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_166), (¶m_167), (¶m_168));
local_39 = (_e271 * _e276);
} else {
local_39 = 1f;
}
let _e278 = local_39;
visibility = _e278;
let _e279 = visibility;
if (_e279 <= 0f) {
continue;
}
let _e281 = (*s_7);
param_169 = _e281;
let _e282 = light_4;
param_170 = _e282;
let _e283 = 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_169), (¶m_170));
let _e285 = light_4.radiance;
let _e288 = light_4.n_dot_l;
let _e290 = visibility;
let _e292 = light_transmittance;
let _e294 = total_1;
total_1 = (_e294 + ((((_e283 * _e285) * _e288) * _e290) * _e292));
continue;
} else {
break;
}
continuing {
let _e296 = i_9;
i_9 = (_e296 + 1i);
}
}
let _e298 = total_1;
return _e298;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e237 = v_lightmap_uv_1;
let _e238 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e237);
texel_4 = _e238;
let _e239 = texel_4;
let _e242 = texel_4[3u];
return ((_e239.xyz * _e242) * 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_171: f32;
var param_172: f32;
var param_173: f32;
var param_174: vec3<f32>;
var param_175: f32;
let _e245 = (*mu_1);
param_171 = _e245;
let _e246 = (*r_4);
param_172 = _e246;
let _e247 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_171), (¶m_172));
e_1 = _e247;
let _e248 = (*rho_2);
let _e249 = e_1;
let _e251 = (*r_4);
param_173 = _e251;
let _e252 = FonAverage_u0028_f1_u003b((¶m_173));
let _e253 = (*rho_2);
param_174 = _e253;
param_175 = _e252;
let _e254 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_174), (¶m_175));
let _e255 = e_1;
return ((_e248 * _e249) + (_e254 * (1f - _e255)));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e238 = frag_info.target_origin[1u];
return _e238;
}
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_8: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e238 = v_texcoord_1;
let _e239 = MaterialLodBias_u0028_();
let _e240 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e238, _e239);
orm = _e240.xyz;
let _e243 = (*s_8).metallic;
let _e245 = orm[2u];
(*s_8).metallic = clamp((_e243 * _e245), 0f, 1f);
let _e250 = (*s_8).roughness;
let _e252 = orm[1u];
(*s_8).roughness = clamp((_e250 * _e252), 0.02f, 1f);
return;
}
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_9: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_176: vec3<f32>;
let _e239 = v_texcoord_1;
let _e240 = MaterialLodBias_u0028_();
let _e241 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e239, _e240);
param_176 = _e241.xyz;
let _e243 = SrgbToLinear_u0028_vf3_u003b((¶m_176));
emissive = _e243;
let _e244 = emissive;
let _e246 = frag_info.emissive;
let _e251 = frag_info.material2_[3u];
(*s_9).emissive = ((_e244 * _e246.xyz) * _e251);
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_10: ptr<function, Surface>) {
var occlusion: f32;
let _e238 = v_texcoord_1;
let _e239 = MaterialLodBias_u0028_();
let _e240 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e238, _e239);
occlusion = _e240.x;
let _e242 = occlusion;
let _e245 = frag_info.material2_[2u];
(*s_10).occlusion = mix(1f, _e242, clamp(_e245, 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_11: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_4: vec3<f32>;
var sampled: vec3<f32>;
let _e241 = v_texcoord_1;
let _e242 = MaterialLodBias_u0028_();
let _e243 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e241, _e242);
sampledTexel = _e243;
let _e244 = v_tangent_1;
t_2 = _e244.xyz;
let _e246 = t_2;
let _e248 = (*s_11).n;
let _e250 = (*s_11).n;
let _e251 = t_2;
t_2 = (_e246 - (_e248 * dot(_e250, _e251)));
let _e255 = t_2;
let _e256 = t_2;
if (dot(_e255, _e256) < 0.000000000001f) {
return;
}
let _e259 = t_2;
t_2 = normalize(_e259);
let _e262 = (*s_11).n;
let _e263 = t_2;
let _e266 = v_tangent_1[3u];
b_4 = (cross(_e262, _e263) * _e266);
let _e268 = gl_FrontFacing_1;
if !(_e268) {
let _e270 = t_2;
t_2 = -(_e270);
}
let _e272 = sampledTexel;
sampled = ((_e272.xyz * 2f) - vec3(1f));
let _e279 = frag_info.emissive[3u];
if (_e279 > 0.5f) {
let _e281 = sampled;
let _e283 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e281.xy, _e283.xy)), 0f));
}
let _e292 = frag_info.material2_[1u];
let _e293 = sampled;
let _e295 = (_e293.xy * _e292);
sampled[0u] = _e295.x;
sampled[1u] = _e295.y;
let _e300 = t_2;
let _e302 = sampled[0u];
let _e304 = b_4;
let _e306 = sampled[1u];
let _e310 = (*s_11).n;
let _e312 = sampled[2u];
(*s_11).n = normalize((((_e300 * _e302) + (_e304 * _e306)) + (_e310 * _e312)));
let _e318 = (*s_11).n;
let _e320 = (*s_11).v;
(*s_11).n_dot_v = max(dot(_e318, _e320), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e237 = (*texel_5);
let _e241 = irradiance_info.atlas;
let _e244 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e237 + vec2(0.5f)) * _e241.xy), 0f);
return _e244;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_7: 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_177: vec2<f32>;
var b_5: vec4<f32>;
var param_178: vec2<f32>;
var c_1: vec4<f32>;
var param_179: vec2<f32>;
var d_5: vec4<f32>;
var param_180: vec2<f32>;
let _e250 = (*uv_7);
let _e251 = (*interior);
at_1 = ((vec2(1f) + (_e250 * _e251)) - vec2(0.5f));
let _e257 = at_1;
low = floor(_e257);
let _e259 = at_1;
let _e260 = low;
f_3 = (_e259 - _e260);
let _e262 = (*corner);
let _e263 = low;
param_177 = (_e262 + _e263);
let _e265 = AtlasTexel_u0028_vf2_u003b((¶m_177));
a_6 = _e265;
let _e266 = (*corner);
let _e267 = low;
param_178 = ((_e266 + _e267) + vec2<f32>(1f, 0f));
let _e270 = AtlasTexel_u0028_vf2_u003b((¶m_178));
b_5 = _e270;
let _e271 = (*corner);
let _e272 = low;
param_179 = ((_e271 + _e272) + vec2<f32>(0f, 1f));
let _e275 = AtlasTexel_u0028_vf2_u003b((¶m_179));
c_1 = _e275;
let _e276 = (*corner);
let _e277 = low;
param_180 = ((_e276 + _e277) + vec2<f32>(1f, 1f));
let _e280 = AtlasTexel_u0028_vf2_u003b((¶m_180));
d_5 = _e280;
let _e281 = a_6;
let _e282 = b_5;
let _e284 = f_3[0u];
let _e287 = c_1;
let _e288 = d_5;
let _e290 = f_3[0u];
let _e294 = f_3[1u];
return mix(mix(_e281, _e282, vec4(_e284)), mix(_e287, _e288, vec4(_e290)), vec4(_e294));
}
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 _e241 = (*direction_1)[0u];
let _e244 = (*direction_1)[1u];
let _e248 = (*direction_1)[2u];
sum_1 = ((abs(_e241) + abs(_e244)) + abs(_e248));
let _e251 = sum_1;
if (_e251 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e253 = (*direction_1);
let _e254 = sum_1;
n_6 = (_e253 / vec3(_e254));
let _e257 = n_6;
xy = _e257.xy;
let _e260 = n_6[2u];
if (_e260 < 0f) {
let _e263 = n_6[1u];
let _e267 = n_6[0u];
let _e272 = n_6[0u];
let _e276 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e263)) * select(-1f, 1f, (_e267 >= 0f))), ((1f - abs(_e272)) * select(-1f, 1f, (_e276 >= 0f))));
}
let _e281 = xy;
return ((_e281 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_181: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_182: vec3<f32>;
var param_183: vec2<f32>;
var param_184: f32;
var param_185: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_186: vec3<f32>;
var param_187: vec2<f32>;
var param_188: f32;
var param_189: vec2<f32>;
var local_40: vec3<f32>;
let _e283 = irradiance_info.origin;
origin_2 = _e283.xyz;
let _e286 = irradiance_info.spacing;
spacing = _e286.xyz;
let _e289 = irradiance_info.counts;
counts = _e289.xyz;
let _e293 = irradiance_info.tiles[0u];
irradianceTile = _e293;
let _e296 = irradiance_info.tiles[1u];
depthTile = _e296;
let _e299 = irradiance_info.tiles[2u];
columns = _e299;
let _e302 = irradiance_info.tiles[3u];
momentsTop = _e302;
let _e303 = (*normal_1);
unit = normalize(_e303);
let _e305 = (*world_4);
let _e306 = unit;
let _e309 = irradiance_info.spacing[3u];
let _e312 = (*view_1);
let _e315 = irradiance_info.counts[3u];
biased = ((_e305 + (_e306 * _e309)) + (_e312 * _e315));
let _e318 = biased;
let _e319 = origin_2;
let _e321 = spacing;
grid_1 = ((_e318 - _e319) / _e321);
let _e323 = grid_1;
let _e325 = counts;
base = clamp(floor(_e323), vec3<f32>(0f, 0f, 0f), (_e325 - vec3(2f)));
let _e329 = grid_1;
let _e330 = base;
f_4 = clamp((_e329 - _e330), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e333 = corner_1;
if (_e333 < 8i) {
let _e335 = corner_1;
let _e338 = corner_1;
let _e343 = corner_1;
offset_3 = vec3<f32>(f32((_e335 & 1i)), f32(((_e338 >> bitcast<u32>(1i)) & 1i)), f32(((_e343 >> bitcast<u32>(2i)) & 1i)));
let _e349 = base;
let _e350 = offset_3;
cell_2 = (_e349 + _e350);
let _e353 = cell_2[2u];
let _e355 = counts[1u];
let _e358 = cell_2[1u];
let _e361 = counts[0u];
let _e364 = cell_2[0u];
probe = ((((_e353 * _e355) + _e358) * _e361) + _e364);
let _e366 = probe;
let _e367 = columns;
let _e372 = probe;
let _e373 = columns;
tile_4 = vec2<f32>((_e366 - (floor((_e366 / _e367)) * _e367)), floor((_e372 / _e373)));
let _e377 = tile_4;
let _e378 = irradianceTile;
irradianceCorner = (_e377 * (_e378 + 2f));
let _e382 = tile_4[0u];
let _e383 = depthTile;
let _e386 = momentsTop;
let _e388 = tile_4[1u];
let _e389 = depthTile;
momentCorner = vec2<f32>((_e382 * (_e383 + 2f)), (_e386 + (_e388 * (_e389 + 2f))));
let _e394 = irradianceCorner;
param_181 = (_e394 + vec2(1f));
let _e397 = AtlasTexel_u0028_vf2_u003b((¶m_181));
if (_e397.w < 0.5f) {
continue;
}
let _e400 = f_4;
let _e402 = f_4;
let _e403 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e400), _e402, _e403);
let _e406 = trilinear[0u];
let _e408 = trilinear[1u];
let _e411 = trilinear[2u];
weight_3 = max(((_e406 * _e408) * _e411), 0.001f);
let _e414 = origin_2;
let _e415 = spacing;
let _e416 = cell_2;
probePosition = (_e414 + (_e415 * _e416));
let _e419 = probePosition;
let _e420 = biased;
toProbe = (_e419 - _e420);
let _e422 = toProbe;
distance_4 = length(_e422);
let _e424 = distance_4;
if (_e424 > 0.000001f) {
let _e426 = toProbe;
let _e427 = distance_4;
direction_2 = (_e426 / vec3(_e427));
let _e430 = unit;
let _e431 = probePosition;
let _e432 = (*world_4);
facing = ((dot(_e430, normalize((_e431 - _e432))) * 0.5f) + 0.5f);
let _e438 = facing;
let _e439 = facing;
probeWeight = ((_e438 * _e439) + 0.2f);
let _e442 = direction_2;
param_182 = -(_e442);
let _e444 = ProbeOctahedral_u0028_vf3_u003b((¶m_182));
let _e445 = momentCorner;
param_183 = _e445;
let _e446 = depthTile;
param_184 = _e446;
param_185 = _e444;
let _e447 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_183), (¶m_184), (¶m_185));
moments_3 = _e447.xy;
chebyshev = 1f;
let _e449 = distance_4;
let _e451 = moments_3[0u];
if (_e449 > _e451) {
let _e454 = moments_3[1u];
let _e456 = moments_3[0u];
let _e458 = moments_3[0u];
variance_1 = max((_e454 - (_e456 * _e458)), 0.000001f);
let _e462 = distance_4;
let _e464 = moments_3[0u];
difference = (_e462 - _e464);
let _e466 = variance_1;
let _e467 = variance_1;
let _e468 = difference;
let _e469 = difference;
chebyshev = (_e466 / (_e467 + (_e468 * _e469)));
let _e473 = chebyshev;
let _e474 = chebyshev;
let _e476 = chebyshev;
chebyshev = ((_e473 * _e474) * _e476);
}
let _e478 = probeWeight;
let _e479 = chebyshev;
probeWeight = max((_e478 * max(_e479, 0.05f)), 0.000001f);
let _e483 = probeWeight;
if (_e483 < 0.2f) {
let _e485 = probeWeight;
let _e486 = probeWeight;
let _e489 = probeWeight;
probeWeight = (_e489 * ((_e485 * _e486) * 25f));
}
let _e491 = probeWeight;
let _e492 = weight_3;
weight_3 = (_e492 * _e491);
}
let _e494 = unit;
param_186 = _e494;
let _e495 = ProbeOctahedral_u0028_vf3_u003b((¶m_186));
let _e496 = irradianceCorner;
param_187 = _e496;
let _e497 = irradianceTile;
param_188 = _e497;
param_189 = _e495;
let _e498 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_187), (¶m_188), (¶m_189));
let _e500 = weight_3;
let _e502 = total_2;
total_2 = (_e502 + (_e498.xyz * _e500));
let _e504 = weight_3;
let _e505 = weights;
weights = (_e505 + _e504);
continue;
} else {
break;
}
continuing {
let _e507 = corner_1;
corner_1 = (_e507 + 1i);
}
}
let _e509 = weights;
if (_e509 > 0f) {
let _e511 = total_2;
let _e512 = weights;
local_40 = (_e511 / vec3(_e512));
} else {
local_40 = vec3<f32>(0f, 0f, 0f);
}
let _e515 = local_40;
return _e515;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e238 = irradiance_info.origin[3u];
return (_e238 > 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_12: ptr<function, Surface>) {
var param_190: vec3<f32>;
var param_191: vec3<f32>;
var param_192: vec3<f32>;
var param_193: Surface;
var param_194: Surface;
var param_195: Surface;
let _e243 = IrradianceEnabled_u0028_();
if _e243 {
let _e244 = v_world_position_1;
param_190 = _e244;
let _e246 = (*s_12).n;
param_191 = _e246;
let _e248 = (*s_12).v;
param_192 = _e248;
let _e249 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_190), (¶m_191), (¶m_192));
let _e252 = frag_info.material[2u];
(*s_12).ambient = (_e249 * _e252);
}
let _e255 = (*s_12);
param_193 = _e255;
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_193));
let _e256 = param_193;
(*s_12) = _e256;
let _e257 = (*s_12);
param_194 = _e257;
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_194));
let _e258 = param_194;
(*s_12) = _e258;
let _e259 = (*s_12);
param_195 = _e259;
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_195));
let _e260 = param_195;
(*s_12) = _e260;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_41: vec3<f32>;
let _e237 = Orthographic_u0028_();
if _e237 {
let _e239 = fog_info.forward;
local_41 = -(_e239.xyz);
} else {
let _e243 = fog_info.eye;
let _e245 = v_world_position_1;
local_41 = normalize((_e243.xyz - _e245));
}
let _e248 = local_41;
return _e248;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_3: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e242 = (*cutoff);
key_2 = (-2f - _e242);
let _e244 = key_2;
let _e247 = key_2;
let _e249 = floor((_e247 / 128f));
let _e254 = key_2;
origin_3 = vec3<f32>(floor((_e244 / 16384f)), (_e249 - (floor((_e249 / 128f)) * 128f)), (_e254 - (floor((_e254 / 128f)) * 128f)));
let _e260 = (*scenePosition);
let _e263 = origin_3;
let _e264 = (floor((_e260 * 16f)) + _e263);
let _e265 = vec3(128f);
cell_3 = (_e264 - (floor((_e264 / _e265)) * _e265));
let _e270 = cell_3;
p3_ = fract((_e270 * 0.1031f));
let _e273 = p3_;
let _e274 = p3_;
let _e279 = p3_;
p3_ = (_e279 + vec3(dot(_e273, (_e274.zyx + vec3(31.32f)))));
let _e283 = p3_[0u];
let _e285 = p3_[1u];
let _e288 = p3_[2u];
return fract(((_e283 + _e285) * _e288));
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_13: Surface;
var param_196: vec3<f32>;
var param_197: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_198: vec3<f32>;
var param_199: f32;
let _e244 = v_texcoord_1;
let _e245 = MaterialLodBias_u0028_();
let _e246 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e244, _e245);
texel_6 = _e246;
let _e247 = texel_6;
param_196 = _e247.xyz;
let _e249 = SrgbToLinear_u0028_vf3_u003b((¶m_196));
let _e251 = frag_info.base_color;
param_197 = _e251.xyz;
let _e253 = SrgbToLinear_u0028_vf3_u003b((¶m_197));
let _e255 = v_color_1;
s_13.albedo = ((_e249 * _e253) * _e255.xyz);
let _e260 = texel_6[3u];
let _e263 = frag_info.base_color[3u];
let _e266 = v_color_1[3u];
s_13.alpha = ((_e260 * _e263) * _e266);
let _e270 = s_13.albedo;
g_albedo = _e270;
let _e273 = frag_info.material2_[0u];
cutoff_1 = _e273;
let _e274 = cutoff_1;
if (_e274 > 1f) {
let _e276 = cutoff_1;
edge = (_e276 - 1f);
let _e279 = s_13.alpha;
let _e280 = edge;
let _e283 = s_13.alpha;
let _e284 = fwidth(_e283);
s_13.alpha = clamp((((_e279 - _e280) / max(_e284, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e290 = cutoff_1;
if (_e290 >= 0f) {
let _e293 = s_13.alpha;
let _e294 = cutoff_1;
if (_e293 < _e294) {
discard;
}
s_13.alpha = 1f;
} else {
let _e297 = cutoff_1;
if (_e297 < -1.5f) {
let _e300 = s_13.alpha;
let _e301 = v_world_position_1;
param_198 = _e301;
let _e302 = cutoff_1;
param_199 = _e302;
let _e303 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_198), (¶m_199));
if (_e300 < _e303) {
discard;
}
}
}
}
let _e305 = cutoff_1;
let _e307 = cutoff_1;
g_premultiply = ((_e305 < 0f) && (_e307 > -0.75f));
let _e310 = v_normal_1;
s_13.n = normalize(_e310);
let _e313 = gl_FrontFacing_1;
if !(_e313) {
let _e316 = s_13.n;
s_13.n = -(_e316);
}
let _e319 = TowardsEye_u0028_();
s_13.v = _e319;
let _e322 = s_13.n;
let _e324 = s_13.v;
s_13.n_dot_v = max(dot(_e322, _e324), 0.0001f);
let _e330 = frag_info.material[0u];
s_13.metallic = clamp(_e330, 0f, 1f);
let _e335 = frag_info.material[1u];
s_13.roughness = clamp(_e335, 0.02f, 1f);
let _e339 = frag_info.ambient_ground;
let _e342 = frag_info.ambient_sky;
let _e346 = s_13.n[1u];
let _e353 = frag_info.material[2u];
s_13.ambient = (mix(_e339.xyz, _e342.xyz, vec3(((_e346 * 0.5f) + 0.5f))) * _e353);
let _e358 = frag_info.frame_params[0u];
s_13.exposure = max(_e358, 0f);
s_13.occlusion = 1f;
s_13.emissive = vec3<f32>(0f, 0f, 0f);
let _e363 = s_13;
return _e363;
}
fn main_1() {
var s_14: Surface;
var param_200: Surface;
var param_201: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_202: vec3<f32>;
var param_203: f32;
var param_204: 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_205: f32;
var param_206: f32;
var single_1: vec3<f32>;
var specular_1: vec3<f32>;
var missed: f32;
var average_2: vec3<f32>;
var multiple: vec3<f32>;
var lit_3: vec3<f32>;
var param_207: Surface;
var param_208: Surface;
var param_209: vec3<f32>;
var param_210: vec3<f32>;
var param_211: f32;
var param_212: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e265 = ReadSurface_u0028_();
s_14 = _e265;
let _e266 = s_14;
param_200 = _e266;
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_200));
let _e267 = param_200;
s_14 = _e267;
let _e268 = s_14;
param_201 = _e268;
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_201));
let _e269 = param_201;
s_14 = _e269;
let _e271 = s_14.metallic;
metallic = clamp(_e271, 0f, 1f);
let _e274 = s_14.albedo;
let _e275 = metallic;
diffuseColor_1 = (_e274 * (1f - _e275));
let _e278 = EonDiffuse_u0028_();
if _e278 {
let _e279 = diffuseColor_1;
param_202 = _e279;
let _e281 = s_14.roughness;
param_203 = _e281;
let _e283 = s_14.n_dot_v;
param_204 = _e283;
let _e284 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_202), (¶m_203), (¶m_204));
diffuseColor_1 = _e284;
}
let _e285 = diffuseColor_1;
let _e287 = s_14.ambient;
let _e290 = s_14.occlusion;
ambient = ((_e285 * _e287) * _e290);
let _e294 = frag_info.frame_params[3u];
levels = _e294;
let _e295 = levels;
if (_e295 > 0f) {
let _e298 = s_14.albedo;
let _e299 = metallic;
f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e298, vec3(_e299));
let _e303 = s_14.v;
let _e306 = s_14.n;
reflected = reflect(-(_e303), _e306);
let _e309 = s_14.n;
let _e310 = levels;
let _e311 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e309, _e310);
irradiance = _e311.xyz;
let _e313 = reflected;
let _e315 = s_14.roughness;
let _e316 = levels;
let _e318 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e313, (_e315 * _e316));
prefiltered = _e318.xyz;
let _e321 = s_14.roughness;
param_205 = _e321;
let _e323 = s_14.n_dot_v;
param_206 = _e323;
let _e324 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_205), (¶m_206));
ab_1 = _e324;
let _e325 = f0_3;
let _e327 = ab_1[0u];
let _e330 = ab_1[1u];
single_1 = ((_e325 * _e327) + vec3(_e330));
let _e333 = prefiltered;
let _e334 = single_1;
specular_1 = (_e333 * _e334);
let _e336 = EnergyCompensation_u0028_();
if _e336 {
let _e338 = ab_1[0u];
let _e340 = ab_1[1u];
missed = (1f - (_e338 + _e340));
let _e343 = f0_3;
let _e344 = f0_3;
average_2 = (_e343 + ((vec3<f32>(1f, 1f, 1f) - _e344) / vec3(21f)));
let _e349 = single_1;
let _e350 = average_2;
let _e352 = missed;
let _e353 = average_2;
multiple = ((_e349 * _e350) / (vec3<f32>(1f, 1f, 1f) - (_e353 * _e352)));
let _e357 = multiple;
let _e358 = missed;
let _e360 = irradiance;
let _e362 = specular_1;
specular_1 = (_e362 + ((_e357 * _e358) * _e360));
}
let _e364 = diffuseColor_1;
let _e365 = irradiance;
let _e367 = specular_1;
let _e371 = frag_info.material[2u];
let _e374 = s_14.occlusion;
ambient = ((((_e364 * _e365) + _e367) * _e371) * _e374);
}
let _e376 = diffuseColor_1;
let _e377 = SampleLightmap_u0028_();
let _e380 = s_14.occlusion;
let _e382 = ambient;
ambient = (_e382 + ((_e376 * _e377) * _e380));
let _e384 = s_14;
param_207 = _e384;
let _e385 = 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_207));
let _e387 = s_14.occlusion;
let _e389 = ambient;
let _e392 = s_14.emissive;
lit_3 = (((_e385 * _e387) + _e389) + _e392);
let _e394 = s_14;
param_208 = _e394;
let _e395 = lit_3;
param_209 = _e395;
let _e396 = WriteDebugView_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_vf3_u003b((¶m_208), (¶m_209));
if _e396 {
return;
}
let _e397 = lit_3;
param_210 = _e397;
let _e399 = s_14.alpha;
param_211 = _e399;
let _e401 = s_14.roughness;
param_212 = _e401;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_210), (¶m_211), (¶m_212));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<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> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e303 = v_world_position_1;
let _e305 = fog_info.eye;
let _e309 = fog_info.forward;
return dot((_e303 - _e305.xyz), _e309.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e308 = ViewDepth_u0028_();
z = abs(_e308);
let _e310 = z;
near = (_e310 / 5f);
let _e312 = z;
far = (_e312 / 200f);
let _e314 = far;
let _e315 = far;
let _e317 = far;
far3_ = ((_e314 * _e315) * _e317);
let _e319 = (*alpha);
let _e320 = near;
let _e321 = near;
let _e324 = far3_;
let _e325 = far3_;
return (_e319 * clamp((10f / ((0.00001f + (_e320 * _e321)) + (_e324 * _e325))), 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 _e312 = fog_info.forward[3u];
mode = _e312;
let _e313 = mode;
if (_e313 > 0.5f) {
let _e316 = frag_color[3u];
alpha_1 = _e316;
let _e317 = alpha_1;
param = _e317;
let _e318 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e318;
let _e319 = frag_color;
let _e321 = weight;
let _e322 = (_e319.xyz * _e321);
let _e323 = alpha_1;
let _e324 = weight;
accumulate = vec4<f32>(_e322.x, _e322.y, _e322.z, (_e323 * _e324));
let _e330 = mode;
let _e332 = mode;
revealage = ((_e330 > 1.5f) && (_e332 < 2.5f));
let _e335 = revealage;
if _e335 {
let _e336 = alpha_1;
local = vec4(_e336);
} else {
let _e338 = accumulate;
local = _e338;
}
let _e339 = local;
frag_color = _e339;
let _e340 = mode;
if (_e340 > 2.5f) {
let _e342 = alpha_1;
frag_surface = vec4(_e342);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e306 = (*n)[0u];
let _e309 = (*n)[1u];
let _e313 = (*n)[2u];
let _e316 = (*n);
(*n) = (_e316 / vec3(((abs(_e306) + abs(_e309)) + abs(_e313))));
let _e319 = (*n);
e = _e319.xy;
let _e322 = (*n)[2u];
if (_e322 < 0f) {
let _e324 = (*n);
let _e330 = (*n)[0u];
let _e334 = (*n)[1u];
e = ((vec2(1f) - abs(_e324.yx)) * vec2<f32>(select(-1f, 1f, (_e330 >= 0f)), select(-1f, 1f, (_e334 >= 0f))));
}
let _e339 = e;
return ((_e339 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e304 = (*linear);
let _e306 = (*linear);
let _e310 = (*linear);
return mix((_e304 * 12.92f), ((pow(_e306, 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), _e310));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e307 = g_albedo;
param_1 = clamp(_e307, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e309 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e309.x, _e309.y, _e309.z, 1f);
let _e314 = g_debug_surface_on;
if _e314 {
let _e315 = g_debug_surface;
let _e316 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e315.x, _e315.y, _e315.z, _e316);
return;
}
let _e321 = v_normal_1;
geometric = normalize(_e321);
let _e323 = gl_FrontFacing_1;
if !(_e323) {
let _e325 = geometric;
geometric = -(_e325);
}
let _e327 = geometric;
param_2 = _e327;
let _e328 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e329 = (*roughness);
let _e331 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e328.x, _e328.y, clamp(_e329, 0f, 1f), _e331);
return;
}
fn Orthographic_u0028_() -> bool {
let _e305 = fog_info.projection[0u];
return (_e305 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e304 = Orthographic_u0028_();
if _e304 {
let _e305 = ViewDepth_u0028_();
local_1 = max(_e305, 0f);
} else {
let _e307 = v_world_position_1;
let _e309 = fog_info.eye;
local_1 = distance(_e307, _e309.xyz);
}
let _e312 = local_1;
return _e312;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e311 = fog_info.fog[3u];
density = _e311;
let _e312 = density;
if (_e312 <= 0f) {
let _e314 = (*color);
return _e314;
}
let _e315 = EyeDistance_u0028_();
d = _e315;
let _e318 = fog_info.eye[3u];
falloff = _e318;
let _e319 = falloff;
if (_e319 > 0f) {
let _e321 = falloff;
let _e323 = v_world_position_1[1u];
let _e326 = fog_info.eye[1u];
k = (_e321 * (_e323 - _e326));
let _e329 = k;
if (abs(_e329) > 0.001f) {
let _e332 = k;
let _e336 = k;
local_2 = ((1f - exp(-(_e332))) / _e336);
} else {
let _e338 = k;
local_2 = (1f - (0.5f * _e338));
}
let _e341 = local_2;
let _e342 = density;
density = (_e342 * _e341);
}
let _e345 = fog_info.fog;
let _e347 = (*color);
let _e348 = density;
let _e350 = d;
return mix(_e345.xyz, _e347, vec3(clamp(exp((-(_e348) * _e350)), 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 _e309 = g_premultiply;
let _e310 = (*alpha_2);
weight_1 = select(1f, _e310, _e309);
let _e312 = (*linearColor);
param_3 = _e312;
let _e313 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e314 = weight_1;
let _e315 = (_e313 * _e314);
let _e316 = (*alpha_2);
let _e317 = g_pass_through;
frag_color = vec4<f32>(_e315.x, _e315.y, _e315.z, (_e316 * (1f - _e317)));
let _e324 = (*roughness_1);
param_4 = _e324;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e304 = (*srgb);
let _e307 = (*srgb);
let _e312 = (*srgb);
return mix((_e304 / vec3(12.92f)), pow(((_e307 + 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), _e312));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e306 = (*key);
hue = fract(((_e306 * 0.618034f) + 0.13f));
let _e310 = hue;
k_1 = clamp((abs(((fract((vec3(_e310) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e323 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e323, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_3091_: bool;
let _e304 = (*c);
let _e305 = (*c);
let _e307 = any((_e304 != _e305));
phi_3091_ = _e307;
if !(_e307) {
let _e309 = (*c);
phi_3091_ = any((abs(_e309) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e314 = phi_3091_;
return _e314;
}
fn MapUv_u0028_i1_u003b(slot: ptr<function, i32>) -> vec2<f32> {
var uvw: vec3<f32>;
let _e305 = v_texcoord_1;
uvw = vec3<f32>(_e305.x, _e305.y, 1f);
let _e309 = (*slot);
let _e313 = layer_info.uv_transform[(_e309 * 2i)];
let _e315 = uvw;
let _e317 = (*slot);
let _e322 = layer_info.uv_transform[((_e317 * 2i) + 1i)];
let _e324 = uvw;
return vec2<f32>(dot(_e313.xyz, _e315), dot(_e322.xyz, _e324));
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var param_7: i32;
var grey: f32;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var param_10: i32;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_11: vec3<f32>;
var key_1: f32;
var param_12: f32;
var srgb_1: vec3<f32>;
var param_13: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_14: vec3<f32>;
var param_15: f32;
var phi_3181_: bool;
var phi_3451_: bool;
let _e348 = gl_FragCoord_1[0u];
let _e351 = frag_info.debug_view[1u];
if (_e348 < _e351) {
let _e355 = frag_info.debug_view[2u];
local_3 = _e355;
} else {
let _e358 = frag_info.debug_view[0u];
local_3 = _e358;
}
let _e359 = local_3;
view = _e359;
let _e360 = view;
if (_e360 < 0.5f) {
return false;
}
let _e362 = view;
code = i32((_e362 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e365 = v_normal_1;
geometric_n = normalize(_e365);
let _e367 = v_tangent_1;
let _e369 = geometric_n;
let _e370 = geometric_n;
let _e371 = v_tangent_1;
tangent = (_e367.xyz - (_e369 * dot(_e370, _e371.xyz)));
let _e376 = tangent;
let _e377 = tangent;
let _e379 = (dot(_e376, _e377) > 0.000000000001f);
phi_3181_ = _e379;
if _e379 {
let _e381 = v_tangent_1[3u];
phi_3181_ = (abs((abs(_e381) - 1f)) < 0.01f);
}
let _e387 = phi_3181_;
tangent_usable = _e387;
let _e390 = frag_info.debug_view[3u];
identity = _e390;
let _e391 = identity;
identity_object = floor((_e391 / 8192f));
let _e394 = identity;
let _e395 = identity_object;
identity_rest = (_e394 - (_e395 * 8192f));
let _e398 = identity_rest;
identity_material = floor((_e398 / 2f));
let _e401 = identity_rest;
let _e402 = identity_material;
normal_mapped = ((_e401 - (_e402 * 2f)) > 0.5f);
let _e406 = code;
if (_e406 == 1i) {
let _e409 = (*s).albedo;
param_5 = clamp(_e409, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e411 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e411;
} else {
let _e412 = code;
if (_e412 == 2i) {
let _e415 = (*s).n;
shown = ((_e415 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e418 = code;
if (_e418 == 3i) {
let _e421 = (*s).roughness;
shown = vec3(clamp(_e421, 0f, 1f));
} else {
let _e424 = code;
if (_e424 == 4i) {
let _e427 = (*s).metallic;
shown = vec3(clamp(_e427, 0f, 1f));
} else {
let _e430 = code;
if (_e430 == 5i) {
let _e433 = (*s).occlusion;
shown = vec3(clamp(_e433, 0f, 1f));
} else {
let _e436 = code;
if (_e436 == 6i) {
let _e439 = (*s).emissive;
param_6 = clamp(_e439, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e441 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e441;
} else {
let _e442 = code;
if (_e442 == 7i) {
param_7 = 0i;
let _e444 = MapUv_u0028_i1_u003b((¶m_7));
let _e445 = fract(_e444);
shown = vec3<f32>(_e445.x, _e445.y, 0f);
} else {
let _e449 = code;
if (_e449 == 8i) {
let _e451 = (*lit);
param_8 = clamp(_e451, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e453 = LinearToSrgb_u0028_vf3_u003b((¶m_8));
grey = dot(_e453, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e455 = (*lit);
param_9 = _e455;
let _e456 = NonFinite_u0028_vf3_u003b((¶m_9));
if _e456 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e457 = grey;
local_4 = vec3((_e457 * 0.5f));
}
let _e460 = local_4;
shown = _e460;
} else {
let _e461 = code;
if (_e461 == 9i) {
let _e463 = tangent_usable;
if _e463 {
let _e464 = tangent;
local_5 = ((normalize(_e464) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e468 = local_5;
shown = _e468;
} else {
let _e469 = code;
if (_e469 == 10i) {
param_10 = 0i;
let _e471 = MapUv_u0028_i1_u003b((¶m_10));
uv = _e471;
let _e472 = uv;
cell = floor((_e472 * 8f));
let _e476 = cell[0u];
let _e478 = cell[1u];
odd = (fract(((_e476 + _e478) * 0.5f)) * 2f);
let _e483 = uv;
within = fract(_e483);
let _e485 = odd;
let _e489 = within[0u];
let _e493 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e485)) * vec3<f32>((0.55f + (0.45f * _e489)), (0.55f + (0.45f * _e493)), 0.85f));
} else {
let _e498 = code;
if (_e498 == 11i) {
let _e500 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e500));
} else {
let _e503 = code;
if (_e503 == 12i) {
let _e505 = v_color_1;
param_11 = clamp(_e505.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e508 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
shown = _e508;
} else {
let _e509 = code;
let _e511 = code;
if ((_e509 == 13i) || (_e511 == 14i)) {
let _e514 = code;
let _e516 = identity_object;
let _e517 = identity_material;
key_1 = select(_e517, _e516, (_e514 == 13i));
let _e519 = key_1;
param_12 = _e519;
let _e520 = DebugIdentityColour_u0028_f1_u003b((¶m_12));
let _e522 = (*s).n_dot_v;
shown = (_e520 * (0.55f + (0.45f * _e522)));
} else {
let _e526 = code;
if (_e526 == 15i) {
let _e529 = (*s).albedo;
param_13 = clamp(_e529, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e531 = LinearToSrgb_u0028_vf3_u003b((¶m_13));
srgb_1 = _e531;
let _e532 = srgb_1;
luma = dot(_e532, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e535 = (*s).metallic;
metal = (_e535 > 0.5f);
let _e537 = metal;
let _e539 = luma;
if (!(_e537) && (_e539 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e542 = metal;
let _e543 = !(_e542);
phi_3451_ = _e543;
if _e543 {
let _e545 = srgb_1[0u];
let _e547 = srgb_1[1u];
let _e549 = srgb_1[2u];
phi_3451_ = (max(_e545, max(_e547, _e549)) > 0.9411765f);
}
let _e554 = phi_3451_;
if _e554 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e555 = metal;
let _e556 = luma;
if (_e555 && (_e556 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e559 = luma;
local_8 = vec3(_e559);
}
let _e561 = local_8;
local_7 = _e561;
}
let _e562 = local_7;
local_6 = _e562;
}
let _e563 = local_6;
shown = _e563;
} else {
let _e564 = code;
if (_e564 == 16i) {
let _e567 = (*s).metallic;
m = _e567;
let _e568 = m;
let _e570 = m;
if ((_e568 > 0.05f) && (_e570 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e573 = m;
local_9 = vec3(select(0.15f, 1f, (_e573 > 0.5f)));
}
let _e577 = local_9;
shown = _e577;
} else {
let _e578 = code;
if (_e578 == 17i) {
let _e580 = normal_mapped;
if !(_e580) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e582 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e582));
}
let _e585 = local_10;
shown = _e585;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e586 = g_premultiply;
if _e586 {
let _e588 = (*s).alpha;
local_11 = _e588;
} else {
local_11 = 1f;
}
let _e589 = local_11;
weight_2 = _e589;
let _e590 = shown;
param_14 = _e590;
let _e591 = SrgbToLinear_u0028_vf3_u003b((¶m_14));
let _e592 = weight_2;
let _e593 = (_e591 * _e592);
let _e595 = (*s).alpha;
frag_color = vec4<f32>(_e593.x, _e593.y, _e593.z, _e595);
let _e601 = (*s).roughness;
param_15 = _e601;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_15));
WriteWeightedBlended_u0028_();
return true;
}
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 _e309 = (*alpha_3);
let _e310 = (*alpha_3);
a2_ = (_e309 * _e310);
let _e312 = (*n_dot_l);
let _e313 = (*n_dot_v);
let _e314 = (*n_dot_v);
let _e316 = a2_;
let _e319 = a2_;
lambda_v = (_e312 * sqrt((((_e313 * _e314) * (1f - _e316)) + _e319)));
let _e323 = (*n_dot_v);
let _e324 = (*n_dot_l);
let _e325 = (*n_dot_l);
let _e327 = a2_;
let _e330 = a2_;
lambda_l = (_e323 * sqrt((((_e324 * _e325) * (1f - _e327)) + _e330)));
let _e334 = lambda_v;
let _e335 = lambda_l;
return (0.5f / max((_e334 + _e335), 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_2: f32;
let _e307 = (*n_dot_h);
let _e308 = (*alpha_4);
a = (_e307 * _e308);
let _e310 = (*alpha_4);
let _e311 = (*n_dot_h);
let _e312 = (*n_dot_h);
let _e315 = a;
let _e316 = a;
k_2 = (_e310 / max(((1f - (_e311 * _e312)) + (_e315 * _e316)), 0.0000001f));
let _e321 = k_2;
let _e322 = k_2;
return ((_e321 * _e322) * 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_12: vec3<f32>;
let _e309 = (*a_1);
let _e310 = (*b);
axis = cross(_e309, _e310);
let _e312 = axis;
len = length(_e312);
let _e314 = (*a_1);
let _e315 = (*b);
angle = acos(clamp(dot(_e314, _e315), -1f, 1f));
let _e319 = len;
if (_e319 > 0.000001f) {
let _e321 = axis;
let _e322 = angle;
let _e323 = len;
local_12 = (_e321 * (_e322 / (_e323 * 6.2831855f)));
} else {
local_12 = vec3<f32>(0f, 0f, 0f);
}
let _e327 = local_12;
return _e327;
}
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 _e307 = (*x);
let _e308 = (*y);
inTable = ((vec2<f32>(_e307, _e308) * 0.984375f) + vec2(0.0078125f));
let _e314 = inTable[0u];
let _e316 = inTable[1u];
let _e317 = (*table);
return vec2<f32>(_e314, ((_e316 + _e317) * 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_1: vec2<f32>;
var inverse: vec4<f32>;
var param_16: f32;
var param_17: f32;
var param_18: f32;
var fit: vec4<f32>;
var param_19: f32;
var param_20: f32;
var param_21: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_13: 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_22: vec3<f32>;
var param_23: vec3<f32>;
var param_24: vec3<f32>;
var param_25: vec3<f32>;
var param_26: vec3<f32>;
var param_27: vec3<f32>;
var param_28: vec3<f32>;
var param_29: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_14: f32;
var sphere: f32;
var param_30: f32;
var param_31: f32;
var param_32: f32;
let _e341 = (*roughness_2);
let _e343 = (*n_1);
let _e344 = (*v);
uv_1 = vec2<f32>(clamp(_e341, 0f, 1f), sqrt(clamp((1f - dot(_e343, _e344)), 0f, 1f)));
let _e351 = uv_1[0u];
param_16 = _e351;
let _e353 = uv_1[1u];
param_17 = _e353;
param_18 = 0f;
let _e354 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18));
let _e355 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e354, 0f);
inverse = _e355;
let _e357 = uv_1[0u];
param_19 = _e357;
let _e359 = uv_1[1u];
param_20 = _e359;
param_21 = 1f;
let _e360 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21));
let _e361 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e360, 0f);
fit = _e361;
let _e362 = (*v);
let _e363 = (*n_1);
let _e364 = (*v);
let _e365 = (*n_1);
along = (_e362 - (_e363 * dot(_e364, _e365)));
let _e369 = along;
alongLength = length(_e369);
let _e371 = alongLength;
if (_e371 > 0.00001f) {
let _e373 = along;
let _e374 = alongLength;
local_13 = (_e373 / vec3(_e374));
} else {
let _e377 = (*n_1);
let _e379 = (*n_1)[2u];
local_13 = normalize(cross(_e377, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e379) < 0.999f)))));
}
let _e386 = local_13;
t1_ = _e386;
let _e387 = (*n_1);
let _e388 = t1_;
t2_ = cross(_e387, _e388);
let _e391 = inverse[0u];
let _e393 = inverse[1u];
let _e394 = vec3<f32>(_e391, 0f, _e393);
let _e396 = inverse[2u];
let _e398 = inverse[3u];
let _e399 = vec3<f32>(_e396, 0f, _e398);
minv = mat3x3<f32>(vec3<f32>(_e394.x, _e394.y, _e394.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e399.x, _e399.y, _e399.z));
i = 0i;
loop {
let _e413 = i;
if (_e413 < 4i) {
let _e415 = i;
let _e417 = (*corners)[_e415];
p = _e417;
let _e418 = i;
let _e419 = minv;
let _e420 = p;
let _e421 = t1_;
let _e423 = p;
let _e424 = t2_;
let _e426 = p;
let _e427 = (*n_1);
l[_e418] = normalize((_e419 * vec3<f32>(dot(_e420, _e421), dot(_e423, _e424), dot(_e426, _e427))));
continue;
} else {
break;
}
continuing {
let _e433 = i;
i = (_e433 + 1i);
}
}
let _e436 = l[0i];
param_22 = _e436;
let _e438 = l[1i];
param_23 = _e438;
let _e439 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_22), (¶m_23));
let _e441 = l[1i];
param_24 = _e441;
let _e443 = l[2i];
param_25 = _e443;
let _e444 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_24), (¶m_25));
let _e447 = l[2i];
param_26 = _e447;
let _e449 = l[3i];
param_27 = _e449;
let _e450 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_26), (¶m_27));
let _e453 = l[3i];
param_28 = _e453;
let _e455 = l[0i];
param_29 = _e455;
let _e456 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_28), (¶m_29));
f = -((((_e439 + _e444) + _e450) + _e456));
let _e459 = f;
len_1 = length(_e459);
let _e461 = len_1;
if (_e461 > 0.000000001f) {
let _e464 = f[2u];
let _e465 = len_1;
local_14 = (_e464 / _e465);
} else {
local_14 = 0f;
}
let _e467 = local_14;
z_1 = _e467;
let _e468 = z_1;
let _e471 = len_1;
param_30 = ((_e468 * 0.5f) + 0.5f);
param_31 = clamp(_e471, 0f, 1f);
param_32 = 1f;
let _e473 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_30), (¶m_31), (¶m_32));
let _e474 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e473, 0f);
sphere = _e474.w;
let _e476 = len_1;
let _e477 = sphere;
let _e481 = fit[0u];
let _e483 = fit[1u];
return vec3<f32>(max((_e476 * _e477), 0f), _e481, _e483);
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
var ltc: vec3<f32>;
var param_33: vec3<f32>;
var param_34: vec3<f32>;
var param_35: f32;
var param_36: 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_37: f32;
var param_38: f32;
var vis: f32;
var param_39: f32;
var param_40: f32;
var param_41: f32;
var f_1: f32;
let _e323 = (*light).integrated;
if (_e323 > 0.5f) {
let _e325 = g_coat_n;
param_33 = _e325;
let _e327 = (*s_1).v;
param_34 = _e327;
let _e328 = g_coat_roughness;
param_35 = _e328;
let _e329 = g_rect_corners;
param_36 = _e329;
let _e330 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
ltc = _e330;
let _e332 = ltc[0u];
let _e334 = ltc[1u];
let _e337 = ltc[2u];
let _e343 = frag_info.material[3u];
let _e346 = (*light).n_dot_l;
return (((_e332 * ((0.04f * _e334) + (0.96f * _e337))) * _e343) / max(_e346, 0.000001f));
}
let _e349 = g_coat_roughness;
lobe = max(_e349, 0.045f);
let _e351 = lobe;
let _e352 = lobe;
alpha_5 = (_e351 * _e352);
let _e354 = g_coat_n;
let _e356 = (*light).l;
n_dot_l_1 = max(dot(_e354, _e356), 0f);
let _e359 = g_coat_n;
let _e361 = (*light).h;
n_dot_h_1 = max(dot(_e359, _e361), 0f);
let _e364 = n_dot_h_1;
param_37 = _e364;
let _e365 = alpha_5;
param_38 = _e365;
let _e366 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_37), (¶m_38));
d_1 = _e366;
let _e367 = g_coat_n_dot_v;
param_39 = _e367;
let _e368 = n_dot_l_1;
param_40 = _e368;
let _e369 = alpha_5;
param_41 = _e369;
let _e370 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_39), (¶m_40), (¶m_41));
vis = _e370;
let _e372 = (*light).v_dot_h;
f_1 = (0.04f + (0.96f * pow((1f - _e372), 5f)));
let _e377 = d_1;
let _e378 = vis;
let _e380 = f_1;
let _e384 = frag_info.material[3u];
let _e386 = n_dot_l_1;
let _e389 = (*light).n_dot_l;
return (((((_e377 * _e378) * _e380) * _e384) * _e386) / max(_e389, 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 _e305 = (*n_dot_l_2);
let _e306 = (*n_dot_v_1);
let _e308 = (*n_dot_l_2);
let _e309 = (*n_dot_v_1);
return (1f / (4f * ((_e305 + _e306) - (_e308 * _e309))));
}
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 _e307 = (*roughness_3);
let _e308 = (*roughness_3);
inv_alpha = (1f / (_e307 * _e308));
let _e311 = (*n_dot_h_2);
let _e312 = (*n_dot_h_2);
sin2h = max((1f - (_e311 * _e312)), 0.0078125f);
let _e316 = inv_alpha;
let _e318 = sin2h;
let _e319 = inv_alpha;
return (((2f + _e316) * pow(_e318, (_e319 * 0.5f))) / 6.2831855f);
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m_1: f32;
var g: f32;
let _e307 = (*mu);
m_1 = (1f - _e307);
let _e309 = m_1;
let _e310 = m_1;
let _e311 = m_1;
let _e312 = m_1;
g = (_e309 * (0.05710853f + (_e310 * (0.49188188f + (_e311 * (-0.33218145f + (_e312 * 0.071443f)))))));
let _e320 = (*r);
let _e321 = g;
let _e324 = (*r);
return ((1f + (_e320 * _e321)) / (1f + (0.2877934f * _e324)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e305 = (*rho);
let _e306 = (*rho);
let _e308 = (*average);
let _e310 = (*rho);
let _e311 = (*average);
return (((_e305 * _e306) * _e308) / (vec3<f32>(1f, 1f, 1f) - (_e310 * (1f - _e311))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e304 = (*r_1);
let _e307 = (*r_1);
return ((1f + (0.07248821f * _e304)) / (1f + (0.2877934f * _e307)));
}
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_2: f32;
var s_over_t: f32;
var local_15: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_42: f32;
var multi: vec3<f32>;
var param_43: vec3<f32>;
var param_44: f32;
var param_45: f32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
let _e322 = (*l_dot_v);
let _e323 = (*mu_i);
let _e324 = (*mu_o);
s_2 = (_e322 - (_e323 * _e324));
let _e327 = s_2;
if (_e327 > 0f) {
let _e329 = s_2;
let _e330 = (*mu_i);
let _e331 = (*mu_o);
local_15 = (_e329 / max(_e330, _e331));
} else {
let _e334 = s_2;
local_15 = _e334;
}
let _e335 = local_15;
s_over_t = _e335;
let _e336 = (*r_2);
af = (1f / (1f + (0.2877934f * _e336)));
let _e340 = (*rho_1);
let _e341 = af;
let _e342 = (*r_2);
let _e343 = s_over_t;
single = (_e340 * (_e341 * (1f + (_e342 * _e343))));
let _e348 = (*r_2);
param_42 = _e348;
let _e349 = FonAverage_u0028_f1_u003b((¶m_42));
average_1 = _e349;
let _e350 = (*rho_1);
param_43 = _e350;
let _e351 = average_1;
param_44 = _e351;
let _e352 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_43), (¶m_44));
let _e353 = (*mu_o);
param_45 = _e353;
let _e354 = (*r_2);
param_46 = _e354;
let _e355 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_45), (¶m_46));
let _e358 = (*mu_i);
param_47 = _e358;
let _e359 = (*r_2);
param_48 = _e359;
let _e360 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_47), (¶m_48));
let _e364 = average_1;
multi = (_e352 * ((max((1f - _e355), 0.0000001f) * max((1f - _e360), 0.0000001f)) / max((1f - _e364), 0.0000001f)));
let _e369 = single;
let _e370 = multi;
return ((_e369 + _e370) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e305 = frag_info.ambient_sky[3u];
return (_e305 > 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_49: f32;
var param_50: f32;
var param_51: f32;
let _e309 = (*roughness_4);
let _e311 = (*n_dot_v_2);
param_49 = clamp(_e309, 0f, 1f);
param_50 = sqrt(clamp((1f - _e311), 0f, 1f));
param_51 = 1f;
let _e315 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51));
let _e316 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e315, 0f);
dfg = _e316.xy;
let _e319 = dfg[0u];
let _e321 = dfg[1u];
let _e324 = dfg[1u];
return vec2<f32>((_e319 - _e321), _e324);
}
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_3: ptr<function, Surface>) -> vec3<f32> {
var ab: vec2<f32>;
var param_52: f32;
var param_53: f32;
var ess: f32;
let _e310 = (*s_3).roughness;
param_52 = max(_e310, 0.045f);
let _e313 = (*s_3).n_dot_v;
param_53 = _e313;
let _e314 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_52), (¶m_53));
ab = _e314;
let _e316 = ab[0u];
let _e318 = ab[1u];
ess = max((_e316 + _e318), 0.0001f);
let _e321 = (*f0_);
let _e322 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e321 * ((1f / _e322) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e305 = frag_info.target_origin[2u];
return (_e305 > 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 _e307 = (*v_dot_h);
f_2 = pow((1f - _e307), 5f);
let _e310 = (*f0_1);
let _e311 = (*f90_);
let _e312 = (*f0_1);
let _e314 = f_2;
return (_e310 + ((_e311 - _e312) * _e314));
}
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 _e313 = (*n_dot_l_3);
let _e314 = (*at);
let _e315 = (*t_dot_v);
let _e317 = (*ab_1);
let _e318 = (*b_dot_v);
let _e320 = (*n_dot_v_3);
ggx_v = (_e313 * length(vec3<f32>((_e314 * _e315), (_e317 * _e318), _e320)));
let _e324 = (*n_dot_v_3);
let _e325 = (*at);
let _e326 = (*t_dot_l);
let _e328 = (*ab_1);
let _e329 = (*b_dot_l);
let _e331 = (*n_dot_l_3);
ggx_l = (_e324 * length(vec3<f32>((_e325 * _e326), (_e328 * _e329), _e331)));
let _e335 = ggx_v;
let _e336 = ggx_l;
return clamp((0.5f / max((_e335 + _e336), 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 _e311 = (*at_1);
let _e312 = (*ab_2);
a2_1 = (_e311 * _e312);
let _e314 = (*ab_2);
let _e315 = (*t_dot_h);
let _e317 = (*at_1);
let _e318 = (*b_dot_h);
let _e320 = a2_1;
let _e321 = (*n_dot_h_3);
f_3 = vec3<f32>((_e314 * _e315), (_e317 * _e318), (_e320 * _e321));
let _e324 = a2_1;
let _e325 = f_3;
let _e326 = f_3;
w2_ = (_e324 / max(dot(_e325, _e326), 0.000000000001f));
let _e330 = a2_1;
let _e331 = w2_;
let _e333 = w2_;
return (((_e330 * _e331) * _e333) / 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_4: 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_54: f32;
var param_55: f32;
var vis_1: f32;
var param_56: f32;
var param_57: f32;
var param_58: f32;
var at_2: f32;
var ab_3: f32;
var param_59: f32;
var param_60: f32;
var param_61: f32;
var param_62: f32;
var param_63: f32;
var param_64: f32;
var param_65: f32;
var param_66: f32;
var param_67: f32;
var param_68: f32;
var param_69: f32;
var param_70: f32;
var param_71: f32;
var f_4: vec3<f32>;
var param_72: vec3<f32>;
var param_73: vec3<f32>;
var param_74: f32;
var specular: vec3<f32>;
var param_75: vec3<f32>;
var param_76: Surface;
var diffuse: vec3<f32>;
var param_77: vec3<f32>;
var param_78: f32;
var param_79: f32;
var param_80: f32;
var param_81: f32;
var sheen: vec3<f32>;
var param_82: f32;
var param_83: f32;
var param_84: f32;
var param_85: f32;
var param_86: Surface;
var param_87: LightSample;
let _e353 = (*s_4).roughness;
lobe_1 = max(_e353, 0.045f);
let _e355 = lobe_1;
let _e356 = lobe_1;
alpha_6 = (_e355 * _e356);
let _e358 = g_f0_dielectric;
let _e360 = (*s_4).albedo;
let _e362 = (*s_4).metallic;
f0_2 = mix(_e358, _e360, vec3(_e362));
let _e365 = g_f90_;
let _e367 = (*s_4).metallic;
f90_1 = vec3(mix(_e365, 1f, _e367));
let _e371 = (*s_4).albedo;
let _e373 = (*s_4).metallic;
diffuseColor = (_e371 * (1f - _e373));
let _e377 = (*light_1).n_dot_h;
param_54 = _e377;
let _e378 = alpha_6;
param_55 = _e378;
let _e379 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_54), (¶m_55));
d_2 = _e379;
let _e381 = (*s_4).n_dot_v;
param_56 = _e381;
let _e383 = (*light_1).n_dot_l;
param_57 = _e383;
let _e384 = alpha_6;
param_58 = _e384;
let _e385 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58));
vis_1 = _e385;
let _e386 = g_aniso;
if (_e386 > 0f) {
let _e388 = alpha_6;
let _e389 = g_aniso;
let _e390 = g_aniso;
at_2 = mix(_e388, 1f, (_e389 * _e390));
let _e393 = alpha_6;
ab_3 = max(_e393, 0.001f);
let _e395 = g_aniso_t;
let _e397 = (*light_1).h;
let _e399 = g_aniso_b;
let _e401 = (*light_1).h;
let _e404 = (*light_1).n_dot_h;
param_59 = _e404;
param_60 = dot(_e395, _e397);
param_61 = dot(_e399, _e401);
let _e405 = at_2;
param_62 = _e405;
let _e406 = ab_3;
param_63 = _e406;
let _e407 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_59), (¶m_60), (¶m_61), (¶m_62), (¶m_63));
d_2 = _e407;
let _e408 = g_aniso_b;
let _e410 = (*s_4).v;
let _e412 = g_aniso_t;
let _e414 = (*s_4).v;
let _e416 = g_aniso_t;
let _e418 = (*light_1).l;
let _e420 = g_aniso_b;
let _e422 = (*light_1).l;
let _e425 = (*light_1).n_dot_l;
param_64 = _e425;
let _e427 = (*s_4).n_dot_v;
param_65 = _e427;
param_66 = dot(_e408, _e410);
param_67 = dot(_e412, _e414);
param_68 = dot(_e416, _e418);
param_69 = dot(_e420, _e422);
let _e428 = at_2;
param_70 = _e428;
let _e429 = ab_3;
param_71 = _e429;
let _e430 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_64), (¶m_65), (¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70), (¶m_71));
vis_1 = _e430;
}
let _e431 = f0_2;
param_72 = _e431;
let _e432 = f90_1;
param_73 = _e432;
let _e434 = (*light_1).v_dot_h;
param_74 = _e434;
let _e435 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_72), (¶m_73), (¶m_74));
f_4 = _e435;
let _e436 = f_4;
let _e437 = g_irid_fresnel;
let _e438 = g_iridescence;
f_4 = mix(_e436, _e437, vec3(_e438));
let _e441 = d_2;
let _e442 = vis_1;
let _e444 = f_4;
let _e448 = frag_info.material[3u];
specular = ((_e444 * (_e441 * _e442)) * _e448);
let _e451 = (*light_1).integrated;
if (_e451 > 0.5f) {
let _e455 = (*light_1).ltc[0u];
let _e456 = f0_2;
let _e459 = (*light_1).ltc[1u];
let _e461 = f90_1;
let _e462 = f0_2;
let _e466 = (*light_1).ltc[2u];
let _e472 = frag_info.material[3u];
let _e475 = (*light_1).n_dot_l;
specular = (((((_e456 * _e459) + ((_e461 - _e462) * _e466)) * _e455) * _e472) / vec3(max(_e475, 0.000001f)));
}
let _e479 = EnergyCompensation_u0028_();
if _e479 {
let _e480 = f0_2;
param_75 = _e480;
let _e481 = (*s_4);
param_76 = _e481;
let _e482 = 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_75), (¶m_76));
let _e483 = specular;
specular = (_e483 * _e482);
}
let _e485 = diffuseColor;
let _e486 = f_4;
diffuse = ((_e485 * (vec3<f32>(1f, 1f, 1f) - _e486)) / vec3(3.1415927f));
let _e491 = EonDiffuse_u0028_();
if _e491 {
let _e493 = (*s_4).n;
let _e495 = (*light_1).l;
let _e499 = (*light_1).l;
let _e501 = (*s_4).v;
let _e503 = diffuseColor;
param_77 = _e503;
let _e505 = (*s_4).roughness;
param_78 = _e505;
param_79 = clamp(dot(_e493, _e495), 0.0001f, 1f);
let _e507 = (*s_4).n_dot_v;
param_80 = _e507;
param_81 = dot(_e499, _e501);
let _e508 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_77), (¶m_78), (¶m_79), (¶m_80), (¶m_81));
let _e509 = f_4;
diffuse = (_e508 * (vec3<f32>(1f, 1f, 1f) - _e509));
}
let _e512 = g_transmission;
let _e514 = diffuse;
diffuse = (_e514 * (1f - _e512));
let _e516 = g_sheen;
let _e517 = g_sheen_roughness;
param_82 = _e517;
let _e519 = (*light_1).n_dot_h;
param_83 = _e519;
let _e520 = D_Charlie_u0028_f1_u003b_f1_u003b((¶m_82), (¶m_83));
let _e523 = (*s_4).n;
let _e525 = (*light_1).l;
let _e529 = (*s_4).n_dot_v;
param_84 = _e529;
param_85 = clamp(dot(_e523, _e525), 0f, 1f);
let _e530 = V_Neubelt_u0028_f1_u003b_f1_u003b((¶m_84), (¶m_85));
sheen = ((_e516 * _e520) * _e530);
let _e532 = diffuse;
let _e533 = specular;
let _e535 = g_sheen_scale;
let _e537 = sheen;
let _e539 = g_coat_through;
let _e541 = g_coat;
let _e542 = (*s_4);
param_86 = _e542;
let _e543 = (*light_1);
param_87 = _e543;
let _e544 = 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_86), (¶m_87));
return ((((((_e532 + _e533) * _e535) + _e537) * _e539) + vec3((_e541 * _e544))) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
let _e304 = (*i_1);
if (_e304 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e306 = (*i_1);
if (_e306 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e308 = (*i_1);
if (_e308 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e310 = (*i_1);
if (_e310 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e312 = (*i_1);
if (_e312 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e314 = (*i_1);
if (_e314 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e316 = (*i_1);
if (_e316 == 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_88: i32;
let _e309 = (*i_2);
param_88 = _e309;
let _e310 = PointShadowDiskTap_u0028_i1_u003b((¶m_88));
p_1 = _e310;
let _e312 = p_1[0u];
let _e313 = (*ca);
let _e316 = p_1[1u];
let _e317 = (*sa);
let _e321 = p_1[0u];
let _e322 = (*sa);
let _e325 = p_1[1u];
let _e326 = (*ca);
let _e330 = (*radius);
return (vec2<f32>(((_e312 * _e313) - (_e316 * _e317)), ((_e321 * _e322) + (_e325 * _e326))) * _e330);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local_16: vec2<f32>;
var atlas: vec2<f32>;
let _e312 = point_shadow.params[0u];
inset = _e312;
let _e313 = (*uv_2);
let _e314 = (*offset);
let _e316 = inset;
let _e317 = inset;
local_16 = clamp((_e313 + _e314), vec2(_e316), vec2((1f - _e317)));
let _e322 = local_16;
let _e323 = (*tile);
atlas = ((_e322 + _e323) * vec2<f32>(0.16666667f, 0.16666667f));
let _e328 = point_shadow.params3_[0u];
if (_e328 > 0.5f) {
let _e331 = atlas[1u];
atlas[1u] = (1f - _e331);
}
let _e334 = atlas;
let _e335 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e334, 0f);
let _e337 = atlas;
let _e338 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e337, 0f);
let _e341 = (*range);
return (min(_e335.x, _e338.x) * _e341);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_3: 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_89: vec2<f32>;
var param_90: vec2<f32>;
var param_91: vec2<f32>;
var param_92: f32;
let _e313 = (*uv_3);
param_89 = _e313;
let _e314 = (*offset_1);
param_90 = _e314;
let _e315 = (*tile_1);
param_91 = _e315;
let _e316 = (*range_1);
param_92 = _e316;
let _e317 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_89), (¶m_90), (¶m_91), (¶m_92));
stored = _e317;
let _e318 = stored;
let _e319 = (*range_1);
if (_e318 >= (_e319 * 0.999f)) {
return 1f;
}
let _e322 = (*receiver);
let _e323 = stored;
return select(1f, 0f, (_e322 > _e323));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_4: 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_93: vec2<f32>;
var param_94: vec2<f32>;
var param_95: vec2<f32>;
var param_96: f32;
var sum: f32;
var count: f32;
var i_3: i32;
var stored_1: f32;
var param_97: i32;
var param_98: f32;
var param_99: f32;
var param_100: f32;
var param_101: vec2<f32>;
var param_102: vec2<f32>;
var param_103: vec2<f32>;
var param_104: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e334 = point_shadow.params2_[1u];
lightRadius = _e334;
let _e337 = point_shadow.params2_[0u];
minRadius = _e337;
let _e340 = point_shadow.params2_[2u];
maxRadius = _e340;
let _e341 = lightRadius;
if (_e341 <= 0f) {
let _e343 = (*uv_4);
param_93 = _e343;
param_94 = vec2<f32>(0f, 0f);
let _e344 = (*tile_2);
param_95 = _e344;
let _e345 = (*range_2);
param_96 = _e345;
let _e346 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_93), (¶m_94), (¶m_95), (¶m_96));
(*blockerOut) = _e346;
let _e347 = minRadius;
return _e347;
}
sum = 0f;
count = 0f;
i_3 = 0i;
loop {
let _e348 = i_3;
if (_e348 < 8i) {
let _e350 = i_3;
param_97 = _e350;
let _e351 = (*ca_1);
param_98 = _e351;
let _e352 = (*sa_1);
param_99 = _e352;
let _e353 = maxRadius;
param_100 = _e353;
let _e354 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_97), (¶m_98), (¶m_99), (¶m_100));
let _e355 = (*uv_4);
param_101 = _e355;
param_102 = _e354;
let _e356 = (*tile_2);
param_103 = _e356;
let _e357 = (*range_2);
param_104 = _e357;
let _e358 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_101), (¶m_102), (¶m_103), (¶m_104));
stored_1 = _e358;
let _e359 = stored_1;
let _e360 = (*range_2);
if (_e359 >= (_e360 * 0.999f)) {
continue;
}
let _e363 = stored_1;
let _e364 = (*receiver_1);
if (_e363 >= _e364) {
continue;
}
let _e366 = stored_1;
let _e367 = sum;
sum = (_e367 + _e366);
let _e369 = count;
count = (_e369 + 1f);
continue;
} else {
break;
}
continuing {
let _e371 = i_3;
i_3 = (_e371 + 1i);
}
}
let _e373 = count;
if (_e373 < 0.5f) {
return -1f;
}
let _e375 = sum;
let _e376 = count;
blocker = max((_e375 / _e376), 0.0001f);
let _e379 = blocker;
(*blockerOut) = _e379;
let _e380 = lightRadius;
let _e381 = (*receiver_1);
let _e382 = blocker;
let _e386 = blocker;
world = ((_e380 * max((_e381 - _e382), 0f)) / _e386);
let _e388 = world;
let _e389 = (*receiver_1);
let _e391 = (*tanHalf);
let _e394 = minRadius;
let _e395 = maxRadius;
return clamp((_e388 / ((2f * _e389) * _e391)), _e394, _e395);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_17: vec2<f32>;
let _e305 = (*rows);
if (_e305 > 0f) {
let _e308 = gl_FragCoord_1[0u];
let _e309 = (*rows);
let _e311 = gl_FragCoord_1[1u];
local_17 = vec2<f32>(_e308, (_e309 - _e311));
} else {
let _e314 = gl_FragCoord_1;
local_17 = _e314.xy;
}
let _e316 = local_17;
return _e316;
}
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_1: 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_5: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_105: 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_106: vec2<f32>;
var param_107: vec2<f32>;
var param_108: f32;
var param_109: f32;
var param_110: f32;
var param_111: f32;
var param_112: f32;
var param_113: f32;
var local_18: vec3<f32>;
var lit_1: f32;
var param_114: vec2<f32>;
var param_115: vec2<f32>;
var param_116: vec2<f32>;
var param_117: f32;
var param_118: f32;
var i_4: i32;
var param_119: i32;
var param_120: f32;
var param_121: f32;
var param_122: f32;
var param_123: vec2<f32>;
var param_124: vec2<f32>;
var param_125: vec2<f32>;
var param_126: f32;
var param_127: f32;
var phi_2780_: bool;
var phi_2841_: bool;
let _e357 = (*lightIndex);
let _e361 = point_shadow.slots[_e357][0u];
slot_1 = i32((_e361 + 0.5f));
let _e364 = (*lightIndex);
let _e368 = point_shadow.slots[_e364][0u];
if (_e368 < 0f) {
return 1f;
}
let _e372 = point_shadow.params[2u];
strength = _e372;
let _e373 = strength;
if (_e373 <= 0f) {
return 1f;
}
let _e375 = slot_1;
let _e378 = point_shadow.lights[_e375];
let _e380 = (*world_1);
toLight = (_e378.xyz - _e380);
let _e382 = toLight;
toLightLength = max(length(_e382), 0.000001f);
let _e385 = (*normal);
let _e386 = toLight;
let _e387 = toLightLength;
nDotL = max(dot(_e385, (_e386 / vec3(_e387))), 0.15f);
let _e392 = nDotL;
let _e393 = nDotL;
let _e398 = nDotL;
let _e399 = nDotL;
slope = min((sqrt(max((1f - (_e392 * _e393)), 0f)) / (_e398 * _e399)), 8f);
let _e403 = toLightLength;
let _e405 = (*lightIndex);
let _e409 = point_shadow.slots[_e405][2u];
let _e414 = point_shadow.params3_[1u];
texel = (((2f * _e403) * max(_e409, 0.0001f)) * _e414);
let _e416 = (*world_1);
let _e417 = (*normal);
let _e418 = texel;
let _e422 = point_shadow.params[3u];
let _e424 = slope;
origin = (_e416 + (((_e417 * _e418) * _e422) * (1f + _e424)));
let _e428 = origin;
let _e429 = slot_1;
let _e432 = point_shadow.lights[_e429];
toFragment = (_e428 - _e432.xyz);
let _e435 = toFragment;
distance_ = length(_e435);
let _e437 = slot_1;
let _e441 = point_shadow.lights[_e437][3u];
range_3 = max(_e441, 0.0001f);
let _e443 = distance_;
let _e444 = range_3;
if (_e443 >= _e444) {
return 1f;
}
face = 0i;
let _e446 = (*lightIndex);
let _e450 = point_shadow.slots[_e446][1u];
if (_e450 < 0.5f) {
let _e452 = toFragment;
a_2 = abs(_e452);
let _e455 = a_2[0u];
let _e457 = a_2[1u];
let _e458 = (_e455 >= _e457);
phi_2780_ = _e458;
if _e458 {
let _e460 = a_2[0u];
let _e462 = a_2[2u];
phi_2780_ = (_e460 >= _e462);
}
let _e465 = phi_2780_;
if _e465 {
let _e467 = toFragment[0u];
face = select(1i, 0i, (_e467 > 0f));
} else {
let _e471 = a_2[1u];
let _e473 = a_2[2u];
if (_e471 >= _e473) {
let _e476 = toFragment[1u];
face = select(3i, 2i, (_e476 > 0f));
} else {
let _e480 = toFragment[2u];
face = select(5i, 4i, (_e480 > 0f));
}
}
}
let _e483 = slot_1;
let _e485 = face;
let _e489 = point_shadow.faces[((_e483 * 6i) + _e485)];
let _e490 = origin;
clip = (_e489 * vec4<f32>(_e490.x, _e490.y, _e490.z, 1f));
let _e497 = clip[3u];
if (_e497 <= 0f) {
return 1f;
}
let _e499 = clip;
let _e502 = clip[3u];
ndc = (_e499.xy / vec2(_e502));
let _e506 = ndc[0u];
let _e508 = (abs(_e506) > 1f);
phi_2841_ = _e508;
if !(_e508) {
let _e511 = ndc[1u];
phi_2841_ = (abs(_e511) > 1f);
}
let _e515 = phi_2841_;
if _e515 {
return 1f;
}
let _e517 = ndc[0u];
let _e521 = ndc[1u];
uv_5 = vec2<f32>(((_e517 * 0.5f) + 0.5f), (0.5f - (_e521 * 0.5f)));
let _e525 = face;
let _e527 = slot_1;
tile_3 = vec2<f32>(f32(_e525), f32(_e527));
let _e530 = distance_;
let _e533 = point_shadow.params[1u];
receiver_2 = (_e530 - _e533);
let _e537 = frag_info.target_origin[0u];
param_105 = _e537;
let _e538 = FragCoordFromTop_u0028_f1_u003b((¶m_105));
noise = fract((52.982918f * fract(dot(_e538, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e543 = noise;
angle_1 = (_e543 * 6.2831855f);
let _e545 = angle_1;
ca_2 = cos(_e545);
let _e547 = angle_1;
sa_2 = sin(_e547);
let _e549 = (*lightIndex);
let _e553 = point_shadow.slots[_e549][2u];
tanHalf_1 = max(_e553, 0.0001f);
blocker_1 = -1f;
let _e555 = uv_5;
param_106 = _e555;
let _e556 = tile_3;
param_107 = _e556;
let _e557 = range_3;
param_108 = _e557;
let _e558 = receiver_2;
param_109 = _e558;
let _e559 = ca_2;
param_110 = _e559;
let _e560 = sa_2;
param_111 = _e560;
let _e561 = tanHalf_1;
param_112 = _e561;
let _e562 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_106), (¶m_107), (¶m_108), (¶m_109), (¶m_110), (¶m_111), (¶m_112), (¶m_113));
let _e563 = param_113;
blocker_1 = _e563;
radius_1 = _e562;
let _e566 = point_shadow.params2_[3u];
if (_e566 > 0.5f) {
g_debug_surface_on = true;
let _e568 = radius_1;
if (_e568 < 0f) {
local_18 = vec3<f32>(0f, 0f, 1f);
} else {
let _e570 = radius_1;
let _e573 = point_shadow.params2_[2u];
let _e577 = blocker_1;
let _e578 = range_3;
local_18 = vec3<f32>(clamp((_e570 / max(_e573, 0.000001f)), 0f, 1f), clamp((_e577 / _e578), 0f, 1f), 0f);
}
let _e582 = local_18;
g_debug_surface = _e582;
}
let _e583 = radius_1;
if (_e583 < 0f) {
return 1f;
}
let _e585 = uv_5;
param_114 = _e585;
param_115 = vec2<f32>(0f, 0f);
let _e586 = tile_3;
param_116 = _e586;
let _e587 = range_3;
param_117 = _e587;
let _e588 = receiver_2;
param_118 = _e588;
let _e589 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_114), (¶m_115), (¶m_116), (¶m_117), (¶m_118));
lit_1 = _e589;
let _e590 = radius_1;
if (_e590 > 0f) {
i_4 = 0i;
loop {
let _e592 = i_4;
if (_e592 < 8i) {
let _e594 = i_4;
param_119 = _e594;
let _e595 = ca_2;
param_120 = _e595;
let _e596 = sa_2;
param_121 = _e596;
let _e597 = radius_1;
param_122 = _e597;
let _e598 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_119), (¶m_120), (¶m_121), (¶m_122));
let _e599 = uv_5;
param_123 = _e599;
param_124 = _e598;
let _e600 = tile_3;
param_125 = _e600;
let _e601 = range_3;
param_126 = _e601;
let _e602 = receiver_2;
param_127 = _e602;
let _e603 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125), (¶m_126), (¶m_127));
let _e604 = lit_1;
lit_1 = (_e604 + _e603);
continue;
} else {
break;
}
continuing {
let _e606 = i_4;
i_4 = (_e606 + 1i);
}
}
let _e608 = lit_1;
lit_1 = (_e608 * 0.11111111f);
}
let _e610 = lit_1;
let _e611 = strength;
return mix(1f, _e610, clamp(_e611, 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 _e308 = (*i_5);
let _e311 = (*n_2);
r_3 = sqrt(((f32(_e308) + 0.5f) / f32(_e311)));
let _e315 = (*i_5);
let _e318 = (*turn);
theta = ((f32(_e315) * 2.3999631f) + _e318);
let _e320 = r_3;
let _e321 = theta;
let _e323 = theta;
return (vec2<f32>(cos(_e321), sin(_e323)) * _e320);
}
fn ShadowNoise_u0028_() -> f32 {
var at_3: vec2<f32>;
var param_128: f32;
let _e307 = frag_info.target_origin[0u];
param_128 = _e307;
let _e308 = FragCoordFromTop_u0028_f1_u003b((¶m_128));
let _e311 = frag_info.target_origin[3u];
at_3 = (_e308 + vec2((5.588238f * max(_e311, 0f))));
let _e316 = at_3;
return fract((52.982918f * fract(dot(_e316, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_19: f32;
let _e306 = (*mode_1);
if (_e306 > 0.5f) {
let _e308 = (*stored_2);
local_19 = (1f - _e308);
} else {
let _e310 = (*stored_2);
local_19 = _e310;
}
let _e311 = local_19;
return _e311;
}
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 _e312 = (*moments)[1u];
let _e314 = (*moments)[0u];
let _e316 = (*moments)[0u];
let _e319 = (*minVariance);
variance = max((_e312 - (_e314 * _e316)), _e319);
let _e321 = (*t);
let _e323 = (*moments)[0u];
d_3 = (_e321 - _e323);
let _e325 = variance;
let _e326 = variance;
let _e327 = d_3;
let _e328 = d_3;
pMax = (_e325 / (_e326 + (_e327 * _e328)));
let _e332 = pMax;
let _e333 = (*bleed);
let _e335 = (*bleed);
reduced = clamp(((_e332 - _e333) / max((1f - _e335), 0.0001f)), 0f, 1f);
let _e340 = (*t);
let _e342 = (*moments)[0u];
let _e344 = reduced;
return select(_e344, 1f, (_e340 <= _e342));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_4: f32;
let _e305 = (*depth);
d_4 = ((2f * clamp(_e305, 0f, 1f)) - 1f);
let _e309 = d_4;
let _e312 = d_4;
return vec2<f32>(exp((40f * _e309)), -(exp((-5f * _e312))));
}
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_129: f32;
var scale: vec2<f32>;
var positive: f32;
var param_130: vec2<f32>;
var param_131: f32;
var param_132: f32;
var param_133: f32;
var negative: f32;
var param_134: vec2<f32>;
var param_135: f32;
var param_136: f32;
var param_137: f32;
let _e319 = (*depth_1);
param_129 = _e319;
let _e320 = EvsmWarp_u0028_f1_u003b((¶m_129));
warped = _e320;
let _e321 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e321);
let _e324 = scale[0u];
let _e326 = scale[0u];
let _e328 = (*moments_1);
param_130 = _e328.xy;
let _e331 = warped[0u];
param_131 = _e331;
param_132 = (_e324 * _e326);
let _e332 = (*bleed_1);
param_133 = _e332;
let _e333 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_130), (¶m_131), (¶m_132), (¶m_133));
positive = _e333;
let _e335 = scale[1u];
let _e337 = scale[1u];
let _e339 = (*moments_1);
param_134 = _e339.zw;
let _e342 = warped[1u];
param_135 = _e342;
param_136 = (_e335 * _e337);
let _e343 = (*bleed_1);
param_137 = _e343;
let _e344 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_134), (¶m_135), (¶m_136), (¶m_137));
negative = _e344;
let _e345 = positive;
let _e346 = negative;
return min(_e345, _e346);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e305 = (*depth_2);
stored_3 = max((1f - _e305), 0.000061035156f);
let _e308 = stored_3;
return exp2((floor(log2(_e308)) - 10f));
}
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_5: 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 local_20: f32;
var cascade: i32;
var uv_6: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_21: mat4x4<f32>;
var local_22: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_23: f32;
var local_24: f32;
var storage_: f32;
var param_138: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_139: vec4<f32>;
var param_140: f32;
var param_141: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var param_142: f32;
var param_143: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_6: i32;
var disc: vec2<f32>;
var param_144: i32;
var param_145: i32;
var param_146: f32;
var tapBias: f32;
var occluder_1: f32;
var param_147: f32;
var param_148: f32;
var gap: f32;
var radius_2: f32;
var i_7: i32;
var disc_1: vec2<f32>;
var param_149: i32;
var param_150: i32;
var param_151: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_152: f32;
var param_153: f32;
var phi_4493_: bool;
var phi_4504_: bool;
var phi_4661_: bool;
var phi_4668_: bool;
var phi_4675_: bool;
let _e382 = frag_info.shadow_params[3u];
strength_1 = _e382;
let _e383 = strength_1;
if (_e383 <= 0f) {
return 1f;
}
let _e385 = (*lightIndex_1);
let _e388 = frag_info.frame_params[2u];
if (_e385 != i32(floor((_e388 + 0.5f)))) {
return 1f;
}
let _e395 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e395 + 0.5f));
let _e398 = Orthographic_u0028_();
if _e398 {
let _e399 = ViewDepth_u0028_();
local_20 = _e399;
} else {
let _e400 = v_world_position_1;
let _e402 = frag_info.camera_position;
local_20 = length((_e400 - _e402.xyz));
}
let _e406 = local_20;
viewDistance = _e406;
cascade = 0i;
let _e407 = cascadeCount;
let _e408 = (_e407 > 1i);
phi_4493_ = _e408;
if _e408 {
let _e409 = viewDistance;
let _e412 = frag_info.shadow_cascades[0u];
phi_4493_ = (_e409 > _e412);
}
let _e415 = phi_4493_;
if _e415 {
cascade = 1i;
}
let _e416 = cascadeCount;
let _e417 = (_e416 > 2i);
phi_4504_ = _e417;
if _e417 {
let _e418 = viewDistance;
let _e421 = frag_info.shadow_cascades[1u];
phi_4504_ = (_e418 > _e421);
}
let _e424 = phi_4504_;
if _e424 {
cascade = 2i;
}
uv_6 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e425 = attempt;
if (_e425 < 3i) {
let _e427 = cascade;
let _e428 = attempt;
which = (_e427 + _e428);
let _e430 = which;
let _e431 = cascadeCount;
if (_e430 >= _e431) {
break;
}
let _e433 = which;
if (_e433 == 0i) {
let _e436 = frag_info.shadow_matrix;
local_21 = _e436;
} else {
let _e437 = which;
if (_e437 == 1i) {
let _e440 = frag_info.shadow_matrix_far;
local_22 = _e440;
} else {
let _e442 = frag_info.shadow_matrix_farthest;
local_22 = _e442;
}
let _e443 = local_22;
local_21 = _e443;
}
let _e444 = local_21;
matrix = _e444;
let _e447 = matrix[0][0u];
let _e450 = matrix[1][0u];
let _e453 = matrix[2][0u];
axisX = vec3<f32>(_e447, _e450, _e453);
let _e457 = matrix[0][1u];
let _e460 = matrix[1][1u];
let _e463 = matrix[2][1u];
axisY = vec3<f32>(_e457, _e460, _e463);
let _e465 = axisX;
rowX = max(length(_e465), 0.000001f);
let _e468 = axisY;
rowY = max(length(_e468), 0.000001f);
let _e473 = frag_info.shadow_cascades[3u];
let _e475 = rowX;
texelMetres = ((2f * _e473) / _e475);
let _e479 = frag_info.shadow_cascades[3u];
let _e482 = (*s_5).n;
let _e483 = axisX;
let _e486 = rowX;
let _e487 = rowX;
let _e491 = (*s_5).n;
let _e492 = axisY;
let _e495 = rowY;
let _e496 = rowY;
reach = ((3f * _e479) * ((abs(dot(_e482, _e483)) / (_e486 * _e487)) + (abs(dot(_e491, _e492)) / (_e495 * _e496))));
let _e503 = frag_info.shadow_params[2u];
let _e504 = texelMetres;
flatOffset = min(_e503, _e504);
let _e506 = v_world_position_1;
let _e508 = (*s_5).n;
let _e509 = flatOffset;
let _e510 = reach;
origin_1 = (_e506 + (_e508 * (_e509 + _e510)));
let _e514 = matrix;
let _e515 = origin_1;
lightSpace = (_e514 * vec4<f32>(_e515.x, _e515.y, _e515.z, 1f));
let _e522 = lightSpace[3u];
if (_e522 <= 0f) {
continue;
}
let _e524 = lightSpace;
let _e527 = lightSpace[3u];
candidate = (_e524.xyz / vec3(_e527));
let _e531 = candidate[0u];
let _e535 = candidate[1u];
inTile = vec2<f32>(((_e531 * 0.5f) + 0.5f), (0.5f - (_e535 * 0.5f)));
let _e540 = inTile[0u];
let _e541 = (_e540 < 0f);
phi_4661_ = _e541;
if !(_e541) {
let _e544 = inTile[0u];
phi_4661_ = (_e544 > 1f);
}
let _e547 = phi_4661_;
phi_4668_ = _e547;
if !(_e547) {
let _e550 = inTile[1u];
phi_4668_ = (_e550 < 0f);
}
let _e553 = phi_4668_;
phi_4675_ = _e553;
if !(_e553) {
let _e556 = inTile[1u];
phi_4675_ = (_e556 > 1f);
}
let _e559 = phi_4675_;
if _e559 {
continue;
}
let _e561 = candidate[2u];
if (_e561 > 1f) {
let _e563 = which;
let _e564 = cascadeCount;
if (_e563 < (_e564 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e569 = inTile[0u];
let _e570 = which;
let _e573 = cascadeCount;
let _e577 = inTile[1u];
uv_6 = vec2<f32>(((_e569 + f32(_e570)) / f32(_e573)), _e577);
let _e579 = candidate;
projected = _e579;
let _e580 = which;
cascade = _e580;
let _e581 = texelMetres;
cascadeTexel = _e581;
let _e584 = matrix[0][2u];
let _e587 = matrix[1][2u];
let _e590 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e584, _e587, _e590)), 0.000001f));
let _e596 = (*s_5).n;
let _e599 = matrix[0][2u];
let _e602 = matrix[1][2u];
let _e605 = matrix[2][2u];
let _e609 = cascadeDepth;
cosSlope = clamp((abs(dot(_e596, vec3<f32>(_e599, _e602, _e605))) * _e609), 0.1f, 1f);
let _e612 = texelMetres;
let _e613 = cosSlope;
let _e614 = cosSlope;
let _e620 = cosSlope;
let _e622 = cascadeDepth;
receiverSlope = (((_e612 * sqrt(max((1f - (_e613 * _e614)), 0f))) / _e620) / _e622);
found = true;
break;
} else {
break;
}
continuing {
let _e624 = attempt;
attempt = (_e624 + 1i);
}
}
let _e626 = found;
if !(_e626) {
return 1f;
}
let _e628 = cascade;
if (_e628 == 0i) {
let _e632 = frag_info.shadow_bias[0u];
local_23 = _e632;
} else {
let _e633 = cascade;
if (_e633 == 1i) {
let _e637 = frag_info.shadow_bias[1u];
local_24 = _e637;
} else {
let _e640 = frag_info.shadow_bias[2u];
local_24 = _e640;
}
let _e641 = local_24;
local_23 = _e641;
}
let _e642 = local_23;
bias = _e642;
let _e645 = frag_info.shadow_params[1u];
storage_ = _e645;
let _e646 = storage_;
let _e648 = storage_;
if ((_e646 > 0.5f) && (_e648 < 1.5f)) {
let _e651 = bias;
let _e653 = projected[2u];
param_138 = _e653;
let _e654 = ShadowStoredStep_u0028_f1_u003b((¶m_138));
bias = max(_e651, _e654);
}
let _e658 = frag_info.shadow_params[0u];
let _e661 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e658, _e661);
let _e663 = cascade;
let _e665 = cascadeCount;
let _e669 = texel_1;
tileLo = (vec2<f32>((f32(_e663) / f32(_e665)), 0f) + (_e669 * 0.5f));
let _e672 = cascade;
let _e675 = cascadeCount;
let _e679 = texel_1;
tileHi = (vec2<f32>((f32((_e672 + 1i)) / f32(_e675)), 1f) - (_e679 * 0.5f));
let _e684 = frag_info.shadow_bias[3u];
if (_e684 > 0.5f) {
let _e686 = uv_6;
let _e687 = tileLo;
let _e688 = tileHi;
let _e690 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e686, _e687, _e688), 0f);
stored_4 = _e690;
let _e692 = stored_4[1u];
let _e695 = stored_4[2u];
let _e698 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e692), (1f - _e695), _e698), vec3(0f), vec3(4f));
let _e703 = through;
let _e704 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e703, vec3(clamp(_e704, 0f, 1f)));
}
let _e710 = frag_info.ambient_ground[3u];
softness = _e710;
lit_2 = 0f;
let _e711 = softness;
if (_e711 < 0f) {
let _e713 = uv_6;
let _e714 = tileLo;
let _e715 = tileHi;
let _e717 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e713, _e714, _e715), 0f);
moments_2 = _e717;
let _e719 = projected[2u];
let _e720 = bias;
let _e722 = softness;
let _e726 = moments_2;
param_139 = _e726;
param_140 = (_e719 - _e720);
param_141 = clamp((-(_e722) - 1f), 0f, 0.95f);
let _e727 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_139), (¶m_140), (¶m_141));
lit_2 = _e727;
} else {
let _e728 = softness;
if (_e728 <= 0f) {
y_1 = -1i;
loop {
let _e730 = y_1;
if (_e730 <= 1i) {
x_1 = -1i;
loop {
let _e732 = x_1;
if (_e732 <= 1i) {
let _e734 = uv_6;
let _e735 = x_1;
let _e737 = y_1;
let _e740 = texel_1;
let _e743 = tileLo;
let _e744 = tileHi;
let _e746 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e734 + (vec2<f32>(f32(_e735), f32(_e737)) * _e740)), _e743, _e744), 0f);
param_142 = _e746.x;
let _e748 = storage_;
param_143 = _e748;
let _e749 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_142), (¶m_143));
occluder = _e749;
let _e751 = projected[2u];
let _e752 = bias;
let _e754 = occluder;
let _e757 = lit_2;
lit_2 = (_e757 + select(1f, 0f, ((_e751 - _e752) > _e754)));
continue;
} else {
break;
}
continuing {
let _e759 = x_1;
x_1 = (_e759 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e761 = y_1;
y_1 = (_e761 + 1i);
}
}
let _e763 = lit_2;
lit_2 = (_e763 * 0.11111111f);
} else {
let _e765 = softness;
spread = tan(min(_e765, 0.5f));
let _e768 = ShadowNoise_u0028_();
turn_1 = (_e768 * 6.2831855f);
let _e770 = spread;
let _e772 = projected[2u];
let _e774 = cascadeDepth;
let _e776 = cascadeTexel;
searchRadius = clamp((((_e770 * _e772) * _e774) / _e776), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_6 = 0i;
loop {
let _e779 = i_6;
if (_e779 < 16i) {
let _e781 = i_6;
param_144 = _e781;
param_145 = 16i;
let _e782 = turn_1;
param_146 = _e782;
let _e783 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_144), (¶m_145), (¶m_146));
disc = _e783;
let _e784 = bias;
let _e785 = disc;
let _e787 = searchRadius;
let _e791 = receiverSlope;
tapBias = (_e784 + (max(((length(_e785) * _e787) - 1.5f), 0f) * _e791));
let _e794 = uv_6;
let _e795 = disc;
let _e796 = texel_1;
let _e798 = searchRadius;
let _e801 = tileLo;
let _e802 = tileHi;
let _e804 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e794 + ((_e795 * _e796) * _e798)), _e801, _e802), 0f);
param_147 = _e804.x;
let _e806 = storage_;
param_148 = _e806;
let _e807 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_147), (¶m_148));
occluder_1 = _e807;
let _e809 = projected[2u];
let _e810 = tapBias;
let _e812 = occluder_1;
if ((_e809 - _e810) > _e812) {
let _e814 = occluder_1;
let _e815 = blockerSum;
blockerSum = (_e815 + _e814);
let _e817 = blockerCount;
blockerCount = (_e817 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e819 = i_6;
i_6 = (_e819 + 1i);
}
}
let _e821 = blockerCount;
if (_e821 <= 0f) {
return 1f;
}
let _e824 = projected[2u];
let _e825 = blockerSum;
let _e826 = blockerCount;
let _e830 = cascadeDepth;
gap = (max((_e824 - (_e825 / _e826)), 0f) * _e830);
let _e832 = spread;
let _e833 = gap;
let _e835 = cascadeTexel;
radius_2 = clamp(((_e832 * _e833) / _e835), 1f, 16f);
i_7 = 0i;
loop {
let _e838 = i_7;
if (_e838 < 16i) {
let _e840 = turn_1;
let _e842 = i_7;
param_149 = _e842;
param_150 = 16i;
param_151 = (_e840 + 1f);
let _e843 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_149), (¶m_150), (¶m_151));
disc_1 = _e843;
let _e844 = bias;
let _e845 = disc_1;
let _e847 = radius_2;
let _e851 = receiverSlope;
tapBias_1 = (_e844 + (max(((length(_e845) * _e847) - 1.5f), 0f) * _e851));
let _e854 = uv_6;
let _e855 = disc_1;
let _e856 = texel_1;
let _e858 = radius_2;
let _e861 = tileLo;
let _e862 = tileHi;
let _e864 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e854 + ((_e855 * _e856) * _e858)), _e861, _e862), 0f);
param_152 = _e864.x;
let _e866 = storage_;
param_153 = _e866;
let _e867 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_152), (¶m_153));
occluder_2 = _e867;
let _e869 = projected[2u];
let _e870 = tapBias_1;
let _e872 = occluder_2;
let _e875 = lit_2;
lit_2 = (_e875 + select(1f, 0f, ((_e869 - _e870) > _e872)));
continue;
} else {
break;
}
continuing {
let _e877 = i_7;
i_7 = (_e877 + 1i);
}
}
let _e879 = lit_2;
lit_2 = (_e879 * 0.0625f);
}
}
let _e881 = lit_2;
let _e882 = strength_1;
return mix(1f, _e881, clamp(_e882, 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_6: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_154: Surface;
var param_155: LightSample;
var param_156: i32;
let _e309 = (*s_6);
param_154 = _e309;
let _e310 = (*light_3);
param_155 = _e310;
let _e311 = (*index);
param_156 = _e311;
let _e312 = 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_154), (¶m_155), (¶m_156));
return _e312;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e304 = (*index_1);
return (_e304 < 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 _e308 = (*distance_1);
let _e309 = (*distance_1);
attenuation = (1f / max((_e308 * _e309), 0.0001f));
let _e313 = (*range_4);
if (_e313 > 0f) {
let _e315 = (*distance_1);
let _e316 = (*range_4);
ratio = (_e315 / _e316);
let _e318 = ratio;
let _e319 = ratio;
let _e321 = ratio;
let _e323 = ratio;
window = clamp((1f - (((_e318 * _e319) * _e321) * _e323)), 0f, 1f);
let _e327 = window;
let _e328 = window;
let _e330 = attenuation;
attenuation = (_e330 * (_e327 * _e328));
}
let _e332 = attenuation;
return _e332;
}
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_25: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e320 = (*halfWidth);
let _e321 = (*halfHeight);
n_3 = cross(_e320, _e321);
let _e323 = n_3;
nLen = length(_e323);
let _e325 = nLen;
if (_e325 < 0.000000000001f) {
let _e327 = (*centre);
return _e327;
}
let _e328 = nLen;
let _e329 = n_3;
n_3 = (_e329 / vec3(_e328));
let _e332 = (*centre);
let _e333 = (*world_2);
toPlane = (_e332 - _e333);
let _e335 = (*mirror);
let _e336 = n_3;
denom = dot(_e335, _e336);
let _e338 = denom;
if (abs(_e338) < 0.00001f) {
let _e341 = toPlane;
let _e342 = n_3;
let _e343 = toPlane;
let _e344 = n_3;
onPlane = (_e341 - (_e342 * dot(_e343, _e344)));
} else {
let _e348 = toPlane;
let _e349 = n_3;
let _e351 = denom;
t_1 = (dot(_e348, _e349) / _e351);
let _e353 = t_1;
if (_e353 > 0f) {
let _e355 = (*mirror);
let _e356 = t_1;
local_25 = (_e355 * _e356);
} else {
let _e358 = toPlane;
let _e359 = n_3;
let _e360 = toPlane;
let _e361 = n_3;
local_25 = (_e358 - (_e359 * dot(_e360, _e361)));
}
let _e365 = local_25;
onPlane = _e365;
}
let _e366 = onPlane;
let _e367 = toPlane;
offset_2 = (_e366 - _e367);
let _e369 = (*halfWidth);
let _e370 = (*halfWidth);
wLen2_ = max(dot(_e369, _e370), 0.000000000001f);
let _e373 = (*halfHeight);
let _e374 = (*halfHeight);
hLen2_ = max(dot(_e373, _e374), 0.000000000001f);
let _e377 = offset_2;
let _e378 = (*halfWidth);
let _e380 = wLen2_;
u = clamp((dot(_e377, _e378) / _e380), -1f, 1f);
let _e383 = offset_2;
let _e384 = (*halfHeight);
let _e386 = hLen2_;
v_1 = clamp((dot(_e383, _e384) / _e386), -1f, 1f);
let _e389 = (*centre);
let _e390 = (*halfWidth);
let _e391 = u;
let _e394 = (*halfHeight);
let _e395 = v_1;
return ((_e389 + (_e390 * _e391)) + (_e394 * _e395));
}
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_26: f32;
let _e312 = (*a_3);
let _e313 = (*a_3);
ua = (_e312 / vec3(max(length(_e313), 0.000000000001f)));
let _e318 = (*b_1);
let _e319 = (*b_1);
ub = (_e318 / vec3(max(length(_e319), 0.000000000001f)));
let _e324 = ua;
let _e325 = ub;
angle_2 = acos(clamp(dot(_e324, _e325), -1f, 1f));
let _e329 = ua;
let _e330 = ub;
axis_1 = cross(_e329, _e330);
let _e332 = axis_1;
len_2 = length(_e332);
let _e334 = len_2;
if (_e334 > 0.000001f) {
let _e336 = angle_2;
let _e337 = axis_1;
let _e338 = (*n_4);
let _e341 = len_2;
local_26 = ((_e336 * dot(_e337, _e338)) / _e341);
} else {
local_26 = 0f;
}
let _e343 = local_26;
return _e343;
}
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_27: i32;
var ha: f32;
var hb: f32;
var d_5: f32;
var q: vec3<f32>;
var local_28: f32;
var aAbove: bool;
var bAbove: bool;
var local_29: f32;
var param_157: vec3<f32>;
var param_158: vec3<f32>;
var param_159: vec3<f32>;
var param_160: vec3<f32>;
var param_161: vec3<f32>;
var param_162: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e326 = i_8;
if (_e326 < 4i) {
let _e328 = i_8;
let _e330 = (*corners_1)[_e328];
a_4 = _e330;
let _e331 = i_8;
if (_e331 == 3i) {
local_27 = 0i;
} else {
let _e333 = i_8;
local_27 = (_e333 + 1i);
}
let _e335 = local_27;
let _e337 = (*corners_1)[_e335];
b_2 = _e337;
let _e338 = a_4;
let _e339 = (*n_5);
ha = dot(_e338, _e339);
let _e341 = b_2;
let _e342 = (*n_5);
hb = dot(_e341, _e342);
let _e344 = ha;
let _e345 = hb;
d_5 = (_e344 - _e345);
let _e347 = a_4;
let _e348 = b_2;
let _e349 = a_4;
let _e351 = d_5;
if (abs(_e351) > 0.000000000001f) {
let _e354 = ha;
let _e355 = d_5;
local_28 = (_e354 / _e355);
} else {
local_28 = 0f;
}
let _e357 = local_28;
q = (_e347 + ((_e348 - _e349) * _e357));
let _e360 = ha;
aAbove = (_e360 > 0f);
let _e362 = hb;
bAbove = (_e362 > 0f);
let _e364 = aAbove;
let _e365 = bAbove;
if (_e364 || _e365) {
let _e367 = aAbove;
let _e368 = a_4;
let _e369 = q;
let _e372 = bAbove;
let _e373 = b_2;
let _e374 = q;
param_157 = select(_e369, _e368, vec3(_e367));
param_158 = select(_e374, _e373, vec3(_e372));
let _e377 = (*n_5);
param_159 = _e377;
let _e378 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_157), (¶m_158), (¶m_159));
local_29 = _e378;
} else {
local_29 = 0f;
}
let _e379 = local_29;
let _e380 = total;
total = (_e380 + _e379);
let _e382 = aAbove;
let _e383 = bAbove;
let _e386 = q;
let _e387 = exit;
exit = select(_e387, _e386, vec3((_e382 && !(_e383))));
let _e390 = aAbove;
let _e392 = bAbove;
let _e394 = q;
let _e395 = entry;
entry = select(_e395, _e394, vec3((!(_e390) && _e392)));
continue;
} else {
break;
}
continuing {
let _e398 = i_8;
i_8 = (_e398 + 1i);
}
}
let _e400 = exit;
param_160 = _e400;
let _e401 = entry;
param_161 = _e401;
let _e402 = (*n_5);
param_162 = _e402;
let _e403 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_160), (¶m_161), (¶m_162));
let _e404 = total;
total = (_e404 + _e403);
let _e406 = total;
return max((-(_e406) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2: ptr<function, i32>) -> f32 {
var lane: i32;
var local_30: f32;
var local_31: f32;
var local_32: f32;
let _e309 = (*slot_2);
let _e310 = (*slot_2);
lane = (_e309 - ((_e310 / 4i) * 4i));
let _e314 = lane;
if (_e314 == 0i) {
let _e317 = (*four)[0u];
local_30 = _e317;
} else {
let _e318 = lane;
if (_e318 == 1i) {
let _e321 = (*four)[1u];
local_31 = _e321;
} else {
let _e322 = lane;
if (_e322 == 2i) {
let _e325 = (*four)[2u];
local_32 = _e325;
} else {
let _e327 = (*four)[3u];
local_32 = _e327;
}
let _e328 = local_32;
local_31 = _e328;
}
let _e329 = local_31;
local_30 = _e329;
}
let _e330 = local_30;
return _e330;
}
fn LightListScale_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_163: vec4<f32>;
var param_164: i32;
let _e306 = (*slot_3);
let _e310 = light_list_info.scales[(_e306 / 4i)];
param_163 = _e310;
let _e311 = (*slot_3);
param_164 = _e311;
let _e312 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_163), (¶m_164));
return _e312;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e308 = light_list_info.slot_rows[0i];
let _e309 = (*row);
a_5 = abs((_e308 - vec4(_e309)));
let _e315 = light_list_info.slot_rows[1i];
let _e316 = (*row);
b_3 = abs((_e315 - vec4(_e316)));
let _e321 = a_5[0u];
let _e323 = a_5[1u];
let _e326 = a_5[2u];
let _e328 = a_5[3u];
let _e332 = b_3[0u];
let _e334 = b_3[1u];
let _e337 = b_3[2u];
let _e339 = b_3[3u];
return (min(min(min(_e321, _e323), min(_e326, _e328)), min(min(_e332, _e334), min(_e337, _e339))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var param_165: vec4<f32>;
var param_166: i32;
let _e306 = (*slot_4);
let _e310 = light_list_info.indices[(_e306 / 4i)];
param_165 = _e310;
let _e311 = (*slot_4);
param_166 = _e311;
let _e312 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_165), (¶m_166));
return _e312;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e305 = (*texel_2);
let _e309 = light_list_info.list[1u];
let _e311 = (*row_1);
let _e315 = light_list_info.list[2u];
let _e318 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e305 + 0.5f) * _e309), ((_e311 + 0.5f) * _e315)), 0f);
return _e318;
}
fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_167: f32;
var param_168: f32;
var param_169: vec4<f32>;
var param_170: i32;
let _e313 = g_cluster_offset;
let _e314 = (*slot_5);
entry_1 = (_e313 + f32(_e314));
let _e317 = entry_1;
row_2 = floor((_e317 / 16f));
let _e320 = entry_1;
let _e321 = row_2;
within_1 = (_e320 - (_e321 * 16f));
let _e324 = within_1;
texel_3 = floor((_e324 / 4f));
let _e329 = light_list_info.cluster_depth[3u];
let _e330 = row_2;
let _e332 = texel_3;
param_167 = _e332;
param_168 = (_e329 + _e330);
let _e333 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_167), (¶m_168));
four_1 = _e333;
let _e334 = within_1;
let _e335 = texel_3;
let _e340 = four_1;
param_169 = _e340;
param_170 = i32(((_e334 - (_e335 * 4f)) + 0.5f));
let _e341 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_169), (¶m_170));
return _e341;
}
fn Clustered_u0028_() -> bool {
let _e305 = light_list_info.cluster_grid[3u];
return (_e305 > 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_7: 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_6: i32;
var clustered: bool;
var listRow: f32;
var local_33: f32;
var param_171: i32;
var param_172: i32;
var v_2: f32;
var u_1: f32;
var local_34: f32;
var param_173: f32;
var param_174: 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_35: f32;
var param_175: array<vec3<f32>, 4>;
var param_176: vec3<f32>;
var area: f32;
var radiance: f32;
var local_36: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_177: vec3<f32>;
var param_178: vec3<f32>;
var param_179: vec3<f32>;
var param_180: vec3<f32>;
var param_181: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_37: vec3<f32>;
var param_182: vec3<f32>;
var param_183: vec3<f32>;
var param_184: f32;
var param_185: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_186: f32;
var param_187: f32;
var cosAngle: f32;
var ramp: f32;
light_4.integrated = 0f;
light_4.ltc = vec3<f32>(0f, 0f, 0f);
let _e361 = (*index_2);
if (_e361 < 8i) {
let _e363 = (*index_2);
let _e366 = frag_info.light_position[_e363];
position = _e366;
let _e367 = (*index_2);
let _e370 = frag_info.light_color[_e367];
color_1 = _e370;
let _e371 = (*index_2);
let _e374 = frag_info.light_direction[_e371];
direction = _e374;
let _e375 = (*index_2);
let _e378 = frag_info.light_cone[_e375];
cone = _e378;
} else {
let _e379 = (*index_2);
slot_6 = (_e379 - 8i);
let _e381 = Clustered_u0028_();
clustered = _e381;
let _e382 = clustered;
if _e382 {
let _e383 = slot_6;
param_171 = _e383;
let _e384 = ClusterRow_u0028_i1_u003b((¶m_171));
local_33 = _e384;
} else {
let _e385 = slot_6;
param_172 = _e385;
let _e386 = LightListRow_u0028_i1_u003b((¶m_172));
local_33 = _e386;
}
let _e387 = local_33;
listRow = _e387;
let _e388 = listRow;
let _e392 = light_list_info.list[2u];
v_2 = ((_e388 + 0.5f) * _e392);
let _e396 = light_list_info.list[1u];
u_1 = _e396;
let _e397 = u_1;
let _e399 = v_2;
let _e401 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e397), _e399), 0f);
position = _e401;
let _e402 = u_1;
let _e404 = v_2;
let _e406 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e402), _e404), 0f);
color_1 = _e406;
let _e407 = u_1;
let _e409 = v_2;
let _e411 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e407), _e409), 0f);
direction = _e411;
let _e412 = u_1;
let _e414 = v_2;
let _e416 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e412), _e414), 0f);
cone = _e416;
let _e417 = clustered;
if _e417 {
let _e418 = listRow;
param_173 = _e418;
let _e419 = InSlots_u0028_f1_u003b((¶m_173));
local_34 = select(1f, 0f, _e419);
} else {
let _e421 = slot_6;
param_174 = _e421;
let _e422 = LightListScale_u0028_i1_u003b((¶m_174));
local_34 = _e422;
}
let _e423 = local_34;
let _e425 = color_1[3u];
color_1[3u] = (_e425 * _e423);
}
let _e429 = position[3u];
type_45 = _e429;
let _e430 = type_45;
if (_e430 > 15.5f) {
let _e433 = (*s_7).n;
light_4.l = _e433;
let _e436 = (*s_7).n;
light_4.h = _e436;
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 _e442 = light_4;
return _e442;
}
let _e443 = type_45;
if (_e443 > 2.5f) {
let _e445 = direction;
halfWidth_1 = _e445.xyz;
let _e447 = cone;
halfHeight_1 = _e447.xyz;
let _e449 = position;
let _e451 = v_world_position_1;
toCentre = (_e449.xyz - _e451);
let _e453 = toCentre;
let _e454 = halfWidth_1;
let _e456 = halfHeight_1;
corners_2[0i] = ((_e453 - _e454) - _e456);
let _e459 = toCentre;
let _e460 = halfWidth_1;
let _e462 = halfHeight_1;
corners_2[1i] = ((_e459 + _e460) - _e462);
let _e465 = toCentre;
let _e466 = halfWidth_1;
let _e468 = halfHeight_1;
corners_2[2i] = ((_e465 + _e466) + _e468);
let _e471 = toCentre;
let _e472 = halfWidth_1;
let _e474 = halfHeight_1;
corners_2[3i] = ((_e471 - _e472) + _e474);
let _e477 = toCentre;
let _e478 = halfWidth_1;
let _e479 = halfHeight_1;
behind = (dot(_e477, cross(_e478, _e479)) >= 0f);
let _e483 = behind;
if _e483 {
local_35 = 0f;
} else {
let _e484 = corners_2;
param_175 = _e484;
let _e486 = (*s_7).n;
param_176 = _e486;
let _e487 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_175), (¶m_176));
local_35 = _e487;
}
let _e488 = local_35;
formFactor = _e488;
let _e489 = halfWidth_1;
let _e490 = halfHeight_1;
area = (length(cross(_e489, _e490)) * 4f);
let _e494 = area;
if (_e494 > 0.000000001f) {
let _e496 = area;
local_36 = (1f / _e496);
} else {
local_36 = 0f;
}
let _e498 = local_36;
radiance = _e498;
let _e499 = toCentre;
distance_2 = length(_e499);
let _e502 = direction[3u];
if (_e502 > 0f) {
let _e504 = distance_2;
let _e506 = direction[3u];
ratio_1 = (_e504 / _e506);
let _e508 = ratio_1;
let _e509 = ratio_1;
let _e511 = ratio_1;
let _e513 = ratio_1;
window_1 = clamp((1f - (((_e508 * _e509) * _e511) * _e513)), 0f, 1f);
let _e517 = window_1;
let _e518 = window_1;
let _e520 = radiance;
radiance = (_e520 * (_e517 * _e518));
}
let _e523 = (*s_7).v;
let _e526 = (*s_7).n;
mirror_1 = reflect(-(_e523), _e526);
let _e528 = position;
param_177 = _e528.xyz;
let _e530 = halfWidth_1;
param_178 = _e530;
let _e531 = halfHeight_1;
param_179 = _e531;
let _e532 = v_world_position_1;
param_180 = _e532;
let _e533 = mirror_1;
param_181 = _e533;
let _e534 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_177), (¶m_178), (¶m_179), (¶m_180), (¶m_181));
representative = _e534;
let _e535 = representative;
let _e536 = v_world_position_1;
toPoint = (_e535 - _e536);
let _e538 = toPoint;
pointDistance = length(_e538);
let _e540 = pointDistance;
if (_e540 > 0.000001f) {
let _e542 = toPoint;
let _e543 = pointDistance;
local_37 = (_e542 / vec3(_e543));
} else {
let _e547 = (*s_7).n;
local_37 = _e547;
}
let _e548 = local_37;
light_4.l = _e548;
let _e551 = light_4.l;
let _e553 = (*s_7).v;
light_4.h = normalize((_e551 + _e553));
let _e557 = formFactor;
light_4.n_dot_l = _e557;
let _e560 = (*s_7).n;
let _e562 = light_4.h;
light_4.n_dot_h = max(dot(_e560, _e562), 0f);
let _e567 = (*s_7).v;
let _e569 = light_4.h;
light_4.v_dot_h = max(dot(_e567, _e569), 0f);
let _e573 = color_1;
let _e576 = color_1[3u];
let _e578 = radiance;
light_4.radiance = ((_e573.xyz * _e576) * _e578);
light_4.integrated = 1f;
let _e583 = (*s_7).n;
param_182 = _e583;
let _e585 = (*s_7).v;
param_183 = _e585;
let _e587 = (*s_7).roughness;
param_184 = _e587;
let _e588 = corners_2;
param_185 = _e588;
let _e589 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_182), (¶m_183), (¶m_184), (¶m_185));
light_4.ltc = _e589;
let _e591 = corners_2;
g_rect_corners = _e591;
let _e592 = light_4;
return _e592;
}
let _e593 = direction;
aim = normalize(_e593.xyz);
attenuation_1 = 1f;
let _e596 = type_45;
if (_e596 < 0.5f) {
let _e598 = aim;
light_4.l = -(_e598);
} else {
let _e601 = position;
let _e603 = v_world_position_1;
toLight_1 = (_e601.xyz - _e603);
let _e605 = toLight_1;
distance_3 = length(_e605);
let _e607 = distance_3;
if (_e607 < 0.000001f) {
let _e610 = (*s_7).n;
light_4.l = _e610;
let _e613 = (*s_7).n;
light_4.h = _e613;
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 _e619 = light_4;
return _e619;
}
let _e620 = toLight_1;
let _e621 = distance_3;
light_4.l = (_e620 / vec3(_e621));
let _e625 = distance_3;
param_186 = _e625;
let _e627 = direction[3u];
param_187 = _e627;
let _e628 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_186), (¶m_187));
attenuation_1 = _e628;
let _e629 = type_45;
if (_e629 > 1.5f) {
let _e631 = aim;
let _e633 = light_4.l;
cosAngle = dot(_e631, -(_e633));
let _e636 = cosAngle;
let _e638 = cone[1u];
let _e641 = cone[0u];
let _e643 = cone[1u];
ramp = clamp(((_e636 - _e638) / (_e641 - _e643)), 0f, 1f);
let _e647 = ramp;
let _e648 = ramp;
let _e650 = attenuation_1;
attenuation_1 = (_e650 * (_e647 * _e648));
}
}
let _e653 = light_4.l;
let _e655 = (*s_7).v;
light_4.h = normalize((_e653 + _e655));
let _e660 = (*s_7).n;
let _e662 = light_4.l;
light_4.n_dot_l = max(dot(_e660, _e662), 0f);
let _e667 = (*s_7).n;
let _e669 = light_4.h;
light_4.n_dot_h = max(dot(_e667, _e669), 0f);
let _e674 = (*s_7).v;
let _e676 = light_4.h;
light_4.v_dot_h = max(dot(_e674, _e676), 0f);
let _e680 = color_1;
let _e683 = color_1[3u];
let _e685 = attenuation_1;
light_4.radiance = ((_e680.xyz * _e683) * _e685);
let _e688 = light_4;
return _e688;
}
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_38: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_188: f32;
var param_189: f32;
let _e318 = light_list_info.cluster_view_projection;
let _e319 = (*world_3);
clip_1 = (_e318 * vec4<f32>(_e319.x, _e319.y, _e319.z, 1f));
let _e325 = clip_1;
let _e328 = clip_1[3u];
ndc_1 = (_e325.xy / vec2(max(_e328, 0.000001f)));
let _e333 = light_list_info.cluster_grid;
grid = _e333.xyz;
let _e337 = light_list_info.cluster_depth[0u];
near_1 = _e337;
let _e339 = ndc_1[0u];
let _e343 = grid[0u];
let _e347 = grid[0u];
tx = clamp(floor((((_e339 * 0.5f) + 0.5f) * _e343)), 0f, (_e347 - 1f));
let _e351 = ndc_1[1u];
let _e355 = grid[1u];
let _e359 = grid[1u];
ty = clamp(floor((((_e351 * 0.5f) + 0.5f) * _e355)), 0f, (_e359 - 1f));
let _e363 = clip_1[3u];
let _e364 = near_1;
if (_e363 <= _e364) {
local_38 = 0f;
} else {
let _e367 = clip_1[3u];
let _e368 = near_1;
let _e373 = light_list_info.cluster_depth[1u];
let _e377 = grid[2u];
local_38 = clamp(floor((log((_e367 / _e368)) * _e373)), 0f, (_e377 - 1f));
}
let _e380 = local_38;
tz = _e380;
let _e381 = tx;
let _e382 = ty;
let _e384 = grid[0u];
let _e387 = tz;
let _e389 = grid[0u];
let _e392 = grid[1u];
cell_1 = ((_e381 + (_e382 * _e384)) + ((_e387 * _e389) * _e392));
let _e395 = cell_1;
row_3 = floor((_e395 / 4f));
let _e398 = cell_1;
let _e399 = row_3;
let _e404 = light_list_info.cluster_depth[2u];
let _e405 = row_3;
param_188 = (_e398 - (_e399 * 4f));
param_189 = (_e404 + _e405);
let _e407 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_188), (¶m_189));
header = _e407;
let _e409 = header[0u];
g_cluster_offset = _e409;
let _e411 = header[1u];
g_cluster_count = _e411;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_190: vec3<f32>;
let _e307 = light_list_info.list[0u];
tail = _e307;
let _e308 = Clustered_u0028_();
if _e308 {
let _e309 = v_world_position_1;
param_190 = _e309;
FindCluster_u0028_vf3_u003b((¶m_190));
let _e310 = g_cluster_count;
tail = _e310;
}
let _e313 = frag_info.frame_params[1u];
let _e317 = tail;
return (clamp(i32((_e313 + 0.5f)), 0i, 8i) + clamp(i32((_e317 + 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_8: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_9: i32;
var light_5: LightSample;
var param_191: i32;
var param_192: Surface;
var visibility: f32;
var param_193: i32;
var local_39: f32;
var param_194: Surface;
var param_195: LightSample;
var param_196: i32;
var param_197: vec3<f32>;
var param_198: vec3<f32>;
var param_199: i32;
var param_200: Surface;
var param_201: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e321 = LightCount_u0028_();
count_1 = _e321;
i_9 = 0i;
loop {
let _e322 = i_9;
if (_e322 < 32i) {
let _e324 = i_9;
let _e325 = count_1;
if (_e324 >= _e325) {
break;
}
let _e327 = i_9;
param_191 = _e327;
let _e328 = (*s_8);
param_192 = _e328;
let _e329 = 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_191), (¶m_192));
light_5 = _e329;
let _e331 = light_5.n_dot_l;
if (_e331 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e333 = i_9;
param_193 = _e333;
let _e334 = LightHasShadow_u0028_i1_u003b((¶m_193));
if _e334 {
let _e335 = (*s_8);
param_194 = _e335;
let _e336 = light_5;
param_195 = _e336;
let _e337 = i_9;
param_196 = _e337;
let _e338 = 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_194), (¶m_195), (¶m_196));
let _e339 = v_world_position_1;
param_197 = _e339;
let _e341 = (*s_8).n;
param_198 = _e341;
let _e342 = i_9;
param_199 = _e342;
let _e343 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_197), (¶m_198), (¶m_199));
local_39 = (_e338 * _e343);
} else {
local_39 = 1f;
}
let _e345 = local_39;
visibility = _e345;
let _e346 = visibility;
if (_e346 <= 0f) {
continue;
}
let _e348 = (*s_8);
param_200 = _e348;
let _e349 = light_5;
param_201 = _e349;
let _e350 = 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_200), (¶m_201));
let _e352 = light_5.radiance;
let _e355 = light_5.n_dot_l;
let _e357 = visibility;
let _e359 = light_transmittance;
let _e361 = total_1;
total_1 = (_e361 + ((((_e350 * _e352) * _e355) * _e357) * _e359));
continue;
} else {
break;
}
continuing {
let _e363 = i_9;
i_9 = (_e363 + 1i);
}
}
let _e365 = total_1;
return _e365;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e304 = v_lightmap_uv_1;
let _e305 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e304);
texel_4 = _e305;
let _e306 = texel_4;
let _e309 = texel_4[3u];
return ((_e306.xyz * _e309) * 8f);
}
fn SceneColourLevel_u0028_vf2_u003b_i1_u003b(uv_7: 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 _e308 = (*level);
let _e311 = layer_info.scene_levels[_e308];
rect = _e311;
let _e313 = layer_info.scene_colour;
inset_1 = (_e313.yz * 0.5f);
let _e316 = rect;
let _e318 = (*uv_7);
let _e319 = rect;
let _e322 = inset_1;
let _e323 = rect;
let _e325 = inset_1;
let _e327 = inset_1;
at_4 = (_e316.xy + clamp((_e318 * _e319.zw), _e322, max((_e323.zw - _e325), _e327)));
let _e331 = at_4;
let _e332 = textureSampleLevel(scene_colour_texture_tex, scene_colour_texture_smp, _e331, 0f);
return _e332.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_1: vec2<f32>;
var uv_8: vec2<f32>;
var top: f32;
var level_1: f32;
var lower: f32;
var near_2: vec3<f32>;
var param_202: vec2<f32>;
var param_203: i32;
var far_1: vec3<f32>;
var param_204: vec2<f32>;
var param_205: i32;
let _e319 = layer_info.scene_view_projection;
let _e320 = (*world_4);
clip_2 = (_e319 * vec4<f32>(_e320.x, _e320.y, _e320.z, 1f));
let _e326 = clip_2;
let _e329 = clip_2[3u];
ndc_2 = (_e326.xy / vec2(max(_e329, 0.000001f)));
let _e334 = ndc_2[0u];
let _e338 = ndc_2[1u];
view_1 = clamp(vec2<f32>(((_e334 * 0.5f) + 0.5f), (0.5f - (_e338 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
let _e344 = layer_info.scene_viewport;
let _e346 = view_1;
let _e348 = layer_info.scene_viewport;
uv_8 = (_e344.xy + (_e346 * _e348.zw));
let _e354 = layer_info.scene_colour[0u];
top = (_e354 - 1f);
let _e356 = (*lod);
let _e357 = top;
level_1 = clamp(_e356, 0f, _e357);
let _e359 = level_1;
lower = floor(_e359);
let _e361 = lower;
let _e363 = uv_8;
param_202 = _e363;
param_203 = i32(_e361);
let _e364 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_202), (¶m_203));
near_2 = _e364;
let _e365 = lower;
let _e367 = top;
let _e370 = uv_8;
param_204 = _e370;
param_205 = i32(min((_e365 + 1f), _e367));
let _e371 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_204), (¶m_205));
far_1 = _e371;
let _e372 = near_2;
let _e373 = far_1;
let _e374 = level_1;
let _e375 = lower;
return mix(_e372, _e373, vec3((_e374 - _e375)));
}
fn IorInfinite_u0028_() -> bool {
let _e305 = layer_info.coat[2u];
return (_e305 == 0f);
}
fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
var local_40: f32;
let _e305 = IorInfinite_u0028_();
if _e305 {
local_40 = 0f;
} else {
let _e306 = (*ior);
let _e311 = layer_info.transmission[3u];
local_40 = (((_e306 - 1f) * 0.025f) * _e311);
}
let _e313 = local_40;
return _e313;
}
fn RefractionIor_u0028_() -> f32 {
var local_41: f32;
let _e304 = IorInfinite_u0028_();
if _e304 {
local_41 = 10000f;
} else {
let _e307 = layer_info.coat[2u];
local_41 = max(_e307, 1f);
}
let _e309 = local_41;
return _e309;
}
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_9: ptr<function, Surface>) -> vec3<f32> {
var ior_1: f32;
var spread_1: f32;
var param_206: f32;
var width: f32;
var lod_1: f32;
var thin: bool;
var red: vec3<f32>;
var local_42: vec3<f32>;
var green: vec3<f32>;
var local_43: vec3<f32>;
var blue: vec3<f32>;
var local_44: vec3<f32>;
var param_207: vec3<f32>;
var param_208: f32;
var param_209: vec3<f32>;
var param_210: f32;
var param_211: vec3<f32>;
var param_212: f32;
let _e322 = RefractionIor_u0028_();
ior_1 = _e322;
let _e323 = ior_1;
param_206 = _e323;
let _e324 = DispersionSpread_u0028_f1_u003b((¶m_206));
spread_1 = _e324;
let _e328 = layer_info.scene_levels[0i][2u];
let _e331 = layer_info.scene_colour[1u];
width = (_e328 / max(_e331, 0.000000001f));
let _e334 = width;
let _e338 = (*s_9).roughness;
let _e340 = ior_1;
lod_1 = ((log2(max(_e334, 1f)) * _e338) * clamp(((_e340 * 2f) - 2f), 0f, 1f));
let _e345 = g_thickness;
thin = (_e345 <= 0f);
let _e347 = thin;
if _e347 {
let _e349 = (*s_9).v;
local_42 = -(_e349);
} else {
let _e352 = (*s_9).v;
let _e355 = (*s_9).n;
let _e356 = ior_1;
let _e357 = spread_1;
local_42 = refract(-(_e352), _e355, (1f / max((_e356 - _e357), 1f)));
}
let _e362 = local_42;
red = _e362;
let _e363 = thin;
if _e363 {
let _e365 = (*s_9).v;
local_43 = -(_e365);
} else {
let _e368 = (*s_9).v;
let _e371 = (*s_9).n;
let _e372 = ior_1;
local_43 = refract(-(_e368), _e371, (1f / _e372));
}
let _e375 = local_43;
green = _e375;
let _e376 = thin;
if _e376 {
let _e378 = (*s_9).v;
local_44 = -(_e378);
} else {
let _e381 = (*s_9).v;
let _e384 = (*s_9).n;
let _e385 = ior_1;
let _e386 = spread_1;
local_44 = refract(-(_e381), _e384, (1f / (_e385 + _e386)));
}
let _e390 = local_44;
blue = _e390;
let _e391 = v_world_position_1;
let _e392 = red;
let _e393 = g_thickness;
param_207 = (_e391 + (_e392 * _e393));
let _e396 = lod_1;
param_208 = _e396;
let _e397 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_207), (¶m_208));
let _e399 = v_world_position_1;
let _e400 = green;
let _e401 = g_thickness;
param_209 = (_e399 + (_e400 * _e401));
let _e404 = lod_1;
param_210 = _e404;
let _e405 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_209), (¶m_210));
let _e407 = v_world_position_1;
let _e408 = blue;
let _e409 = g_thickness;
param_211 = (_e407 + (_e408 * _e409));
let _e412 = lod_1;
param_212 = _e412;
let _e413 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_211), (¶m_212));
return vec3<f32>(_e397.x, _e405.y, _e413.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_10: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
var ior_2: f32;
var spread_2: f32;
var param_213: f32;
var lod_2: f32;
var thin_1: bool;
var red_1: vec3<f32>;
var local_45: vec3<f32>;
var green_1: vec3<f32>;
var local_46: vec3<f32>;
var blue_1: vec3<f32>;
var local_47: vec3<f32>;
let _e316 = RefractionIor_u0028_();
ior_2 = _e316;
let _e317 = ior_2;
param_213 = _e317;
let _e318 = DispersionSpread_u0028_f1_u003b((¶m_213));
spread_2 = _e318;
let _e320 = (*s_10).roughness;
let _e321 = ior_2;
let _e326 = (*levels);
lod_2 = ((_e320 * clamp(((_e321 * 2f) - 2f), 0f, 1f)) * _e326);
let _e328 = g_thickness;
thin_1 = (_e328 <= 0f);
let _e330 = thin_1;
if _e330 {
let _e332 = (*s_10).v;
local_45 = -(_e332);
} else {
let _e335 = (*s_10).v;
let _e338 = (*s_10).n;
let _e339 = ior_2;
let _e340 = spread_2;
local_45 = refract(-(_e335), _e338, (1f / max((_e339 - _e340), 1f)));
}
let _e345 = local_45;
red_1 = _e345;
let _e346 = thin_1;
if _e346 {
let _e348 = (*s_10).v;
local_46 = -(_e348);
} else {
let _e351 = (*s_10).v;
let _e354 = (*s_10).n;
let _e355 = ior_2;
local_46 = refract(-(_e351), _e354, (1f / _e355));
}
let _e358 = local_46;
green_1 = _e358;
let _e359 = thin_1;
if _e359 {
let _e361 = (*s_10).v;
local_47 = -(_e361);
} else {
let _e364 = (*s_10).v;
let _e367 = (*s_10).n;
let _e368 = ior_2;
let _e369 = spread_2;
local_47 = refract(-(_e364), _e367, (1f / (_e368 + _e369)));
}
let _e373 = local_47;
blue_1 = _e373;
let _e374 = red_1;
let _e375 = lod_2;
let _e376 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e374, _e375);
let _e378 = green_1;
let _e379 = lod_2;
let _e380 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e378, _e379);
let _e382 = blue_1;
let _e383 = lod_2;
let _e384 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e382, _e383);
return vec3<f32>(_e376.x, _e380.y, _e384.z);
}
fn SceneColourBound_u0028_() -> bool {
let _e305 = layer_info.scene_colour[0u];
return (_e305 > 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_214: f32;
var param_215: f32;
var param_216: f32;
var param_217: vec3<f32>;
var param_218: f32;
let _e312 = (*mu_1);
param_214 = _e312;
let _e313 = (*r_4);
param_215 = _e313;
let _e314 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_214), (¶m_215));
e_1 = _e314;
let _e315 = (*rho_2);
let _e316 = e_1;
let _e318 = (*r_4);
param_216 = _e318;
let _e319 = FonAverage_u0028_f1_u003b((¶m_216));
let _e320 = (*rho_2);
param_217 = _e320;
param_218 = _e319;
let _e321 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_217), (¶m_218));
let _e322 = e_1;
return ((_e315 * _e316) + (_e321 * (1f - _e322)));
}
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 _e310 = (*opd);
phase = ((6.2831855f * _e310) * 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 _e313 = val;
let _e314 = variance_1;
let _e318 = pos;
let _e319 = phase;
let _e321 = (*shift);
let _e325 = phase;
let _e326 = phase;
let _e329 = variance_1;
xyz = (((_e313 * sqrt((_e314 * 6.2831855f))) * cos(((_e318 * _e319) + _e321))) * exp((_e329 * -((_e325 * _e326)))));
let _e333 = phase;
let _e336 = (*shift)[0u];
let _e340 = phase;
let _e342 = phase;
let _e347 = xyz[0u];
xyz[0u] = (_e347 + ((0.00000001644083f * cos(((2239900f * _e333) + _e336))) * exp(((-4528200000f * _e340) * _e342))));
let _e350 = xyz;
xyz = (_e350 / vec3(0.00000010685f));
let _e353 = 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)) * _e353);
}
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_2: i32;
var param_219: f32;
var param_220: vec3<f32>;
var local_48: vec3<f32>;
let _e332 = (*film);
let _e333 = (*thickness);
eta2_ = mix(1f, _e332, smoothstep(0f, 0.03f, _e333));
let _e336 = (*cos1_);
let _e337 = (*cos1_);
let _e340 = eta2_;
let _e341 = eta2_;
sin2Sq = ((1f - (_e336 * _e337)) / (_e340 * _e341));
let _e344 = sin2Sq;
cos2Sq = (1f - _e344);
let _e346 = cos2Sq;
cos2_ = sqrt(max(_e346, 0f));
let _e349 = eta2_;
let _e351 = eta2_;
r0_ = ((_e349 - 1f) / (_e351 + 1f));
let _e354 = r0_;
let _e355 = r0_;
let _e357 = r0_;
let _e358 = r0_;
let _e361 = (*cos1_);
r12_ = ((_e354 * _e355) + ((1f - (_e357 * _e358)) * pow((1f - _e361), 5f)));
let _e366 = r12_;
t121_ = (1f - _e366);
let _e368 = eta2_;
phi12_ = select(0f, 3.1415927f, (_e368 < 1f));
let _e371 = phi12_;
phi21_ = (3.1415927f - _e371);
let _e373 = (*base);
sqrtBase = sqrt(clamp(_e373, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
let _e376 = sqrtBase;
let _e378 = sqrtBase;
baseIor = ((vec3<f32>(1f, 1f, 1f) + _e376) / (vec3<f32>(1f, 1f, 1f) - _e378));
let _e381 = baseIor;
let _e382 = eta2_;
let _e385 = baseIor;
let _e386 = eta2_;
r1_ = ((_e381 - vec3(_e382)) / (_e385 + vec3(_e386)));
let _e390 = r1_;
let _e391 = r1_;
r1_ = (_e391 * _e390);
let _e393 = r1_;
let _e394 = r1_;
let _e396 = cos2_;
r23_ = (_e393 + ((vec3<f32>(1f, 1f, 1f) - _e394) * pow((1f - _e396), 5f)));
let _e402 = baseIor[0u];
let _e403 = eta2_;
let _e407 = baseIor[1u];
let _e408 = eta2_;
let _e412 = baseIor[2u];
let _e413 = eta2_;
phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e402 < _e403)), select(0f, 3.1415927f, (_e407 < _e408)), select(0f, 3.1415927f, (_e412 < _e413)));
let _e417 = eta2_;
let _e419 = (*thickness);
let _e421 = cos2_;
opd_1 = (((2f * _e417) * _e419) * _e421);
let _e423 = phi21_;
let _e425 = phi23_;
phi = (vec3(_e423) + _e425);
let _e427 = r12_;
let _e428 = r23_;
r123_ = clamp((_e428 * _e427), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
let _e431 = r123_;
rootR123_ = sqrt(_e431);
let _e433 = t121_;
let _e434 = t121_;
let _e436 = r23_;
let _e438 = r123_;
rs = ((_e436 * (_e433 * _e434)) / (vec3<f32>(1f, 1f, 1f) - _e438));
let _e441 = r12_;
let _e443 = rs;
total_2 = (vec3(_e441) + _e443);
let _e445 = rs;
let _e446 = t121_;
cm = (_e445 - vec3(_e446));
m_2 = 1i;
loop {
let _e449 = m_2;
if (_e449 <= 2i) {
let _e451 = rootR123_;
let _e452 = cm;
cm = (_e452 * _e451);
let _e454 = cm;
let _e456 = m_2;
let _e458 = opd_1;
let _e460 = m_2;
let _e462 = phi;
param_219 = (f32(_e456) * _e458);
param_220 = (_e462 * f32(_e460));
let _e464 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((¶m_219), (¶m_220));
let _e466 = total_2;
total_2 = (_e466 + ((_e454 * 2f) * _e464));
continue;
} else {
break;
}
continuing {
let _e468 = m_2;
m_2 = (_e468 + 1i);
}
}
let _e470 = cos2Sq;
if (_e470 < 0f) {
local_48 = vec3<f32>(1f, 1f, 1f);
} else {
let _e472 = total_2;
local_48 = max(_e472, vec3<f32>(0f, 0f, 0f));
}
let _e474 = local_48;
return _e474;
}
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_11: ptr<function, Surface>) {
var f0_3: vec3<f32>;
var param_221: f32;
var param_222: f32;
var param_223: f32;
var param_224: vec3<f32>;
let _e309 = g_f0_dielectric;
let _e311 = (*s_11).albedo;
let _e313 = (*s_11).metallic;
f0_3 = mix(_e309, _e311, vec3(clamp(_e313, 0f, 1f)));
let _e319 = layer_info.iridescence[1u];
param_221 = _e319;
let _e321 = (*s_11).n_dot_v;
param_222 = _e321;
let _e324 = layer_info.iridescence[2u];
param_223 = _e324;
let _e325 = f0_3;
param_224 = _e325;
let _e326 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((¶m_221), (¶m_222), (¶m_223), (¶m_224));
g_irid_fresnel = _e326;
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_12: ptr<function, Surface>) {
var param_225: f32;
var param_226: f32;
var param_227: f32;
var t_2: vec3<f32>;
var usable: bool;
var local_49: vec3<f32>;
var b_4: vec3<f32>;
var turn_2: vec2<f32>;
var along_1: vec3<f32>;
var local_50: f32;
var local_51: vec3<f32>;
var phi_5434_: bool;
let _e316 = (*s_12).n_dot_v;
let _e320 = g_sheen_roughness;
param_225 = _e320;
param_226 = sqrt(clamp((1f - _e316), 0f, 1f));
param_227 = 1f;
let _e321 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_225), (¶m_226), (¶m_227));
let _e322 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e321, 0f);
g_sheen_albedo = _e322.z;
let _e325 = g_sheen[0u];
let _e327 = g_sheen[1u];
let _e330 = g_sheen[2u];
let _e332 = g_sheen_albedo;
g_sheen_scale = (1f - (max(max(_e325, _e327), _e330) * _e332));
let _e335 = v_tangent_1;
let _e338 = (*s_12).n;
let _e340 = (*s_12).n;
let _e341 = v_tangent_1;
t_2 = (_e335.xyz - (_e338 * dot(_e340, _e341.xyz)));
let _e346 = t_2;
let _e347 = t_2;
usable = (dot(_e346, _e347) > 0.000000000001f);
let _e350 = usable;
if _e350 {
let _e351 = t_2;
local_49 = normalize(_e351);
} else {
local_49 = vec3<f32>(1f, 0f, 0f);
}
let _e353 = local_49;
t_2 = _e353;
let _e355 = (*s_12).n;
let _e356 = t_2;
let _e359 = v_tangent_1[3u];
b_4 = (cross(_e355, _e356) * _e359);
let _e361 = gl_FrontFacing_1;
if !(_e361) {
let _e363 = t_2;
t_2 = -(_e363);
}
let _e366 = layer_info.anisotropy;
turn_2 = _e366.yz;
let _e368 = t_2;
let _e370 = turn_2[0u];
let _e372 = b_4;
let _e374 = turn_2[1u];
along_1 = ((_e368 * _e370) + (_e372 * _e374));
let _e377 = usable;
phi_5434_ = _e377;
if _e377 {
let _e378 = along_1;
let _e379 = along_1;
phi_5434_ = (dot(_e378, _e379) > 0.000000000001f);
}
let _e383 = phi_5434_;
if _e383 {
let _e386 = layer_info.anisotropy[0u];
local_50 = clamp(_e386, 0f, 1f);
} else {
local_50 = 0f;
}
let _e388 = local_50;
g_aniso = _e388;
let _e389 = g_aniso;
if (_e389 > 0f) {
let _e391 = along_1;
local_51 = normalize(_e391);
} else {
let _e393 = t_2;
local_51 = _e393;
}
let _e394 = local_51;
g_aniso_t = _e394;
let _e396 = (*s_12).n;
let _e397 = g_aniso_t;
g_aniso_b = cross(_e396, _e397);
return;
}
fn MaterialLodBias_u0028_() -> f32 {
let _e305 = frag_info.target_origin[1u];
return _e305;
}
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_13: ptr<function, Surface>) {
var orm: vec3<f32>;
var param_228: i32;
param_228 = 1i;
let _e306 = MapUv_u0028_i1_u003b((¶m_228));
let _e307 = MaterialLodBias_u0028_();
let _e308 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e306, _e307);
orm = _e308.xyz;
let _e311 = (*s_13).metallic;
let _e313 = orm[2u];
(*s_13).metallic = clamp((_e311 * _e313), 0f, 1f);
let _e318 = (*s_13).roughness;
let _e320 = orm[1u];
(*s_13).roughness = clamp((_e318 * _e320), 0.02f, 1f);
return;
}
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_14: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_229: i32;
var param_230: vec3<f32>;
param_229 = 4i;
let _e307 = MapUv_u0028_i1_u003b((¶m_229));
let _e308 = MaterialLodBias_u0028_();
let _e309 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e307, _e308);
param_230 = _e309.xyz;
let _e311 = SrgbToLinear_u0028_vf3_u003b((¶m_230));
emissive = _e311;
let _e312 = emissive;
let _e314 = frag_info.emissive;
let _e319 = frag_info.material2_[3u];
(*s_14).emissive = ((_e312 * _e314.xyz) * _e319);
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_15: ptr<function, Surface>) {
var occlusion: f32;
var param_231: i32;
param_231 = 3i;
let _e306 = MapUv_u0028_i1_u003b((¶m_231));
let _e307 = MaterialLodBias_u0028_();
let _e308 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e306, _e307);
occlusion = _e308.x;
let _e310 = occlusion;
let _e313 = frag_info.material2_[2u];
(*s_15).occlusion = mix(1f, _e310, clamp(_e313, 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 _e306 = (*slot_7);
let _e310 = layer_info.uv_transform[(_e306 * 2i)];
u_2 = _e310;
let _e311 = (*slot_7);
let _e316 = layer_info.uv_transform[((_e311 * 2i) + 1i)];
v_3 = _e316;
let _e318 = u_2[0u];
let _e320 = u_2[1u];
let _e322 = v_3[0u];
let _e324 = v_3[1u];
return vec4<f32>(_e318, _e320, _e322, _e324);
}
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_16: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var param_232: i32;
var t_3: vec3<f32>;
var b_5: vec3<f32>;
var m_3: vec4<f32>;
var param_233: i32;
var det: f32;
var flip: f32;
var front: vec3<f32>;
var local_52: vec3<f32>;
var turned: vec3<f32>;
var turns: bool;
var local_53: vec3<f32>;
var local_54: vec3<f32>;
var sampled: vec3<f32>;
var phi_4141_: bool;
var phi_4148_: bool;
var phi_4155_: bool;
var phi_4162_: bool;
param_232 = 2i;
let _e319 = MapUv_u0028_i1_u003b((¶m_232));
let _e320 = MaterialLodBias_u0028_();
let _e321 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e319, _e320);
sampledTexel = _e321;
let _e322 = v_tangent_1;
t_3 = _e322.xyz;
let _e324 = t_3;
let _e326 = (*s_16).n;
let _e328 = (*s_16).n;
let _e329 = t_3;
t_3 = (_e324 - (_e326 * dot(_e328, _e329)));
let _e333 = t_3;
let _e334 = t_3;
if (dot(_e333, _e334) < 0.000000000001f) {
return;
}
let _e337 = t_3;
t_3 = normalize(_e337);
let _e340 = (*s_16).n;
let _e341 = t_3;
let _e344 = v_tangent_1[3u];
b_5 = (cross(_e340, _e341) * _e344);
param_233 = 2i;
let _e346 = MapMatrix_u0028_i1_u003b((¶m_233));
m_3 = _e346;
let _e348 = m_3[0u];
let _e350 = m_3[3u];
let _e353 = m_3[1u];
let _e355 = m_3[2u];
det = ((_e348 * _e350) - (_e353 * _e355));
let _e358 = det;
flip = select(1f, -1f, (_e358 < 0f));
let _e361 = gl_FrontFacing_1;
if _e361 {
let _e362 = b_5;
local_52 = _e362;
} else {
let _e363 = b_5;
local_52 = -(_e363);
}
let _e365 = local_52;
front = _e365;
let _e366 = t_3;
let _e368 = m_3[3u];
let _e370 = front;
let _e372 = m_3[2u];
let _e375 = flip;
turned = (((_e366 * _e368) + (_e370 * _e372)) * _e375);
let _e378 = m_3[1u];
let _e379 = (_e378 != 0f);
phi_4141_ = _e379;
if !(_e379) {
let _e382 = m_3[2u];
phi_4141_ = (_e382 != 0f);
}
let _e385 = phi_4141_;
phi_4148_ = _e385;
if !(_e385) {
let _e388 = m_3[0u];
phi_4148_ = (_e388 < 0f);
}
let _e391 = phi_4148_;
phi_4155_ = _e391;
if !(_e391) {
let _e394 = m_3[3u];
phi_4155_ = (_e394 < 0f);
}
let _e397 = phi_4155_;
phi_4162_ = _e397;
if _e397 {
let _e398 = turned;
let _e399 = turned;
phi_4162_ = (dot(_e398, _e399) > 0.000000000001f);
}
let _e403 = phi_4162_;
turns = _e403;
let _e404 = turns;
if _e404 {
let _e405 = turned;
local_53 = normalize(_e405);
} else {
let _e407 = t_3;
local_53 = _e407;
}
let _e408 = local_53;
t_3 = _e408;
let _e409 = turns;
if _e409 {
let _e411 = (*s_16).n;
let _e412 = t_3;
let _e415 = v_tangent_1[3u];
let _e417 = flip;
local_54 = ((cross(_e411, _e412) * _e415) * _e417);
} else {
let _e419 = b_5;
local_54 = _e419;
}
let _e420 = local_54;
b_5 = _e420;
let _e421 = gl_FrontFacing_1;
if !(_e421) {
let _e423 = t_3;
t_3 = -(_e423);
}
let _e425 = sampledTexel;
sampled = ((_e425.xyz * 2f) - vec3(1f));
let _e432 = frag_info.emissive[3u];
if (_e432 > 0.5f) {
let _e434 = sampled;
let _e436 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e434.xy, _e436.xy)), 0f));
}
let _e445 = frag_info.material2_[1u];
let _e446 = sampled;
let _e448 = (_e446.xy * _e445);
sampled[0u] = _e448.x;
sampled[1u] = _e448.y;
let _e453 = t_3;
let _e455 = sampled[0u];
let _e457 = b_5;
let _e459 = sampled[1u];
let _e463 = (*s_16).n;
let _e465 = sampled[2u];
(*s_16).n = normalize((((_e453 * _e455) + (_e457 * _e459)) + (_e463 * _e465)));
let _e471 = (*s_16).n;
let _e473 = (*s_16).v;
(*s_16).n_dot_v = max(dot(_e471, _e473), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e304 = (*texel_5);
let _e308 = irradiance_info.atlas;
let _e311 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e304 + vec2(0.5f)) * _e308.xy), 0f);
return _e311;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_9: 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_234: vec2<f32>;
var b_6: vec4<f32>;
var param_235: vec2<f32>;
var c_1: vec4<f32>;
var param_236: vec2<f32>;
var d_6: vec4<f32>;
var param_237: vec2<f32>;
let _e317 = (*uv_9);
let _e318 = (*interior);
at_5 = ((vec2(1f) + (_e317 * _e318)) - vec2(0.5f));
let _e324 = at_5;
low = floor(_e324);
let _e326 = at_5;
let _e327 = low;
f_5 = (_e326 - _e327);
let _e329 = (*corner);
let _e330 = low;
param_234 = (_e329 + _e330);
let _e332 = AtlasTexel_u0028_vf2_u003b((¶m_234));
a_6 = _e332;
let _e333 = (*corner);
let _e334 = low;
param_235 = ((_e333 + _e334) + vec2<f32>(1f, 0f));
let _e337 = AtlasTexel_u0028_vf2_u003b((¶m_235));
b_6 = _e337;
let _e338 = (*corner);
let _e339 = low;
param_236 = ((_e338 + _e339) + vec2<f32>(0f, 1f));
let _e342 = AtlasTexel_u0028_vf2_u003b((¶m_236));
c_1 = _e342;
let _e343 = (*corner);
let _e344 = low;
param_237 = ((_e343 + _e344) + vec2<f32>(1f, 1f));
let _e347 = AtlasTexel_u0028_vf2_u003b((¶m_237));
d_6 = _e347;
let _e348 = a_6;
let _e349 = b_6;
let _e351 = f_5[0u];
let _e354 = c_1;
let _e355 = d_6;
let _e357 = f_5[0u];
let _e361 = f_5[1u];
return mix(mix(_e348, _e349, vec4(_e351)), mix(_e354, _e355, vec4(_e357)), vec4(_e361));
}
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 _e308 = (*direction_1)[0u];
let _e311 = (*direction_1)[1u];
let _e315 = (*direction_1)[2u];
sum_1 = ((abs(_e308) + abs(_e311)) + abs(_e315));
let _e318 = sum_1;
if (_e318 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e320 = (*direction_1);
let _e321 = sum_1;
n_6 = (_e320 / vec3(_e321));
let _e324 = n_6;
xy = _e324.xy;
let _e327 = n_6[2u];
if (_e327 < 0f) {
let _e330 = n_6[1u];
let _e334 = n_6[0u];
let _e339 = n_6[0u];
let _e343 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e330)) * select(-1f, 1f, (_e334 >= 0f))), ((1f - abs(_e339)) * select(-1f, 1f, (_e343 >= 0f))));
}
let _e348 = xy;
return ((_e348 * 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_2: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_238: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_239: vec3<f32>;
var param_240: vec2<f32>;
var param_241: f32;
var param_242: vec2<f32>;
var chebyshev: f32;
var variance_2: f32;
var difference: f32;
var param_243: vec3<f32>;
var param_244: vec2<f32>;
var param_245: f32;
var param_246: vec2<f32>;
var local_55: vec3<f32>;
let _e350 = irradiance_info.origin;
origin_2 = _e350.xyz;
let _e353 = irradiance_info.spacing;
spacing = _e353.xyz;
let _e356 = irradiance_info.counts;
counts = _e356.xyz;
let _e360 = irradiance_info.tiles[0u];
irradianceTile = _e360;
let _e363 = irradiance_info.tiles[1u];
depthTile = _e363;
let _e366 = irradiance_info.tiles[2u];
columns = _e366;
let _e369 = irradiance_info.tiles[3u];
momentsTop = _e369;
let _e370 = (*normal_1);
unit = normalize(_e370);
let _e372 = (*world_5);
let _e373 = unit;
let _e376 = irradiance_info.spacing[3u];
let _e379 = (*view_2);
let _e382 = irradiance_info.counts[3u];
biased = ((_e372 + (_e373 * _e376)) + (_e379 * _e382));
let _e385 = biased;
let _e386 = origin_2;
let _e388 = spacing;
grid_1 = ((_e385 - _e386) / _e388);
let _e390 = grid_1;
let _e392 = counts;
base_1 = clamp(floor(_e390), vec3<f32>(0f, 0f, 0f), (_e392 - vec3(2f)));
let _e396 = grid_1;
let _e397 = base_1;
f_6 = clamp((_e396 - _e397), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_3 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e400 = corner_1;
if (_e400 < 8i) {
let _e402 = corner_1;
let _e405 = corner_1;
let _e410 = corner_1;
offset_3 = vec3<f32>(f32((_e402 & 1i)), f32(((_e405 >> bitcast<u32>(1i)) & 1i)), f32(((_e410 >> bitcast<u32>(2i)) & 1i)));
let _e416 = base_1;
let _e417 = offset_3;
cell_2 = (_e416 + _e417);
let _e420 = cell_2[2u];
let _e422 = counts[1u];
let _e425 = cell_2[1u];
let _e428 = counts[0u];
let _e431 = cell_2[0u];
probe = ((((_e420 * _e422) + _e425) * _e428) + _e431);
let _e433 = probe;
let _e434 = columns;
let _e439 = probe;
let _e440 = columns;
tile_4 = vec2<f32>((_e433 - (floor((_e433 / _e434)) * _e434)), floor((_e439 / _e440)));
let _e444 = tile_4;
let _e445 = irradianceTile;
irradianceCorner = (_e444 * (_e445 + 2f));
let _e449 = tile_4[0u];
let _e450 = depthTile;
let _e453 = momentsTop;
let _e455 = tile_4[1u];
let _e456 = depthTile;
momentCorner = vec2<f32>((_e449 * (_e450 + 2f)), (_e453 + (_e455 * (_e456 + 2f))));
let _e461 = irradianceCorner;
param_238 = (_e461 + vec2(1f));
let _e464 = AtlasTexel_u0028_vf2_u003b((¶m_238));
if (_e464.w < 0.5f) {
continue;
}
let _e467 = f_6;
let _e469 = f_6;
let _e470 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e467), _e469, _e470);
let _e473 = trilinear[0u];
let _e475 = trilinear[1u];
let _e478 = trilinear[2u];
weight_3 = max(((_e473 * _e475) * _e478), 0.001f);
let _e481 = origin_2;
let _e482 = spacing;
let _e483 = cell_2;
probePosition = (_e481 + (_e482 * _e483));
let _e486 = probePosition;
let _e487 = biased;
toProbe = (_e486 - _e487);
let _e489 = toProbe;
distance_4 = length(_e489);
let _e491 = distance_4;
if (_e491 > 0.000001f) {
let _e493 = toProbe;
let _e494 = distance_4;
direction_2 = (_e493 / vec3(_e494));
let _e497 = unit;
let _e498 = probePosition;
let _e499 = (*world_5);
facing = ((dot(_e497, normalize((_e498 - _e499))) * 0.5f) + 0.5f);
let _e505 = facing;
let _e506 = facing;
probeWeight = ((_e505 * _e506) + 0.2f);
let _e509 = direction_2;
param_239 = -(_e509);
let _e511 = ProbeOctahedral_u0028_vf3_u003b((¶m_239));
let _e512 = momentCorner;
param_240 = _e512;
let _e513 = depthTile;
param_241 = _e513;
param_242 = _e511;
let _e514 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_240), (¶m_241), (¶m_242));
moments_3 = _e514.xy;
chebyshev = 1f;
let _e516 = distance_4;
let _e518 = moments_3[0u];
if (_e516 > _e518) {
let _e521 = moments_3[1u];
let _e523 = moments_3[0u];
let _e525 = moments_3[0u];
variance_2 = max((_e521 - (_e523 * _e525)), 0.000001f);
let _e529 = distance_4;
let _e531 = moments_3[0u];
difference = (_e529 - _e531);
let _e533 = variance_2;
let _e534 = variance_2;
let _e535 = difference;
let _e536 = difference;
chebyshev = (_e533 / (_e534 + (_e535 * _e536)));
let _e540 = chebyshev;
let _e541 = chebyshev;
let _e543 = chebyshev;
chebyshev = ((_e540 * _e541) * _e543);
}
let _e545 = probeWeight;
let _e546 = chebyshev;
probeWeight = max((_e545 * max(_e546, 0.05f)), 0.000001f);
let _e550 = probeWeight;
if (_e550 < 0.2f) {
let _e552 = probeWeight;
let _e553 = probeWeight;
let _e556 = probeWeight;
probeWeight = (_e556 * ((_e552 * _e553) * 25f));
}
let _e558 = probeWeight;
let _e559 = weight_3;
weight_3 = (_e559 * _e558);
}
let _e561 = unit;
param_243 = _e561;
let _e562 = ProbeOctahedral_u0028_vf3_u003b((¶m_243));
let _e563 = irradianceCorner;
param_244 = _e563;
let _e564 = irradianceTile;
param_245 = _e564;
param_246 = _e562;
let _e565 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_244), (¶m_245), (¶m_246));
let _e567 = weight_3;
let _e569 = total_3;
total_3 = (_e569 + (_e565.xyz * _e567));
let _e571 = weight_3;
let _e572 = weights;
weights = (_e572 + _e571);
continue;
} else {
break;
}
continuing {
let _e574 = corner_1;
corner_1 = (_e574 + 1i);
}
}
let _e576 = weights;
if (_e576 > 0f) {
let _e578 = total_3;
let _e579 = weights;
local_55 = (_e578 / vec3(_e579));
} else {
local_55 = vec3<f32>(0f, 0f, 0f);
}
let _e582 = local_55;
return _e582;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e305 = irradiance_info.origin[3u];
return (_e305 > 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_17: ptr<function, Surface>) {
var param_247: vec3<f32>;
var param_248: vec3<f32>;
var param_249: vec3<f32>;
var param_250: Surface;
var param_251: Surface;
var param_252: Surface;
let _e310 = IrradianceEnabled_u0028_();
if _e310 {
let _e311 = v_world_position_1;
param_247 = _e311;
let _e313 = (*s_17).n;
param_248 = _e313;
let _e315 = (*s_17).v;
param_249 = _e315;
let _e316 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_247), (¶m_248), (¶m_249));
let _e319 = frag_info.material[2u];
(*s_17).ambient = (_e316 * _e319);
}
let _e322 = (*s_17);
param_250 = _e322;
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_250));
let _e323 = param_250;
(*s_17) = _e323;
let _e324 = (*s_17);
param_251 = _e324;
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_251));
let _e325 = param_251;
(*s_17) = _e325;
let _e326 = (*s_17);
param_252 = _e326;
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_252));
let _e327 = param_252;
(*s_17) = _e327;
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_18: ptr<function, Surface>) {
var coatTexel: vec4<f32>;
var sheenTexel: vec4<f32>;
var param_253: vec3<f32>;
var ior_3: f32;
var r_5: f32;
var local_56: f32;
var bent: vec3<f32>;
var distance_5: f32;
var local_57: vec3<f32>;
var fc: f32;
let _e314 = v_texcoord_1;
let _e315 = MaterialLodBias_u0028_();
let _e316 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e314, _e315);
coatTexel = _e316;
let _e317 = v_texcoord_1;
let _e318 = MaterialLodBias_u0028_();
let _e319 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e317, _e318);
sheenTexel = _e319;
let _e321 = layer_info.sheen;
let _e323 = sheenTexel;
param_253 = _e323.xyz;
let _e325 = SrgbToLinear_u0028_vf3_u003b((¶m_253));
g_sheen = (_e321.xyz * _e325);
let _e329 = layer_info.sheen[3u];
let _e331 = sheenTexel[3u];
g_sheen_roughness = clamp((_e329 * _e331), 0.07f, 1f);
let _e336 = layer_info.coat[2u];
ior_3 = max(_e336, 1f);
let _e338 = IorInfinite_u0028_();
if _e338 {
local_56 = 1f;
} else {
let _e339 = ior_3;
let _e341 = ior_3;
local_56 = ((_e339 - 1f) / (_e341 + 1f));
}
let _e344 = local_56;
r_5 = _e344;
let _e345 = r_5;
let _e346 = r_5;
let _e350 = layer_info.specular;
let _e356 = layer_info.specular[3u];
g_f0_dielectric = (min((vec3((_e345 * _e346)) * _e350.xyz), vec3<f32>(1f, 1f, 1f)) * _e356);
let _e360 = layer_info.specular[3u];
g_f90_ = _e360;
let _e363 = layer_info.coat[0u];
let _e365 = coatTexel[0u];
g_coat = clamp((_e363 * _e365), 0f, 1f);
let _e370 = layer_info.coat[1u];
let _e372 = coatTexel[1u];
g_coat_roughness = clamp((_e370 * _e372), 0.02f, 1f);
let _e377 = layer_info.transmission[0u];
let _e379 = coatTexel[2u];
g_transmission = clamp((_e377 * _e379), 0f, 1f);
let _e384 = layer_info.transmission[1u];
let _e386 = coatTexel[3u];
g_thickness = max((_e384 * _e386), 0f);
let _e391 = layer_info.attenuation[3u];
let _e393 = g_thickness;
if ((_e391 > 0.5f) && (_e393 > 0f)) {
let _e397 = (*s_18).v;
let _e400 = (*s_18).n;
let _e401 = RefractionIor_u0028_();
bent = refract(-(_e397), _e400, (1f / _e401));
let _e404 = g_thickness;
let _e406 = (*s_18).n;
let _e407 = bent;
let _e412 = g_thickness;
g_thickness = max((_e404 * max(-(dot(_e406, _e407)), 0f)), (0.0001f * _e412));
}
let _e417 = layer_info.transmission[2u];
distance_5 = _e417;
let _e418 = distance_5;
if (_e418 > 0f) {
let _e421 = layer_info.attenuation;
let _e424 = g_thickness;
let _e425 = distance_5;
local_57 = pow(max(_e421.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e424 / _e425)));
} else {
local_57 = vec3<f32>(1f, 1f, 1f);
}
let _e429 = local_57;
g_transmittance = _e429;
let _e432 = layer_info.iridescence[0u];
g_iridescence = clamp(_e432, 0f, 1f);
let _e435 = (*s_18).n;
g_coat_n = _e435;
let _e437 = (*s_18).n;
let _e439 = (*s_18).v;
g_coat_n_dot_v = max(dot(_e437, _e439), 0.0001f);
let _e442 = g_coat_n_dot_v;
fc = (0.04f + (0.96f * pow((1f - _e442), 5f)));
let _e447 = g_coat;
let _e448 = fc;
g_coat_through = (1f - (_e447 * _e448));
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_58: vec3<f32>;
let _e304 = Orthographic_u0028_();
if _e304 {
let _e306 = fog_info.forward;
local_58 = -(_e306.xyz);
} else {
let _e310 = fog_info.eye;
let _e312 = v_world_position_1;
local_58 = normalize((_e310.xyz - _e312));
}
let _e315 = local_58;
return _e315;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_3: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e309 = (*cutoff);
key_2 = (-2f - _e309);
let _e311 = key_2;
let _e314 = key_2;
let _e316 = floor((_e314 / 128f));
let _e321 = key_2;
origin_3 = vec3<f32>(floor((_e311 / 16384f)), (_e316 - (floor((_e316 / 128f)) * 128f)), (_e321 - (floor((_e321 / 128f)) * 128f)));
let _e327 = (*scenePosition);
let _e330 = origin_3;
let _e331 = (floor((_e327 * 16f)) + _e330);
let _e332 = vec3(128f);
cell_3 = (_e331 - (floor((_e331 / _e332)) * _e332));
let _e337 = cell_3;
p3_ = fract((_e337 * 0.1031f));
let _e340 = p3_;
let _e341 = p3_;
let _e346 = p3_;
p3_ = (_e346 + vec3(dot(_e340, (_e341.zyx + vec3(31.32f)))));
let _e350 = p3_[0u];
let _e352 = p3_[1u];
let _e355 = p3_[2u];
return fract(((_e350 + _e352) * _e355));
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var param_254: i32;
var s_19: Surface;
var param_255: vec3<f32>;
var param_256: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_257: vec3<f32>;
var param_258: f32;
param_254 = 0i;
let _e312 = MapUv_u0028_i1_u003b((¶m_254));
let _e313 = MaterialLodBias_u0028_();
let _e314 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e312, _e313);
texel_6 = _e314;
let _e315 = texel_6;
param_255 = _e315.xyz;
let _e317 = SrgbToLinear_u0028_vf3_u003b((¶m_255));
let _e319 = frag_info.base_color;
param_256 = _e319.xyz;
let _e321 = SrgbToLinear_u0028_vf3_u003b((¶m_256));
let _e323 = v_color_1;
s_19.albedo = ((_e317 * _e321) * _e323.xyz);
let _e328 = texel_6[3u];
let _e331 = frag_info.base_color[3u];
let _e334 = v_color_1[3u];
s_19.alpha = ((_e328 * _e331) * _e334);
let _e338 = s_19.albedo;
g_albedo = _e338;
let _e341 = frag_info.material2_[0u];
cutoff_1 = _e341;
let _e342 = cutoff_1;
if (_e342 > 1f) {
let _e344 = cutoff_1;
edge = (_e344 - 1f);
let _e347 = s_19.alpha;
let _e348 = edge;
let _e351 = s_19.alpha;
let _e352 = fwidth(_e351);
s_19.alpha = clamp((((_e347 - _e348) / max(_e352, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e358 = cutoff_1;
if (_e358 >= 0f) {
let _e361 = s_19.alpha;
let _e362 = cutoff_1;
if (_e361 < _e362) {
discard;
}
s_19.alpha = 1f;
} else {
let _e365 = cutoff_1;
if (_e365 < -1.5f) {
let _e368 = s_19.alpha;
let _e369 = v_world_position_1;
param_257 = _e369;
let _e370 = cutoff_1;
param_258 = _e370;
let _e371 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_257), (¶m_258));
if (_e368 < _e371) {
discard;
}
}
}
}
let _e373 = cutoff_1;
let _e375 = cutoff_1;
g_premultiply = ((_e373 < 0f) && (_e375 > -0.75f));
let _e378 = v_normal_1;
s_19.n = normalize(_e378);
let _e381 = gl_FrontFacing_1;
if !(_e381) {
let _e384 = s_19.n;
s_19.n = -(_e384);
}
let _e387 = TowardsEye_u0028_();
s_19.v = _e387;
let _e390 = s_19.n;
let _e392 = s_19.v;
s_19.n_dot_v = max(dot(_e390, _e392), 0.0001f);
let _e398 = frag_info.material[0u];
s_19.metallic = clamp(_e398, 0f, 1f);
let _e403 = frag_info.material[1u];
s_19.roughness = clamp(_e403, 0.02f, 1f);
let _e407 = frag_info.ambient_ground;
let _e410 = frag_info.ambient_sky;
let _e414 = s_19.n[1u];
let _e421 = frag_info.material[2u];
s_19.ambient = (mix(_e407.xyz, _e410.xyz, vec3(((_e414 * 0.5f) + 0.5f))) * _e421);
let _e426 = frag_info.frame_params[0u];
s_19.exposure = max(_e426, 0f);
s_19.occlusion = 1f;
s_19.emissive = vec3<f32>(0f, 0f, 0f);
let _e431 = s_19;
return _e431;
}
fn main_1() {
var s_20: Surface;
var param_259: Surface;
var param_260: Surface;
var param_261: Surface;
var param_262: Surface;
var param_263: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_264: vec3<f32>;
var param_265: f32;
var param_266: 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_1: 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_267: f32;
var param_268: 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_1: vec3<f32>;
var local_59: vec3<f32>;
var param_269: Surface;
var param_270: f32;
var coatPrefiltered: vec3<f32>;
var coatAb: vec2<f32>;
var param_271: f32;
var param_272: f32;
var sceneAb: vec2<f32>;
var param_273: f32;
var param_274: f32;
var sceneReflects: vec3<f32>;
var passes: vec3<f32>;
var param_275: Surface;
var sheenAmbient: vec3<f32>;
var lit_3: vec3<f32>;
var param_276: Surface;
var param_277: Surface;
var param_278: vec3<f32>;
var param_279: vec3<f32>;
var param_280: f32;
var param_281: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
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);
g_pane = false;
let _e359 = ReadSurface_u0028_();
s_20 = _e359;
let _e360 = s_20;
param_259 = _e360;
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_259));
let _e361 = s_20;
param_260 = _e361;
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_260));
let _e362 = param_260;
s_20 = _e362;
let _e363 = s_20;
param_261 = _e363;
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_261));
let _e364 = param_261;
s_20 = _e364;
let _e365 = s_20;
param_262 = _e365;
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_262));
let _e366 = s_20;
param_263 = _e366;
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_263));
let _e368 = s_20.metallic;
metallic = clamp(_e368, 0f, 1f);
let _e371 = s_20.albedo;
let _e372 = metallic;
diffuseColor_1 = (_e371 * (1f - _e372));
let _e375 = EonDiffuse_u0028_();
if _e375 {
let _e376 = diffuseColor_1;
param_264 = _e376;
let _e378 = s_20.roughness;
param_265 = _e378;
let _e380 = s_20.n_dot_v;
param_266 = _e380;
let _e381 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_264), (¶m_265), (¶m_266));
diffuseColor_1 = _e381;
}
let _e382 = diffuseColor_1;
let _e384 = s_20.ambient;
let _e387 = s_20.occlusion;
ambient = ((_e382 * _e384) * _e387);
let _e389 = g_premultiply;
let _e390 = g_transmission;
let _e393 = g_thickness;
g_pane = ((_e389 && (_e390 > 0f)) && (_e393 <= 0f));
let _e396 = SceneColourBound_u0028_();
let _e397 = g_pane;
let _e399 = g_transmittance;
let _e402 = g_transmission;
let _e405 = ambient;
ambient = (_e405 * mix(vec3<f32>(1f, 1f, 1f), select(_e399, vec3<f32>(0f, 0f, 0f), vec3((_e396 || _e397))), vec3(_e402)));
let _e409 = frag_info.frame_params[3u];
levels_1 = _e409;
coatAmbient = vec3<f32>(0f, 0f, 0f);
let _e411 = s_20.ambient;
sheenIncoming = _e411;
let _e412 = levels_1;
if (_e412 > 0f) {
let _e414 = g_f0_dielectric;
let _e416 = s_20.albedo;
let _e417 = metallic;
f0_4 = mix(_e414, _e416, vec3(_e417));
let _e420 = g_f90_;
let _e421 = metallic;
f90_2 = mix(_e420, 1f, _e421);
let _e424 = s_20.n;
bent_1 = _e424;
let _e425 = g_aniso;
if (_e425 > 0f) {
let _e427 = g_aniso_t;
let _e429 = s_20.v;
across = cross(_e427, _e429);
let _e431 = across;
let _e432 = g_aniso_t;
anisoN = cross(_e431, _e432);
let _e434 = g_aniso;
let _e436 = s_20.roughness;
bend = (1f - (_e434 * (1f - _e436)));
let _e440 = bend;
let _e441 = bend;
let _e443 = bend;
let _e445 = bend;
bend4_ = (((_e440 * _e441) * _e443) * _e445);
let _e447 = anisoN;
let _e449 = s_20.n;
let _e450 = bend4_;
bent_1 = normalize(mix(_e447, _e449, vec3(_e450)));
}
let _e455 = s_20.v;
let _e457 = bent_1;
reflected = reflect(-(_e455), _e457);
let _e460 = s_20.n;
let _e461 = levels_1;
let _e462 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e460, _e461);
irradiance = _e462.xyz;
let _e464 = reflected;
let _e466 = s_20.roughness;
let _e467 = levels_1;
let _e469 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e464, (_e466 * _e467));
prefiltered = _e469.xyz;
let _e472 = s_20.roughness;
param_267 = _e472;
let _e474 = s_20.n_dot_v;
param_268 = _e474;
let _e475 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_267), (¶m_268));
ab_4 = _e475;
let _e476 = f0_4;
let _e477 = g_irid_fresnel;
let _e478 = g_iridescence;
let _e482 = ab_4[0u];
let _e484 = f90_2;
let _e486 = ab_4[1u];
single_1 = ((mix(_e476, _e477, vec3(_e478)) * _e482) + vec3((_e484 * _e486)));
let _e490 = prefiltered;
let _e491 = single_1;
specular_1 = (_e490 * _e491);
let _e493 = EnergyCompensation_u0028_();
if _e493 {
let _e495 = ab_4[0u];
let _e497 = ab_4[1u];
missed = (1f - (_e495 + _e497));
let _e500 = f0_4;
let _e501 = f0_4;
average_2 = (_e500 + ((vec3<f32>(1f, 1f, 1f) - _e501) / vec3(21f)));
let _e506 = single_1;
let _e507 = average_2;
let _e509 = missed;
let _e510 = average_2;
multiple = ((_e506 * _e507) / (vec3<f32>(1f, 1f, 1f) - (_e510 * _e509)));
let _e514 = multiple;
let _e515 = missed;
let _e517 = irradiance;
let _e519 = specular_1;
specular_1 = (_e519 + ((_e514 * _e515) * _e517));
}
let _e521 = diffuseColor_1;
let _e522 = irradiance;
let _e524 = specular_1;
let _e528 = frag_info.material[2u];
let _e531 = s_20.occlusion;
ambient = ((((_e521 * _e522) + _e524) * _e528) * _e531);
let _e533 = g_f0_dielectric;
let _e534 = g_irid_fresnel;
let _e535 = g_iridescence;
let _e539 = ab_4[0u];
let _e541 = g_f90_;
let _e543 = ab_4[1u];
reflects = ((mix(_e533, _e534, vec3(_e535)) * _e539) + vec3((_e541 * _e543)));
let _e547 = SceneColourBound_u0028_();
let _e548 = g_pane;
if (_e547 || _e548) {
local_59 = vec3<f32>(0f, 0f, 0f);
} else {
let _e550 = s_20;
param_269 = _e550;
let _e551 = levels_1;
param_270 = _e551;
let _e552 = 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_269), (¶m_270));
let _e553 = g_transmittance;
let _e555 = reflects;
local_59 = ((_e552 * _e553) * (vec3<f32>(1f, 1f, 1f) - min(_e555, vec3<f32>(1f, 1f, 1f))));
}
let _e559 = local_59;
through_1 = _e559;
let _e560 = diffuseColor_1;
let _e561 = through_1;
let _e562 = irradiance;
let _e565 = g_transmission;
let _e569 = frag_info.material[2u];
let _e572 = s_20.occlusion;
let _e574 = ambient;
ambient = (_e574 + ((((_e560 * (_e561 - _e562)) * _e565) * _e569) * _e572));
let _e577 = s_20.v;
let _e579 = g_coat_n;
let _e581 = g_coat_roughness;
let _e582 = levels_1;
let _e584 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e577), _e579), (_e581 * _e582));
coatPrefiltered = _e584.xyz;
let _e586 = g_coat_roughness;
param_271 = _e586;
let _e587 = g_coat_n_dot_v;
param_272 = _e587;
let _e588 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_271), (¶m_272));
coatAb = _e588;
let _e589 = coatPrefiltered;
let _e591 = coatAb[0u];
let _e594 = coatAb[1u];
let _e597 = g_coat;
let _e601 = frag_info.material[2u];
let _e604 = s_20.occlusion;
coatAmbient = ((((_e589 * ((0.04f * _e591) + _e594)) * _e597) * _e601) * _e604);
let _e607 = s_20.n;
let _e608 = g_sheen_roughness;
let _e609 = levels_1;
let _e611 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e607, (_e608 * _e609));
let _e615 = frag_info.material[2u];
sheenIncoming = (_e611.xyz * _e615);
}
let _e618 = s_20.roughness;
param_273 = _e618;
let _e620 = s_20.n_dot_v;
param_274 = _e620;
let _e621 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_273), (¶m_274));
sceneAb = _e621;
let _e622 = g_f0_dielectric;
let _e623 = g_irid_fresnel;
let _e624 = g_iridescence;
let _e628 = sceneAb[0u];
let _e630 = g_f90_;
let _e632 = sceneAb[1u];
sceneReflects = ((mix(_e622, _e623, vec3(_e624)) * _e628) + vec3((_e630 * _e632)));
let _e636 = diffuseColor_1;
let _e637 = g_transmittance;
let _e639 = sceneReflects;
let _e643 = g_transmission;
passes = (((_e636 * _e637) * (vec3<f32>(1f, 1f, 1f) - min(_e639, vec3<f32>(1f, 1f, 1f)))) * _e643);
let _e645 = g_pane;
if _e645 {
let _e647 = passes[0u];
let _e649 = passes[1u];
let _e652 = passes[2u];
g_pass_through = clamp((((_e647 + _e649) + _e652) / 3f), 0f, 1f);
} else {
let _e656 = SceneColourBound_u0028_();
if _e656 {
let _e657 = s_20;
param_275 = _e657;
let _e658 = 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_275));
let _e659 = passes;
let _e661 = ambient;
ambient = (_e661 + (_e658 * _e659));
}
}
let _e663 = diffuseColor_1;
let _e664 = SampleLightmap_u0028_();
let _e667 = s_20.occlusion;
let _e669 = ambient;
ambient = (_e669 + ((_e663 * _e664) * _e667));
let _e671 = g_sheen;
let _e672 = g_sheen_albedo;
let _e674 = sheenIncoming;
let _e677 = s_20.occlusion;
sheenAmbient = (((_e671 * _e672) * _e674) * _e677);
let _e679 = s_20;
param_276 = _e679;
let _e680 = 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_276));
let _e682 = s_20.occlusion;
let _e684 = ambient;
let _e685 = g_sheen_scale;
let _e687 = sheenAmbient;
let _e690 = s_20.emissive;
let _e692 = g_coat_through;
let _e695 = coatAmbient;
lit_3 = (((_e680 * _e682) + ((((_e684 * _e685) + _e687) + _e690) * _e692)) + _e695);
let _e697 = s_20;
param_277 = _e697;
let _e698 = lit_3;
param_278 = _e698;
let _e699 = WriteDebugView_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_vf3_u003b((¶m_277), (¶m_278));
if _e699 {
return;
}
let _e700 = lit_3;
param_279 = _e700;
let _e702 = s_20.alpha;
param_280 = _e702;
let _e704 = s_20.roughness;
param_281 = _e704;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_279), (¶m_280), (¶m_281));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(5) 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_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e216 = v_world_position_1;
let _e218 = fog_info.eye;
let _e222 = fog_info.forward;
return dot((_e216 - _e218.xyz), _e222.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e221 = ViewDepth_u0028_();
z = abs(_e221);
let _e223 = z;
near = (_e223 / 5f);
let _e225 = z;
far = (_e225 / 200f);
let _e227 = far;
let _e228 = far;
let _e230 = far;
far3_ = ((_e227 * _e228) * _e230);
let _e232 = (*alpha);
let _e233 = near;
let _e234 = near;
let _e237 = far3_;
let _e238 = far3_;
return (_e232 * clamp((10f / ((0.00001f + (_e233 * _e234)) + (_e237 * _e238))), 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 _e225 = fog_info.forward[3u];
mode = _e225;
let _e226 = mode;
if (_e226 > 0.5f) {
let _e229 = frag_color[3u];
alpha_1 = _e229;
let _e230 = alpha_1;
param = _e230;
let _e231 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e231;
let _e232 = frag_color;
let _e234 = weight;
let _e235 = (_e232.xyz * _e234);
let _e236 = alpha_1;
let _e237 = weight;
accumulate = vec4<f32>(_e235.x, _e235.y, _e235.z, (_e236 * _e237));
let _e243 = mode;
let _e245 = mode;
revealage = ((_e243 > 1.5f) && (_e245 < 2.5f));
let _e248 = revealage;
if _e248 {
let _e249 = alpha_1;
local = vec4(_e249);
} else {
let _e251 = accumulate;
local = _e251;
}
let _e252 = local;
frag_color = _e252;
let _e253 = mode;
if (_e253 > 2.5f) {
let _e255 = alpha_1;
frag_surface = vec4(_e255);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e219 = (*n)[0u];
let _e222 = (*n)[1u];
let _e226 = (*n)[2u];
let _e229 = (*n);
(*n) = (_e229 / vec3(((abs(_e219) + abs(_e222)) + abs(_e226))));
let _e232 = (*n);
e = _e232.xy;
let _e235 = (*n)[2u];
if (_e235 < 0f) {
let _e237 = (*n);
let _e243 = (*n)[0u];
let _e247 = (*n)[1u];
e = ((vec2(1f) - abs(_e237.yx)) * vec2<f32>(select(-1f, 1f, (_e243 >= 0f)), select(-1f, 1f, (_e247 >= 0f))));
}
let _e252 = e;
return ((_e252 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e217 = (*linear);
let _e219 = (*linear);
let _e223 = (*linear);
return mix((_e217 * 12.92f), ((pow(_e219, 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), _e223));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e220 = g_albedo;
param_1 = clamp(_e220, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e222 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e222.x, _e222.y, _e222.z, 1f);
let _e227 = g_debug_surface_on;
if _e227 {
let _e228 = g_debug_surface;
let _e229 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e228.x, _e228.y, _e228.z, _e229);
return;
}
let _e234 = v_normal_1;
geometric = normalize(_e234);
let _e236 = gl_FrontFacing_1;
if !(_e236) {
let _e238 = geometric;
geometric = -(_e238);
}
let _e240 = geometric;
param_2 = _e240;
let _e241 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e242 = (*roughness);
let _e244 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e241.x, _e241.y, clamp(_e242, 0f, 1f), _e244);
return;
}
fn Orthographic_u0028_() -> bool {
let _e218 = fog_info.projection[0u];
return (_e218 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e217 = Orthographic_u0028_();
if _e217 {
let _e218 = ViewDepth_u0028_();
local_1 = max(_e218, 0f);
} else {
let _e220 = v_world_position_1;
let _e222 = fog_info.eye;
local_1 = distance(_e220, _e222.xyz);
}
let _e225 = local_1;
return _e225;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e224 = fog_info.fog[3u];
density = _e224;
let _e225 = density;
if (_e225 <= 0f) {
let _e227 = (*color);
return _e227;
}
let _e228 = EyeDistance_u0028_();
d = _e228;
let _e231 = fog_info.eye[3u];
falloff = _e231;
let _e232 = falloff;
if (_e232 > 0f) {
let _e234 = falloff;
let _e236 = v_world_position_1[1u];
let _e239 = fog_info.eye[1u];
k = (_e234 * (_e236 - _e239));
let _e242 = k;
if (abs(_e242) > 0.001f) {
let _e245 = k;
let _e249 = k;
local_2 = ((1f - exp(-(_e245))) / _e249);
} else {
let _e251 = k;
local_2 = (1f - (0.5f * _e251));
}
let _e254 = local_2;
let _e255 = density;
density = (_e255 * _e254);
}
let _e258 = fog_info.fog;
let _e260 = (*color);
let _e261 = density;
let _e263 = d;
return mix(_e258.xyz, _e260, vec3(clamp(exp((-(_e261) * _e263)), 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 _e222 = g_premultiply;
let _e223 = (*alpha_2);
weight_1 = select(1f, _e223, _e222);
let _e225 = (*linearColor);
param_3 = _e225;
let _e226 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e227 = weight_1;
let _e228 = (_e226 * _e227);
let _e229 = (*alpha_2);
let _e230 = g_pass_through;
frag_color = vec4<f32>(_e228.x, _e228.y, _e228.z, (_e229 * (1f - _e230)));
let _e237 = (*roughness_1);
param_4 = _e237;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e217 = (*srgb);
let _e220 = (*srgb);
let _e225 = (*srgb);
return mix((_e217 / vec3(12.92f)), pow(((_e220 + 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), _e225));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e219 = (*key);
hue = fract(((_e219 * 0.618034f) + 0.13f));
let _e223 = hue;
k_1 = clamp((abs(((fract((vec3(_e223) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e236 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e236, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2639_: bool;
let _e217 = (*c);
let _e218 = (*c);
let _e220 = any((_e217 != _e218));
phi_2639_ = _e220;
if !(_e220) {
let _e222 = (*c);
phi_2639_ = any((abs(_e222) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e227 = phi_2639_;
return _e227;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2729_: bool;
var phi_2997_: bool;
let _e259 = gl_FragCoord_1[0u];
let _e262 = frag_info.debug_view[1u];
if (_e259 < _e262) {
let _e266 = frag_info.debug_view[2u];
local_3 = _e266;
} else {
let _e269 = frag_info.debug_view[0u];
local_3 = _e269;
}
let _e270 = local_3;
view = _e270;
let _e271 = view;
if (_e271 < 0.5f) {
return false;
}
let _e273 = view;
code = i32((_e273 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e276 = v_normal_1;
geometric_n = normalize(_e276);
let _e278 = v_tangent_1;
let _e280 = geometric_n;
let _e281 = geometric_n;
let _e282 = v_tangent_1;
tangent = (_e278.xyz - (_e280 * dot(_e281, _e282.xyz)));
let _e287 = tangent;
let _e288 = tangent;
let _e290 = (dot(_e287, _e288) > 0.000000000001f);
phi_2729_ = _e290;
if _e290 {
let _e292 = v_tangent_1[3u];
phi_2729_ = (abs((abs(_e292) - 1f)) < 0.01f);
}
let _e298 = phi_2729_;
tangent_usable = _e298;
let _e301 = frag_info.debug_view[3u];
identity = _e301;
let _e302 = identity;
identity_object = floor((_e302 / 8192f));
let _e305 = identity;
let _e306 = identity_object;
identity_rest = (_e305 - (_e306 * 8192f));
let _e309 = identity_rest;
identity_material = floor((_e309 / 2f));
let _e312 = identity_rest;
let _e313 = identity_material;
normal_mapped = ((_e312 - (_e313 * 2f)) > 0.5f);
let _e317 = code;
if (_e317 == 1i) {
let _e320 = (*s).albedo;
param_5 = clamp(_e320, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e322 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e322;
} else {
let _e323 = code;
if (_e323 == 2i) {
let _e326 = (*s).n;
shown = ((_e326 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e329 = code;
if (_e329 == 3i) {
let _e332 = (*s).roughness;
shown = vec3(clamp(_e332, 0f, 1f));
} else {
let _e335 = code;
if (_e335 == 4i) {
let _e338 = (*s).metallic;
shown = vec3(clamp(_e338, 0f, 1f));
} else {
let _e341 = code;
if (_e341 == 5i) {
let _e344 = (*s).occlusion;
shown = vec3(clamp(_e344, 0f, 1f));
} else {
let _e347 = code;
if (_e347 == 6i) {
let _e350 = (*s).emissive;
param_6 = clamp(_e350, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e352 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e352;
} else {
let _e353 = code;
if (_e353 == 7i) {
let _e355 = v_texcoord_1;
let _e356 = fract(_e355);
shown = vec3<f32>(_e356.x, _e356.y, 0f);
} else {
let _e360 = code;
if (_e360 == 8i) {
let _e362 = (*lit);
param_7 = clamp(_e362, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e364 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e364, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e366 = (*lit);
param_8 = _e366;
let _e367 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e367 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e368 = grey;
local_4 = vec3((_e368 * 0.5f));
}
let _e371 = local_4;
shown = _e371;
} else {
let _e372 = code;
if (_e372 == 9i) {
let _e374 = tangent_usable;
if _e374 {
let _e375 = tangent;
local_5 = ((normalize(_e375) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e379 = local_5;
shown = _e379;
} else {
let _e380 = code;
if (_e380 == 10i) {
let _e382 = v_texcoord_1;
uv = _e382;
let _e383 = uv;
cell = floor((_e383 * 8f));
let _e387 = cell[0u];
let _e389 = cell[1u];
odd = (fract(((_e387 + _e389) * 0.5f)) * 2f);
let _e394 = uv;
within = fract(_e394);
let _e396 = odd;
let _e400 = within[0u];
let _e404 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e396)) * vec3<f32>((0.55f + (0.45f * _e400)), (0.55f + (0.45f * _e404)), 0.85f));
} else {
let _e409 = code;
if (_e409 == 11i) {
let _e411 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e411));
} else {
let _e414 = code;
if (_e414 == 12i) {
let _e416 = v_color_1;
param_9 = clamp(_e416.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e419 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e419;
} else {
let _e420 = code;
let _e422 = code;
if ((_e420 == 13i) || (_e422 == 14i)) {
let _e425 = code;
let _e427 = identity_object;
let _e428 = identity_material;
key_1 = select(_e428, _e427, (_e425 == 13i));
let _e430 = key_1;
param_10 = _e430;
let _e431 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e433 = (*s).n_dot_v;
shown = (_e431 * (0.55f + (0.45f * _e433)));
} else {
let _e437 = code;
if (_e437 == 15i) {
let _e440 = (*s).albedo;
param_11 = clamp(_e440, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e442 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e442;
let _e443 = srgb_1;
luma = dot(_e443, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e446 = (*s).metallic;
metal = (_e446 > 0.5f);
let _e448 = metal;
let _e450 = luma;
if (!(_e448) && (_e450 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e453 = metal;
let _e454 = !(_e453);
phi_2997_ = _e454;
if _e454 {
let _e456 = srgb_1[0u];
let _e458 = srgb_1[1u];
let _e460 = srgb_1[2u];
phi_2997_ = (max(_e456, max(_e458, _e460)) > 0.9411765f);
}
let _e465 = phi_2997_;
if _e465 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e466 = metal;
let _e467 = luma;
if (_e466 && (_e467 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e470 = luma;
local_8 = vec3(_e470);
}
let _e472 = local_8;
local_7 = _e472;
}
let _e473 = local_7;
local_6 = _e473;
}
let _e474 = local_6;
shown = _e474;
} else {
let _e475 = code;
if (_e475 == 16i) {
let _e478 = (*s).metallic;
m = _e478;
let _e479 = m;
let _e481 = m;
if ((_e479 > 0.05f) && (_e481 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e484 = m;
local_9 = vec3(select(0.15f, 1f, (_e484 > 0.5f)));
}
let _e488 = local_9;
shown = _e488;
} else {
let _e489 = code;
if (_e489 == 17i) {
let _e491 = normal_mapped;
if !(_e491) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e493 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e493));
}
let _e496 = local_10;
shown = _e496;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e497 = g_premultiply;
if _e497 {
let _e499 = (*s).alpha;
local_11 = _e499;
} else {
local_11 = 1f;
}
let _e500 = local_11;
weight_2 = _e500;
let _e501 = shown;
param_12 = _e501;
let _e502 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e503 = weight_2;
let _e504 = (_e502 * _e503);
let _e506 = (*s).alpha;
frag_color = vec4<f32>(_e504.x, _e504.y, _e504.z, _e506);
let _e512 = (*s).roughness;
param_13 = _e512;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var bands: f32;
var quantized: f32;
var fraction: f32;
var ramp: f32;
let _e223 = (*s_1).roughness;
bands = mix(5f, 2f, _e223);
let _e226 = (*light).n_dot_l;
let _e227 = bands;
let _e230 = bands;
quantized = (floor((_e226 * _e227)) / _e230);
let _e233 = (*light).n_dot_l;
let _e234 = bands;
fraction = fract((_e233 * _e234));
let _e237 = fraction;
let _e239 = bands;
let _e241 = quantized;
quantized = (_e241 + (smoothstep(0.85f, 1f, _e237) / _e239));
let _e243 = quantized;
let _e245 = (*light).n_dot_l;
ramp = (_e243 / max(_e245, 0.001f));
let _e249 = (*s_1).albedo;
let _e250 = ramp;
return (_e249 * _e250);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e217 = (*i);
if (_e217 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e219 = (*i);
if (_e219 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e221 = (*i);
if (_e221 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e223 = (*i);
if (_e223 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e225 = (*i);
if (_e225 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e227 = (*i);
if (_e227 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e229 = (*i);
if (_e229 == 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_14: i32;
let _e222 = (*i_1);
param_14 = _e222;
let _e223 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e223;
let _e225 = p[0u];
let _e226 = (*ca);
let _e229 = p[1u];
let _e230 = (*sa);
let _e234 = p[0u];
let _e235 = (*sa);
let _e238 = p[1u];
let _e239 = (*ca);
let _e243 = (*radius);
return (vec2<f32>(((_e225 * _e226) - (_e229 * _e230)), ((_e234 * _e235) + (_e238 * _e239))) * _e243);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e225 = point_shadow.params[0u];
inset = _e225;
let _e226 = (*uv_1);
let _e227 = (*offset);
let _e229 = inset;
let _e230 = inset;
local_12 = clamp((_e226 + _e227), vec2(_e229), vec2((1f - _e230)));
let _e235 = local_12;
let _e236 = (*tile);
atlas = ((_e235 + _e236) * vec2<f32>(0.16666667f, 0.16666667f));
let _e241 = point_shadow.params3_[0u];
if (_e241 > 0.5f) {
let _e244 = atlas[1u];
atlas[1u] = (1f - _e244);
}
let _e247 = atlas;
let _e248 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e247, 0f);
let _e250 = atlas;
let _e251 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e250, 0f);
let _e254 = (*range);
return (min(_e248.x, _e251.x) * _e254);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e226 = (*uv_2);
param_15 = _e226;
let _e227 = (*offset_1);
param_16 = _e227;
let _e228 = (*tile_1);
param_17 = _e228;
let _e229 = (*range_1);
param_18 = _e229;
let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e230;
let _e231 = stored;
let _e232 = (*range_1);
if (_e231 >= (_e232 * 0.999f)) {
return 1f;
}
let _e235 = (*receiver);
let _e236 = stored;
return select(1f, 0f, (_e235 > _e236));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e247 = point_shadow.params2_[1u];
lightRadius = _e247;
let _e250 = point_shadow.params2_[0u];
minRadius = _e250;
let _e253 = point_shadow.params2_[2u];
maxRadius = _e253;
let _e254 = lightRadius;
if (_e254 <= 0f) {
let _e256 = (*uv_3);
param_19 = _e256;
param_20 = vec2<f32>(0f, 0f);
let _e257 = (*tile_2);
param_21 = _e257;
let _e258 = (*range_2);
param_22 = _e258;
let _e259 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e259;
let _e260 = minRadius;
return _e260;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e261 = i_2;
if (_e261 < 8i) {
let _e263 = i_2;
param_23 = _e263;
let _e264 = (*ca_1);
param_24 = _e264;
let _e265 = (*sa_1);
param_25 = _e265;
let _e266 = maxRadius;
param_26 = _e266;
let _e267 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e268 = (*uv_3);
param_27 = _e268;
param_28 = _e267;
let _e269 = (*tile_2);
param_29 = _e269;
let _e270 = (*range_2);
param_30 = _e270;
let _e271 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e271;
let _e272 = stored_1;
let _e273 = (*range_2);
if (_e272 >= (_e273 * 0.999f)) {
continue;
}
let _e276 = stored_1;
let _e277 = (*receiver_1);
if (_e276 >= _e277) {
continue;
}
let _e279 = stored_1;
let _e280 = sum;
sum = (_e280 + _e279);
let _e282 = count;
count = (_e282 + 1f);
continue;
} else {
break;
}
continuing {
let _e284 = i_2;
i_2 = (_e284 + 1i);
}
}
let _e286 = count;
if (_e286 < 0.5f) {
return -1f;
}
let _e288 = sum;
let _e289 = count;
blocker = max((_e288 / _e289), 0.0001f);
let _e292 = blocker;
(*blockerOut) = _e292;
let _e293 = lightRadius;
let _e294 = (*receiver_1);
let _e295 = blocker;
let _e299 = blocker;
world = ((_e293 * max((_e294 - _e295), 0f)) / _e299);
let _e301 = world;
let _e302 = (*receiver_1);
let _e304 = (*tanHalf);
let _e307 = minRadius;
let _e308 = maxRadius;
return clamp((_e301 / ((2f * _e302) * _e304)), _e307, _e308);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e218 = (*rows);
if (_e218 > 0f) {
let _e221 = gl_FragCoord_1[0u];
let _e222 = (*rows);
let _e224 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e221, (_e222 - _e224));
} else {
let _e227 = gl_FragCoord_1;
local_13 = _e227.xy;
}
let _e229 = local_13;
return _e229;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2326_: bool;
var phi_2387_: bool;
let _e270 = (*lightIndex);
let _e274 = point_shadow.slots[_e270][0u];
slot = i32((_e274 + 0.5f));
let _e277 = (*lightIndex);
let _e281 = point_shadow.slots[_e277][0u];
if (_e281 < 0f) {
return 1f;
}
let _e285 = point_shadow.params[2u];
strength = _e285;
let _e286 = strength;
if (_e286 <= 0f) {
return 1f;
}
let _e288 = slot;
let _e291 = point_shadow.lights[_e288];
let _e293 = (*world_1);
toLight = (_e291.xyz - _e293);
let _e295 = toLight;
toLightLength = max(length(_e295), 0.000001f);
let _e298 = (*normal);
let _e299 = toLight;
let _e300 = toLightLength;
nDotL = max(dot(_e298, (_e299 / vec3(_e300))), 0.15f);
let _e305 = nDotL;
let _e306 = nDotL;
let _e311 = nDotL;
let _e312 = nDotL;
slope = min((sqrt(max((1f - (_e305 * _e306)), 0f)) / (_e311 * _e312)), 8f);
let _e316 = toLightLength;
let _e318 = (*lightIndex);
let _e322 = point_shadow.slots[_e318][2u];
let _e327 = point_shadow.params3_[1u];
texel = (((2f * _e316) * max(_e322, 0.0001f)) * _e327);
let _e329 = (*world_1);
let _e330 = (*normal);
let _e331 = texel;
let _e335 = point_shadow.params[3u];
let _e337 = slope;
origin = (_e329 + (((_e330 * _e331) * _e335) * (1f + _e337)));
let _e341 = origin;
let _e342 = slot;
let _e345 = point_shadow.lights[_e342];
toFragment = (_e341 - _e345.xyz);
let _e348 = toFragment;
distance_ = length(_e348);
let _e350 = slot;
let _e354 = point_shadow.lights[_e350][3u];
range_3 = max(_e354, 0.0001f);
let _e356 = distance_;
let _e357 = range_3;
if (_e356 >= _e357) {
return 1f;
}
face = 0i;
let _e359 = (*lightIndex);
let _e363 = point_shadow.slots[_e359][1u];
if (_e363 < 0.5f) {
let _e365 = toFragment;
a = abs(_e365);
let _e368 = a[0u];
let _e370 = a[1u];
let _e371 = (_e368 >= _e370);
phi_2326_ = _e371;
if _e371 {
let _e373 = a[0u];
let _e375 = a[2u];
phi_2326_ = (_e373 >= _e375);
}
let _e378 = phi_2326_;
if _e378 {
let _e380 = toFragment[0u];
face = select(1i, 0i, (_e380 > 0f));
} else {
let _e384 = a[1u];
let _e386 = a[2u];
if (_e384 >= _e386) {
let _e389 = toFragment[1u];
face = select(3i, 2i, (_e389 > 0f));
} else {
let _e393 = toFragment[2u];
face = select(5i, 4i, (_e393 > 0f));
}
}
}
let _e396 = slot;
let _e398 = face;
let _e402 = point_shadow.faces[((_e396 * 6i) + _e398)];
let _e403 = origin;
clip = (_e402 * vec4<f32>(_e403.x, _e403.y, _e403.z, 1f));
let _e410 = clip[3u];
if (_e410 <= 0f) {
return 1f;
}
let _e412 = clip;
let _e415 = clip[3u];
ndc = (_e412.xy / vec2(_e415));
let _e419 = ndc[0u];
let _e421 = (abs(_e419) > 1f);
phi_2387_ = _e421;
if !(_e421) {
let _e424 = ndc[1u];
phi_2387_ = (abs(_e424) > 1f);
}
let _e428 = phi_2387_;
if _e428 {
return 1f;
}
let _e430 = ndc[0u];
let _e434 = ndc[1u];
uv_4 = vec2<f32>(((_e430 * 0.5f) + 0.5f), (0.5f - (_e434 * 0.5f)));
let _e438 = face;
let _e440 = slot;
tile_3 = vec2<f32>(f32(_e438), f32(_e440));
let _e443 = distance_;
let _e446 = point_shadow.params[1u];
receiver_2 = (_e443 - _e446);
let _e450 = frag_info.target_origin[0u];
param_31 = _e450;
let _e451 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e451, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e456 = noise;
angle = (_e456 * 6.2831855f);
let _e458 = angle;
ca_2 = cos(_e458);
let _e460 = angle;
sa_2 = sin(_e460);
let _e462 = (*lightIndex);
let _e466 = point_shadow.slots[_e462][2u];
tanHalf_1 = max(_e466, 0.0001f);
blocker_1 = -1f;
let _e468 = uv_4;
param_32 = _e468;
let _e469 = tile_3;
param_33 = _e469;
let _e470 = range_3;
param_34 = _e470;
let _e471 = receiver_2;
param_35 = _e471;
let _e472 = ca_2;
param_36 = _e472;
let _e473 = sa_2;
param_37 = _e473;
let _e474 = tanHalf_1;
param_38 = _e474;
let _e475 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e476 = param_39;
blocker_1 = _e476;
radius_1 = _e475;
let _e479 = point_shadow.params2_[3u];
if (_e479 > 0.5f) {
g_debug_surface_on = true;
let _e481 = radius_1;
if (_e481 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e483 = radius_1;
let _e486 = point_shadow.params2_[2u];
let _e490 = blocker_1;
let _e491 = range_3;
local_14 = vec3<f32>(clamp((_e483 / max(_e486, 0.000001f)), 0f, 1f), clamp((_e490 / _e491), 0f, 1f), 0f);
}
let _e495 = local_14;
g_debug_surface = _e495;
}
let _e496 = radius_1;
if (_e496 < 0f) {
return 1f;
}
let _e498 = uv_4;
param_40 = _e498;
param_41 = vec2<f32>(0f, 0f);
let _e499 = tile_3;
param_42 = _e499;
let _e500 = range_3;
param_43 = _e500;
let _e501 = receiver_2;
param_44 = _e501;
let _e502 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e502;
let _e503 = radius_1;
if (_e503 > 0f) {
i_3 = 0i;
loop {
let _e505 = i_3;
if (_e505 < 8i) {
let _e507 = i_3;
param_45 = _e507;
let _e508 = ca_2;
param_46 = _e508;
let _e509 = sa_2;
param_47 = _e509;
let _e510 = radius_1;
param_48 = _e510;
let _e511 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e512 = uv_4;
param_49 = _e512;
param_50 = _e511;
let _e513 = tile_3;
param_51 = _e513;
let _e514 = range_3;
param_52 = _e514;
let _e515 = receiver_2;
param_53 = _e515;
let _e516 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e517 = lit_1;
lit_1 = (_e517 + _e516);
continue;
} else {
break;
}
continuing {
let _e519 = i_3;
i_3 = (_e519 + 1i);
}
}
let _e521 = lit_1;
lit_1 = (_e521 * 0.11111111f);
}
let _e523 = lit_1;
let _e524 = strength;
return mix(1f, _e523, clamp(_e524, 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 _e221 = (*i_4);
let _e224 = (*n_1);
r = sqrt(((f32(_e221) + 0.5f) / f32(_e224)));
let _e228 = (*i_4);
let _e231 = (*turn);
theta = ((f32(_e228) * 2.3999631f) + _e231);
let _e233 = r;
let _e234 = theta;
let _e236 = theta;
return (vec2<f32>(cos(_e234), sin(_e236)) * _e233);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e220 = frag_info.target_origin[0u];
param_54 = _e220;
let _e221 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e224 = frag_info.target_origin[3u];
at = (_e221 + vec2((5.588238f * max(_e224, 0f))));
let _e229 = at;
return fract((52.982918f * fract(dot(_e229, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e219 = (*mode_1);
if (_e219 > 0.5f) {
let _e221 = (*stored_2);
local_15 = (1f - _e221);
} else {
let _e223 = (*stored_2);
local_15 = _e223;
}
let _e224 = local_15;
return _e224;
}
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 _e225 = (*moments)[1u];
let _e227 = (*moments)[0u];
let _e229 = (*moments)[0u];
let _e232 = (*minVariance);
variance = max((_e225 - (_e227 * _e229)), _e232);
let _e234 = (*t);
let _e236 = (*moments)[0u];
d_1 = (_e234 - _e236);
let _e238 = variance;
let _e239 = variance;
let _e240 = d_1;
let _e241 = d_1;
pMax = (_e238 / (_e239 + (_e240 * _e241)));
let _e245 = pMax;
let _e246 = (*bleed);
let _e248 = (*bleed);
reduced = clamp(((_e245 - _e246) / max((1f - _e248), 0.0001f)), 0f, 1f);
let _e253 = (*t);
let _e255 = (*moments)[0u];
let _e257 = reduced;
return select(_e257, 1f, (_e253 <= _e255));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e218 = (*depth);
d_2 = ((2f * clamp(_e218, 0f, 1f)) - 1f);
let _e222 = d_2;
let _e225 = d_2;
return vec2<f32>(exp((40f * _e222)), -(exp((-5f * _e225))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e232 = (*depth_1);
param_55 = _e232;
let _e233 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e233;
let _e234 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e234);
let _e237 = scale[0u];
let _e239 = scale[0u];
let _e241 = (*moments_1);
param_56 = _e241.xy;
let _e244 = warped[0u];
param_57 = _e244;
param_58 = (_e237 * _e239);
let _e245 = (*bleed_1);
param_59 = _e245;
let _e246 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e246;
let _e248 = scale[1u];
let _e250 = scale[1u];
let _e252 = (*moments_1);
param_60 = _e252.zw;
let _e255 = warped[1u];
param_61 = _e255;
param_62 = (_e248 * _e250);
let _e256 = (*bleed_1);
param_63 = _e256;
let _e257 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e257;
let _e258 = positive;
let _e259 = negative;
return min(_e258, _e259);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e218 = (*depth_2);
stored_3 = max((1f - _e218), 0.000061035156f);
let _e221 = stored_3;
return exp2((floor(log2(_e221)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3936_: bool;
var phi_3947_: bool;
var phi_4104_: bool;
var phi_4111_: bool;
var phi_4118_: bool;
let _e295 = frag_info.shadow_params[3u];
strength_1 = _e295;
let _e296 = strength_1;
if (_e296 <= 0f) {
return 1f;
}
let _e298 = (*lightIndex_1);
let _e301 = frag_info.frame_params[2u];
if (_e298 != i32(floor((_e301 + 0.5f)))) {
return 1f;
}
let _e308 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e308 + 0.5f));
let _e311 = Orthographic_u0028_();
if _e311 {
let _e312 = ViewDepth_u0028_();
local_16 = _e312;
} else {
let _e313 = v_world_position_1;
let _e315 = frag_info.camera_position;
local_16 = length((_e313 - _e315.xyz));
}
let _e319 = local_16;
viewDistance = _e319;
cascade = 0i;
let _e320 = cascadeCount;
let _e321 = (_e320 > 1i);
phi_3936_ = _e321;
if _e321 {
let _e322 = viewDistance;
let _e325 = frag_info.shadow_cascades[0u];
phi_3936_ = (_e322 > _e325);
}
let _e328 = phi_3936_;
if _e328 {
cascade = 1i;
}
let _e329 = cascadeCount;
let _e330 = (_e329 > 2i);
phi_3947_ = _e330;
if _e330 {
let _e331 = viewDistance;
let _e334 = frag_info.shadow_cascades[1u];
phi_3947_ = (_e331 > _e334);
}
let _e337 = phi_3947_;
if _e337 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e338 = attempt;
if (_e338 < 3i) {
let _e340 = cascade;
let _e341 = attempt;
which = (_e340 + _e341);
let _e343 = which;
let _e344 = cascadeCount;
if (_e343 >= _e344) {
break;
}
let _e346 = which;
if (_e346 == 0i) {
let _e349 = frag_info.shadow_matrix;
local_17 = _e349;
} else {
let _e350 = which;
if (_e350 == 1i) {
let _e353 = frag_info.shadow_matrix_far;
local_18 = _e353;
} else {
let _e355 = frag_info.shadow_matrix_farthest;
local_18 = _e355;
}
let _e356 = local_18;
local_17 = _e356;
}
let _e357 = local_17;
matrix = _e357;
let _e360 = matrix[0][0u];
let _e363 = matrix[1][0u];
let _e366 = matrix[2][0u];
axisX = vec3<f32>(_e360, _e363, _e366);
let _e370 = matrix[0][1u];
let _e373 = matrix[1][1u];
let _e376 = matrix[2][1u];
axisY = vec3<f32>(_e370, _e373, _e376);
let _e378 = axisX;
rowX = max(length(_e378), 0.000001f);
let _e381 = axisY;
rowY = max(length(_e381), 0.000001f);
let _e386 = frag_info.shadow_cascades[3u];
let _e388 = rowX;
texelMetres = ((2f * _e386) / _e388);
let _e392 = frag_info.shadow_cascades[3u];
let _e395 = (*s_2).n;
let _e396 = axisX;
let _e399 = rowX;
let _e400 = rowX;
let _e404 = (*s_2).n;
let _e405 = axisY;
let _e408 = rowY;
let _e409 = rowY;
reach = ((3f * _e392) * ((abs(dot(_e395, _e396)) / (_e399 * _e400)) + (abs(dot(_e404, _e405)) / (_e408 * _e409))));
let _e416 = frag_info.shadow_params[2u];
let _e417 = texelMetres;
flatOffset = min(_e416, _e417);
let _e419 = v_world_position_1;
let _e421 = (*s_2).n;
let _e422 = flatOffset;
let _e423 = reach;
origin_1 = (_e419 + (_e421 * (_e422 + _e423)));
let _e427 = matrix;
let _e428 = origin_1;
lightSpace = (_e427 * vec4<f32>(_e428.x, _e428.y, _e428.z, 1f));
let _e435 = lightSpace[3u];
if (_e435 <= 0f) {
continue;
}
let _e437 = lightSpace;
let _e440 = lightSpace[3u];
candidate = (_e437.xyz / vec3(_e440));
let _e444 = candidate[0u];
let _e448 = candidate[1u];
inTile = vec2<f32>(((_e444 * 0.5f) + 0.5f), (0.5f - (_e448 * 0.5f)));
let _e453 = inTile[0u];
let _e454 = (_e453 < 0f);
phi_4104_ = _e454;
if !(_e454) {
let _e457 = inTile[0u];
phi_4104_ = (_e457 > 1f);
}
let _e460 = phi_4104_;
phi_4111_ = _e460;
if !(_e460) {
let _e463 = inTile[1u];
phi_4111_ = (_e463 < 0f);
}
let _e466 = phi_4111_;
phi_4118_ = _e466;
if !(_e466) {
let _e469 = inTile[1u];
phi_4118_ = (_e469 > 1f);
}
let _e472 = phi_4118_;
if _e472 {
continue;
}
let _e474 = candidate[2u];
if (_e474 > 1f) {
let _e476 = which;
let _e477 = cascadeCount;
if (_e476 < (_e477 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e482 = inTile[0u];
let _e483 = which;
let _e486 = cascadeCount;
let _e490 = inTile[1u];
uv_5 = vec2<f32>(((_e482 + f32(_e483)) / f32(_e486)), _e490);
let _e492 = candidate;
projected = _e492;
let _e493 = which;
cascade = _e493;
let _e494 = texelMetres;
cascadeTexel = _e494;
let _e497 = matrix[0][2u];
let _e500 = matrix[1][2u];
let _e503 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e497, _e500, _e503)), 0.000001f));
let _e509 = (*s_2).n;
let _e512 = matrix[0][2u];
let _e515 = matrix[1][2u];
let _e518 = matrix[2][2u];
let _e522 = cascadeDepth;
cosSlope = clamp((abs(dot(_e509, vec3<f32>(_e512, _e515, _e518))) * _e522), 0.1f, 1f);
let _e525 = texelMetres;
let _e526 = cosSlope;
let _e527 = cosSlope;
let _e533 = cosSlope;
let _e535 = cascadeDepth;
receiverSlope = (((_e525 * sqrt(max((1f - (_e526 * _e527)), 0f))) / _e533) / _e535);
found = true;
break;
} else {
break;
}
continuing {
let _e537 = attempt;
attempt = (_e537 + 1i);
}
}
let _e539 = found;
if !(_e539) {
return 1f;
}
let _e541 = cascade;
if (_e541 == 0i) {
let _e545 = frag_info.shadow_bias[0u];
local_19 = _e545;
} else {
let _e546 = cascade;
if (_e546 == 1i) {
let _e550 = frag_info.shadow_bias[1u];
local_20 = _e550;
} else {
let _e553 = frag_info.shadow_bias[2u];
local_20 = _e553;
}
let _e554 = local_20;
local_19 = _e554;
}
let _e555 = local_19;
bias = _e555;
let _e558 = frag_info.shadow_params[1u];
storage_ = _e558;
let _e559 = storage_;
let _e561 = storage_;
if ((_e559 > 0.5f) && (_e561 < 1.5f)) {
let _e564 = bias;
let _e566 = projected[2u];
param_64 = _e566;
let _e567 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e564, _e567);
}
let _e571 = frag_info.shadow_params[0u];
let _e574 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e571, _e574);
let _e576 = cascade;
let _e578 = cascadeCount;
let _e582 = texel_1;
tileLo = (vec2<f32>((f32(_e576) / f32(_e578)), 0f) + (_e582 * 0.5f));
let _e585 = cascade;
let _e588 = cascadeCount;
let _e592 = texel_1;
tileHi = (vec2<f32>((f32((_e585 + 1i)) / f32(_e588)), 1f) - (_e592 * 0.5f));
let _e597 = frag_info.shadow_bias[3u];
if (_e597 > 0.5f) {
let _e599 = uv_5;
let _e600 = tileLo;
let _e601 = tileHi;
let _e603 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e599, _e600, _e601), 0f);
stored_4 = _e603;
let _e605 = stored_4[1u];
let _e608 = stored_4[2u];
let _e611 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e605), (1f - _e608), _e611), vec3(0f), vec3(4f));
let _e616 = through;
let _e617 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e616, vec3(clamp(_e617, 0f, 1f)));
}
let _e623 = frag_info.ambient_ground[3u];
softness = _e623;
lit_2 = 0f;
let _e624 = softness;
if (_e624 < 0f) {
let _e626 = uv_5;
let _e627 = tileLo;
let _e628 = tileHi;
let _e630 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e626, _e627, _e628), 0f);
moments_2 = _e630;
let _e632 = projected[2u];
let _e633 = bias;
let _e635 = softness;
let _e639 = moments_2;
param_65 = _e639;
param_66 = (_e632 - _e633);
param_67 = clamp((-(_e635) - 1f), 0f, 0.95f);
let _e640 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e640;
} else {
let _e641 = softness;
if (_e641 <= 0f) {
y = -1i;
loop {
let _e643 = y;
if (_e643 <= 1i) {
x = -1i;
loop {
let _e645 = x;
if (_e645 <= 1i) {
let _e647 = uv_5;
let _e648 = x;
let _e650 = y;
let _e653 = texel_1;
let _e656 = tileLo;
let _e657 = tileHi;
let _e659 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e647 + (vec2<f32>(f32(_e648), f32(_e650)) * _e653)), _e656, _e657), 0f);
param_68 = _e659.x;
let _e661 = storage_;
param_69 = _e661;
let _e662 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e662;
let _e664 = projected[2u];
let _e665 = bias;
let _e667 = occluder;
let _e670 = lit_2;
lit_2 = (_e670 + select(1f, 0f, ((_e664 - _e665) > _e667)));
continue;
} else {
break;
}
continuing {
let _e672 = x;
x = (_e672 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e674 = y;
y = (_e674 + 1i);
}
}
let _e676 = lit_2;
lit_2 = (_e676 * 0.11111111f);
} else {
let _e678 = softness;
spread = tan(min(_e678, 0.5f));
let _e681 = ShadowNoise_u0028_();
turn_1 = (_e681 * 6.2831855f);
let _e683 = spread;
let _e685 = projected[2u];
let _e687 = cascadeDepth;
let _e689 = cascadeTexel;
searchRadius = clamp((((_e683 * _e685) * _e687) / _e689), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e692 = i_5;
if (_e692 < 16i) {
let _e694 = i_5;
param_70 = _e694;
param_71 = 16i;
let _e695 = turn_1;
param_72 = _e695;
let _e696 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e696;
let _e697 = bias;
let _e698 = disc;
let _e700 = searchRadius;
let _e704 = receiverSlope;
tapBias = (_e697 + (max(((length(_e698) * _e700) - 1.5f), 0f) * _e704));
let _e707 = uv_5;
let _e708 = disc;
let _e709 = texel_1;
let _e711 = searchRadius;
let _e714 = tileLo;
let _e715 = tileHi;
let _e717 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e707 + ((_e708 * _e709) * _e711)), _e714, _e715), 0f);
param_73 = _e717.x;
let _e719 = storage_;
param_74 = _e719;
let _e720 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e720;
let _e722 = projected[2u];
let _e723 = tapBias;
let _e725 = occluder_1;
if ((_e722 - _e723) > _e725) {
let _e727 = occluder_1;
let _e728 = blockerSum;
blockerSum = (_e728 + _e727);
let _e730 = blockerCount;
blockerCount = (_e730 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e732 = i_5;
i_5 = (_e732 + 1i);
}
}
let _e734 = blockerCount;
if (_e734 <= 0f) {
return 1f;
}
let _e737 = projected[2u];
let _e738 = blockerSum;
let _e739 = blockerCount;
let _e743 = cascadeDepth;
gap = (max((_e737 - (_e738 / _e739)), 0f) * _e743);
let _e745 = spread;
let _e746 = gap;
let _e748 = cascadeTexel;
radius_2 = clamp(((_e745 * _e746) / _e748), 1f, 16f);
i_6 = 0i;
loop {
let _e751 = i_6;
if (_e751 < 16i) {
let _e753 = turn_1;
let _e755 = i_6;
param_75 = _e755;
param_76 = 16i;
param_77 = (_e753 + 1f);
let _e756 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e756;
let _e757 = bias;
let _e758 = disc_1;
let _e760 = radius_2;
let _e764 = receiverSlope;
tapBias_1 = (_e757 + (max(((length(_e758) * _e760) - 1.5f), 0f) * _e764));
let _e767 = uv_5;
let _e768 = disc_1;
let _e769 = texel_1;
let _e771 = radius_2;
let _e774 = tileLo;
let _e775 = tileHi;
let _e777 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e767 + ((_e768 * _e769) * _e771)), _e774, _e775), 0f);
param_78 = _e777.x;
let _e779 = storage_;
param_79 = _e779;
let _e780 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e780;
let _e782 = projected[2u];
let _e783 = tapBias_1;
let _e785 = occluder_2;
let _e788 = lit_2;
lit_2 = (_e788 + select(1f, 0f, ((_e782 - _e783) > _e785)));
continue;
} else {
break;
}
continuing {
let _e790 = i_6;
i_6 = (_e790 + 1i);
}
}
let _e792 = lit_2;
lit_2 = (_e792 * 0.0625f);
}
}
let _e794 = lit_2;
let _e795 = strength_1;
return mix(1f, _e794, clamp(_e795, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e222 = (*s_3);
param_80 = _e222;
let _e223 = (*light_2);
param_81 = _e223;
let _e224 = (*index);
param_82 = _e224;
let _e225 = 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_80), (¶m_81), (¶m_82));
return _e225;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e217 = (*index_1);
return (_e217 < 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 _e221 = (*distance_1);
let _e222 = (*distance_1);
attenuation = (1f / max((_e221 * _e222), 0.0001f));
let _e226 = (*range_4);
if (_e226 > 0f) {
let _e228 = (*distance_1);
let _e229 = (*range_4);
ratio = (_e228 / _e229);
let _e231 = ratio;
let _e232 = ratio;
let _e234 = ratio;
let _e236 = ratio;
window = clamp((1f - (((_e231 * _e232) * _e234) * _e236)), 0f, 1f);
let _e240 = window;
let _e241 = window;
let _e243 = attenuation;
attenuation = (_e243 * (_e240 * _e241));
}
let _e245 = attenuation;
return _e245;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e233 = (*halfWidth);
let _e234 = (*halfHeight);
n_2 = cross(_e233, _e234);
let _e236 = n_2;
nLen = length(_e236);
let _e238 = nLen;
if (_e238 < 0.000000000001f) {
let _e240 = (*centre);
return _e240;
}
let _e241 = nLen;
let _e242 = n_2;
n_2 = (_e242 / vec3(_e241));
let _e245 = (*centre);
let _e246 = (*world_2);
toPlane = (_e245 - _e246);
let _e248 = (*mirror);
let _e249 = n_2;
denom = dot(_e248, _e249);
let _e251 = denom;
if (abs(_e251) < 0.00001f) {
let _e254 = toPlane;
let _e255 = n_2;
let _e256 = toPlane;
let _e257 = n_2;
onPlane = (_e254 - (_e255 * dot(_e256, _e257)));
} else {
let _e261 = toPlane;
let _e262 = n_2;
let _e264 = denom;
t_1 = (dot(_e261, _e262) / _e264);
let _e266 = t_1;
if (_e266 > 0f) {
let _e268 = (*mirror);
let _e269 = t_1;
local_21 = (_e268 * _e269);
} else {
let _e271 = toPlane;
let _e272 = n_2;
let _e273 = toPlane;
let _e274 = n_2;
local_21 = (_e271 - (_e272 * dot(_e273, _e274)));
}
let _e278 = local_21;
onPlane = _e278;
}
let _e279 = onPlane;
let _e280 = toPlane;
offset_2 = (_e279 - _e280);
let _e282 = (*halfWidth);
let _e283 = (*halfWidth);
wLen2_ = max(dot(_e282, _e283), 0.000000000001f);
let _e286 = (*halfHeight);
let _e287 = (*halfHeight);
hLen2_ = max(dot(_e286, _e287), 0.000000000001f);
let _e290 = offset_2;
let _e291 = (*halfWidth);
let _e293 = wLen2_;
u = clamp((dot(_e290, _e291) / _e293), -1f, 1f);
let _e296 = offset_2;
let _e297 = (*halfHeight);
let _e299 = hLen2_;
v = clamp((dot(_e296, _e297) / _e299), -1f, 1f);
let _e302 = (*centre);
let _e303 = (*halfWidth);
let _e304 = u;
let _e307 = (*halfHeight);
let _e308 = v;
return ((_e302 + (_e303 * _e304)) + (_e307 * _e308));
}
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_22: f32;
let _e225 = (*a_1);
let _e226 = (*a_1);
ua = (_e225 / vec3(max(length(_e226), 0.000000000001f)));
let _e231 = (*b);
let _e232 = (*b);
ub = (_e231 / vec3(max(length(_e232), 0.000000000001f)));
let _e237 = ua;
let _e238 = ub;
angle_1 = acos(clamp(dot(_e237, _e238), -1f, 1f));
let _e242 = ua;
let _e243 = ub;
axis = cross(_e242, _e243);
let _e245 = axis;
len = length(_e245);
let _e247 = len;
if (_e247 > 0.000001f) {
let _e249 = angle_1;
let _e250 = axis;
let _e251 = (*n_3);
let _e254 = len;
local_22 = ((_e249 * dot(_e250, _e251)) / _e254);
} else {
local_22 = 0f;
}
let _e256 = local_22;
return _e256;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e239 = i_7;
if (_e239 < 4i) {
let _e241 = i_7;
let _e243 = (*corners)[_e241];
a_2 = _e243;
let _e244 = i_7;
if (_e244 == 3i) {
local_23 = 0i;
} else {
let _e246 = i_7;
local_23 = (_e246 + 1i);
}
let _e248 = local_23;
let _e250 = (*corners)[_e248];
b_1 = _e250;
let _e251 = a_2;
let _e252 = (*n_4);
ha = dot(_e251, _e252);
let _e254 = b_1;
let _e255 = (*n_4);
hb = dot(_e254, _e255);
let _e257 = ha;
let _e258 = hb;
d_3 = (_e257 - _e258);
let _e260 = a_2;
let _e261 = b_1;
let _e262 = a_2;
let _e264 = d_3;
if (abs(_e264) > 0.000000000001f) {
let _e267 = ha;
let _e268 = d_3;
local_24 = (_e267 / _e268);
} else {
local_24 = 0f;
}
let _e270 = local_24;
q = (_e260 + ((_e261 - _e262) * _e270));
let _e273 = ha;
aAbove = (_e273 > 0f);
let _e275 = hb;
bAbove = (_e275 > 0f);
let _e277 = aAbove;
let _e278 = bAbove;
if (_e277 || _e278) {
let _e280 = aAbove;
let _e281 = a_2;
let _e282 = q;
let _e285 = bAbove;
let _e286 = b_1;
let _e287 = q;
param_83 = select(_e282, _e281, vec3(_e280));
param_84 = select(_e287, _e286, vec3(_e285));
let _e290 = (*n_4);
param_85 = _e290;
let _e291 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e291;
} else {
local_25 = 0f;
}
let _e292 = local_25;
let _e293 = total;
total = (_e293 + _e292);
let _e295 = aAbove;
let _e296 = bAbove;
let _e299 = q;
let _e300 = exit;
exit = select(_e300, _e299, vec3((_e295 && !(_e296))));
let _e303 = aAbove;
let _e305 = bAbove;
let _e307 = q;
let _e308 = entry;
entry = select(_e308, _e307, vec3((!(_e303) && _e305)));
continue;
} else {
break;
}
continuing {
let _e311 = i_7;
i_7 = (_e311 + 1i);
}
}
let _e313 = exit;
param_86 = _e313;
let _e314 = entry;
param_87 = _e314;
let _e315 = (*n_4);
param_88 = _e315;
let _e316 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e317 = total;
total = (_e317 + _e316);
let _e319 = total;
return max((-(_e319) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e222 = (*slot_1);
let _e223 = (*slot_1);
lane = (_e222 - ((_e223 / 4i) * 4i));
let _e227 = lane;
if (_e227 == 0i) {
let _e230 = (*four)[0u];
local_26 = _e230;
} else {
let _e231 = lane;
if (_e231 == 1i) {
let _e234 = (*four)[1u];
local_27 = _e234;
} else {
let _e235 = lane;
if (_e235 == 2i) {
let _e238 = (*four)[2u];
local_28 = _e238;
} else {
let _e240 = (*four)[3u];
local_28 = _e240;
}
let _e241 = local_28;
local_27 = _e241;
}
let _e242 = local_27;
local_26 = _e242;
}
let _e243 = local_26;
return _e243;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e219 = (*slot_2);
let _e223 = light_list_info.scales[(_e219 / 4i)];
param_89 = _e223;
let _e224 = (*slot_2);
param_90 = _e224;
let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e225;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e221 = light_list_info.slot_rows[0i];
let _e222 = (*row);
a_3 = abs((_e221 - vec4(_e222)));
let _e228 = light_list_info.slot_rows[1i];
let _e229 = (*row);
b_2 = abs((_e228 - vec4(_e229)));
let _e234 = a_3[0u];
let _e236 = a_3[1u];
let _e239 = a_3[2u];
let _e241 = a_3[3u];
let _e245 = b_2[0u];
let _e247 = b_2[1u];
let _e250 = b_2[2u];
let _e252 = b_2[3u];
return (min(min(min(_e234, _e236), min(_e239, _e241)), min(min(_e245, _e247), min(_e250, _e252))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e219 = (*slot_3);
let _e223 = light_list_info.indices[(_e219 / 4i)];
param_91 = _e223;
let _e224 = (*slot_3);
param_92 = _e224;
let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e225;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e218 = (*texel_2);
let _e222 = light_list_info.list[1u];
let _e224 = (*row_1);
let _e228 = light_list_info.list[2u];
let _e231 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e218 + 0.5f) * _e222), ((_e224 + 0.5f) * _e228)), 0f);
return _e231;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e226 = g_cluster_offset;
let _e227 = (*slot_4);
entry_1 = (_e226 + f32(_e227));
let _e230 = entry_1;
row_2 = floor((_e230 / 16f));
let _e233 = entry_1;
let _e234 = row_2;
within_1 = (_e233 - (_e234 * 16f));
let _e237 = within_1;
texel_3 = floor((_e237 / 4f));
let _e242 = light_list_info.cluster_depth[3u];
let _e243 = row_2;
let _e245 = texel_3;
param_93 = _e245;
param_94 = (_e242 + _e243);
let _e246 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e246;
let _e247 = within_1;
let _e248 = texel_3;
let _e253 = four_1;
param_95 = _e253;
param_96 = i32(((_e247 - (_e248 * 4f)) + 0.5f));
let _e254 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e254;
}
fn Clustered_u0028_() -> bool {
let _e218 = light_list_info.cluster_grid[3u];
return (_e218 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp_1: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e270 = (*index_2);
if (_e270 < 8i) {
let _e272 = (*index_2);
let _e275 = frag_info.light_position[_e272];
position = _e275;
let _e276 = (*index_2);
let _e279 = frag_info.light_color[_e276];
color_1 = _e279;
let _e280 = (*index_2);
let _e283 = frag_info.light_direction[_e280];
direction = _e283;
let _e284 = (*index_2);
let _e287 = frag_info.light_cone[_e284];
cone = _e287;
} else {
let _e288 = (*index_2);
slot_5 = (_e288 - 8i);
let _e290 = Clustered_u0028_();
clustered = _e290;
let _e291 = clustered;
if _e291 {
let _e292 = slot_5;
param_97 = _e292;
let _e293 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e293;
} else {
let _e294 = slot_5;
param_98 = _e294;
let _e295 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e295;
}
let _e296 = local_29;
listRow = _e296;
let _e297 = listRow;
let _e301 = light_list_info.list[2u];
v_1 = ((_e297 + 0.5f) * _e301);
let _e305 = light_list_info.list[1u];
u_1 = _e305;
let _e306 = u_1;
let _e308 = v_1;
let _e310 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e306), _e308), 0f);
position = _e310;
let _e311 = u_1;
let _e313 = v_1;
let _e315 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e311), _e313), 0f);
color_1 = _e315;
let _e316 = u_1;
let _e318 = v_1;
let _e320 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e316), _e318), 0f);
direction = _e320;
let _e321 = u_1;
let _e323 = v_1;
let _e325 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e321), _e323), 0f);
cone = _e325;
let _e326 = clustered;
if _e326 {
let _e327 = listRow;
param_99 = _e327;
let _e328 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e328);
} else {
let _e330 = slot_5;
param_100 = _e330;
let _e331 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e331;
}
let _e332 = local_30;
let _e334 = color_1[3u];
color_1[3u] = (_e334 * _e332);
}
let _e338 = position[3u];
type_39 = _e338;
let _e339 = type_39;
if (_e339 > 15.5f) {
let _e342 = (*s_4).n;
light_3.l = _e342;
let _e345 = (*s_4).n;
light_3.h = _e345;
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 _e351 = light_3;
return _e351;
}
let _e352 = type_39;
if (_e352 > 2.5f) {
let _e354 = direction;
halfWidth_1 = _e354.xyz;
let _e356 = cone;
halfHeight_1 = _e356.xyz;
let _e358 = position;
let _e360 = v_world_position_1;
toCentre = (_e358.xyz - _e360);
let _e362 = toCentre;
let _e363 = halfWidth_1;
let _e365 = halfHeight_1;
corners_1[0i] = ((_e362 - _e363) - _e365);
let _e368 = toCentre;
let _e369 = halfWidth_1;
let _e371 = halfHeight_1;
corners_1[1i] = ((_e368 + _e369) - _e371);
let _e374 = toCentre;
let _e375 = halfWidth_1;
let _e377 = halfHeight_1;
corners_1[2i] = ((_e374 + _e375) + _e377);
let _e380 = toCentre;
let _e381 = halfWidth_1;
let _e383 = halfHeight_1;
corners_1[3i] = ((_e380 - _e381) + _e383);
let _e386 = toCentre;
let _e387 = halfWidth_1;
let _e388 = halfHeight_1;
behind = (dot(_e386, cross(_e387, _e388)) >= 0f);
let _e392 = behind;
if _e392 {
local_31 = 0f;
} else {
let _e393 = corners_1;
param_101 = _e393;
let _e395 = (*s_4).n;
param_102 = _e395;
let _e396 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e396;
}
let _e397 = local_31;
formFactor = _e397;
let _e398 = halfWidth_1;
let _e399 = halfHeight_1;
area = (length(cross(_e398, _e399)) * 4f);
let _e403 = area;
if (_e403 > 0.000000001f) {
let _e405 = area;
local_32 = (1f / _e405);
} else {
local_32 = 0f;
}
let _e407 = local_32;
radiance = _e407;
let _e408 = toCentre;
distance_2 = length(_e408);
let _e411 = direction[3u];
if (_e411 > 0f) {
let _e413 = distance_2;
let _e415 = direction[3u];
ratio_1 = (_e413 / _e415);
let _e417 = ratio_1;
let _e418 = ratio_1;
let _e420 = ratio_1;
let _e422 = ratio_1;
window_1 = clamp((1f - (((_e417 * _e418) * _e420) * _e422)), 0f, 1f);
let _e426 = window_1;
let _e427 = window_1;
let _e429 = radiance;
radiance = (_e429 * (_e426 * _e427));
}
let _e432 = (*s_4).v;
let _e435 = (*s_4).n;
mirror_1 = reflect(-(_e432), _e435);
let _e437 = position;
param_103 = _e437.xyz;
let _e439 = halfWidth_1;
param_104 = _e439;
let _e440 = halfHeight_1;
param_105 = _e440;
let _e441 = v_world_position_1;
param_106 = _e441;
let _e442 = mirror_1;
param_107 = _e442;
let _e443 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e443;
let _e444 = representative;
let _e445 = v_world_position_1;
toPoint = (_e444 - _e445);
let _e447 = toPoint;
pointDistance = length(_e447);
let _e449 = pointDistance;
if (_e449 > 0.000001f) {
let _e451 = toPoint;
let _e452 = pointDistance;
local_33 = (_e451 / vec3(_e452));
} else {
let _e456 = (*s_4).n;
local_33 = _e456;
}
let _e457 = local_33;
light_3.l = _e457;
let _e460 = light_3.l;
let _e462 = (*s_4).v;
light_3.h = normalize((_e460 + _e462));
let _e466 = formFactor;
light_3.n_dot_l = _e466;
let _e469 = (*s_4).n;
let _e471 = light_3.h;
light_3.n_dot_h = max(dot(_e469, _e471), 0f);
let _e476 = (*s_4).v;
let _e478 = light_3.h;
light_3.v_dot_h = max(dot(_e476, _e478), 0f);
let _e482 = color_1;
let _e485 = color_1[3u];
let _e487 = radiance;
light_3.radiance = ((_e482.xyz * _e485) * _e487);
let _e490 = light_3;
return _e490;
}
let _e491 = direction;
aim = normalize(_e491.xyz);
attenuation_1 = 1f;
let _e494 = type_39;
if (_e494 < 0.5f) {
let _e496 = aim;
light_3.l = -(_e496);
} else {
let _e499 = position;
let _e501 = v_world_position_1;
toLight_1 = (_e499.xyz - _e501);
let _e503 = toLight_1;
distance_3 = length(_e503);
let _e505 = distance_3;
if (_e505 < 0.000001f) {
let _e508 = (*s_4).n;
light_3.l = _e508;
let _e511 = (*s_4).n;
light_3.h = _e511;
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 _e517 = light_3;
return _e517;
}
let _e518 = toLight_1;
let _e519 = distance_3;
light_3.l = (_e518 / vec3(_e519));
let _e523 = distance_3;
param_108 = _e523;
let _e525 = direction[3u];
param_109 = _e525;
let _e526 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e526;
let _e527 = type_39;
if (_e527 > 1.5f) {
let _e529 = aim;
let _e531 = light_3.l;
cosAngle = dot(_e529, -(_e531));
let _e534 = cosAngle;
let _e536 = cone[1u];
let _e539 = cone[0u];
let _e541 = cone[1u];
ramp_1 = clamp(((_e534 - _e536) / (_e539 - _e541)), 0f, 1f);
let _e545 = ramp_1;
let _e546 = ramp_1;
let _e548 = attenuation_1;
attenuation_1 = (_e548 * (_e545 * _e546));
}
}
let _e551 = light_3.l;
let _e553 = (*s_4).v;
light_3.h = normalize((_e551 + _e553));
let _e558 = (*s_4).n;
let _e560 = light_3.l;
light_3.n_dot_l = max(dot(_e558, _e560), 0f);
let _e565 = (*s_4).n;
let _e567 = light_3.h;
light_3.n_dot_h = max(dot(_e565, _e567), 0f);
let _e572 = (*s_4).v;
let _e574 = light_3.h;
light_3.v_dot_h = max(dot(_e572, _e574), 0f);
let _e578 = color_1;
let _e581 = color_1[3u];
let _e583 = attenuation_1;
light_3.radiance = ((_e578.xyz * _e581) * _e583);
let _e586 = light_3;
return _e586;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e231 = light_list_info.cluster_view_projection;
let _e232 = (*world_3);
clip_1 = (_e231 * vec4<f32>(_e232.x, _e232.y, _e232.z, 1f));
let _e238 = clip_1;
let _e241 = clip_1[3u];
ndc_1 = (_e238.xy / vec2(max(_e241, 0.000001f)));
let _e246 = light_list_info.cluster_grid;
grid = _e246.xyz;
let _e250 = light_list_info.cluster_depth[0u];
near_1 = _e250;
let _e252 = ndc_1[0u];
let _e256 = grid[0u];
let _e260 = grid[0u];
tx = clamp(floor((((_e252 * 0.5f) + 0.5f) * _e256)), 0f, (_e260 - 1f));
let _e264 = ndc_1[1u];
let _e268 = grid[1u];
let _e272 = grid[1u];
ty = clamp(floor((((_e264 * 0.5f) + 0.5f) * _e268)), 0f, (_e272 - 1f));
let _e276 = clip_1[3u];
let _e277 = near_1;
if (_e276 <= _e277) {
local_34 = 0f;
} else {
let _e280 = clip_1[3u];
let _e281 = near_1;
let _e286 = light_list_info.cluster_depth[1u];
let _e290 = grid[2u];
local_34 = clamp(floor((log((_e280 / _e281)) * _e286)), 0f, (_e290 - 1f));
}
let _e293 = local_34;
tz = _e293;
let _e294 = tx;
let _e295 = ty;
let _e297 = grid[0u];
let _e300 = tz;
let _e302 = grid[0u];
let _e305 = grid[1u];
cell_1 = ((_e294 + (_e295 * _e297)) + ((_e300 * _e302) * _e305));
let _e308 = cell_1;
row_3 = floor((_e308 / 4f));
let _e311 = cell_1;
let _e312 = row_3;
let _e317 = light_list_info.cluster_depth[2u];
let _e318 = row_3;
param_110 = (_e311 - (_e312 * 4f));
param_111 = (_e317 + _e318);
let _e320 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e320;
let _e322 = header[0u];
g_cluster_offset = _e322;
let _e324 = header[1u];
g_cluster_count = _e324;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e220 = light_list_info.list[0u];
tail = _e220;
let _e221 = Clustered_u0028_();
if _e221 {
let _e222 = v_world_position_1;
param_112 = _e222;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e223 = g_cluster_count;
tail = _e223;
}
let _e226 = frag_info.frame_params[1u];
let _e230 = tail;
return (clamp(i32((_e226 + 0.5f)), 0i, 8i) + clamp(i32((_e230 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e234 = LightCount_u0028_();
count_1 = _e234;
i_8 = 0i;
loop {
let _e235 = i_8;
if (_e235 < 32i) {
let _e237 = i_8;
let _e238 = count_1;
if (_e237 >= _e238) {
break;
}
let _e240 = i_8;
param_113 = _e240;
let _e241 = (*s_5);
param_114 = _e241;
let _e242 = 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_113), (¶m_114));
light_4 = _e242;
let _e244 = light_4.n_dot_l;
if (_e244 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e246 = i_8;
param_115 = _e246;
let _e247 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e247 {
let _e248 = (*s_5);
param_116 = _e248;
let _e249 = light_4;
param_117 = _e249;
let _e250 = i_8;
param_118 = _e250;
let _e251 = 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_116), (¶m_117), (¶m_118));
let _e252 = v_world_position_1;
param_119 = _e252;
let _e254 = (*s_5).n;
param_120 = _e254;
let _e255 = i_8;
param_121 = _e255;
let _e256 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e251 * _e256);
} else {
local_35 = 1f;
}
let _e258 = local_35;
visibility = _e258;
let _e259 = visibility;
if (_e259 <= 0f) {
continue;
}
let _e261 = (*s_5);
param_122 = _e261;
let _e262 = light_4;
param_123 = _e262;
let _e263 = 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_122), (¶m_123));
let _e265 = light_4.radiance;
let _e268 = light_4.n_dot_l;
let _e270 = visibility;
let _e272 = light_transmittance;
let _e274 = total_1;
total_1 = (_e274 + ((((_e263 * _e265) * _e268) * _e270) * _e272));
continue;
} else {
break;
}
continuing {
let _e276 = i_8;
i_8 = (_e276 + 1i);
}
}
let _e278 = total_1;
return _e278;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e217 = v_lightmap_uv_1;
let _e218 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e217);
texel_4 = _e218;
let _e219 = texel_4;
let _e222 = texel_4[3u];
return ((_e219.xyz * _e222) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e218 = frag_info.target_origin[1u];
return _e218;
}
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_6: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e218 = v_texcoord_1;
let _e219 = MaterialLodBias_u0028_();
let _e220 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e218, _e219);
orm = _e220.xyz;
let _e223 = (*s_6).metallic;
let _e225 = orm[2u];
(*s_6).metallic = clamp((_e223 * _e225), 0f, 1f);
let _e230 = (*s_6).roughness;
let _e232 = orm[1u];
(*s_6).roughness = clamp((_e230 * _e232), 0.02f, 1f);
return;
}
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_7: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_124: vec3<f32>;
let _e219 = v_texcoord_1;
let _e220 = MaterialLodBias_u0028_();
let _e221 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e219, _e220);
param_124 = _e221.xyz;
let _e223 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e223;
let _e224 = emissive;
let _e226 = frag_info.emissive;
let _e231 = frag_info.material2_[3u];
(*s_7).emissive = ((_e224 * _e226.xyz) * _e231);
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_8: ptr<function, Surface>) {
var occlusion: f32;
let _e218 = v_texcoord_1;
let _e219 = MaterialLodBias_u0028_();
let _e220 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e218, _e219);
occlusion = _e220.x;
let _e222 = occlusion;
let _e225 = frag_info.material2_[2u];
(*s_8).occlusion = mix(1f, _e222, clamp(_e225, 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_9: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e221 = v_texcoord_1;
let _e222 = MaterialLodBias_u0028_();
let _e223 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e221, _e222);
sampledTexel = _e223;
let _e224 = v_tangent_1;
t_2 = _e224.xyz;
let _e226 = t_2;
let _e228 = (*s_9).n;
let _e230 = (*s_9).n;
let _e231 = t_2;
t_2 = (_e226 - (_e228 * dot(_e230, _e231)));
let _e235 = t_2;
let _e236 = t_2;
if (dot(_e235, _e236) < 0.000000000001f) {
return;
}
let _e239 = t_2;
t_2 = normalize(_e239);
let _e242 = (*s_9).n;
let _e243 = t_2;
let _e246 = v_tangent_1[3u];
b_3 = (cross(_e242, _e243) * _e246);
let _e248 = gl_FrontFacing_1;
if !(_e248) {
let _e250 = t_2;
t_2 = -(_e250);
}
let _e252 = sampledTexel;
sampled = ((_e252.xyz * 2f) - vec3(1f));
let _e259 = frag_info.emissive[3u];
if (_e259 > 0.5f) {
let _e261 = sampled;
let _e263 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e261.xy, _e263.xy)), 0f));
}
let _e272 = frag_info.material2_[1u];
let _e273 = sampled;
let _e275 = (_e273.xy * _e272);
sampled[0u] = _e275.x;
sampled[1u] = _e275.y;
let _e280 = t_2;
let _e282 = sampled[0u];
let _e284 = b_3;
let _e286 = sampled[1u];
let _e290 = (*s_9).n;
let _e292 = sampled[2u];
(*s_9).n = normalize((((_e280 * _e282) + (_e284 * _e286)) + (_e290 * _e292)));
let _e298 = (*s_9).n;
let _e300 = (*s_9).v;
(*s_9).n_dot_v = max(dot(_e298, _e300), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e217 = (*texel_5);
let _e221 = irradiance_info.atlas;
let _e224 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e217 + vec2(0.5f)) * _e221.xy), 0f);
return _e224;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e230 = (*uv_6);
let _e231 = (*interior);
at_1 = ((vec2(1f) + (_e230 * _e231)) - vec2(0.5f));
let _e237 = at_1;
low = floor(_e237);
let _e239 = at_1;
let _e240 = low;
f = (_e239 - _e240);
let _e242 = (*corner);
let _e243 = low;
param_125 = (_e242 + _e243);
let _e245 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e245;
let _e246 = (*corner);
let _e247 = low;
param_126 = ((_e246 + _e247) + vec2<f32>(1f, 0f));
let _e250 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e250;
let _e251 = (*corner);
let _e252 = low;
param_127 = ((_e251 + _e252) + vec2<f32>(0f, 1f));
let _e255 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e255;
let _e256 = (*corner);
let _e257 = low;
param_128 = ((_e256 + _e257) + vec2<f32>(1f, 1f));
let _e260 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e260;
let _e261 = a_4;
let _e262 = b_4;
let _e264 = f[0u];
let _e267 = c_1;
let _e268 = d_4;
let _e270 = f[0u];
let _e274 = f[1u];
return mix(mix(_e261, _e262, vec4(_e264)), mix(_e267, _e268, vec4(_e270)), vec4(_e274));
}
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 _e221 = (*direction_1)[0u];
let _e224 = (*direction_1)[1u];
let _e228 = (*direction_1)[2u];
sum_1 = ((abs(_e221) + abs(_e224)) + abs(_e228));
let _e231 = sum_1;
if (_e231 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e233 = (*direction_1);
let _e234 = sum_1;
n_5 = (_e233 / vec3(_e234));
let _e237 = n_5;
xy = _e237.xy;
let _e240 = n_5[2u];
if (_e240 < 0f) {
let _e243 = n_5[1u];
let _e247 = n_5[0u];
let _e252 = n_5[0u];
let _e256 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e243)) * select(-1f, 1f, (_e247 >= 0f))), ((1f - abs(_e252)) * select(-1f, 1f, (_e256 >= 0f))));
}
let _e261 = xy;
return ((_e261 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e263 = irradiance_info.origin;
origin_2 = _e263.xyz;
let _e266 = irradiance_info.spacing;
spacing = _e266.xyz;
let _e269 = irradiance_info.counts;
counts = _e269.xyz;
let _e273 = irradiance_info.tiles[0u];
irradianceTile = _e273;
let _e276 = irradiance_info.tiles[1u];
depthTile = _e276;
let _e279 = irradiance_info.tiles[2u];
columns = _e279;
let _e282 = irradiance_info.tiles[3u];
momentsTop = _e282;
let _e283 = (*normal_1);
unit = normalize(_e283);
let _e285 = (*world_4);
let _e286 = unit;
let _e289 = irradiance_info.spacing[3u];
let _e292 = (*view_1);
let _e295 = irradiance_info.counts[3u];
biased = ((_e285 + (_e286 * _e289)) + (_e292 * _e295));
let _e298 = biased;
let _e299 = origin_2;
let _e301 = spacing;
grid_1 = ((_e298 - _e299) / _e301);
let _e303 = grid_1;
let _e305 = counts;
base = clamp(floor(_e303), vec3<f32>(0f, 0f, 0f), (_e305 - vec3(2f)));
let _e309 = grid_1;
let _e310 = base;
f_1 = clamp((_e309 - _e310), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e313 = corner_1;
if (_e313 < 8i) {
let _e315 = corner_1;
let _e318 = corner_1;
let _e323 = corner_1;
offset_3 = vec3<f32>(f32((_e315 & 1i)), f32(((_e318 >> bitcast<u32>(1i)) & 1i)), f32(((_e323 >> bitcast<u32>(2i)) & 1i)));
let _e329 = base;
let _e330 = offset_3;
cell_2 = (_e329 + _e330);
let _e333 = cell_2[2u];
let _e335 = counts[1u];
let _e338 = cell_2[1u];
let _e341 = counts[0u];
let _e344 = cell_2[0u];
probe = ((((_e333 * _e335) + _e338) * _e341) + _e344);
let _e346 = probe;
let _e347 = columns;
let _e352 = probe;
let _e353 = columns;
tile_4 = vec2<f32>((_e346 - (floor((_e346 / _e347)) * _e347)), floor((_e352 / _e353)));
let _e357 = tile_4;
let _e358 = irradianceTile;
irradianceCorner = (_e357 * (_e358 + 2f));
let _e362 = tile_4[0u];
let _e363 = depthTile;
let _e366 = momentsTop;
let _e368 = tile_4[1u];
let _e369 = depthTile;
momentCorner = vec2<f32>((_e362 * (_e363 + 2f)), (_e366 + (_e368 * (_e369 + 2f))));
let _e374 = irradianceCorner;
param_129 = (_e374 + vec2(1f));
let _e377 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e377.w < 0.5f) {
continue;
}
let _e380 = f_1;
let _e382 = f_1;
let _e383 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e380), _e382, _e383);
let _e386 = trilinear[0u];
let _e388 = trilinear[1u];
let _e391 = trilinear[2u];
weight_3 = max(((_e386 * _e388) * _e391), 0.001f);
let _e394 = origin_2;
let _e395 = spacing;
let _e396 = cell_2;
probePosition = (_e394 + (_e395 * _e396));
let _e399 = probePosition;
let _e400 = biased;
toProbe = (_e399 - _e400);
let _e402 = toProbe;
distance_4 = length(_e402);
let _e404 = distance_4;
if (_e404 > 0.000001f) {
let _e406 = toProbe;
let _e407 = distance_4;
direction_2 = (_e406 / vec3(_e407));
let _e410 = unit;
let _e411 = probePosition;
let _e412 = (*world_4);
facing = ((dot(_e410, normalize((_e411 - _e412))) * 0.5f) + 0.5f);
let _e418 = facing;
let _e419 = facing;
probeWeight = ((_e418 * _e419) + 0.2f);
let _e422 = direction_2;
param_130 = -(_e422);
let _e424 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e425 = momentCorner;
param_131 = _e425;
let _e426 = depthTile;
param_132 = _e426;
param_133 = _e424;
let _e427 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e427.xy;
chebyshev = 1f;
let _e429 = distance_4;
let _e431 = moments_3[0u];
if (_e429 > _e431) {
let _e434 = moments_3[1u];
let _e436 = moments_3[0u];
let _e438 = moments_3[0u];
variance_1 = max((_e434 - (_e436 * _e438)), 0.000001f);
let _e442 = distance_4;
let _e444 = moments_3[0u];
difference = (_e442 - _e444);
let _e446 = variance_1;
let _e447 = variance_1;
let _e448 = difference;
let _e449 = difference;
chebyshev = (_e446 / (_e447 + (_e448 * _e449)));
let _e453 = chebyshev;
let _e454 = chebyshev;
let _e456 = chebyshev;
chebyshev = ((_e453 * _e454) * _e456);
}
let _e458 = probeWeight;
let _e459 = chebyshev;
probeWeight = max((_e458 * max(_e459, 0.05f)), 0.000001f);
let _e463 = probeWeight;
if (_e463 < 0.2f) {
let _e465 = probeWeight;
let _e466 = probeWeight;
let _e469 = probeWeight;
probeWeight = (_e469 * ((_e465 * _e466) * 25f));
}
let _e471 = probeWeight;
let _e472 = weight_3;
weight_3 = (_e472 * _e471);
}
let _e474 = unit;
param_134 = _e474;
let _e475 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e476 = irradianceCorner;
param_135 = _e476;
let _e477 = irradianceTile;
param_136 = _e477;
param_137 = _e475;
let _e478 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e480 = weight_3;
let _e482 = total_2;
total_2 = (_e482 + (_e478.xyz * _e480));
let _e484 = weight_3;
let _e485 = weights;
weights = (_e485 + _e484);
continue;
} else {
break;
}
continuing {
let _e487 = corner_1;
corner_1 = (_e487 + 1i);
}
}
let _e489 = weights;
if (_e489 > 0f) {
let _e491 = total_2;
let _e492 = weights;
local_36 = (_e491 / vec3(_e492));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e495 = local_36;
return _e495;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e218 = irradiance_info.origin[3u];
return (_e218 > 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_10: ptr<function, Surface>) {
var param_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e223 = IrradianceEnabled_u0028_();
if _e223 {
let _e224 = v_world_position_1;
param_138 = _e224;
let _e226 = (*s_10).n;
param_139 = _e226;
let _e228 = (*s_10).v;
param_140 = _e228;
let _e229 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e232 = frag_info.material[2u];
(*s_10).ambient = (_e229 * _e232);
}
let _e235 = (*s_10);
param_141 = _e235;
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_141));
let _e236 = param_141;
(*s_10) = _e236;
let _e237 = (*s_10);
param_142 = _e237;
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_142));
let _e238 = param_142;
(*s_10) = _e238;
let _e239 = (*s_10);
param_143 = _e239;
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_143));
let _e240 = param_143;
(*s_10) = _e240;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e217 = Orthographic_u0028_();
if _e217 {
let _e219 = fog_info.forward;
local_37 = -(_e219.xyz);
} else {
let _e223 = fog_info.eye;
let _e225 = v_world_position_1;
local_37 = normalize((_e223.xyz - _e225));
}
let _e228 = local_37;
return _e228;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_3: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e222 = (*cutoff);
key_2 = (-2f - _e222);
let _e224 = key_2;
let _e227 = key_2;
let _e229 = floor((_e227 / 128f));
let _e234 = key_2;
origin_3 = vec3<f32>(floor((_e224 / 16384f)), (_e229 - (floor((_e229 / 128f)) * 128f)), (_e234 - (floor((_e234 / 128f)) * 128f)));
let _e240 = (*scenePosition);
let _e243 = origin_3;
let _e244 = (floor((_e240 * 16f)) + _e243);
let _e245 = vec3(128f);
cell_3 = (_e244 - (floor((_e244 / _e245)) * _e245));
let _e250 = cell_3;
p3_ = fract((_e250 * 0.1031f));
let _e253 = p3_;
let _e254 = p3_;
let _e259 = p3_;
p3_ = (_e259 + vec3(dot(_e253, (_e254.zyx + vec3(31.32f)))));
let _e263 = p3_[0u];
let _e265 = p3_[1u];
let _e268 = p3_[2u];
return fract(((_e263 + _e265) * _e268));
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_11: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_146: vec3<f32>;
var param_147: f32;
let _e224 = v_texcoord_1;
let _e225 = MaterialLodBias_u0028_();
let _e226 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e224, _e225);
texel_6 = _e226;
let _e227 = texel_6;
param_144 = _e227.xyz;
let _e229 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e231 = frag_info.base_color;
param_145 = _e231.xyz;
let _e233 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e235 = v_color_1;
s_11.albedo = ((_e229 * _e233) * _e235.xyz);
let _e240 = texel_6[3u];
let _e243 = frag_info.base_color[3u];
let _e246 = v_color_1[3u];
s_11.alpha = ((_e240 * _e243) * _e246);
let _e250 = s_11.albedo;
g_albedo = _e250;
let _e253 = frag_info.material2_[0u];
cutoff_1 = _e253;
let _e254 = cutoff_1;
if (_e254 > 1f) {
let _e256 = cutoff_1;
edge = (_e256 - 1f);
let _e259 = s_11.alpha;
let _e260 = edge;
let _e263 = s_11.alpha;
let _e264 = fwidth(_e263);
s_11.alpha = clamp((((_e259 - _e260) / max(_e264, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e270 = cutoff_1;
if (_e270 >= 0f) {
let _e273 = s_11.alpha;
let _e274 = cutoff_1;
if (_e273 < _e274) {
discard;
}
s_11.alpha = 1f;
} else {
let _e277 = cutoff_1;
if (_e277 < -1.5f) {
let _e280 = s_11.alpha;
let _e281 = v_world_position_1;
param_146 = _e281;
let _e282 = cutoff_1;
param_147 = _e282;
let _e283 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_146), (¶m_147));
if (_e280 < _e283) {
discard;
}
}
}
}
let _e285 = cutoff_1;
let _e287 = cutoff_1;
g_premultiply = ((_e285 < 0f) && (_e287 > -0.75f));
let _e290 = v_normal_1;
s_11.n = normalize(_e290);
let _e293 = gl_FrontFacing_1;
if !(_e293) {
let _e296 = s_11.n;
s_11.n = -(_e296);
}
let _e299 = TowardsEye_u0028_();
s_11.v = _e299;
let _e302 = s_11.n;
let _e304 = s_11.v;
s_11.n_dot_v = max(dot(_e302, _e304), 0.0001f);
let _e310 = frag_info.material[0u];
s_11.metallic = clamp(_e310, 0f, 1f);
let _e315 = frag_info.material[1u];
s_11.roughness = clamp(_e315, 0.02f, 1f);
let _e319 = frag_info.ambient_ground;
let _e322 = frag_info.ambient_sky;
let _e326 = s_11.n[1u];
let _e333 = frag_info.material[2u];
s_11.ambient = (mix(_e319.xyz, _e322.xyz, vec3(((_e326 * 0.5f) + 0.5f))) * _e333);
let _e338 = frag_info.frame_params[0u];
s_11.exposure = max(_e338, 0f);
s_11.occlusion = 1f;
s_11.emissive = vec3<f32>(0f, 0f, 0f);
let _e343 = s_11;
return _e343;
}
fn main_1() {
var s_12: Surface;
var param_148: Surface;
var param_149: Surface;
var rim: f32;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_150: Surface;
var param_151: Surface;
var param_152: vec3<f32>;
var param_153: vec3<f32>;
var param_154: f32;
var param_155: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e228 = ReadSurface_u0028_();
s_12 = _e228;
let _e229 = s_12;
param_148 = _e229;
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_148));
let _e230 = param_148;
s_12 = _e230;
let _e231 = s_12;
param_149 = _e231;
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_149));
let _e232 = param_149;
s_12 = _e232;
let _e234 = s_12.n_dot_v;
let _e239 = frag_info.material[3u];
rim = (pow((1f - _e234), 3f) * _e239);
let _e242 = s_12.albedo;
let _e244 = s_12.ambient;
let _e245 = SampleLightmap_u0028_();
let _e249 = s_12.occlusion;
ambient = ((_e242 * (_e244 + _e245)) * _e249);
let _e251 = s_12;
param_150 = _e251;
let _e252 = 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_150));
let _e254 = s_12.occlusion;
let _e256 = ambient;
let _e258 = rim;
let _e263 = s_12.emissive;
lit_3 = ((((_e252 * _e254) + _e256) + vec3((_e258 * 0.35f))) + _e263);
let _e265 = s_12;
param_151 = _e265;
let _e266 = lit_3;
param_152 = _e266;
let _e267 = WriteDebugView_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_vf3_u003b((¶m_151), (¶m_152));
if _e267 {
return;
}
let _e268 = lit_3;
param_153 = _e268;
let _e270 = s_12.alpha;
param_154 = _e270;
let _e272 = s_12.roughness;
param_155 = _e272;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_153), (¶m_154), (¶m_155));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
'UnlitOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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> gl_FragCoord_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e124 = v_world_position_1;
let _e126 = fog_info.eye;
let _e130 = fog_info.forward;
return dot((_e124 - _e126.xyz), _e130.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e129 = ViewDepth_u0028_();
z = abs(_e129);
let _e131 = z;
near = (_e131 / 5f);
let _e133 = z;
far = (_e133 / 200f);
let _e135 = far;
let _e136 = far;
let _e138 = far;
far3_ = ((_e135 * _e136) * _e138);
let _e140 = (*alpha);
let _e141 = near;
let _e142 = near;
let _e145 = far3_;
let _e146 = far3_;
return (_e140 * clamp((10f / ((0.00001f + (_e141 * _e142)) + (_e145 * _e146))), 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 _e133 = fog_info.forward[3u];
mode = _e133;
let _e134 = mode;
if (_e134 > 0.5f) {
let _e137 = frag_color[3u];
alpha_1 = _e137;
let _e138 = alpha_1;
param = _e138;
let _e139 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e139;
let _e140 = frag_color;
let _e142 = weight;
let _e143 = (_e140.xyz * _e142);
let _e144 = alpha_1;
let _e145 = weight;
accumulate = vec4<f32>(_e143.x, _e143.y, _e143.z, (_e144 * _e145));
let _e151 = mode;
let _e153 = mode;
revealage = ((_e151 > 1.5f) && (_e153 < 2.5f));
let _e156 = revealage;
if _e156 {
let _e157 = alpha_1;
local = vec4(_e157);
} else {
let _e159 = accumulate;
local = _e159;
}
let _e160 = local;
frag_color = _e160;
let _e161 = mode;
if (_e161 > 2.5f) {
let _e163 = alpha_1;
frag_surface = vec4(_e163);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e127 = (*n)[0u];
let _e130 = (*n)[1u];
let _e134 = (*n)[2u];
let _e137 = (*n);
(*n) = (_e137 / vec3(((abs(_e127) + abs(_e130)) + abs(_e134))));
let _e140 = (*n);
e = _e140.xy;
let _e143 = (*n)[2u];
if (_e143 < 0f) {
let _e145 = (*n);
let _e151 = (*n)[0u];
let _e155 = (*n)[1u];
e = ((vec2(1f) - abs(_e145.yx)) * vec2<f32>(select(-1f, 1f, (_e151 >= 0f)), select(-1f, 1f, (_e155 >= 0f))));
}
let _e160 = e;
return ((_e160 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e125 = (*linear);
let _e127 = (*linear);
let _e131 = (*linear);
return mix((_e125 * 12.92f), ((pow(_e127, 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), _e131));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e128 = g_albedo;
param_1 = clamp(_e128, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e130 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e130.x, _e130.y, _e130.z, 1f);
let _e135 = g_debug_surface_on;
if _e135 {
let _e136 = g_debug_surface;
let _e137 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e136.x, _e136.y, _e136.z, _e137);
return;
}
let _e142 = v_normal_1;
geometric = normalize(_e142);
let _e144 = gl_FrontFacing_1;
if !(_e144) {
let _e146 = geometric;
geometric = -(_e146);
}
let _e148 = geometric;
param_2 = _e148;
let _e149 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e150 = (*roughness);
let _e152 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e149.x, _e149.y, clamp(_e150, 0f, 1f), _e152);
return;
}
fn Orthographic_u0028_() -> bool {
let _e126 = fog_info.projection[0u];
return (_e126 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e125 = Orthographic_u0028_();
if _e125 {
let _e126 = ViewDepth_u0028_();
local_1 = max(_e126, 0f);
} else {
let _e128 = v_world_position_1;
let _e130 = fog_info.eye;
local_1 = distance(_e128, _e130.xyz);
}
let _e133 = local_1;
return _e133;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e132 = fog_info.fog[3u];
density = _e132;
let _e133 = density;
if (_e133 <= 0f) {
let _e135 = (*color);
return _e135;
}
let _e136 = EyeDistance_u0028_();
d = _e136;
let _e139 = fog_info.eye[3u];
falloff = _e139;
let _e140 = falloff;
if (_e140 > 0f) {
let _e142 = falloff;
let _e144 = v_world_position_1[1u];
let _e147 = fog_info.eye[1u];
k = (_e142 * (_e144 - _e147));
let _e150 = k;
if (abs(_e150) > 0.001f) {
let _e153 = k;
let _e157 = k;
local_2 = ((1f - exp(-(_e153))) / _e157);
} else {
let _e159 = k;
local_2 = (1f - (0.5f * _e159));
}
let _e162 = local_2;
let _e163 = density;
density = (_e163 * _e162);
}
let _e166 = fog_info.fog;
let _e168 = (*color);
let _e169 = density;
let _e171 = d;
return mix(_e166.xyz, _e168, vec3(clamp(exp((-(_e169) * _e171)), 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 _e130 = g_premultiply;
let _e131 = (*alpha_2);
weight_1 = select(1f, _e131, _e130);
let _e133 = (*linearColor);
param_3 = _e133;
let _e134 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e135 = weight_1;
let _e136 = (_e134 * _e135);
let _e137 = (*alpha_2);
let _e138 = g_pass_through;
frag_color = vec4<f32>(_e136.x, _e136.y, _e136.z, (_e137 * (1f - _e138)));
let _e145 = (*roughness_1);
param_4 = _e145;
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 _e129 = (*linearColor_1);
param_5 = _e129;
let _e130 = (*alpha_3);
param_6 = _e130;
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 _e125 = (*srgb);
let _e128 = (*srgb);
let _e133 = (*srgb);
return mix((_e125 / vec3(12.92f)), pow(((_e128 + 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), _e133));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e127 = (*key);
hue = fract(((_e127 * 0.618034f) + 0.13f));
let _e131 = hue;
k_1 = clamp((abs(((fract((vec3(_e131) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e144 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e144, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_629_: bool;
let _e125 = (*c);
let _e126 = (*c);
let _e128 = any((_e125 != _e126));
phi_629_ = _e128;
if !(_e128) {
let _e130 = (*c);
phi_629_ = any((abs(_e130) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e135 = phi_629_;
return _e135;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var grey: f32;
var param_10: vec3<f32>;
var param_11: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_12: vec3<f32>;
var key_1: f32;
var param_13: f32;
var srgb_1: vec3<f32>;
var param_14: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_15: vec3<f32>;
var param_16: f32;
var phi_722_: bool;
var phi_993_: bool;
let _e167 = gl_FragCoord_1[0u];
let _e170 = frag_info.debug_view[1u];
if (_e167 < _e170) {
let _e174 = frag_info.debug_view[2u];
local_3 = _e174;
} else {
let _e177 = frag_info.debug_view[0u];
local_3 = _e177;
}
let _e178 = local_3;
view = _e178;
let _e179 = view;
if (_e179 < 0.5f) {
return false;
}
let _e181 = view;
code = i32((_e181 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e184 = v_normal_1;
geometric_n = normalize(_e184);
let _e186 = v_tangent_1;
let _e188 = geometric_n;
let _e189 = geometric_n;
let _e190 = v_tangent_1;
tangent = (_e186.xyz - (_e188 * dot(_e189, _e190.xyz)));
let _e195 = tangent;
let _e196 = tangent;
let _e198 = (dot(_e195, _e196) > 0.000000000001f);
phi_722_ = _e198;
if _e198 {
let _e200 = v_tangent_1[3u];
phi_722_ = (abs((abs(_e200) - 1f)) < 0.01f);
}
let _e206 = phi_722_;
tangent_usable = _e206;
let _e209 = frag_info.debug_view[3u];
identity = _e209;
let _e210 = identity;
identity_object = floor((_e210 / 8192f));
let _e213 = identity;
let _e214 = identity_object;
identity_rest = (_e213 - (_e214 * 8192f));
let _e217 = identity_rest;
identity_material = floor((_e217 / 2f));
let _e220 = identity_rest;
let _e221 = identity_material;
normal_mapped = ((_e220 - (_e221 * 2f)) > 0.5f);
let _e225 = code;
if (_e225 == 1i) {
let _e228 = (*s).albedo;
param_8 = clamp(_e228, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e230 = LinearToSrgb_u0028_vf3_u003b((¶m_8));
shown = _e230;
} else {
let _e231 = code;
if (_e231 == 2i) {
let _e234 = (*s).n;
shown = ((_e234 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e237 = code;
if (_e237 == 3i) {
let _e240 = (*s).roughness;
shown = vec3(clamp(_e240, 0f, 1f));
} else {
let _e243 = code;
if (_e243 == 4i) {
let _e246 = (*s).metallic;
shown = vec3(clamp(_e246, 0f, 1f));
} else {
let _e249 = code;
if (_e249 == 5i) {
let _e252 = (*s).occlusion;
shown = vec3(clamp(_e252, 0f, 1f));
} else {
let _e255 = code;
if (_e255 == 6i) {
let _e258 = (*s).emissive;
param_9 = clamp(_e258, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e260 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e260;
} else {
let _e261 = code;
if (_e261 == 7i) {
let _e263 = v_texcoord_1;
let _e264 = fract(_e263);
shown = vec3<f32>(_e264.x, _e264.y, 0f);
} else {
let _e268 = code;
if (_e268 == 8i) {
let _e270 = (*lit);
param_10 = clamp(_e270, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e272 = LinearToSrgb_u0028_vf3_u003b((¶m_10));
grey = dot(_e272, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e274 = (*lit);
param_11 = _e274;
let _e275 = NonFinite_u0028_vf3_u003b((¶m_11));
if _e275 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e276 = grey;
local_4 = vec3((_e276 * 0.5f));
}
let _e279 = local_4;
shown = _e279;
} else {
let _e280 = code;
if (_e280 == 9i) {
let _e282 = tangent_usable;
if _e282 {
let _e283 = tangent;
local_5 = ((normalize(_e283) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e287 = local_5;
shown = _e287;
} else {
let _e288 = code;
if (_e288 == 10i) {
let _e290 = v_texcoord_1;
uv = _e290;
let _e291 = uv;
cell = floor((_e291 * 8f));
let _e295 = cell[0u];
let _e297 = cell[1u];
odd = (fract(((_e295 + _e297) * 0.5f)) * 2f);
let _e302 = uv;
within = fract(_e302);
let _e304 = odd;
let _e308 = within[0u];
let _e312 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e304)) * vec3<f32>((0.55f + (0.45f * _e308)), (0.55f + (0.45f * _e312)), 0.85f));
} else {
let _e317 = code;
if (_e317 == 11i) {
let _e319 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e319));
} else {
let _e322 = code;
if (_e322 == 12i) {
let _e324 = v_color_1;
param_12 = clamp(_e324.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e327 = LinearToSrgb_u0028_vf3_u003b((¶m_12));
shown = _e327;
} else {
let _e328 = code;
let _e330 = code;
if ((_e328 == 13i) || (_e330 == 14i)) {
let _e333 = code;
let _e335 = identity_object;
let _e336 = identity_material;
key_1 = select(_e336, _e335, (_e333 == 13i));
let _e338 = key_1;
param_13 = _e338;
let _e339 = DebugIdentityColour_u0028_f1_u003b((¶m_13));
let _e341 = (*s).n_dot_v;
shown = (_e339 * (0.55f + (0.45f * _e341)));
} else {
let _e345 = code;
if (_e345 == 15i) {
let _e348 = (*s).albedo;
param_14 = clamp(_e348, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e350 = LinearToSrgb_u0028_vf3_u003b((¶m_14));
srgb_1 = _e350;
let _e351 = srgb_1;
luma = dot(_e351, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e354 = (*s).metallic;
metal = (_e354 > 0.5f);
let _e356 = metal;
let _e358 = luma;
if (!(_e356) && (_e358 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e361 = metal;
let _e362 = !(_e361);
phi_993_ = _e362;
if _e362 {
let _e364 = srgb_1[0u];
let _e366 = srgb_1[1u];
let _e368 = srgb_1[2u];
phi_993_ = (max(_e364, max(_e366, _e368)) > 0.9411765f);
}
let _e373 = phi_993_;
if _e373 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e374 = metal;
let _e375 = luma;
if (_e374 && (_e375 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e378 = luma;
local_8 = vec3(_e378);
}
let _e380 = local_8;
local_7 = _e380;
}
let _e381 = local_7;
local_6 = _e381;
}
let _e382 = local_6;
shown = _e382;
} else {
let _e383 = code;
if (_e383 == 16i) {
let _e386 = (*s).metallic;
m = _e386;
let _e387 = m;
let _e389 = m;
if ((_e387 > 0.05f) && (_e389 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e392 = m;
local_9 = vec3(select(0.15f, 1f, (_e392 > 0.5f)));
}
let _e396 = local_9;
shown = _e396;
} else {
let _e397 = code;
if (_e397 == 17i) {
let _e399 = normal_mapped;
if !(_e399) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e401 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e401));
}
let _e404 = local_10;
shown = _e404;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e405 = g_premultiply;
if _e405 {
let _e407 = (*s).alpha;
local_11 = _e407;
} else {
local_11 = 1f;
}
let _e408 = local_11;
weight_2 = _e408;
let _e409 = shown;
param_15 = _e409;
let _e410 = SrgbToLinear_u0028_vf3_u003b((¶m_15));
let _e411 = weight_2;
let _e412 = (_e410 * _e411);
let _e414 = (*s).alpha;
frag_color = vec4<f32>(_e412.x, _e412.y, _e412.z, _e414);
let _e420 = (*s).roughness;
param_16 = _e420;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_16));
WriteWeightedBlended_u0028_();
return true;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_12: vec3<f32>;
let _e125 = Orthographic_u0028_();
if _e125 {
let _e127 = fog_info.forward;
local_12 = -(_e127.xyz);
} else {
let _e131 = fog_info.eye;
let _e133 = v_world_position_1;
local_12 = normalize((_e131.xyz - _e133));
}
let _e136 = local_12;
return _e136;
}
fn MaterialLodBias_u0028_() -> f32 {
let _e126 = frag_info.target_origin[1u];
return _e126;
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s_1: Surface;
var param_17: vec3<f32>;
var param_18: vec3<f32>;
var cutoff: f32;
var edge: f32;
let _e130 = v_texcoord_1;
let _e131 = MaterialLodBias_u0028_();
let _e132 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e130, _e131);
texel = _e132;
let _e133 = texel;
param_17 = _e133.xyz;
let _e135 = SrgbToLinear_u0028_vf3_u003b((¶m_17));
let _e137 = frag_info.base_color;
param_18 = _e137.xyz;
let _e139 = SrgbToLinear_u0028_vf3_u003b((¶m_18));
let _e141 = v_color_1;
s_1.albedo = ((_e135 * _e139) * _e141.xyz);
let _e146 = texel[3u];
let _e149 = frag_info.base_color[3u];
let _e152 = v_color_1[3u];
s_1.alpha = ((_e146 * _e149) * _e152);
let _e156 = s_1.albedo;
g_albedo = _e156;
let _e159 = frag_info.material2_[0u];
cutoff = _e159;
let _e160 = cutoff;
if (_e160 > 1f) {
let _e162 = cutoff;
edge = (_e162 - 1f);
let _e165 = s_1.alpha;
let _e166 = edge;
let _e169 = s_1.alpha;
let _e170 = fwidth(_e169);
s_1.alpha = clamp((((_e165 - _e166) / max(_e170, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e176 = cutoff;
if (_e176 >= 0f) {
s_1.alpha = 1f;
}
}
let _e179 = cutoff;
let _e181 = cutoff;
g_premultiply = ((_e179 < 0f) && (_e181 > -0.75f));
let _e184 = v_normal_1;
s_1.n = normalize(_e184);
let _e187 = gl_FrontFacing_1;
if !(_e187) {
let _e190 = s_1.n;
s_1.n = -(_e190);
}
let _e193 = TowardsEye_u0028_();
s_1.v = _e193;
let _e196 = s_1.n;
let _e198 = s_1.v;
s_1.n_dot_v = max(dot(_e196, _e198), 0.0001f);
let _e204 = frag_info.material[0u];
s_1.metallic = clamp(_e204, 0f, 1f);
let _e209 = frag_info.material[1u];
s_1.roughness = clamp(_e209, 0.02f, 1f);
let _e213 = frag_info.ambient_ground;
let _e216 = frag_info.ambient_sky;
let _e220 = s_1.n[1u];
let _e227 = frag_info.material[2u];
s_1.ambient = (mix(_e213.xyz, _e216.xyz, vec3(((_e220 * 0.5f) + 0.5f))) * _e227);
let _e232 = frag_info.frame_params[0u];
s_1.exposure = max(_e232, 0f);
s_1.occlusion = 1f;
s_1.emissive = vec3<f32>(0f, 0f, 0f);
let _e237 = s_1;
return _e237;
}
fn main_1() {
var s_2: Surface;
var param_19: Surface;
var param_20: vec3<f32>;
var param_21: vec3<f32>;
var param_22: 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_pass_through = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e129 = ReadSurface_u0028_();
s_2 = _e129;
g_albedo = vec3<f32>(0f, 0f, 0f);
let _e130 = s_2;
param_19 = _e130;
let _e132 = s_2.albedo;
param_20 = _e132;
let _e133 = WriteDebugView_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_vf3_u003b((¶m_19), (¶m_20));
if _e133 {
return;
}
let _e135 = s_2.albedo;
param_21 = _e135;
let _e137 = s_2.alpha;
param_22 = _e137;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_21), (¶m_22));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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;
gl_FragCoord_1 = gl_FragCoord;
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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LambertOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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(21)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_texture_smp: sampler;
@group(1) @binding(19)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@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(17)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
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(15)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var normal_texture_smp: sampler;
@group(1) @binding(23)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var shadow_texture_smp: sampler;
fn ViewDepth_u0028_() -> f32 {
let _e208 = v_world_position_1;
let _e210 = fog_info.eye;
let _e214 = fog_info.forward;
return dot((_e208 - _e210.xyz), _e214.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e213 = ViewDepth_u0028_();
z = abs(_e213);
let _e215 = z;
near = (_e215 / 5f);
let _e217 = z;
far = (_e217 / 200f);
let _e219 = far;
let _e220 = far;
let _e222 = far;
far3_ = ((_e219 * _e220) * _e222);
let _e224 = (*alpha);
let _e225 = near;
let _e226 = near;
let _e229 = far3_;
let _e230 = far3_;
return (_e224 * clamp((10f / ((0.00001f + (_e225 * _e226)) + (_e229 * _e230))), 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 _e217 = fog_info.forward[3u];
mode = _e217;
let _e218 = mode;
if (_e218 > 0.5f) {
let _e221 = frag_color[3u];
alpha_1 = _e221;
let _e222 = alpha_1;
param = _e222;
let _e223 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e223;
let _e224 = frag_color;
let _e226 = weight;
let _e227 = (_e224.xyz * _e226);
let _e228 = alpha_1;
let _e229 = weight;
accumulate = vec4<f32>(_e227.x, _e227.y, _e227.z, (_e228 * _e229));
let _e235 = mode;
let _e237 = mode;
revealage = ((_e235 > 1.5f) && (_e237 < 2.5f));
let _e240 = revealage;
if _e240 {
let _e241 = alpha_1;
local = vec4(_e241);
} else {
let _e243 = accumulate;
local = _e243;
}
let _e244 = local;
frag_color = _e244;
let _e245 = mode;
if (_e245 > 2.5f) {
let _e247 = alpha_1;
frag_surface = vec4(_e247);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e211 = (*n)[0u];
let _e214 = (*n)[1u];
let _e218 = (*n)[2u];
let _e221 = (*n);
(*n) = (_e221 / vec3(((abs(_e211) + abs(_e214)) + abs(_e218))));
let _e224 = (*n);
e = _e224.xy;
let _e227 = (*n)[2u];
if (_e227 < 0f) {
let _e229 = (*n);
let _e235 = (*n)[0u];
let _e239 = (*n)[1u];
e = ((vec2(1f) - abs(_e229.yx)) * vec2<f32>(select(-1f, 1f, (_e235 >= 0f)), select(-1f, 1f, (_e239 >= 0f))));
}
let _e244 = e;
return ((_e244 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e209 = (*linear);
let _e211 = (*linear);
let _e215 = (*linear);
return mix((_e209 * 12.92f), ((pow(_e211, 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), _e215));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e212 = g_albedo;
param_1 = clamp(_e212, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e214 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e214.x, _e214.y, _e214.z, 1f);
let _e219 = g_debug_surface_on;
if _e219 {
let _e220 = g_debug_surface;
let _e221 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e220.x, _e220.y, _e220.z, _e221);
return;
}
let _e226 = v_normal_1;
geometric = normalize(_e226);
let _e228 = gl_FrontFacing_1;
if !(_e228) {
let _e230 = geometric;
geometric = -(_e230);
}
let _e232 = geometric;
param_2 = _e232;
let _e233 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e234 = (*roughness);
let _e236 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e233.x, _e233.y, clamp(_e234, 0f, 1f), _e236);
return;
}
fn Orthographic_u0028_() -> bool {
let _e210 = fog_info.projection[0u];
return (_e210 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e209 = Orthographic_u0028_();
if _e209 {
let _e210 = ViewDepth_u0028_();
local_1 = max(_e210, 0f);
} else {
let _e212 = v_world_position_1;
let _e214 = fog_info.eye;
local_1 = distance(_e212, _e214.xyz);
}
let _e217 = local_1;
return _e217;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e216 = fog_info.fog[3u];
density = _e216;
let _e217 = density;
if (_e217 <= 0f) {
let _e219 = (*color);
return _e219;
}
let _e220 = EyeDistance_u0028_();
d = _e220;
let _e223 = fog_info.eye[3u];
falloff = _e223;
let _e224 = falloff;
if (_e224 > 0f) {
let _e226 = falloff;
let _e228 = v_world_position_1[1u];
let _e231 = fog_info.eye[1u];
k = (_e226 * (_e228 - _e231));
let _e234 = k;
if (abs(_e234) > 0.001f) {
let _e237 = k;
let _e241 = k;
local_2 = ((1f - exp(-(_e237))) / _e241);
} else {
let _e243 = k;
local_2 = (1f - (0.5f * _e243));
}
let _e246 = local_2;
let _e247 = density;
density = (_e247 * _e246);
}
let _e250 = fog_info.fog;
let _e252 = (*color);
let _e253 = density;
let _e255 = d;
return mix(_e250.xyz, _e252, vec3(clamp(exp((-(_e253) * _e255)), 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 _e214 = g_premultiply;
let _e215 = (*alpha_2);
weight_1 = select(1f, _e215, _e214);
let _e217 = (*linearColor);
param_3 = _e217;
let _e218 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e219 = weight_1;
let _e220 = (_e218 * _e219);
let _e221 = (*alpha_2);
let _e222 = g_pass_through;
frag_color = vec4<f32>(_e220.x, _e220.y, _e220.z, (_e221 * (1f - _e222)));
let _e229 = (*roughness_1);
param_4 = _e229;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e209 = (*srgb);
let _e212 = (*srgb);
let _e217 = (*srgb);
return mix((_e209 / vec3(12.92f)), pow(((_e212 + 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), _e217));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e211 = (*key);
hue = fract(((_e211 * 0.618034f) + 0.13f));
let _e215 = hue;
k_1 = clamp((abs(((fract((vec3(_e215) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e228 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e228, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2556_: bool;
let _e209 = (*c);
let _e210 = (*c);
let _e212 = any((_e209 != _e210));
phi_2556_ = _e212;
if !(_e212) {
let _e214 = (*c);
phi_2556_ = any((abs(_e214) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e219 = phi_2556_;
return _e219;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2646_: bool;
var phi_2914_: bool;
let _e251 = gl_FragCoord_1[0u];
let _e254 = frag_info.debug_view[1u];
if (_e251 < _e254) {
let _e258 = frag_info.debug_view[2u];
local_3 = _e258;
} else {
let _e261 = frag_info.debug_view[0u];
local_3 = _e261;
}
let _e262 = local_3;
view = _e262;
let _e263 = view;
if (_e263 < 0.5f) {
return false;
}
let _e265 = view;
code = i32((_e265 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e268 = v_normal_1;
geometric_n = normalize(_e268);
let _e270 = v_tangent_1;
let _e272 = geometric_n;
let _e273 = geometric_n;
let _e274 = v_tangent_1;
tangent = (_e270.xyz - (_e272 * dot(_e273, _e274.xyz)));
let _e279 = tangent;
let _e280 = tangent;
let _e282 = (dot(_e279, _e280) > 0.000000000001f);
phi_2646_ = _e282;
if _e282 {
let _e284 = v_tangent_1[3u];
phi_2646_ = (abs((abs(_e284) - 1f)) < 0.01f);
}
let _e290 = phi_2646_;
tangent_usable = _e290;
let _e293 = frag_info.debug_view[3u];
identity = _e293;
let _e294 = identity;
identity_object = floor((_e294 / 8192f));
let _e297 = identity;
let _e298 = identity_object;
identity_rest = (_e297 - (_e298 * 8192f));
let _e301 = identity_rest;
identity_material = floor((_e301 / 2f));
let _e304 = identity_rest;
let _e305 = identity_material;
normal_mapped = ((_e304 - (_e305 * 2f)) > 0.5f);
let _e309 = code;
if (_e309 == 1i) {
let _e312 = (*s).albedo;
param_5 = clamp(_e312, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e314 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e314;
} else {
let _e315 = code;
if (_e315 == 2i) {
let _e318 = (*s).n;
shown = ((_e318 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e321 = code;
if (_e321 == 3i) {
let _e324 = (*s).roughness;
shown = vec3(clamp(_e324, 0f, 1f));
} else {
let _e327 = code;
if (_e327 == 4i) {
let _e330 = (*s).metallic;
shown = vec3(clamp(_e330, 0f, 1f));
} else {
let _e333 = code;
if (_e333 == 5i) {
let _e336 = (*s).occlusion;
shown = vec3(clamp(_e336, 0f, 1f));
} else {
let _e339 = code;
if (_e339 == 6i) {
let _e342 = (*s).emissive;
param_6 = clamp(_e342, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e344 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e344;
} else {
let _e345 = code;
if (_e345 == 7i) {
let _e347 = v_texcoord_1;
let _e348 = fract(_e347);
shown = vec3<f32>(_e348.x, _e348.y, 0f);
} else {
let _e352 = code;
if (_e352 == 8i) {
let _e354 = (*lit);
param_7 = clamp(_e354, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e356 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e356, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e358 = (*lit);
param_8 = _e358;
let _e359 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e359 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e360 = grey;
local_4 = vec3((_e360 * 0.5f));
}
let _e363 = local_4;
shown = _e363;
} else {
let _e364 = code;
if (_e364 == 9i) {
let _e366 = tangent_usable;
if _e366 {
let _e367 = tangent;
local_5 = ((normalize(_e367) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e371 = local_5;
shown = _e371;
} else {
let _e372 = code;
if (_e372 == 10i) {
let _e374 = v_texcoord_1;
uv = _e374;
let _e375 = uv;
cell = floor((_e375 * 8f));
let _e379 = cell[0u];
let _e381 = cell[1u];
odd = (fract(((_e379 + _e381) * 0.5f)) * 2f);
let _e386 = uv;
within = fract(_e386);
let _e388 = odd;
let _e392 = within[0u];
let _e396 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e388)) * vec3<f32>((0.55f + (0.45f * _e392)), (0.55f + (0.45f * _e396)), 0.85f));
} else {
let _e401 = code;
if (_e401 == 11i) {
let _e403 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e403));
} else {
let _e406 = code;
if (_e406 == 12i) {
let _e408 = v_color_1;
param_9 = clamp(_e408.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e411 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e411;
} else {
let _e412 = code;
let _e414 = code;
if ((_e412 == 13i) || (_e414 == 14i)) {
let _e417 = code;
let _e419 = identity_object;
let _e420 = identity_material;
key_1 = select(_e420, _e419, (_e417 == 13i));
let _e422 = key_1;
param_10 = _e422;
let _e423 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e425 = (*s).n_dot_v;
shown = (_e423 * (0.55f + (0.45f * _e425)));
} else {
let _e429 = code;
if (_e429 == 15i) {
let _e432 = (*s).albedo;
param_11 = clamp(_e432, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e434 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e434;
let _e435 = srgb_1;
luma = dot(_e435, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e438 = (*s).metallic;
metal = (_e438 > 0.5f);
let _e440 = metal;
let _e442 = luma;
if (!(_e440) && (_e442 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e445 = metal;
let _e446 = !(_e445);
phi_2914_ = _e446;
if _e446 {
let _e448 = srgb_1[0u];
let _e450 = srgb_1[1u];
let _e452 = srgb_1[2u];
phi_2914_ = (max(_e448, max(_e450, _e452)) > 0.9411765f);
}
let _e457 = phi_2914_;
if _e457 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e458 = metal;
let _e459 = luma;
if (_e458 && (_e459 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e462 = luma;
local_8 = vec3(_e462);
}
let _e464 = local_8;
local_7 = _e464;
}
let _e465 = local_7;
local_6 = _e465;
}
let _e466 = local_6;
shown = _e466;
} else {
let _e467 = code;
if (_e467 == 16i) {
let _e470 = (*s).metallic;
m = _e470;
let _e471 = m;
let _e473 = m;
if ((_e471 > 0.05f) && (_e473 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e476 = m;
local_9 = vec3(select(0.15f, 1f, (_e476 > 0.5f)));
}
let _e480 = local_9;
shown = _e480;
} else {
let _e481 = code;
if (_e481 == 17i) {
let _e483 = normal_mapped;
if !(_e483) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e485 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e485));
}
let _e488 = local_10;
shown = _e488;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e489 = g_premultiply;
if _e489 {
let _e491 = (*s).alpha;
local_11 = _e491;
} else {
local_11 = 1f;
}
let _e492 = local_11;
weight_2 = _e492;
let _e493 = shown;
param_12 = _e493;
let _e494 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e495 = weight_2;
let _e496 = (_e494 * _e495);
let _e498 = (*s).alpha;
frag_color = vec4<f32>(_e496.x, _e496.y, _e496.z, _e498);
let _e504 = (*s).roughness;
param_13 = _e504;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e211 = (*s_1).albedo;
return _e211;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e209 = (*i);
if (_e209 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e211 = (*i);
if (_e211 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e213 = (*i);
if (_e213 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e215 = (*i);
if (_e215 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e217 = (*i);
if (_e217 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e219 = (*i);
if (_e219 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e221 = (*i);
if (_e221 == 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_14: i32;
let _e214 = (*i_1);
param_14 = _e214;
let _e215 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e215;
let _e217 = p[0u];
let _e218 = (*ca);
let _e221 = p[1u];
let _e222 = (*sa);
let _e226 = p[0u];
let _e227 = (*sa);
let _e230 = p[1u];
let _e231 = (*ca);
let _e235 = (*radius);
return (vec2<f32>(((_e217 * _e218) - (_e221 * _e222)), ((_e226 * _e227) + (_e230 * _e231))) * _e235);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e217 = point_shadow.params[0u];
inset = _e217;
let _e218 = (*uv_1);
let _e219 = (*offset);
let _e221 = inset;
let _e222 = inset;
local_12 = clamp((_e218 + _e219), vec2(_e221), vec2((1f - _e222)));
let _e227 = local_12;
let _e228 = (*tile);
atlas = ((_e227 + _e228) * vec2<f32>(0.16666667f, 0.16666667f));
let _e233 = point_shadow.params3_[0u];
if (_e233 > 0.5f) {
let _e236 = atlas[1u];
atlas[1u] = (1f - _e236);
}
let _e239 = atlas;
let _e240 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e239, 0f);
let _e242 = atlas;
let _e243 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e242, 0f);
let _e246 = (*range);
return (min(_e240.x, _e243.x) * _e246);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e218 = (*uv_2);
param_15 = _e218;
let _e219 = (*offset_1);
param_16 = _e219;
let _e220 = (*tile_1);
param_17 = _e220;
let _e221 = (*range_1);
param_18 = _e221;
let _e222 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e222;
let _e223 = stored;
let _e224 = (*range_1);
if (_e223 >= (_e224 * 0.999f)) {
return 1f;
}
let _e227 = (*receiver);
let _e228 = stored;
return select(1f, 0f, (_e227 > _e228));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e239 = point_shadow.params2_[1u];
lightRadius = _e239;
let _e242 = point_shadow.params2_[0u];
minRadius = _e242;
let _e245 = point_shadow.params2_[2u];
maxRadius = _e245;
let _e246 = lightRadius;
if (_e246 <= 0f) {
let _e248 = (*uv_3);
param_19 = _e248;
param_20 = vec2<f32>(0f, 0f);
let _e249 = (*tile_2);
param_21 = _e249;
let _e250 = (*range_2);
param_22 = _e250;
let _e251 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e251;
let _e252 = minRadius;
return _e252;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e253 = i_2;
if (_e253 < 8i) {
let _e255 = i_2;
param_23 = _e255;
let _e256 = (*ca_1);
param_24 = _e256;
let _e257 = (*sa_1);
param_25 = _e257;
let _e258 = maxRadius;
param_26 = _e258;
let _e259 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e260 = (*uv_3);
param_27 = _e260;
param_28 = _e259;
let _e261 = (*tile_2);
param_29 = _e261;
let _e262 = (*range_2);
param_30 = _e262;
let _e263 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e263;
let _e264 = stored_1;
let _e265 = (*range_2);
if (_e264 >= (_e265 * 0.999f)) {
continue;
}
let _e268 = stored_1;
let _e269 = (*receiver_1);
if (_e268 >= _e269) {
continue;
}
let _e271 = stored_1;
let _e272 = sum;
sum = (_e272 + _e271);
let _e274 = count;
count = (_e274 + 1f);
continue;
} else {
break;
}
continuing {
let _e276 = i_2;
i_2 = (_e276 + 1i);
}
}
let _e278 = count;
if (_e278 < 0.5f) {
return -1f;
}
let _e280 = sum;
let _e281 = count;
blocker = max((_e280 / _e281), 0.0001f);
let _e284 = blocker;
(*blockerOut) = _e284;
let _e285 = lightRadius;
let _e286 = (*receiver_1);
let _e287 = blocker;
let _e291 = blocker;
world = ((_e285 * max((_e286 - _e287), 0f)) / _e291);
let _e293 = world;
let _e294 = (*receiver_1);
let _e296 = (*tanHalf);
let _e299 = minRadius;
let _e300 = maxRadius;
return clamp((_e293 / ((2f * _e294) * _e296)), _e299, _e300);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e210 = (*rows);
if (_e210 > 0f) {
let _e213 = gl_FragCoord_1[0u];
let _e214 = (*rows);
let _e216 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e213, (_e214 - _e216));
} else {
let _e219 = gl_FragCoord_1;
local_13 = _e219.xy;
}
let _e221 = local_13;
return _e221;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2243_: bool;
var phi_2304_: bool;
let _e262 = (*lightIndex);
let _e266 = point_shadow.slots[_e262][0u];
slot = i32((_e266 + 0.5f));
let _e269 = (*lightIndex);
let _e273 = point_shadow.slots[_e269][0u];
if (_e273 < 0f) {
return 1f;
}
let _e277 = point_shadow.params[2u];
strength = _e277;
let _e278 = strength;
if (_e278 <= 0f) {
return 1f;
}
let _e280 = slot;
let _e283 = point_shadow.lights[_e280];
let _e285 = (*world_1);
toLight = (_e283.xyz - _e285);
let _e287 = toLight;
toLightLength = max(length(_e287), 0.000001f);
let _e290 = (*normal);
let _e291 = toLight;
let _e292 = toLightLength;
nDotL = max(dot(_e290, (_e291 / vec3(_e292))), 0.15f);
let _e297 = nDotL;
let _e298 = nDotL;
let _e303 = nDotL;
let _e304 = nDotL;
slope = min((sqrt(max((1f - (_e297 * _e298)), 0f)) / (_e303 * _e304)), 8f);
let _e308 = toLightLength;
let _e310 = (*lightIndex);
let _e314 = point_shadow.slots[_e310][2u];
let _e319 = point_shadow.params3_[1u];
texel = (((2f * _e308) * max(_e314, 0.0001f)) * _e319);
let _e321 = (*world_1);
let _e322 = (*normal);
let _e323 = texel;
let _e327 = point_shadow.params[3u];
let _e329 = slope;
origin = (_e321 + (((_e322 * _e323) * _e327) * (1f + _e329)));
let _e333 = origin;
let _e334 = slot;
let _e337 = point_shadow.lights[_e334];
toFragment = (_e333 - _e337.xyz);
let _e340 = toFragment;
distance_ = length(_e340);
let _e342 = slot;
let _e346 = point_shadow.lights[_e342][3u];
range_3 = max(_e346, 0.0001f);
let _e348 = distance_;
let _e349 = range_3;
if (_e348 >= _e349) {
return 1f;
}
face = 0i;
let _e351 = (*lightIndex);
let _e355 = point_shadow.slots[_e351][1u];
if (_e355 < 0.5f) {
let _e357 = toFragment;
a = abs(_e357);
let _e360 = a[0u];
let _e362 = a[1u];
let _e363 = (_e360 >= _e362);
phi_2243_ = _e363;
if _e363 {
let _e365 = a[0u];
let _e367 = a[2u];
phi_2243_ = (_e365 >= _e367);
}
let _e370 = phi_2243_;
if _e370 {
let _e372 = toFragment[0u];
face = select(1i, 0i, (_e372 > 0f));
} else {
let _e376 = a[1u];
let _e378 = a[2u];
if (_e376 >= _e378) {
let _e381 = toFragment[1u];
face = select(3i, 2i, (_e381 > 0f));
} else {
let _e385 = toFragment[2u];
face = select(5i, 4i, (_e385 > 0f));
}
}
}
let _e388 = slot;
let _e390 = face;
let _e394 = point_shadow.faces[((_e388 * 6i) + _e390)];
let _e395 = origin;
clip = (_e394 * vec4<f32>(_e395.x, _e395.y, _e395.z, 1f));
let _e402 = clip[3u];
if (_e402 <= 0f) {
return 1f;
}
let _e404 = clip;
let _e407 = clip[3u];
ndc = (_e404.xy / vec2(_e407));
let _e411 = ndc[0u];
let _e413 = (abs(_e411) > 1f);
phi_2304_ = _e413;
if !(_e413) {
let _e416 = ndc[1u];
phi_2304_ = (abs(_e416) > 1f);
}
let _e420 = phi_2304_;
if _e420 {
return 1f;
}
let _e422 = ndc[0u];
let _e426 = ndc[1u];
uv_4 = vec2<f32>(((_e422 * 0.5f) + 0.5f), (0.5f - (_e426 * 0.5f)));
let _e430 = face;
let _e432 = slot;
tile_3 = vec2<f32>(f32(_e430), f32(_e432));
let _e435 = distance_;
let _e438 = point_shadow.params[1u];
receiver_2 = (_e435 - _e438);
let _e442 = frag_info.target_origin[0u];
param_31 = _e442;
let _e443 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e443, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e448 = noise;
angle = (_e448 * 6.2831855f);
let _e450 = angle;
ca_2 = cos(_e450);
let _e452 = angle;
sa_2 = sin(_e452);
let _e454 = (*lightIndex);
let _e458 = point_shadow.slots[_e454][2u];
tanHalf_1 = max(_e458, 0.0001f);
blocker_1 = -1f;
let _e460 = uv_4;
param_32 = _e460;
let _e461 = tile_3;
param_33 = _e461;
let _e462 = range_3;
param_34 = _e462;
let _e463 = receiver_2;
param_35 = _e463;
let _e464 = ca_2;
param_36 = _e464;
let _e465 = sa_2;
param_37 = _e465;
let _e466 = tanHalf_1;
param_38 = _e466;
let _e467 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e468 = param_39;
blocker_1 = _e468;
radius_1 = _e467;
let _e471 = point_shadow.params2_[3u];
if (_e471 > 0.5f) {
g_debug_surface_on = true;
let _e473 = radius_1;
if (_e473 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e475 = radius_1;
let _e478 = point_shadow.params2_[2u];
let _e482 = blocker_1;
let _e483 = range_3;
local_14 = vec3<f32>(clamp((_e475 / max(_e478, 0.000001f)), 0f, 1f), clamp((_e482 / _e483), 0f, 1f), 0f);
}
let _e487 = local_14;
g_debug_surface = _e487;
}
let _e488 = radius_1;
if (_e488 < 0f) {
return 1f;
}
let _e490 = uv_4;
param_40 = _e490;
param_41 = vec2<f32>(0f, 0f);
let _e491 = tile_3;
param_42 = _e491;
let _e492 = range_3;
param_43 = _e492;
let _e493 = receiver_2;
param_44 = _e493;
let _e494 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e494;
let _e495 = radius_1;
if (_e495 > 0f) {
i_3 = 0i;
loop {
let _e497 = i_3;
if (_e497 < 8i) {
let _e499 = i_3;
param_45 = _e499;
let _e500 = ca_2;
param_46 = _e500;
let _e501 = sa_2;
param_47 = _e501;
let _e502 = radius_1;
param_48 = _e502;
let _e503 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e504 = uv_4;
param_49 = _e504;
param_50 = _e503;
let _e505 = tile_3;
param_51 = _e505;
let _e506 = range_3;
param_52 = _e506;
let _e507 = receiver_2;
param_53 = _e507;
let _e508 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e509 = lit_1;
lit_1 = (_e509 + _e508);
continue;
} else {
break;
}
continuing {
let _e511 = i_3;
i_3 = (_e511 + 1i);
}
}
let _e513 = lit_1;
lit_1 = (_e513 * 0.11111111f);
}
let _e515 = lit_1;
let _e516 = strength;
return mix(1f, _e515, clamp(_e516, 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 _e213 = (*i_4);
let _e216 = (*n_1);
r = sqrt(((f32(_e213) + 0.5f) / f32(_e216)));
let _e220 = (*i_4);
let _e223 = (*turn);
theta = ((f32(_e220) * 2.3999631f) + _e223);
let _e225 = r;
let _e226 = theta;
let _e228 = theta;
return (vec2<f32>(cos(_e226), sin(_e228)) * _e225);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e212 = frag_info.target_origin[0u];
param_54 = _e212;
let _e213 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e216 = frag_info.target_origin[3u];
at = (_e213 + vec2((5.588238f * max(_e216, 0f))));
let _e221 = at;
return fract((52.982918f * fract(dot(_e221, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e211 = (*mode_1);
if (_e211 > 0.5f) {
let _e213 = (*stored_2);
local_15 = (1f - _e213);
} else {
let _e215 = (*stored_2);
local_15 = _e215;
}
let _e216 = local_15;
return _e216;
}
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 _e217 = (*moments)[1u];
let _e219 = (*moments)[0u];
let _e221 = (*moments)[0u];
let _e224 = (*minVariance);
variance = max((_e217 - (_e219 * _e221)), _e224);
let _e226 = (*t);
let _e228 = (*moments)[0u];
d_1 = (_e226 - _e228);
let _e230 = variance;
let _e231 = variance;
let _e232 = d_1;
let _e233 = d_1;
pMax = (_e230 / (_e231 + (_e232 * _e233)));
let _e237 = pMax;
let _e238 = (*bleed);
let _e240 = (*bleed);
reduced = clamp(((_e237 - _e238) / max((1f - _e240), 0.0001f)), 0f, 1f);
let _e245 = (*t);
let _e247 = (*moments)[0u];
let _e249 = reduced;
return select(_e249, 1f, (_e245 <= _e247));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e210 = (*depth);
d_2 = ((2f * clamp(_e210, 0f, 1f)) - 1f);
let _e214 = d_2;
let _e217 = d_2;
return vec2<f32>(exp((40f * _e214)), -(exp((-5f * _e217))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e224 = (*depth_1);
param_55 = _e224;
let _e225 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e225;
let _e226 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e226);
let _e229 = scale[0u];
let _e231 = scale[0u];
let _e233 = (*moments_1);
param_56 = _e233.xy;
let _e236 = warped[0u];
param_57 = _e236;
param_58 = (_e229 * _e231);
let _e237 = (*bleed_1);
param_59 = _e237;
let _e238 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e238;
let _e240 = scale[1u];
let _e242 = scale[1u];
let _e244 = (*moments_1);
param_60 = _e244.zw;
let _e247 = warped[1u];
param_61 = _e247;
param_62 = (_e240 * _e242);
let _e248 = (*bleed_1);
param_63 = _e248;
let _e249 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e249;
let _e250 = positive;
let _e251 = negative;
return min(_e250, _e251);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e210 = (*depth_2);
stored_3 = max((1f - _e210), 0.000061035156f);
let _e213 = stored_3;
return exp2((floor(log2(_e213)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3829_: bool;
var phi_3840_: bool;
var phi_3997_: bool;
var phi_4004_: bool;
var phi_4011_: bool;
let _e287 = frag_info.shadow_params[3u];
strength_1 = _e287;
let _e288 = strength_1;
if (_e288 <= 0f) {
return 1f;
}
let _e290 = (*lightIndex_1);
let _e293 = frag_info.frame_params[2u];
if (_e290 != i32(floor((_e293 + 0.5f)))) {
return 1f;
}
let _e300 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e300 + 0.5f));
let _e303 = Orthographic_u0028_();
if _e303 {
let _e304 = ViewDepth_u0028_();
local_16 = _e304;
} else {
let _e305 = v_world_position_1;
let _e307 = frag_info.camera_position;
local_16 = length((_e305 - _e307.xyz));
}
let _e311 = local_16;
viewDistance = _e311;
cascade = 0i;
let _e312 = cascadeCount;
let _e313 = (_e312 > 1i);
phi_3829_ = _e313;
if _e313 {
let _e314 = viewDistance;
let _e317 = frag_info.shadow_cascades[0u];
phi_3829_ = (_e314 > _e317);
}
let _e320 = phi_3829_;
if _e320 {
cascade = 1i;
}
let _e321 = cascadeCount;
let _e322 = (_e321 > 2i);
phi_3840_ = _e322;
if _e322 {
let _e323 = viewDistance;
let _e326 = frag_info.shadow_cascades[1u];
phi_3840_ = (_e323 > _e326);
}
let _e329 = phi_3840_;
if _e329 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e330 = attempt;
if (_e330 < 3i) {
let _e332 = cascade;
let _e333 = attempt;
which = (_e332 + _e333);
let _e335 = which;
let _e336 = cascadeCount;
if (_e335 >= _e336) {
break;
}
let _e338 = which;
if (_e338 == 0i) {
let _e341 = frag_info.shadow_matrix;
local_17 = _e341;
} else {
let _e342 = which;
if (_e342 == 1i) {
let _e345 = frag_info.shadow_matrix_far;
local_18 = _e345;
} else {
let _e347 = frag_info.shadow_matrix_farthest;
local_18 = _e347;
}
let _e348 = local_18;
local_17 = _e348;
}
let _e349 = local_17;
matrix = _e349;
let _e352 = matrix[0][0u];
let _e355 = matrix[1][0u];
let _e358 = matrix[2][0u];
axisX = vec3<f32>(_e352, _e355, _e358);
let _e362 = matrix[0][1u];
let _e365 = matrix[1][1u];
let _e368 = matrix[2][1u];
axisY = vec3<f32>(_e362, _e365, _e368);
let _e370 = axisX;
rowX = max(length(_e370), 0.000001f);
let _e373 = axisY;
rowY = max(length(_e373), 0.000001f);
let _e378 = frag_info.shadow_cascades[3u];
let _e380 = rowX;
texelMetres = ((2f * _e378) / _e380);
let _e384 = frag_info.shadow_cascades[3u];
let _e387 = (*s_2).n;
let _e388 = axisX;
let _e391 = rowX;
let _e392 = rowX;
let _e396 = (*s_2).n;
let _e397 = axisY;
let _e400 = rowY;
let _e401 = rowY;
reach = ((3f * _e384) * ((abs(dot(_e387, _e388)) / (_e391 * _e392)) + (abs(dot(_e396, _e397)) / (_e400 * _e401))));
let _e408 = frag_info.shadow_params[2u];
let _e409 = texelMetres;
flatOffset = min(_e408, _e409);
let _e411 = v_world_position_1;
let _e413 = (*s_2).n;
let _e414 = flatOffset;
let _e415 = reach;
origin_1 = (_e411 + (_e413 * (_e414 + _e415)));
let _e419 = matrix;
let _e420 = origin_1;
lightSpace = (_e419 * vec4<f32>(_e420.x, _e420.y, _e420.z, 1f));
let _e427 = lightSpace[3u];
if (_e427 <= 0f) {
continue;
}
let _e429 = lightSpace;
let _e432 = lightSpace[3u];
candidate = (_e429.xyz / vec3(_e432));
let _e436 = candidate[0u];
let _e440 = candidate[1u];
inTile = vec2<f32>(((_e436 * 0.5f) + 0.5f), (0.5f - (_e440 * 0.5f)));
let _e445 = inTile[0u];
let _e446 = (_e445 < 0f);
phi_3997_ = _e446;
if !(_e446) {
let _e449 = inTile[0u];
phi_3997_ = (_e449 > 1f);
}
let _e452 = phi_3997_;
phi_4004_ = _e452;
if !(_e452) {
let _e455 = inTile[1u];
phi_4004_ = (_e455 < 0f);
}
let _e458 = phi_4004_;
phi_4011_ = _e458;
if !(_e458) {
let _e461 = inTile[1u];
phi_4011_ = (_e461 > 1f);
}
let _e464 = phi_4011_;
if _e464 {
continue;
}
let _e466 = candidate[2u];
if (_e466 > 1f) {
let _e468 = which;
let _e469 = cascadeCount;
if (_e468 < (_e469 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e474 = inTile[0u];
let _e475 = which;
let _e478 = cascadeCount;
let _e482 = inTile[1u];
uv_5 = vec2<f32>(((_e474 + f32(_e475)) / f32(_e478)), _e482);
let _e484 = candidate;
projected = _e484;
let _e485 = which;
cascade = _e485;
let _e486 = texelMetres;
cascadeTexel = _e486;
let _e489 = matrix[0][2u];
let _e492 = matrix[1][2u];
let _e495 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e489, _e492, _e495)), 0.000001f));
let _e501 = (*s_2).n;
let _e504 = matrix[0][2u];
let _e507 = matrix[1][2u];
let _e510 = matrix[2][2u];
let _e514 = cascadeDepth;
cosSlope = clamp((abs(dot(_e501, vec3<f32>(_e504, _e507, _e510))) * _e514), 0.1f, 1f);
let _e517 = texelMetres;
let _e518 = cosSlope;
let _e519 = cosSlope;
let _e525 = cosSlope;
let _e527 = cascadeDepth;
receiverSlope = (((_e517 * sqrt(max((1f - (_e518 * _e519)), 0f))) / _e525) / _e527);
found = true;
break;
} else {
break;
}
continuing {
let _e529 = attempt;
attempt = (_e529 + 1i);
}
}
let _e531 = found;
if !(_e531) {
return 1f;
}
let _e533 = cascade;
if (_e533 == 0i) {
let _e537 = frag_info.shadow_bias[0u];
local_19 = _e537;
} else {
let _e538 = cascade;
if (_e538 == 1i) {
let _e542 = frag_info.shadow_bias[1u];
local_20 = _e542;
} else {
let _e545 = frag_info.shadow_bias[2u];
local_20 = _e545;
}
let _e546 = local_20;
local_19 = _e546;
}
let _e547 = local_19;
bias = _e547;
let _e550 = frag_info.shadow_params[1u];
storage_ = _e550;
let _e551 = storage_;
let _e553 = storage_;
if ((_e551 > 0.5f) && (_e553 < 1.5f)) {
let _e556 = bias;
let _e558 = projected[2u];
param_64 = _e558;
let _e559 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e556, _e559);
}
let _e563 = frag_info.shadow_params[0u];
let _e566 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e563, _e566);
let _e568 = cascade;
let _e570 = cascadeCount;
let _e574 = texel_1;
tileLo = (vec2<f32>((f32(_e568) / f32(_e570)), 0f) + (_e574 * 0.5f));
let _e577 = cascade;
let _e580 = cascadeCount;
let _e584 = texel_1;
tileHi = (vec2<f32>((f32((_e577 + 1i)) / f32(_e580)), 1f) - (_e584 * 0.5f));
let _e589 = frag_info.shadow_bias[3u];
if (_e589 > 0.5f) {
let _e591 = uv_5;
let _e592 = tileLo;
let _e593 = tileHi;
let _e595 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e591, _e592, _e593), 0f);
stored_4 = _e595;
let _e597 = stored_4[1u];
let _e600 = stored_4[2u];
let _e603 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e597), (1f - _e600), _e603), vec3(0f), vec3(4f));
let _e608 = through;
let _e609 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e608, vec3(clamp(_e609, 0f, 1f)));
}
let _e615 = frag_info.ambient_ground[3u];
softness = _e615;
lit_2 = 0f;
let _e616 = softness;
if (_e616 < 0f) {
let _e618 = uv_5;
let _e619 = tileLo;
let _e620 = tileHi;
let _e622 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e618, _e619, _e620), 0f);
moments_2 = _e622;
let _e624 = projected[2u];
let _e625 = bias;
let _e627 = softness;
let _e631 = moments_2;
param_65 = _e631;
param_66 = (_e624 - _e625);
param_67 = clamp((-(_e627) - 1f), 0f, 0.95f);
let _e632 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e632;
} else {
let _e633 = softness;
if (_e633 <= 0f) {
y = -1i;
loop {
let _e635 = y;
if (_e635 <= 1i) {
x = -1i;
loop {
let _e637 = x;
if (_e637 <= 1i) {
let _e639 = uv_5;
let _e640 = x;
let _e642 = y;
let _e645 = texel_1;
let _e648 = tileLo;
let _e649 = tileHi;
let _e651 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e639 + (vec2<f32>(f32(_e640), f32(_e642)) * _e645)), _e648, _e649), 0f);
param_68 = _e651.x;
let _e653 = storage_;
param_69 = _e653;
let _e654 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e654;
let _e656 = projected[2u];
let _e657 = bias;
let _e659 = occluder;
let _e662 = lit_2;
lit_2 = (_e662 + select(1f, 0f, ((_e656 - _e657) > _e659)));
continue;
} else {
break;
}
continuing {
let _e664 = x;
x = (_e664 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e666 = y;
y = (_e666 + 1i);
}
}
let _e668 = lit_2;
lit_2 = (_e668 * 0.11111111f);
} else {
let _e670 = softness;
spread = tan(min(_e670, 0.5f));
let _e673 = ShadowNoise_u0028_();
turn_1 = (_e673 * 6.2831855f);
let _e675 = spread;
let _e677 = projected[2u];
let _e679 = cascadeDepth;
let _e681 = cascadeTexel;
searchRadius = clamp((((_e675 * _e677) * _e679) / _e681), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e684 = i_5;
if (_e684 < 16i) {
let _e686 = i_5;
param_70 = _e686;
param_71 = 16i;
let _e687 = turn_1;
param_72 = _e687;
let _e688 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e688;
let _e689 = bias;
let _e690 = disc;
let _e692 = searchRadius;
let _e696 = receiverSlope;
tapBias = (_e689 + (max(((length(_e690) * _e692) - 1.5f), 0f) * _e696));
let _e699 = uv_5;
let _e700 = disc;
let _e701 = texel_1;
let _e703 = searchRadius;
let _e706 = tileLo;
let _e707 = tileHi;
let _e709 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e699 + ((_e700 * _e701) * _e703)), _e706, _e707), 0f);
param_73 = _e709.x;
let _e711 = storage_;
param_74 = _e711;
let _e712 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e712;
let _e714 = projected[2u];
let _e715 = tapBias;
let _e717 = occluder_1;
if ((_e714 - _e715) > _e717) {
let _e719 = occluder_1;
let _e720 = blockerSum;
blockerSum = (_e720 + _e719);
let _e722 = blockerCount;
blockerCount = (_e722 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e724 = i_5;
i_5 = (_e724 + 1i);
}
}
let _e726 = blockerCount;
if (_e726 <= 0f) {
return 1f;
}
let _e729 = projected[2u];
let _e730 = blockerSum;
let _e731 = blockerCount;
let _e735 = cascadeDepth;
gap = (max((_e729 - (_e730 / _e731)), 0f) * _e735);
let _e737 = spread;
let _e738 = gap;
let _e740 = cascadeTexel;
radius_2 = clamp(((_e737 * _e738) / _e740), 1f, 16f);
i_6 = 0i;
loop {
let _e743 = i_6;
if (_e743 < 16i) {
let _e745 = turn_1;
let _e747 = i_6;
param_75 = _e747;
param_76 = 16i;
param_77 = (_e745 + 1f);
let _e748 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e748;
let _e749 = bias;
let _e750 = disc_1;
let _e752 = radius_2;
let _e756 = receiverSlope;
tapBias_1 = (_e749 + (max(((length(_e750) * _e752) - 1.5f), 0f) * _e756));
let _e759 = uv_5;
let _e760 = disc_1;
let _e761 = texel_1;
let _e763 = radius_2;
let _e766 = tileLo;
let _e767 = tileHi;
let _e769 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e759 + ((_e760 * _e761) * _e763)), _e766, _e767), 0f);
param_78 = _e769.x;
let _e771 = storage_;
param_79 = _e771;
let _e772 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e772;
let _e774 = projected[2u];
let _e775 = tapBias_1;
let _e777 = occluder_2;
let _e780 = lit_2;
lit_2 = (_e780 + select(1f, 0f, ((_e774 - _e775) > _e777)));
continue;
} else {
break;
}
continuing {
let _e782 = i_6;
i_6 = (_e782 + 1i);
}
}
let _e784 = lit_2;
lit_2 = (_e784 * 0.0625f);
}
}
let _e786 = lit_2;
let _e787 = strength_1;
return mix(1f, _e786, clamp(_e787, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e214 = (*s_3);
param_80 = _e214;
let _e215 = (*light_2);
param_81 = _e215;
let _e216 = (*index);
param_82 = _e216;
let _e217 = 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_80), (¶m_81), (¶m_82));
return _e217;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e209 = (*index_1);
return (_e209 < 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 _e213 = (*distance_1);
let _e214 = (*distance_1);
attenuation = (1f / max((_e213 * _e214), 0.0001f));
let _e218 = (*range_4);
if (_e218 > 0f) {
let _e220 = (*distance_1);
let _e221 = (*range_4);
ratio = (_e220 / _e221);
let _e223 = ratio;
let _e224 = ratio;
let _e226 = ratio;
let _e228 = ratio;
window = clamp((1f - (((_e223 * _e224) * _e226) * _e228)), 0f, 1f);
let _e232 = window;
let _e233 = window;
let _e235 = attenuation;
attenuation = (_e235 * (_e232 * _e233));
}
let _e237 = attenuation;
return _e237;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e225 = (*halfWidth);
let _e226 = (*halfHeight);
n_2 = cross(_e225, _e226);
let _e228 = n_2;
nLen = length(_e228);
let _e230 = nLen;
if (_e230 < 0.000000000001f) {
let _e232 = (*centre);
return _e232;
}
let _e233 = nLen;
let _e234 = n_2;
n_2 = (_e234 / vec3(_e233));
let _e237 = (*centre);
let _e238 = (*world_2);
toPlane = (_e237 - _e238);
let _e240 = (*mirror);
let _e241 = n_2;
denom = dot(_e240, _e241);
let _e243 = denom;
if (abs(_e243) < 0.00001f) {
let _e246 = toPlane;
let _e247 = n_2;
let _e248 = toPlane;
let _e249 = n_2;
onPlane = (_e246 - (_e247 * dot(_e248, _e249)));
} else {
let _e253 = toPlane;
let _e254 = n_2;
let _e256 = denom;
t_1 = (dot(_e253, _e254) / _e256);
let _e258 = t_1;
if (_e258 > 0f) {
let _e260 = (*mirror);
let _e261 = t_1;
local_21 = (_e260 * _e261);
} else {
let _e263 = toPlane;
let _e264 = n_2;
let _e265 = toPlane;
let _e266 = n_2;
local_21 = (_e263 - (_e264 * dot(_e265, _e266)));
}
let _e270 = local_21;
onPlane = _e270;
}
let _e271 = onPlane;
let _e272 = toPlane;
offset_2 = (_e271 - _e272);
let _e274 = (*halfWidth);
let _e275 = (*halfWidth);
wLen2_ = max(dot(_e274, _e275), 0.000000000001f);
let _e278 = (*halfHeight);
let _e279 = (*halfHeight);
hLen2_ = max(dot(_e278, _e279), 0.000000000001f);
let _e282 = offset_2;
let _e283 = (*halfWidth);
let _e285 = wLen2_;
u = clamp((dot(_e282, _e283) / _e285), -1f, 1f);
let _e288 = offset_2;
let _e289 = (*halfHeight);
let _e291 = hLen2_;
v = clamp((dot(_e288, _e289) / _e291), -1f, 1f);
let _e294 = (*centre);
let _e295 = (*halfWidth);
let _e296 = u;
let _e299 = (*halfHeight);
let _e300 = v;
return ((_e294 + (_e295 * _e296)) + (_e299 * _e300));
}
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_22: f32;
let _e217 = (*a_1);
let _e218 = (*a_1);
ua = (_e217 / vec3(max(length(_e218), 0.000000000001f)));
let _e223 = (*b);
let _e224 = (*b);
ub = (_e223 / vec3(max(length(_e224), 0.000000000001f)));
let _e229 = ua;
let _e230 = ub;
angle_1 = acos(clamp(dot(_e229, _e230), -1f, 1f));
let _e234 = ua;
let _e235 = ub;
axis = cross(_e234, _e235);
let _e237 = axis;
len = length(_e237);
let _e239 = len;
if (_e239 > 0.000001f) {
let _e241 = angle_1;
let _e242 = axis;
let _e243 = (*n_3);
let _e246 = len;
local_22 = ((_e241 * dot(_e242, _e243)) / _e246);
} else {
local_22 = 0f;
}
let _e248 = local_22;
return _e248;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e231 = i_7;
if (_e231 < 4i) {
let _e233 = i_7;
let _e235 = (*corners)[_e233];
a_2 = _e235;
let _e236 = i_7;
if (_e236 == 3i) {
local_23 = 0i;
} else {
let _e238 = i_7;
local_23 = (_e238 + 1i);
}
let _e240 = local_23;
let _e242 = (*corners)[_e240];
b_1 = _e242;
let _e243 = a_2;
let _e244 = (*n_4);
ha = dot(_e243, _e244);
let _e246 = b_1;
let _e247 = (*n_4);
hb = dot(_e246, _e247);
let _e249 = ha;
let _e250 = hb;
d_3 = (_e249 - _e250);
let _e252 = a_2;
let _e253 = b_1;
let _e254 = a_2;
let _e256 = d_3;
if (abs(_e256) > 0.000000000001f) {
let _e259 = ha;
let _e260 = d_3;
local_24 = (_e259 / _e260);
} else {
local_24 = 0f;
}
let _e262 = local_24;
q = (_e252 + ((_e253 - _e254) * _e262));
let _e265 = ha;
aAbove = (_e265 > 0f);
let _e267 = hb;
bAbove = (_e267 > 0f);
let _e269 = aAbove;
let _e270 = bAbove;
if (_e269 || _e270) {
let _e272 = aAbove;
let _e273 = a_2;
let _e274 = q;
let _e277 = bAbove;
let _e278 = b_1;
let _e279 = q;
param_83 = select(_e274, _e273, vec3(_e272));
param_84 = select(_e279, _e278, vec3(_e277));
let _e282 = (*n_4);
param_85 = _e282;
let _e283 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e283;
} else {
local_25 = 0f;
}
let _e284 = local_25;
let _e285 = total;
total = (_e285 + _e284);
let _e287 = aAbove;
let _e288 = bAbove;
let _e291 = q;
let _e292 = exit;
exit = select(_e292, _e291, vec3((_e287 && !(_e288))));
let _e295 = aAbove;
let _e297 = bAbove;
let _e299 = q;
let _e300 = entry;
entry = select(_e300, _e299, vec3((!(_e295) && _e297)));
continue;
} else {
break;
}
continuing {
let _e303 = i_7;
i_7 = (_e303 + 1i);
}
}
let _e305 = exit;
param_86 = _e305;
let _e306 = entry;
param_87 = _e306;
let _e307 = (*n_4);
param_88 = _e307;
let _e308 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e309 = total;
total = (_e309 + _e308);
let _e311 = total;
return max((-(_e311) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e214 = (*slot_1);
let _e215 = (*slot_1);
lane = (_e214 - ((_e215 / 4i) * 4i));
let _e219 = lane;
if (_e219 == 0i) {
let _e222 = (*four)[0u];
local_26 = _e222;
} else {
let _e223 = lane;
if (_e223 == 1i) {
let _e226 = (*four)[1u];
local_27 = _e226;
} else {
let _e227 = lane;
if (_e227 == 2i) {
let _e230 = (*four)[2u];
local_28 = _e230;
} else {
let _e232 = (*four)[3u];
local_28 = _e232;
}
let _e233 = local_28;
local_27 = _e233;
}
let _e234 = local_27;
local_26 = _e234;
}
let _e235 = local_26;
return _e235;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e211 = (*slot_2);
let _e215 = light_list_info.scales[(_e211 / 4i)];
param_89 = _e215;
let _e216 = (*slot_2);
param_90 = _e216;
let _e217 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e217;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e213 = light_list_info.slot_rows[0i];
let _e214 = (*row);
a_3 = abs((_e213 - vec4(_e214)));
let _e220 = light_list_info.slot_rows[1i];
let _e221 = (*row);
b_2 = abs((_e220 - vec4(_e221)));
let _e226 = a_3[0u];
let _e228 = a_3[1u];
let _e231 = a_3[2u];
let _e233 = a_3[3u];
let _e237 = b_2[0u];
let _e239 = b_2[1u];
let _e242 = b_2[2u];
let _e244 = b_2[3u];
return (min(min(min(_e226, _e228), min(_e231, _e233)), min(min(_e237, _e239), min(_e242, _e244))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e211 = (*slot_3);
let _e215 = light_list_info.indices[(_e211 / 4i)];
param_91 = _e215;
let _e216 = (*slot_3);
param_92 = _e216;
let _e217 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e217;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e210 = (*texel_2);
let _e214 = light_list_info.list[1u];
let _e216 = (*row_1);
let _e220 = light_list_info.list[2u];
let _e223 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e210 + 0.5f) * _e214), ((_e216 + 0.5f) * _e220)), 0f);
return _e223;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e218 = g_cluster_offset;
let _e219 = (*slot_4);
entry_1 = (_e218 + f32(_e219));
let _e222 = entry_1;
row_2 = floor((_e222 / 16f));
let _e225 = entry_1;
let _e226 = row_2;
within_1 = (_e225 - (_e226 * 16f));
let _e229 = within_1;
texel_3 = floor((_e229 / 4f));
let _e234 = light_list_info.cluster_depth[3u];
let _e235 = row_2;
let _e237 = texel_3;
param_93 = _e237;
param_94 = (_e234 + _e235);
let _e238 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e238;
let _e239 = within_1;
let _e240 = texel_3;
let _e245 = four_1;
param_95 = _e245;
param_96 = i32(((_e239 - (_e240 * 4f)) + 0.5f));
let _e246 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e246;
}
fn Clustered_u0028_() -> bool {
let _e210 = light_list_info.cluster_grid[3u];
return (_e210 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e262 = (*index_2);
if (_e262 < 8i) {
let _e264 = (*index_2);
let _e267 = frag_info.light_position[_e264];
position = _e267;
let _e268 = (*index_2);
let _e271 = frag_info.light_color[_e268];
color_1 = _e271;
let _e272 = (*index_2);
let _e275 = frag_info.light_direction[_e272];
direction = _e275;
let _e276 = (*index_2);
let _e279 = frag_info.light_cone[_e276];
cone = _e279;
} else {
let _e280 = (*index_2);
slot_5 = (_e280 - 8i);
let _e282 = Clustered_u0028_();
clustered = _e282;
let _e283 = clustered;
if _e283 {
let _e284 = slot_5;
param_97 = _e284;
let _e285 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e285;
} else {
let _e286 = slot_5;
param_98 = _e286;
let _e287 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e287;
}
let _e288 = local_29;
listRow = _e288;
let _e289 = listRow;
let _e293 = light_list_info.list[2u];
v_1 = ((_e289 + 0.5f) * _e293);
let _e297 = light_list_info.list[1u];
u_1 = _e297;
let _e298 = u_1;
let _e300 = v_1;
let _e302 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e298), _e300), 0f);
position = _e302;
let _e303 = u_1;
let _e305 = v_1;
let _e307 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e303), _e305), 0f);
color_1 = _e307;
let _e308 = u_1;
let _e310 = v_1;
let _e312 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e308), _e310), 0f);
direction = _e312;
let _e313 = u_1;
let _e315 = v_1;
let _e317 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e313), _e315), 0f);
cone = _e317;
let _e318 = clustered;
if _e318 {
let _e319 = listRow;
param_99 = _e319;
let _e320 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e320);
} else {
let _e322 = slot_5;
param_100 = _e322;
let _e323 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e323;
}
let _e324 = local_30;
let _e326 = color_1[3u];
color_1[3u] = (_e326 * _e324);
}
let _e330 = position[3u];
type_39 = _e330;
let _e331 = type_39;
if (_e331 > 15.5f) {
let _e334 = (*s_4).n;
light_3.l = _e334;
let _e337 = (*s_4).n;
light_3.h = _e337;
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 _e343 = light_3;
return _e343;
}
let _e344 = type_39;
if (_e344 > 2.5f) {
let _e346 = direction;
halfWidth_1 = _e346.xyz;
let _e348 = cone;
halfHeight_1 = _e348.xyz;
let _e350 = position;
let _e352 = v_world_position_1;
toCentre = (_e350.xyz - _e352);
let _e354 = toCentre;
let _e355 = halfWidth_1;
let _e357 = halfHeight_1;
corners_1[0i] = ((_e354 - _e355) - _e357);
let _e360 = toCentre;
let _e361 = halfWidth_1;
let _e363 = halfHeight_1;
corners_1[1i] = ((_e360 + _e361) - _e363);
let _e366 = toCentre;
let _e367 = halfWidth_1;
let _e369 = halfHeight_1;
corners_1[2i] = ((_e366 + _e367) + _e369);
let _e372 = toCentre;
let _e373 = halfWidth_1;
let _e375 = halfHeight_1;
corners_1[3i] = ((_e372 - _e373) + _e375);
let _e378 = toCentre;
let _e379 = halfWidth_1;
let _e380 = halfHeight_1;
behind = (dot(_e378, cross(_e379, _e380)) >= 0f);
let _e384 = behind;
if _e384 {
local_31 = 0f;
} else {
let _e385 = corners_1;
param_101 = _e385;
let _e387 = (*s_4).n;
param_102 = _e387;
let _e388 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e388;
}
let _e389 = local_31;
formFactor = _e389;
let _e390 = halfWidth_1;
let _e391 = halfHeight_1;
area = (length(cross(_e390, _e391)) * 4f);
let _e395 = area;
if (_e395 > 0.000000001f) {
let _e397 = area;
local_32 = (1f / _e397);
} else {
local_32 = 0f;
}
let _e399 = local_32;
radiance = _e399;
let _e400 = toCentre;
distance_2 = length(_e400);
let _e403 = direction[3u];
if (_e403 > 0f) {
let _e405 = distance_2;
let _e407 = direction[3u];
ratio_1 = (_e405 / _e407);
let _e409 = ratio_1;
let _e410 = ratio_1;
let _e412 = ratio_1;
let _e414 = ratio_1;
window_1 = clamp((1f - (((_e409 * _e410) * _e412) * _e414)), 0f, 1f);
let _e418 = window_1;
let _e419 = window_1;
let _e421 = radiance;
radiance = (_e421 * (_e418 * _e419));
}
let _e424 = (*s_4).v;
let _e427 = (*s_4).n;
mirror_1 = reflect(-(_e424), _e427);
let _e429 = position;
param_103 = _e429.xyz;
let _e431 = halfWidth_1;
param_104 = _e431;
let _e432 = halfHeight_1;
param_105 = _e432;
let _e433 = v_world_position_1;
param_106 = _e433;
let _e434 = mirror_1;
param_107 = _e434;
let _e435 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e435;
let _e436 = representative;
let _e437 = v_world_position_1;
toPoint = (_e436 - _e437);
let _e439 = toPoint;
pointDistance = length(_e439);
let _e441 = pointDistance;
if (_e441 > 0.000001f) {
let _e443 = toPoint;
let _e444 = pointDistance;
local_33 = (_e443 / vec3(_e444));
} else {
let _e448 = (*s_4).n;
local_33 = _e448;
}
let _e449 = local_33;
light_3.l = _e449;
let _e452 = light_3.l;
let _e454 = (*s_4).v;
light_3.h = normalize((_e452 + _e454));
let _e458 = formFactor;
light_3.n_dot_l = _e458;
let _e461 = (*s_4).n;
let _e463 = light_3.h;
light_3.n_dot_h = max(dot(_e461, _e463), 0f);
let _e468 = (*s_4).v;
let _e470 = light_3.h;
light_3.v_dot_h = max(dot(_e468, _e470), 0f);
let _e474 = color_1;
let _e477 = color_1[3u];
let _e479 = radiance;
light_3.radiance = ((_e474.xyz * _e477) * _e479);
let _e482 = light_3;
return _e482;
}
let _e483 = direction;
aim = normalize(_e483.xyz);
attenuation_1 = 1f;
let _e486 = type_39;
if (_e486 < 0.5f) {
let _e488 = aim;
light_3.l = -(_e488);
} else {
let _e491 = position;
let _e493 = v_world_position_1;
toLight_1 = (_e491.xyz - _e493);
let _e495 = toLight_1;
distance_3 = length(_e495);
let _e497 = distance_3;
if (_e497 < 0.000001f) {
let _e500 = (*s_4).n;
light_3.l = _e500;
let _e503 = (*s_4).n;
light_3.h = _e503;
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 _e509 = light_3;
return _e509;
}
let _e510 = toLight_1;
let _e511 = distance_3;
light_3.l = (_e510 / vec3(_e511));
let _e515 = distance_3;
param_108 = _e515;
let _e517 = direction[3u];
param_109 = _e517;
let _e518 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e518;
let _e519 = type_39;
if (_e519 > 1.5f) {
let _e521 = aim;
let _e523 = light_3.l;
cosAngle = dot(_e521, -(_e523));
let _e526 = cosAngle;
let _e528 = cone[1u];
let _e531 = cone[0u];
let _e533 = cone[1u];
ramp = clamp(((_e526 - _e528) / (_e531 - _e533)), 0f, 1f);
let _e537 = ramp;
let _e538 = ramp;
let _e540 = attenuation_1;
attenuation_1 = (_e540 * (_e537 * _e538));
}
}
let _e543 = light_3.l;
let _e545 = (*s_4).v;
light_3.h = normalize((_e543 + _e545));
let _e550 = (*s_4).n;
let _e552 = light_3.l;
light_3.n_dot_l = max(dot(_e550, _e552), 0f);
let _e557 = (*s_4).n;
let _e559 = light_3.h;
light_3.n_dot_h = max(dot(_e557, _e559), 0f);
let _e564 = (*s_4).v;
let _e566 = light_3.h;
light_3.v_dot_h = max(dot(_e564, _e566), 0f);
let _e570 = color_1;
let _e573 = color_1[3u];
let _e575 = attenuation_1;
light_3.radiance = ((_e570.xyz * _e573) * _e575);
let _e578 = light_3;
return _e578;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e223 = light_list_info.cluster_view_projection;
let _e224 = (*world_3);
clip_1 = (_e223 * vec4<f32>(_e224.x, _e224.y, _e224.z, 1f));
let _e230 = clip_1;
let _e233 = clip_1[3u];
ndc_1 = (_e230.xy / vec2(max(_e233, 0.000001f)));
let _e238 = light_list_info.cluster_grid;
grid = _e238.xyz;
let _e242 = light_list_info.cluster_depth[0u];
near_1 = _e242;
let _e244 = ndc_1[0u];
let _e248 = grid[0u];
let _e252 = grid[0u];
tx = clamp(floor((((_e244 * 0.5f) + 0.5f) * _e248)), 0f, (_e252 - 1f));
let _e256 = ndc_1[1u];
let _e260 = grid[1u];
let _e264 = grid[1u];
ty = clamp(floor((((_e256 * 0.5f) + 0.5f) * _e260)), 0f, (_e264 - 1f));
let _e268 = clip_1[3u];
let _e269 = near_1;
if (_e268 <= _e269) {
local_34 = 0f;
} else {
let _e272 = clip_1[3u];
let _e273 = near_1;
let _e278 = light_list_info.cluster_depth[1u];
let _e282 = grid[2u];
local_34 = clamp(floor((log((_e272 / _e273)) * _e278)), 0f, (_e282 - 1f));
}
let _e285 = local_34;
tz = _e285;
let _e286 = tx;
let _e287 = ty;
let _e289 = grid[0u];
let _e292 = tz;
let _e294 = grid[0u];
let _e297 = grid[1u];
cell_1 = ((_e286 + (_e287 * _e289)) + ((_e292 * _e294) * _e297));
let _e300 = cell_1;
row_3 = floor((_e300 / 4f));
let _e303 = cell_1;
let _e304 = row_3;
let _e309 = light_list_info.cluster_depth[2u];
let _e310 = row_3;
param_110 = (_e303 - (_e304 * 4f));
param_111 = (_e309 + _e310);
let _e312 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e312;
let _e314 = header[0u];
g_cluster_offset = _e314;
let _e316 = header[1u];
g_cluster_count = _e316;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e212 = light_list_info.list[0u];
tail = _e212;
let _e213 = Clustered_u0028_();
if _e213 {
let _e214 = v_world_position_1;
param_112 = _e214;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e215 = g_cluster_count;
tail = _e215;
}
let _e218 = frag_info.frame_params[1u];
let _e222 = tail;
return (clamp(i32((_e218 + 0.5f)), 0i, 8i) + clamp(i32((_e222 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e226 = LightCount_u0028_();
count_1 = _e226;
i_8 = 0i;
loop {
let _e227 = i_8;
if (_e227 < 32i) {
let _e229 = i_8;
let _e230 = count_1;
if (_e229 >= _e230) {
break;
}
let _e232 = i_8;
param_113 = _e232;
let _e233 = (*s_5);
param_114 = _e233;
let _e234 = 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_113), (¶m_114));
light_4 = _e234;
let _e236 = light_4.n_dot_l;
if (_e236 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e238 = i_8;
param_115 = _e238;
let _e239 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e239 {
let _e240 = (*s_5);
param_116 = _e240;
let _e241 = light_4;
param_117 = _e241;
let _e242 = i_8;
param_118 = _e242;
let _e243 = 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_116), (¶m_117), (¶m_118));
let _e244 = v_world_position_1;
param_119 = _e244;
let _e246 = (*s_5).n;
param_120 = _e246;
let _e247 = i_8;
param_121 = _e247;
let _e248 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e243 * _e248);
} else {
local_35 = 1f;
}
let _e250 = local_35;
visibility = _e250;
let _e251 = visibility;
if (_e251 <= 0f) {
continue;
}
let _e253 = (*s_5);
param_122 = _e253;
let _e254 = light_4;
param_123 = _e254;
let _e255 = 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_122), (¶m_123));
let _e257 = light_4.radiance;
let _e260 = light_4.n_dot_l;
let _e262 = visibility;
let _e264 = light_transmittance;
let _e266 = total_1;
total_1 = (_e266 + ((((_e255 * _e257) * _e260) * _e262) * _e264));
continue;
} else {
break;
}
continuing {
let _e268 = i_8;
i_8 = (_e268 + 1i);
}
}
let _e270 = total_1;
return _e270;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e209 = v_lightmap_uv_1;
let _e210 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e209);
texel_4 = _e210;
let _e211 = texel_4;
let _e214 = texel_4[3u];
return ((_e211.xyz * _e214) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e210 = frag_info.target_origin[1u];
return _e210;
}
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_124: vec3<f32>;
let _e211 = v_texcoord_1;
let _e212 = MaterialLodBias_u0028_();
let _e213 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e211, _e212);
param_124 = _e213.xyz;
let _e215 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e215;
let _e216 = emissive;
let _e218 = frag_info.emissive;
let _e223 = frag_info.material2_[3u];
(*s_6).emissive = ((_e216 * _e218.xyz) * _e223);
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 _e210 = v_texcoord_1;
let _e211 = MaterialLodBias_u0028_();
let _e212 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e210, _e211);
occlusion = _e212.x;
let _e214 = occlusion;
let _e217 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e214, clamp(_e217, 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 _e213 = v_texcoord_1;
let _e214 = MaterialLodBias_u0028_();
let _e215 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e213, _e214);
sampledTexel = _e215;
let _e216 = v_tangent_1;
t_2 = _e216.xyz;
let _e218 = t_2;
let _e220 = (*s_8).n;
let _e222 = (*s_8).n;
let _e223 = t_2;
t_2 = (_e218 - (_e220 * dot(_e222, _e223)));
let _e227 = t_2;
let _e228 = t_2;
if (dot(_e227, _e228) < 0.000000000001f) {
return;
}
let _e231 = t_2;
t_2 = normalize(_e231);
let _e234 = (*s_8).n;
let _e235 = t_2;
let _e238 = v_tangent_1[3u];
b_3 = (cross(_e234, _e235) * _e238);
let _e240 = gl_FrontFacing_1;
if !(_e240) {
let _e242 = t_2;
t_2 = -(_e242);
}
let _e244 = sampledTexel;
sampled = ((_e244.xyz * 2f) - vec3(1f));
let _e251 = frag_info.emissive[3u];
if (_e251 > 0.5f) {
let _e253 = sampled;
let _e255 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e253.xy, _e255.xy)), 0f));
}
let _e264 = frag_info.material2_[1u];
let _e265 = sampled;
let _e267 = (_e265.xy * _e264);
sampled[0u] = _e267.x;
sampled[1u] = _e267.y;
let _e272 = t_2;
let _e274 = sampled[0u];
let _e276 = b_3;
let _e278 = sampled[1u];
let _e282 = (*s_8).n;
let _e284 = sampled[2u];
(*s_8).n = normalize((((_e272 * _e274) + (_e276 * _e278)) + (_e282 * _e284)));
let _e290 = (*s_8).n;
let _e292 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e290, _e292), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e209 = (*texel_5);
let _e213 = irradiance_info.atlas;
let _e216 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e209 + vec2(0.5f)) * _e213.xy), 0f);
return _e216;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e222 = (*uv_6);
let _e223 = (*interior);
at_1 = ((vec2(1f) + (_e222 * _e223)) - vec2(0.5f));
let _e229 = at_1;
low = floor(_e229);
let _e231 = at_1;
let _e232 = low;
f = (_e231 - _e232);
let _e234 = (*corner);
let _e235 = low;
param_125 = (_e234 + _e235);
let _e237 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e237;
let _e238 = (*corner);
let _e239 = low;
param_126 = ((_e238 + _e239) + vec2<f32>(1f, 0f));
let _e242 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e242;
let _e243 = (*corner);
let _e244 = low;
param_127 = ((_e243 + _e244) + vec2<f32>(0f, 1f));
let _e247 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e247;
let _e248 = (*corner);
let _e249 = low;
param_128 = ((_e248 + _e249) + vec2<f32>(1f, 1f));
let _e252 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e252;
let _e253 = a_4;
let _e254 = b_4;
let _e256 = f[0u];
let _e259 = c_1;
let _e260 = d_4;
let _e262 = f[0u];
let _e266 = f[1u];
return mix(mix(_e253, _e254, vec4(_e256)), mix(_e259, _e260, vec4(_e262)), vec4(_e266));
}
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 _e213 = (*direction_1)[0u];
let _e216 = (*direction_1)[1u];
let _e220 = (*direction_1)[2u];
sum_1 = ((abs(_e213) + abs(_e216)) + abs(_e220));
let _e223 = sum_1;
if (_e223 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e225 = (*direction_1);
let _e226 = sum_1;
n_5 = (_e225 / vec3(_e226));
let _e229 = n_5;
xy = _e229.xy;
let _e232 = n_5[2u];
if (_e232 < 0f) {
let _e235 = n_5[1u];
let _e239 = n_5[0u];
let _e244 = n_5[0u];
let _e248 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e235)) * select(-1f, 1f, (_e239 >= 0f))), ((1f - abs(_e244)) * select(-1f, 1f, (_e248 >= 0f))));
}
let _e253 = xy;
return ((_e253 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e255 = irradiance_info.origin;
origin_2 = _e255.xyz;
let _e258 = irradiance_info.spacing;
spacing = _e258.xyz;
let _e261 = irradiance_info.counts;
counts = _e261.xyz;
let _e265 = irradiance_info.tiles[0u];
irradianceTile = _e265;
let _e268 = irradiance_info.tiles[1u];
depthTile = _e268;
let _e271 = irradiance_info.tiles[2u];
columns = _e271;
let _e274 = irradiance_info.tiles[3u];
momentsTop = _e274;
let _e275 = (*normal_1);
unit = normalize(_e275);
let _e277 = (*world_4);
let _e278 = unit;
let _e281 = irradiance_info.spacing[3u];
let _e284 = (*view_1);
let _e287 = irradiance_info.counts[3u];
biased = ((_e277 + (_e278 * _e281)) + (_e284 * _e287));
let _e290 = biased;
let _e291 = origin_2;
let _e293 = spacing;
grid_1 = ((_e290 - _e291) / _e293);
let _e295 = grid_1;
let _e297 = counts;
base = clamp(floor(_e295), vec3<f32>(0f, 0f, 0f), (_e297 - vec3(2f)));
let _e301 = grid_1;
let _e302 = base;
f_1 = clamp((_e301 - _e302), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e305 = corner_1;
if (_e305 < 8i) {
let _e307 = corner_1;
let _e310 = corner_1;
let _e315 = corner_1;
offset_3 = vec3<f32>(f32((_e307 & 1i)), f32(((_e310 >> bitcast<u32>(1i)) & 1i)), f32(((_e315 >> bitcast<u32>(2i)) & 1i)));
let _e321 = base;
let _e322 = offset_3;
cell_2 = (_e321 + _e322);
let _e325 = cell_2[2u];
let _e327 = counts[1u];
let _e330 = cell_2[1u];
let _e333 = counts[0u];
let _e336 = cell_2[0u];
probe = ((((_e325 * _e327) + _e330) * _e333) + _e336);
let _e338 = probe;
let _e339 = columns;
let _e344 = probe;
let _e345 = columns;
tile_4 = vec2<f32>((_e338 - (floor((_e338 / _e339)) * _e339)), floor((_e344 / _e345)));
let _e349 = tile_4;
let _e350 = irradianceTile;
irradianceCorner = (_e349 * (_e350 + 2f));
let _e354 = tile_4[0u];
let _e355 = depthTile;
let _e358 = momentsTop;
let _e360 = tile_4[1u];
let _e361 = depthTile;
momentCorner = vec2<f32>((_e354 * (_e355 + 2f)), (_e358 + (_e360 * (_e361 + 2f))));
let _e366 = irradianceCorner;
param_129 = (_e366 + vec2(1f));
let _e369 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e369.w < 0.5f) {
continue;
}
let _e372 = f_1;
let _e374 = f_1;
let _e375 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e372), _e374, _e375);
let _e378 = trilinear[0u];
let _e380 = trilinear[1u];
let _e383 = trilinear[2u];
weight_3 = max(((_e378 * _e380) * _e383), 0.001f);
let _e386 = origin_2;
let _e387 = spacing;
let _e388 = cell_2;
probePosition = (_e386 + (_e387 * _e388));
let _e391 = probePosition;
let _e392 = biased;
toProbe = (_e391 - _e392);
let _e394 = toProbe;
distance_4 = length(_e394);
let _e396 = distance_4;
if (_e396 > 0.000001f) {
let _e398 = toProbe;
let _e399 = distance_4;
direction_2 = (_e398 / vec3(_e399));
let _e402 = unit;
let _e403 = probePosition;
let _e404 = (*world_4);
facing = ((dot(_e402, normalize((_e403 - _e404))) * 0.5f) + 0.5f);
let _e410 = facing;
let _e411 = facing;
probeWeight = ((_e410 * _e411) + 0.2f);
let _e414 = direction_2;
param_130 = -(_e414);
let _e416 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e417 = momentCorner;
param_131 = _e417;
let _e418 = depthTile;
param_132 = _e418;
param_133 = _e416;
let _e419 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e419.xy;
chebyshev = 1f;
let _e421 = distance_4;
let _e423 = moments_3[0u];
if (_e421 > _e423) {
let _e426 = moments_3[1u];
let _e428 = moments_3[0u];
let _e430 = moments_3[0u];
variance_1 = max((_e426 - (_e428 * _e430)), 0.000001f);
let _e434 = distance_4;
let _e436 = moments_3[0u];
difference = (_e434 - _e436);
let _e438 = variance_1;
let _e439 = variance_1;
let _e440 = difference;
let _e441 = difference;
chebyshev = (_e438 / (_e439 + (_e440 * _e441)));
let _e445 = chebyshev;
let _e446 = chebyshev;
let _e448 = chebyshev;
chebyshev = ((_e445 * _e446) * _e448);
}
let _e450 = probeWeight;
let _e451 = chebyshev;
probeWeight = max((_e450 * max(_e451, 0.05f)), 0.000001f);
let _e455 = probeWeight;
if (_e455 < 0.2f) {
let _e457 = probeWeight;
let _e458 = probeWeight;
let _e461 = probeWeight;
probeWeight = (_e461 * ((_e457 * _e458) * 25f));
}
let _e463 = probeWeight;
let _e464 = weight_3;
weight_3 = (_e464 * _e463);
}
let _e466 = unit;
param_134 = _e466;
let _e467 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e468 = irradianceCorner;
param_135 = _e468;
let _e469 = irradianceTile;
param_136 = _e469;
param_137 = _e467;
let _e470 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e472 = weight_3;
let _e474 = total_2;
total_2 = (_e474 + (_e470.xyz * _e472));
let _e476 = weight_3;
let _e477 = weights;
weights = (_e477 + _e476);
continue;
} else {
break;
}
continuing {
let _e479 = corner_1;
corner_1 = (_e479 + 1i);
}
}
let _e481 = weights;
if (_e481 > 0f) {
let _e483 = total_2;
let _e484 = weights;
local_36 = (_e483 / vec3(_e484));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e487 = local_36;
return _e487;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e210 = irradiance_info.origin[3u];
return (_e210 > 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_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e215 = IrradianceEnabled_u0028_();
if _e215 {
let _e216 = v_world_position_1;
param_138 = _e216;
let _e218 = (*s_9).n;
param_139 = _e218;
let _e220 = (*s_9).v;
param_140 = _e220;
let _e221 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e224 = frag_info.material[2u];
(*s_9).ambient = (_e221 * _e224);
}
let _e227 = (*s_9);
param_141 = _e227;
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_141));
let _e228 = param_141;
(*s_9) = _e228;
let _e229 = (*s_9);
param_142 = _e229;
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_142));
let _e230 = param_142;
(*s_9) = _e230;
let _e231 = (*s_9);
param_143 = _e231;
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_143));
let _e232 = param_143;
(*s_9) = _e232;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e209 = Orthographic_u0028_();
if _e209 {
let _e211 = fog_info.forward;
local_37 = -(_e211.xyz);
} else {
let _e215 = fog_info.eye;
let _e217 = v_world_position_1;
local_37 = normalize((_e215.xyz - _e217));
}
let _e220 = local_37;
return _e220;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_10: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff: f32;
var edge: f32;
let _e214 = v_texcoord_1;
let _e215 = MaterialLodBias_u0028_();
let _e216 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e214, _e215);
texel_6 = _e216;
let _e217 = texel_6;
param_144 = _e217.xyz;
let _e219 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e221 = frag_info.base_color;
param_145 = _e221.xyz;
let _e223 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e225 = v_color_1;
s_10.albedo = ((_e219 * _e223) * _e225.xyz);
let _e230 = texel_6[3u];
let _e233 = frag_info.base_color[3u];
let _e236 = v_color_1[3u];
s_10.alpha = ((_e230 * _e233) * _e236);
let _e240 = s_10.albedo;
g_albedo = _e240;
let _e243 = frag_info.material2_[0u];
cutoff = _e243;
let _e244 = cutoff;
if (_e244 > 1f) {
let _e246 = cutoff;
edge = (_e246 - 1f);
let _e249 = s_10.alpha;
let _e250 = edge;
let _e253 = s_10.alpha;
let _e254 = fwidth(_e253);
s_10.alpha = clamp((((_e249 - _e250) / max(_e254, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e260 = cutoff;
if (_e260 >= 0f) {
s_10.alpha = 1f;
}
}
let _e263 = cutoff;
let _e265 = cutoff;
g_premultiply = ((_e263 < 0f) && (_e265 > -0.75f));
let _e268 = v_normal_1;
s_10.n = normalize(_e268);
let _e271 = gl_FrontFacing_1;
if !(_e271) {
let _e274 = s_10.n;
s_10.n = -(_e274);
}
let _e277 = TowardsEye_u0028_();
s_10.v = _e277;
let _e280 = s_10.n;
let _e282 = s_10.v;
s_10.n_dot_v = max(dot(_e280, _e282), 0.0001f);
let _e288 = frag_info.material[0u];
s_10.metallic = clamp(_e288, 0f, 1f);
let _e293 = frag_info.material[1u];
s_10.roughness = clamp(_e293, 0.02f, 1f);
let _e297 = frag_info.ambient_ground;
let _e300 = frag_info.ambient_sky;
let _e304 = s_10.n[1u];
let _e311 = frag_info.material[2u];
s_10.ambient = (mix(_e297.xyz, _e300.xyz, vec3(((_e304 * 0.5f) + 0.5f))) * _e311);
let _e316 = frag_info.frame_params[0u];
s_10.exposure = max(_e316, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e321 = s_10;
return _e321;
}
fn main_1() {
var s_11: Surface;
var param_146: Surface;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_147: Surface;
var param_148: Surface;
var param_149: vec3<f32>;
var param_150: vec3<f32>;
var param_151: f32;
var param_152: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e218 = ReadSurface_u0028_();
s_11 = _e218;
let _e219 = s_11;
param_146 = _e219;
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_146));
let _e220 = param_146;
s_11 = _e220;
let _e222 = s_11.albedo;
let _e224 = s_11.ambient;
let _e225 = SampleLightmap_u0028_();
let _e229 = s_11.occlusion;
ambient = ((_e222 * (_e224 + _e225)) * _e229);
let _e231 = s_11;
param_147 = _e231;
let _e232 = 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_147));
let _e234 = s_11.occlusion;
let _e236 = ambient;
let _e239 = s_11.emissive;
lit_3 = (((_e232 * _e234) + _e236) + _e239);
let _e241 = s_11;
param_148 = _e241;
let _e242 = lit_3;
param_149 = _e242;
let _e243 = WriteDebugView_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_vf3_u003b((¶m_148), (¶m_149));
if _e243 {
return;
}
let _e244 = lit_3;
param_150 = _e244;
let _e246 = s_11.alpha;
param_151 = _e246;
let _e248 = s_11.roughness;
param_152 = _e248;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_150), (¶m_151), (¶m_152));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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: 'normal_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 23,
samplerBinding: 24,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BlinnPhongOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e211 = v_world_position_1;
let _e213 = fog_info.eye;
let _e217 = fog_info.forward;
return dot((_e211 - _e213.xyz), _e217.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e216 = ViewDepth_u0028_();
z = abs(_e216);
let _e218 = z;
near = (_e218 / 5f);
let _e220 = z;
far = (_e220 / 200f);
let _e222 = far;
let _e223 = far;
let _e225 = far;
far3_ = ((_e222 * _e223) * _e225);
let _e227 = (*alpha);
let _e228 = near;
let _e229 = near;
let _e232 = far3_;
let _e233 = far3_;
return (_e227 * clamp((10f / ((0.00001f + (_e228 * _e229)) + (_e232 * _e233))), 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 _e220 = fog_info.forward[3u];
mode = _e220;
let _e221 = mode;
if (_e221 > 0.5f) {
let _e224 = frag_color[3u];
alpha_1 = _e224;
let _e225 = alpha_1;
param = _e225;
let _e226 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e226;
let _e227 = frag_color;
let _e229 = weight;
let _e230 = (_e227.xyz * _e229);
let _e231 = alpha_1;
let _e232 = weight;
accumulate = vec4<f32>(_e230.x, _e230.y, _e230.z, (_e231 * _e232));
let _e238 = mode;
let _e240 = mode;
revealage = ((_e238 > 1.5f) && (_e240 < 2.5f));
let _e243 = revealage;
if _e243 {
let _e244 = alpha_1;
local = vec4(_e244);
} else {
let _e246 = accumulate;
local = _e246;
}
let _e247 = local;
frag_color = _e247;
let _e248 = mode;
if (_e248 > 2.5f) {
let _e250 = alpha_1;
frag_surface = vec4(_e250);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e214 = (*n)[0u];
let _e217 = (*n)[1u];
let _e221 = (*n)[2u];
let _e224 = (*n);
(*n) = (_e224 / vec3(((abs(_e214) + abs(_e217)) + abs(_e221))));
let _e227 = (*n);
e = _e227.xy;
let _e230 = (*n)[2u];
if (_e230 < 0f) {
let _e232 = (*n);
let _e238 = (*n)[0u];
let _e242 = (*n)[1u];
e = ((vec2(1f) - abs(_e232.yx)) * vec2<f32>(select(-1f, 1f, (_e238 >= 0f)), select(-1f, 1f, (_e242 >= 0f))));
}
let _e247 = e;
return ((_e247 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e212 = (*linear);
let _e214 = (*linear);
let _e218 = (*linear);
return mix((_e212 * 12.92f), ((pow(_e214, 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), _e218));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e215 = g_albedo;
param_1 = clamp(_e215, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e217 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e217.x, _e217.y, _e217.z, 1f);
let _e222 = g_debug_surface_on;
if _e222 {
let _e223 = g_debug_surface;
let _e224 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e223.x, _e223.y, _e223.z, _e224);
return;
}
let _e229 = v_normal_1;
geometric = normalize(_e229);
let _e231 = gl_FrontFacing_1;
if !(_e231) {
let _e233 = geometric;
geometric = -(_e233);
}
let _e235 = geometric;
param_2 = _e235;
let _e236 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e237 = (*roughness);
let _e239 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e236.x, _e236.y, clamp(_e237, 0f, 1f), _e239);
return;
}
fn Orthographic_u0028_() -> bool {
let _e213 = fog_info.projection[0u];
return (_e213 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e212 = Orthographic_u0028_();
if _e212 {
let _e213 = ViewDepth_u0028_();
local_1 = max(_e213, 0f);
} else {
let _e215 = v_world_position_1;
let _e217 = fog_info.eye;
local_1 = distance(_e215, _e217.xyz);
}
let _e220 = local_1;
return _e220;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e219 = fog_info.fog[3u];
density = _e219;
let _e220 = density;
if (_e220 <= 0f) {
let _e222 = (*color);
return _e222;
}
let _e223 = EyeDistance_u0028_();
d = _e223;
let _e226 = fog_info.eye[3u];
falloff = _e226;
let _e227 = falloff;
if (_e227 > 0f) {
let _e229 = falloff;
let _e231 = v_world_position_1[1u];
let _e234 = fog_info.eye[1u];
k = (_e229 * (_e231 - _e234));
let _e237 = k;
if (abs(_e237) > 0.001f) {
let _e240 = k;
let _e244 = k;
local_2 = ((1f - exp(-(_e240))) / _e244);
} else {
let _e246 = k;
local_2 = (1f - (0.5f * _e246));
}
let _e249 = local_2;
let _e250 = density;
density = (_e250 * _e249);
}
let _e253 = fog_info.fog;
let _e255 = (*color);
let _e256 = density;
let _e258 = d;
return mix(_e253.xyz, _e255, vec3(clamp(exp((-(_e256) * _e258)), 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 _e217 = g_premultiply;
let _e218 = (*alpha_2);
weight_1 = select(1f, _e218, _e217);
let _e220 = (*linearColor);
param_3 = _e220;
let _e221 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e222 = weight_1;
let _e223 = (_e221 * _e222);
let _e224 = (*alpha_2);
let _e225 = g_pass_through;
frag_color = vec4<f32>(_e223.x, _e223.y, _e223.z, (_e224 * (1f - _e225)));
let _e232 = (*roughness_1);
param_4 = _e232;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e212 = (*srgb);
let _e215 = (*srgb);
let _e220 = (*srgb);
return mix((_e212 / vec3(12.92f)), pow(((_e215 + 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), _e220));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e214 = (*key);
hue = fract(((_e214 * 0.618034f) + 0.13f));
let _e218 = hue;
k_1 = clamp((abs(((fract((vec3(_e218) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e231 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e231, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2559_: bool;
let _e212 = (*c);
let _e213 = (*c);
let _e215 = any((_e212 != _e213));
phi_2559_ = _e215;
if !(_e215) {
let _e217 = (*c);
phi_2559_ = any((abs(_e217) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e222 = phi_2559_;
return _e222;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2649_: bool;
var phi_2917_: bool;
let _e254 = gl_FragCoord_1[0u];
let _e257 = frag_info.debug_view[1u];
if (_e254 < _e257) {
let _e261 = frag_info.debug_view[2u];
local_3 = _e261;
} else {
let _e264 = frag_info.debug_view[0u];
local_3 = _e264;
}
let _e265 = local_3;
view = _e265;
let _e266 = view;
if (_e266 < 0.5f) {
return false;
}
let _e268 = view;
code = i32((_e268 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e271 = v_normal_1;
geometric_n = normalize(_e271);
let _e273 = v_tangent_1;
let _e275 = geometric_n;
let _e276 = geometric_n;
let _e277 = v_tangent_1;
tangent = (_e273.xyz - (_e275 * dot(_e276, _e277.xyz)));
let _e282 = tangent;
let _e283 = tangent;
let _e285 = (dot(_e282, _e283) > 0.000000000001f);
phi_2649_ = _e285;
if _e285 {
let _e287 = v_tangent_1[3u];
phi_2649_ = (abs((abs(_e287) - 1f)) < 0.01f);
}
let _e293 = phi_2649_;
tangent_usable = _e293;
let _e296 = frag_info.debug_view[3u];
identity = _e296;
let _e297 = identity;
identity_object = floor((_e297 / 8192f));
let _e300 = identity;
let _e301 = identity_object;
identity_rest = (_e300 - (_e301 * 8192f));
let _e304 = identity_rest;
identity_material = floor((_e304 / 2f));
let _e307 = identity_rest;
let _e308 = identity_material;
normal_mapped = ((_e307 - (_e308 * 2f)) > 0.5f);
let _e312 = code;
if (_e312 == 1i) {
let _e315 = (*s).albedo;
param_5 = clamp(_e315, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e317 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e317;
} else {
let _e318 = code;
if (_e318 == 2i) {
let _e321 = (*s).n;
shown = ((_e321 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e324 = code;
if (_e324 == 3i) {
let _e327 = (*s).roughness;
shown = vec3(clamp(_e327, 0f, 1f));
} else {
let _e330 = code;
if (_e330 == 4i) {
let _e333 = (*s).metallic;
shown = vec3(clamp(_e333, 0f, 1f));
} else {
let _e336 = code;
if (_e336 == 5i) {
let _e339 = (*s).occlusion;
shown = vec3(clamp(_e339, 0f, 1f));
} else {
let _e342 = code;
if (_e342 == 6i) {
let _e345 = (*s).emissive;
param_6 = clamp(_e345, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e347 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e347;
} else {
let _e348 = code;
if (_e348 == 7i) {
let _e350 = v_texcoord_1;
let _e351 = fract(_e350);
shown = vec3<f32>(_e351.x, _e351.y, 0f);
} else {
let _e355 = code;
if (_e355 == 8i) {
let _e357 = (*lit);
param_7 = clamp(_e357, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e359 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e359, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e361 = (*lit);
param_8 = _e361;
let _e362 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e362 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e363 = grey;
local_4 = vec3((_e363 * 0.5f));
}
let _e366 = local_4;
shown = _e366;
} else {
let _e367 = code;
if (_e367 == 9i) {
let _e369 = tangent_usable;
if _e369 {
let _e370 = tangent;
local_5 = ((normalize(_e370) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e374 = local_5;
shown = _e374;
} else {
let _e375 = code;
if (_e375 == 10i) {
let _e377 = v_texcoord_1;
uv = _e377;
let _e378 = uv;
cell = floor((_e378 * 8f));
let _e382 = cell[0u];
let _e384 = cell[1u];
odd = (fract(((_e382 + _e384) * 0.5f)) * 2f);
let _e389 = uv;
within = fract(_e389);
let _e391 = odd;
let _e395 = within[0u];
let _e399 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e391)) * vec3<f32>((0.55f + (0.45f * _e395)), (0.55f + (0.45f * _e399)), 0.85f));
} else {
let _e404 = code;
if (_e404 == 11i) {
let _e406 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e406));
} else {
let _e409 = code;
if (_e409 == 12i) {
let _e411 = v_color_1;
param_9 = clamp(_e411.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e414 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e414;
} else {
let _e415 = code;
let _e417 = code;
if ((_e415 == 13i) || (_e417 == 14i)) {
let _e420 = code;
let _e422 = identity_object;
let _e423 = identity_material;
key_1 = select(_e423, _e422, (_e420 == 13i));
let _e425 = key_1;
param_10 = _e425;
let _e426 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e428 = (*s).n_dot_v;
shown = (_e426 * (0.55f + (0.45f * _e428)));
} else {
let _e432 = code;
if (_e432 == 15i) {
let _e435 = (*s).albedo;
param_11 = clamp(_e435, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e437 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e437;
let _e438 = srgb_1;
luma = dot(_e438, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e441 = (*s).metallic;
metal = (_e441 > 0.5f);
let _e443 = metal;
let _e445 = luma;
if (!(_e443) && (_e445 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e448 = metal;
let _e449 = !(_e448);
phi_2917_ = _e449;
if _e449 {
let _e451 = srgb_1[0u];
let _e453 = srgb_1[1u];
let _e455 = srgb_1[2u];
phi_2917_ = (max(_e451, max(_e453, _e455)) > 0.9411765f);
}
let _e460 = phi_2917_;
if _e460 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e461 = metal;
let _e462 = luma;
if (_e461 && (_e462 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e465 = luma;
local_8 = vec3(_e465);
}
let _e467 = local_8;
local_7 = _e467;
}
let _e468 = local_7;
local_6 = _e468;
}
let _e469 = local_6;
shown = _e469;
} else {
let _e470 = code;
if (_e470 == 16i) {
let _e473 = (*s).metallic;
m = _e473;
let _e474 = m;
let _e476 = m;
if ((_e474 > 0.05f) && (_e476 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e479 = m;
local_9 = vec3(select(0.15f, 1f, (_e479 > 0.5f)));
}
let _e483 = local_9;
shown = _e483;
} else {
let _e484 = code;
if (_e484 == 17i) {
let _e486 = normal_mapped;
if !(_e486) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e488 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e488));
}
let _e491 = local_10;
shown = _e491;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e492 = g_premultiply;
if _e492 {
let _e494 = (*s).alpha;
local_11 = _e494;
} else {
local_11 = 1f;
}
let _e495 = local_11;
weight_2 = _e495;
let _e496 = shown;
param_12 = _e496;
let _e497 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e498 = weight_2;
let _e499 = (_e497 * _e498);
let _e501 = (*s).alpha;
frag_color = vec4<f32>(_e499.x, _e499.y, _e499.z, _e501);
let _e507 = (*s).roughness;
param_13 = _e507;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var shininess: f32;
var specular: f32;
let _e216 = (*s_1).roughness;
shininess = mix(256f, 4f, _e216);
let _e219 = (*light).n_dot_h;
let _e220 = shininess;
let _e224 = frag_info.material[3u];
specular = (pow(_e219, _e220) * _e224);
let _e227 = (*s_1).albedo;
let _e228 = specular;
return (_e227 + vec3(_e228));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e212 = (*i);
if (_e212 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e214 = (*i);
if (_e214 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e216 = (*i);
if (_e216 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e218 = (*i);
if (_e218 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e220 = (*i);
if (_e220 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e222 = (*i);
if (_e222 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e224 = (*i);
if (_e224 == 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_14: i32;
let _e217 = (*i_1);
param_14 = _e217;
let _e218 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e218;
let _e220 = p[0u];
let _e221 = (*ca);
let _e224 = p[1u];
let _e225 = (*sa);
let _e229 = p[0u];
let _e230 = (*sa);
let _e233 = p[1u];
let _e234 = (*ca);
let _e238 = (*radius);
return (vec2<f32>(((_e220 * _e221) - (_e224 * _e225)), ((_e229 * _e230) + (_e233 * _e234))) * _e238);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e220 = point_shadow.params[0u];
inset = _e220;
let _e221 = (*uv_1);
let _e222 = (*offset);
let _e224 = inset;
let _e225 = inset;
local_12 = clamp((_e221 + _e222), vec2(_e224), vec2((1f - _e225)));
let _e230 = local_12;
let _e231 = (*tile);
atlas = ((_e230 + _e231) * vec2<f32>(0.16666667f, 0.16666667f));
let _e236 = point_shadow.params3_[0u];
if (_e236 > 0.5f) {
let _e239 = atlas[1u];
atlas[1u] = (1f - _e239);
}
let _e242 = atlas;
let _e243 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e242, 0f);
let _e245 = atlas;
let _e246 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e245, 0f);
let _e249 = (*range);
return (min(_e243.x, _e246.x) * _e249);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e221 = (*uv_2);
param_15 = _e221;
let _e222 = (*offset_1);
param_16 = _e222;
let _e223 = (*tile_1);
param_17 = _e223;
let _e224 = (*range_1);
param_18 = _e224;
let _e225 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e225;
let _e226 = stored;
let _e227 = (*range_1);
if (_e226 >= (_e227 * 0.999f)) {
return 1f;
}
let _e230 = (*receiver);
let _e231 = stored;
return select(1f, 0f, (_e230 > _e231));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e242 = point_shadow.params2_[1u];
lightRadius = _e242;
let _e245 = point_shadow.params2_[0u];
minRadius = _e245;
let _e248 = point_shadow.params2_[2u];
maxRadius = _e248;
let _e249 = lightRadius;
if (_e249 <= 0f) {
let _e251 = (*uv_3);
param_19 = _e251;
param_20 = vec2<f32>(0f, 0f);
let _e252 = (*tile_2);
param_21 = _e252;
let _e253 = (*range_2);
param_22 = _e253;
let _e254 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e254;
let _e255 = minRadius;
return _e255;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e256 = i_2;
if (_e256 < 8i) {
let _e258 = i_2;
param_23 = _e258;
let _e259 = (*ca_1);
param_24 = _e259;
let _e260 = (*sa_1);
param_25 = _e260;
let _e261 = maxRadius;
param_26 = _e261;
let _e262 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e263 = (*uv_3);
param_27 = _e263;
param_28 = _e262;
let _e264 = (*tile_2);
param_29 = _e264;
let _e265 = (*range_2);
param_30 = _e265;
let _e266 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e266;
let _e267 = stored_1;
let _e268 = (*range_2);
if (_e267 >= (_e268 * 0.999f)) {
continue;
}
let _e271 = stored_1;
let _e272 = (*receiver_1);
if (_e271 >= _e272) {
continue;
}
let _e274 = stored_1;
let _e275 = sum;
sum = (_e275 + _e274);
let _e277 = count;
count = (_e277 + 1f);
continue;
} else {
break;
}
continuing {
let _e279 = i_2;
i_2 = (_e279 + 1i);
}
}
let _e281 = count;
if (_e281 < 0.5f) {
return -1f;
}
let _e283 = sum;
let _e284 = count;
blocker = max((_e283 / _e284), 0.0001f);
let _e287 = blocker;
(*blockerOut) = _e287;
let _e288 = lightRadius;
let _e289 = (*receiver_1);
let _e290 = blocker;
let _e294 = blocker;
world = ((_e288 * max((_e289 - _e290), 0f)) / _e294);
let _e296 = world;
let _e297 = (*receiver_1);
let _e299 = (*tanHalf);
let _e302 = minRadius;
let _e303 = maxRadius;
return clamp((_e296 / ((2f * _e297) * _e299)), _e302, _e303);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e213 = (*rows);
if (_e213 > 0f) {
let _e216 = gl_FragCoord_1[0u];
let _e217 = (*rows);
let _e219 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e216, (_e217 - _e219));
} else {
let _e222 = gl_FragCoord_1;
local_13 = _e222.xy;
}
let _e224 = local_13;
return _e224;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2246_: bool;
var phi_2307_: bool;
let _e265 = (*lightIndex);
let _e269 = point_shadow.slots[_e265][0u];
slot = i32((_e269 + 0.5f));
let _e272 = (*lightIndex);
let _e276 = point_shadow.slots[_e272][0u];
if (_e276 < 0f) {
return 1f;
}
let _e280 = point_shadow.params[2u];
strength = _e280;
let _e281 = strength;
if (_e281 <= 0f) {
return 1f;
}
let _e283 = slot;
let _e286 = point_shadow.lights[_e283];
let _e288 = (*world_1);
toLight = (_e286.xyz - _e288);
let _e290 = toLight;
toLightLength = max(length(_e290), 0.000001f);
let _e293 = (*normal);
let _e294 = toLight;
let _e295 = toLightLength;
nDotL = max(dot(_e293, (_e294 / vec3(_e295))), 0.15f);
let _e300 = nDotL;
let _e301 = nDotL;
let _e306 = nDotL;
let _e307 = nDotL;
slope = min((sqrt(max((1f - (_e300 * _e301)), 0f)) / (_e306 * _e307)), 8f);
let _e311 = toLightLength;
let _e313 = (*lightIndex);
let _e317 = point_shadow.slots[_e313][2u];
let _e322 = point_shadow.params3_[1u];
texel = (((2f * _e311) * max(_e317, 0.0001f)) * _e322);
let _e324 = (*world_1);
let _e325 = (*normal);
let _e326 = texel;
let _e330 = point_shadow.params[3u];
let _e332 = slope;
origin = (_e324 + (((_e325 * _e326) * _e330) * (1f + _e332)));
let _e336 = origin;
let _e337 = slot;
let _e340 = point_shadow.lights[_e337];
toFragment = (_e336 - _e340.xyz);
let _e343 = toFragment;
distance_ = length(_e343);
let _e345 = slot;
let _e349 = point_shadow.lights[_e345][3u];
range_3 = max(_e349, 0.0001f);
let _e351 = distance_;
let _e352 = range_3;
if (_e351 >= _e352) {
return 1f;
}
face = 0i;
let _e354 = (*lightIndex);
let _e358 = point_shadow.slots[_e354][1u];
if (_e358 < 0.5f) {
let _e360 = toFragment;
a = abs(_e360);
let _e363 = a[0u];
let _e365 = a[1u];
let _e366 = (_e363 >= _e365);
phi_2246_ = _e366;
if _e366 {
let _e368 = a[0u];
let _e370 = a[2u];
phi_2246_ = (_e368 >= _e370);
}
let _e373 = phi_2246_;
if _e373 {
let _e375 = toFragment[0u];
face = select(1i, 0i, (_e375 > 0f));
} else {
let _e379 = a[1u];
let _e381 = a[2u];
if (_e379 >= _e381) {
let _e384 = toFragment[1u];
face = select(3i, 2i, (_e384 > 0f));
} else {
let _e388 = toFragment[2u];
face = select(5i, 4i, (_e388 > 0f));
}
}
}
let _e391 = slot;
let _e393 = face;
let _e397 = point_shadow.faces[((_e391 * 6i) + _e393)];
let _e398 = origin;
clip = (_e397 * vec4<f32>(_e398.x, _e398.y, _e398.z, 1f));
let _e405 = clip[3u];
if (_e405 <= 0f) {
return 1f;
}
let _e407 = clip;
let _e410 = clip[3u];
ndc = (_e407.xy / vec2(_e410));
let _e414 = ndc[0u];
let _e416 = (abs(_e414) > 1f);
phi_2307_ = _e416;
if !(_e416) {
let _e419 = ndc[1u];
phi_2307_ = (abs(_e419) > 1f);
}
let _e423 = phi_2307_;
if _e423 {
return 1f;
}
let _e425 = ndc[0u];
let _e429 = ndc[1u];
uv_4 = vec2<f32>(((_e425 * 0.5f) + 0.5f), (0.5f - (_e429 * 0.5f)));
let _e433 = face;
let _e435 = slot;
tile_3 = vec2<f32>(f32(_e433), f32(_e435));
let _e438 = distance_;
let _e441 = point_shadow.params[1u];
receiver_2 = (_e438 - _e441);
let _e445 = frag_info.target_origin[0u];
param_31 = _e445;
let _e446 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e446, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e451 = noise;
angle = (_e451 * 6.2831855f);
let _e453 = angle;
ca_2 = cos(_e453);
let _e455 = angle;
sa_2 = sin(_e455);
let _e457 = (*lightIndex);
let _e461 = point_shadow.slots[_e457][2u];
tanHalf_1 = max(_e461, 0.0001f);
blocker_1 = -1f;
let _e463 = uv_4;
param_32 = _e463;
let _e464 = tile_3;
param_33 = _e464;
let _e465 = range_3;
param_34 = _e465;
let _e466 = receiver_2;
param_35 = _e466;
let _e467 = ca_2;
param_36 = _e467;
let _e468 = sa_2;
param_37 = _e468;
let _e469 = tanHalf_1;
param_38 = _e469;
let _e470 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e471 = param_39;
blocker_1 = _e471;
radius_1 = _e470;
let _e474 = point_shadow.params2_[3u];
if (_e474 > 0.5f) {
g_debug_surface_on = true;
let _e476 = radius_1;
if (_e476 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e478 = radius_1;
let _e481 = point_shadow.params2_[2u];
let _e485 = blocker_1;
let _e486 = range_3;
local_14 = vec3<f32>(clamp((_e478 / max(_e481, 0.000001f)), 0f, 1f), clamp((_e485 / _e486), 0f, 1f), 0f);
}
let _e490 = local_14;
g_debug_surface = _e490;
}
let _e491 = radius_1;
if (_e491 < 0f) {
return 1f;
}
let _e493 = uv_4;
param_40 = _e493;
param_41 = vec2<f32>(0f, 0f);
let _e494 = tile_3;
param_42 = _e494;
let _e495 = range_3;
param_43 = _e495;
let _e496 = receiver_2;
param_44 = _e496;
let _e497 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e497;
let _e498 = radius_1;
if (_e498 > 0f) {
i_3 = 0i;
loop {
let _e500 = i_3;
if (_e500 < 8i) {
let _e502 = i_3;
param_45 = _e502;
let _e503 = ca_2;
param_46 = _e503;
let _e504 = sa_2;
param_47 = _e504;
let _e505 = radius_1;
param_48 = _e505;
let _e506 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e507 = uv_4;
param_49 = _e507;
param_50 = _e506;
let _e508 = tile_3;
param_51 = _e508;
let _e509 = range_3;
param_52 = _e509;
let _e510 = receiver_2;
param_53 = _e510;
let _e511 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e512 = lit_1;
lit_1 = (_e512 + _e511);
continue;
} else {
break;
}
continuing {
let _e514 = i_3;
i_3 = (_e514 + 1i);
}
}
let _e516 = lit_1;
lit_1 = (_e516 * 0.11111111f);
}
let _e518 = lit_1;
let _e519 = strength;
return mix(1f, _e518, clamp(_e519, 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 _e216 = (*i_4);
let _e219 = (*n_1);
r = sqrt(((f32(_e216) + 0.5f) / f32(_e219)));
let _e223 = (*i_4);
let _e226 = (*turn);
theta = ((f32(_e223) * 2.3999631f) + _e226);
let _e228 = r;
let _e229 = theta;
let _e231 = theta;
return (vec2<f32>(cos(_e229), sin(_e231)) * _e228);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e215 = frag_info.target_origin[0u];
param_54 = _e215;
let _e216 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e219 = frag_info.target_origin[3u];
at = (_e216 + vec2((5.588238f * max(_e219, 0f))));
let _e224 = at;
return fract((52.982918f * fract(dot(_e224, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e214 = (*mode_1);
if (_e214 > 0.5f) {
let _e216 = (*stored_2);
local_15 = (1f - _e216);
} else {
let _e218 = (*stored_2);
local_15 = _e218;
}
let _e219 = local_15;
return _e219;
}
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 _e220 = (*moments)[1u];
let _e222 = (*moments)[0u];
let _e224 = (*moments)[0u];
let _e227 = (*minVariance);
variance = max((_e220 - (_e222 * _e224)), _e227);
let _e229 = (*t);
let _e231 = (*moments)[0u];
d_1 = (_e229 - _e231);
let _e233 = variance;
let _e234 = variance;
let _e235 = d_1;
let _e236 = d_1;
pMax = (_e233 / (_e234 + (_e235 * _e236)));
let _e240 = pMax;
let _e241 = (*bleed);
let _e243 = (*bleed);
reduced = clamp(((_e240 - _e241) / max((1f - _e243), 0.0001f)), 0f, 1f);
let _e248 = (*t);
let _e250 = (*moments)[0u];
let _e252 = reduced;
return select(_e252, 1f, (_e248 <= _e250));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e213 = (*depth);
d_2 = ((2f * clamp(_e213, 0f, 1f)) - 1f);
let _e217 = d_2;
let _e220 = d_2;
return vec2<f32>(exp((40f * _e217)), -(exp((-5f * _e220))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e227 = (*depth_1);
param_55 = _e227;
let _e228 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e228;
let _e229 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e229);
let _e232 = scale[0u];
let _e234 = scale[0u];
let _e236 = (*moments_1);
param_56 = _e236.xy;
let _e239 = warped[0u];
param_57 = _e239;
param_58 = (_e232 * _e234);
let _e240 = (*bleed_1);
param_59 = _e240;
let _e241 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e241;
let _e243 = scale[1u];
let _e245 = scale[1u];
let _e247 = (*moments_1);
param_60 = _e247.zw;
let _e250 = warped[1u];
param_61 = _e250;
param_62 = (_e243 * _e245);
let _e251 = (*bleed_1);
param_63 = _e251;
let _e252 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e252;
let _e253 = positive;
let _e254 = negative;
return min(_e253, _e254);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e213 = (*depth_2);
stored_3 = max((1f - _e213), 0.000061035156f);
let _e216 = stored_3;
return exp2((floor(log2(_e216)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3856_: bool;
var phi_3867_: bool;
var phi_4024_: bool;
var phi_4031_: bool;
var phi_4038_: bool;
let _e290 = frag_info.shadow_params[3u];
strength_1 = _e290;
let _e291 = strength_1;
if (_e291 <= 0f) {
return 1f;
}
let _e293 = (*lightIndex_1);
let _e296 = frag_info.frame_params[2u];
if (_e293 != i32(floor((_e296 + 0.5f)))) {
return 1f;
}
let _e303 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e303 + 0.5f));
let _e306 = Orthographic_u0028_();
if _e306 {
let _e307 = ViewDepth_u0028_();
local_16 = _e307;
} else {
let _e308 = v_world_position_1;
let _e310 = frag_info.camera_position;
local_16 = length((_e308 - _e310.xyz));
}
let _e314 = local_16;
viewDistance = _e314;
cascade = 0i;
let _e315 = cascadeCount;
let _e316 = (_e315 > 1i);
phi_3856_ = _e316;
if _e316 {
let _e317 = viewDistance;
let _e320 = frag_info.shadow_cascades[0u];
phi_3856_ = (_e317 > _e320);
}
let _e323 = phi_3856_;
if _e323 {
cascade = 1i;
}
let _e324 = cascadeCount;
let _e325 = (_e324 > 2i);
phi_3867_ = _e325;
if _e325 {
let _e326 = viewDistance;
let _e329 = frag_info.shadow_cascades[1u];
phi_3867_ = (_e326 > _e329);
}
let _e332 = phi_3867_;
if _e332 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e333 = attempt;
if (_e333 < 3i) {
let _e335 = cascade;
let _e336 = attempt;
which = (_e335 + _e336);
let _e338 = which;
let _e339 = cascadeCount;
if (_e338 >= _e339) {
break;
}
let _e341 = which;
if (_e341 == 0i) {
let _e344 = frag_info.shadow_matrix;
local_17 = _e344;
} else {
let _e345 = which;
if (_e345 == 1i) {
let _e348 = frag_info.shadow_matrix_far;
local_18 = _e348;
} else {
let _e350 = frag_info.shadow_matrix_farthest;
local_18 = _e350;
}
let _e351 = local_18;
local_17 = _e351;
}
let _e352 = local_17;
matrix = _e352;
let _e355 = matrix[0][0u];
let _e358 = matrix[1][0u];
let _e361 = matrix[2][0u];
axisX = vec3<f32>(_e355, _e358, _e361);
let _e365 = matrix[0][1u];
let _e368 = matrix[1][1u];
let _e371 = matrix[2][1u];
axisY = vec3<f32>(_e365, _e368, _e371);
let _e373 = axisX;
rowX = max(length(_e373), 0.000001f);
let _e376 = axisY;
rowY = max(length(_e376), 0.000001f);
let _e381 = frag_info.shadow_cascades[3u];
let _e383 = rowX;
texelMetres = ((2f * _e381) / _e383);
let _e387 = frag_info.shadow_cascades[3u];
let _e390 = (*s_2).n;
let _e391 = axisX;
let _e394 = rowX;
let _e395 = rowX;
let _e399 = (*s_2).n;
let _e400 = axisY;
let _e403 = rowY;
let _e404 = rowY;
reach = ((3f * _e387) * ((abs(dot(_e390, _e391)) / (_e394 * _e395)) + (abs(dot(_e399, _e400)) / (_e403 * _e404))));
let _e411 = frag_info.shadow_params[2u];
let _e412 = texelMetres;
flatOffset = min(_e411, _e412);
let _e414 = v_world_position_1;
let _e416 = (*s_2).n;
let _e417 = flatOffset;
let _e418 = reach;
origin_1 = (_e414 + (_e416 * (_e417 + _e418)));
let _e422 = matrix;
let _e423 = origin_1;
lightSpace = (_e422 * vec4<f32>(_e423.x, _e423.y, _e423.z, 1f));
let _e430 = lightSpace[3u];
if (_e430 <= 0f) {
continue;
}
let _e432 = lightSpace;
let _e435 = lightSpace[3u];
candidate = (_e432.xyz / vec3(_e435));
let _e439 = candidate[0u];
let _e443 = candidate[1u];
inTile = vec2<f32>(((_e439 * 0.5f) + 0.5f), (0.5f - (_e443 * 0.5f)));
let _e448 = inTile[0u];
let _e449 = (_e448 < 0f);
phi_4024_ = _e449;
if !(_e449) {
let _e452 = inTile[0u];
phi_4024_ = (_e452 > 1f);
}
let _e455 = phi_4024_;
phi_4031_ = _e455;
if !(_e455) {
let _e458 = inTile[1u];
phi_4031_ = (_e458 < 0f);
}
let _e461 = phi_4031_;
phi_4038_ = _e461;
if !(_e461) {
let _e464 = inTile[1u];
phi_4038_ = (_e464 > 1f);
}
let _e467 = phi_4038_;
if _e467 {
continue;
}
let _e469 = candidate[2u];
if (_e469 > 1f) {
let _e471 = which;
let _e472 = cascadeCount;
if (_e471 < (_e472 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e477 = inTile[0u];
let _e478 = which;
let _e481 = cascadeCount;
let _e485 = inTile[1u];
uv_5 = vec2<f32>(((_e477 + f32(_e478)) / f32(_e481)), _e485);
let _e487 = candidate;
projected = _e487;
let _e488 = which;
cascade = _e488;
let _e489 = texelMetres;
cascadeTexel = _e489;
let _e492 = matrix[0][2u];
let _e495 = matrix[1][2u];
let _e498 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e492, _e495, _e498)), 0.000001f));
let _e504 = (*s_2).n;
let _e507 = matrix[0][2u];
let _e510 = matrix[1][2u];
let _e513 = matrix[2][2u];
let _e517 = cascadeDepth;
cosSlope = clamp((abs(dot(_e504, vec3<f32>(_e507, _e510, _e513))) * _e517), 0.1f, 1f);
let _e520 = texelMetres;
let _e521 = cosSlope;
let _e522 = cosSlope;
let _e528 = cosSlope;
let _e530 = cascadeDepth;
receiverSlope = (((_e520 * sqrt(max((1f - (_e521 * _e522)), 0f))) / _e528) / _e530);
found = true;
break;
} else {
break;
}
continuing {
let _e532 = attempt;
attempt = (_e532 + 1i);
}
}
let _e534 = found;
if !(_e534) {
return 1f;
}
let _e536 = cascade;
if (_e536 == 0i) {
let _e540 = frag_info.shadow_bias[0u];
local_19 = _e540;
} else {
let _e541 = cascade;
if (_e541 == 1i) {
let _e545 = frag_info.shadow_bias[1u];
local_20 = _e545;
} else {
let _e548 = frag_info.shadow_bias[2u];
local_20 = _e548;
}
let _e549 = local_20;
local_19 = _e549;
}
let _e550 = local_19;
bias = _e550;
let _e553 = frag_info.shadow_params[1u];
storage_ = _e553;
let _e554 = storage_;
let _e556 = storage_;
if ((_e554 > 0.5f) && (_e556 < 1.5f)) {
let _e559 = bias;
let _e561 = projected[2u];
param_64 = _e561;
let _e562 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e559, _e562);
}
let _e566 = frag_info.shadow_params[0u];
let _e569 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e566, _e569);
let _e571 = cascade;
let _e573 = cascadeCount;
let _e577 = texel_1;
tileLo = (vec2<f32>((f32(_e571) / f32(_e573)), 0f) + (_e577 * 0.5f));
let _e580 = cascade;
let _e583 = cascadeCount;
let _e587 = texel_1;
tileHi = (vec2<f32>((f32((_e580 + 1i)) / f32(_e583)), 1f) - (_e587 * 0.5f));
let _e592 = frag_info.shadow_bias[3u];
if (_e592 > 0.5f) {
let _e594 = uv_5;
let _e595 = tileLo;
let _e596 = tileHi;
let _e598 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e594, _e595, _e596), 0f);
stored_4 = _e598;
let _e600 = stored_4[1u];
let _e603 = stored_4[2u];
let _e606 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e600), (1f - _e603), _e606), vec3(0f), vec3(4f));
let _e611 = through;
let _e612 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e611, vec3(clamp(_e612, 0f, 1f)));
}
let _e618 = frag_info.ambient_ground[3u];
softness = _e618;
lit_2 = 0f;
let _e619 = softness;
if (_e619 < 0f) {
let _e621 = uv_5;
let _e622 = tileLo;
let _e623 = tileHi;
let _e625 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e621, _e622, _e623), 0f);
moments_2 = _e625;
let _e627 = projected[2u];
let _e628 = bias;
let _e630 = softness;
let _e634 = moments_2;
param_65 = _e634;
param_66 = (_e627 - _e628);
param_67 = clamp((-(_e630) - 1f), 0f, 0.95f);
let _e635 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e635;
} else {
let _e636 = softness;
if (_e636 <= 0f) {
y = -1i;
loop {
let _e638 = y;
if (_e638 <= 1i) {
x = -1i;
loop {
let _e640 = x;
if (_e640 <= 1i) {
let _e642 = uv_5;
let _e643 = x;
let _e645 = y;
let _e648 = texel_1;
let _e651 = tileLo;
let _e652 = tileHi;
let _e654 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e642 + (vec2<f32>(f32(_e643), f32(_e645)) * _e648)), _e651, _e652), 0f);
param_68 = _e654.x;
let _e656 = storage_;
param_69 = _e656;
let _e657 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e657;
let _e659 = projected[2u];
let _e660 = bias;
let _e662 = occluder;
let _e665 = lit_2;
lit_2 = (_e665 + select(1f, 0f, ((_e659 - _e660) > _e662)));
continue;
} else {
break;
}
continuing {
let _e667 = x;
x = (_e667 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e669 = y;
y = (_e669 + 1i);
}
}
let _e671 = lit_2;
lit_2 = (_e671 * 0.11111111f);
} else {
let _e673 = softness;
spread = tan(min(_e673, 0.5f));
let _e676 = ShadowNoise_u0028_();
turn_1 = (_e676 * 6.2831855f);
let _e678 = spread;
let _e680 = projected[2u];
let _e682 = cascadeDepth;
let _e684 = cascadeTexel;
searchRadius = clamp((((_e678 * _e680) * _e682) / _e684), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e687 = i_5;
if (_e687 < 16i) {
let _e689 = i_5;
param_70 = _e689;
param_71 = 16i;
let _e690 = turn_1;
param_72 = _e690;
let _e691 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e691;
let _e692 = bias;
let _e693 = disc;
let _e695 = searchRadius;
let _e699 = receiverSlope;
tapBias = (_e692 + (max(((length(_e693) * _e695) - 1.5f), 0f) * _e699));
let _e702 = uv_5;
let _e703 = disc;
let _e704 = texel_1;
let _e706 = searchRadius;
let _e709 = tileLo;
let _e710 = tileHi;
let _e712 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e702 + ((_e703 * _e704) * _e706)), _e709, _e710), 0f);
param_73 = _e712.x;
let _e714 = storage_;
param_74 = _e714;
let _e715 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e715;
let _e717 = projected[2u];
let _e718 = tapBias;
let _e720 = occluder_1;
if ((_e717 - _e718) > _e720) {
let _e722 = occluder_1;
let _e723 = blockerSum;
blockerSum = (_e723 + _e722);
let _e725 = blockerCount;
blockerCount = (_e725 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e727 = i_5;
i_5 = (_e727 + 1i);
}
}
let _e729 = blockerCount;
if (_e729 <= 0f) {
return 1f;
}
let _e732 = projected[2u];
let _e733 = blockerSum;
let _e734 = blockerCount;
let _e738 = cascadeDepth;
gap = (max((_e732 - (_e733 / _e734)), 0f) * _e738);
let _e740 = spread;
let _e741 = gap;
let _e743 = cascadeTexel;
radius_2 = clamp(((_e740 * _e741) / _e743), 1f, 16f);
i_6 = 0i;
loop {
let _e746 = i_6;
if (_e746 < 16i) {
let _e748 = turn_1;
let _e750 = i_6;
param_75 = _e750;
param_76 = 16i;
param_77 = (_e748 + 1f);
let _e751 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e751;
let _e752 = bias;
let _e753 = disc_1;
let _e755 = radius_2;
let _e759 = receiverSlope;
tapBias_1 = (_e752 + (max(((length(_e753) * _e755) - 1.5f), 0f) * _e759));
let _e762 = uv_5;
let _e763 = disc_1;
let _e764 = texel_1;
let _e766 = radius_2;
let _e769 = tileLo;
let _e770 = tileHi;
let _e772 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e762 + ((_e763 * _e764) * _e766)), _e769, _e770), 0f);
param_78 = _e772.x;
let _e774 = storage_;
param_79 = _e774;
let _e775 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e775;
let _e777 = projected[2u];
let _e778 = tapBias_1;
let _e780 = occluder_2;
let _e783 = lit_2;
lit_2 = (_e783 + select(1f, 0f, ((_e777 - _e778) > _e780)));
continue;
} else {
break;
}
continuing {
let _e785 = i_6;
i_6 = (_e785 + 1i);
}
}
let _e787 = lit_2;
lit_2 = (_e787 * 0.0625f);
}
}
let _e789 = lit_2;
let _e790 = strength_1;
return mix(1f, _e789, clamp(_e790, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e217 = (*s_3);
param_80 = _e217;
let _e218 = (*light_2);
param_81 = _e218;
let _e219 = (*index);
param_82 = _e219;
let _e220 = 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_80), (¶m_81), (¶m_82));
return _e220;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e212 = (*index_1);
return (_e212 < 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 _e216 = (*distance_1);
let _e217 = (*distance_1);
attenuation = (1f / max((_e216 * _e217), 0.0001f));
let _e221 = (*range_4);
if (_e221 > 0f) {
let _e223 = (*distance_1);
let _e224 = (*range_4);
ratio = (_e223 / _e224);
let _e226 = ratio;
let _e227 = ratio;
let _e229 = ratio;
let _e231 = ratio;
window = clamp((1f - (((_e226 * _e227) * _e229) * _e231)), 0f, 1f);
let _e235 = window;
let _e236 = window;
let _e238 = attenuation;
attenuation = (_e238 * (_e235 * _e236));
}
let _e240 = attenuation;
return _e240;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e228 = (*halfWidth);
let _e229 = (*halfHeight);
n_2 = cross(_e228, _e229);
let _e231 = n_2;
nLen = length(_e231);
let _e233 = nLen;
if (_e233 < 0.000000000001f) {
let _e235 = (*centre);
return _e235;
}
let _e236 = nLen;
let _e237 = n_2;
n_2 = (_e237 / vec3(_e236));
let _e240 = (*centre);
let _e241 = (*world_2);
toPlane = (_e240 - _e241);
let _e243 = (*mirror);
let _e244 = n_2;
denom = dot(_e243, _e244);
let _e246 = denom;
if (abs(_e246) < 0.00001f) {
let _e249 = toPlane;
let _e250 = n_2;
let _e251 = toPlane;
let _e252 = n_2;
onPlane = (_e249 - (_e250 * dot(_e251, _e252)));
} else {
let _e256 = toPlane;
let _e257 = n_2;
let _e259 = denom;
t_1 = (dot(_e256, _e257) / _e259);
let _e261 = t_1;
if (_e261 > 0f) {
let _e263 = (*mirror);
let _e264 = t_1;
local_21 = (_e263 * _e264);
} else {
let _e266 = toPlane;
let _e267 = n_2;
let _e268 = toPlane;
let _e269 = n_2;
local_21 = (_e266 - (_e267 * dot(_e268, _e269)));
}
let _e273 = local_21;
onPlane = _e273;
}
let _e274 = onPlane;
let _e275 = toPlane;
offset_2 = (_e274 - _e275);
let _e277 = (*halfWidth);
let _e278 = (*halfWidth);
wLen2_ = max(dot(_e277, _e278), 0.000000000001f);
let _e281 = (*halfHeight);
let _e282 = (*halfHeight);
hLen2_ = max(dot(_e281, _e282), 0.000000000001f);
let _e285 = offset_2;
let _e286 = (*halfWidth);
let _e288 = wLen2_;
u = clamp((dot(_e285, _e286) / _e288), -1f, 1f);
let _e291 = offset_2;
let _e292 = (*halfHeight);
let _e294 = hLen2_;
v = clamp((dot(_e291, _e292) / _e294), -1f, 1f);
let _e297 = (*centre);
let _e298 = (*halfWidth);
let _e299 = u;
let _e302 = (*halfHeight);
let _e303 = v;
return ((_e297 + (_e298 * _e299)) + (_e302 * _e303));
}
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_22: f32;
let _e220 = (*a_1);
let _e221 = (*a_1);
ua = (_e220 / vec3(max(length(_e221), 0.000000000001f)));
let _e226 = (*b);
let _e227 = (*b);
ub = (_e226 / vec3(max(length(_e227), 0.000000000001f)));
let _e232 = ua;
let _e233 = ub;
angle_1 = acos(clamp(dot(_e232, _e233), -1f, 1f));
let _e237 = ua;
let _e238 = ub;
axis = cross(_e237, _e238);
let _e240 = axis;
len = length(_e240);
let _e242 = len;
if (_e242 > 0.000001f) {
let _e244 = angle_1;
let _e245 = axis;
let _e246 = (*n_3);
let _e249 = len;
local_22 = ((_e244 * dot(_e245, _e246)) / _e249);
} else {
local_22 = 0f;
}
let _e251 = local_22;
return _e251;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e234 = i_7;
if (_e234 < 4i) {
let _e236 = i_7;
let _e238 = (*corners)[_e236];
a_2 = _e238;
let _e239 = i_7;
if (_e239 == 3i) {
local_23 = 0i;
} else {
let _e241 = i_7;
local_23 = (_e241 + 1i);
}
let _e243 = local_23;
let _e245 = (*corners)[_e243];
b_1 = _e245;
let _e246 = a_2;
let _e247 = (*n_4);
ha = dot(_e246, _e247);
let _e249 = b_1;
let _e250 = (*n_4);
hb = dot(_e249, _e250);
let _e252 = ha;
let _e253 = hb;
d_3 = (_e252 - _e253);
let _e255 = a_2;
let _e256 = b_1;
let _e257 = a_2;
let _e259 = d_3;
if (abs(_e259) > 0.000000000001f) {
let _e262 = ha;
let _e263 = d_3;
local_24 = (_e262 / _e263);
} else {
local_24 = 0f;
}
let _e265 = local_24;
q = (_e255 + ((_e256 - _e257) * _e265));
let _e268 = ha;
aAbove = (_e268 > 0f);
let _e270 = hb;
bAbove = (_e270 > 0f);
let _e272 = aAbove;
let _e273 = bAbove;
if (_e272 || _e273) {
let _e275 = aAbove;
let _e276 = a_2;
let _e277 = q;
let _e280 = bAbove;
let _e281 = b_1;
let _e282 = q;
param_83 = select(_e277, _e276, vec3(_e275));
param_84 = select(_e282, _e281, vec3(_e280));
let _e285 = (*n_4);
param_85 = _e285;
let _e286 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e286;
} else {
local_25 = 0f;
}
let _e287 = local_25;
let _e288 = total;
total = (_e288 + _e287);
let _e290 = aAbove;
let _e291 = bAbove;
let _e294 = q;
let _e295 = exit;
exit = select(_e295, _e294, vec3((_e290 && !(_e291))));
let _e298 = aAbove;
let _e300 = bAbove;
let _e302 = q;
let _e303 = entry;
entry = select(_e303, _e302, vec3((!(_e298) && _e300)));
continue;
} else {
break;
}
continuing {
let _e306 = i_7;
i_7 = (_e306 + 1i);
}
}
let _e308 = exit;
param_86 = _e308;
let _e309 = entry;
param_87 = _e309;
let _e310 = (*n_4);
param_88 = _e310;
let _e311 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e312 = total;
total = (_e312 + _e311);
let _e314 = total;
return max((-(_e314) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e217 = (*slot_1);
let _e218 = (*slot_1);
lane = (_e217 - ((_e218 / 4i) * 4i));
let _e222 = lane;
if (_e222 == 0i) {
let _e225 = (*four)[0u];
local_26 = _e225;
} else {
let _e226 = lane;
if (_e226 == 1i) {
let _e229 = (*four)[1u];
local_27 = _e229;
} else {
let _e230 = lane;
if (_e230 == 2i) {
let _e233 = (*four)[2u];
local_28 = _e233;
} else {
let _e235 = (*four)[3u];
local_28 = _e235;
}
let _e236 = local_28;
local_27 = _e236;
}
let _e237 = local_27;
local_26 = _e237;
}
let _e238 = local_26;
return _e238;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e214 = (*slot_2);
let _e218 = light_list_info.scales[(_e214 / 4i)];
param_89 = _e218;
let _e219 = (*slot_2);
param_90 = _e219;
let _e220 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e220;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e216 = light_list_info.slot_rows[0i];
let _e217 = (*row);
a_3 = abs((_e216 - vec4(_e217)));
let _e223 = light_list_info.slot_rows[1i];
let _e224 = (*row);
b_2 = abs((_e223 - vec4(_e224)));
let _e229 = a_3[0u];
let _e231 = a_3[1u];
let _e234 = a_3[2u];
let _e236 = a_3[3u];
let _e240 = b_2[0u];
let _e242 = b_2[1u];
let _e245 = b_2[2u];
let _e247 = b_2[3u];
return (min(min(min(_e229, _e231), min(_e234, _e236)), min(min(_e240, _e242), min(_e245, _e247))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e214 = (*slot_3);
let _e218 = light_list_info.indices[(_e214 / 4i)];
param_91 = _e218;
let _e219 = (*slot_3);
param_92 = _e219;
let _e220 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e220;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e213 = (*texel_2);
let _e217 = light_list_info.list[1u];
let _e219 = (*row_1);
let _e223 = light_list_info.list[2u];
let _e226 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e213 + 0.5f) * _e217), ((_e219 + 0.5f) * _e223)), 0f);
return _e226;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e221 = g_cluster_offset;
let _e222 = (*slot_4);
entry_1 = (_e221 + f32(_e222));
let _e225 = entry_1;
row_2 = floor((_e225 / 16f));
let _e228 = entry_1;
let _e229 = row_2;
within_1 = (_e228 - (_e229 * 16f));
let _e232 = within_1;
texel_3 = floor((_e232 / 4f));
let _e237 = light_list_info.cluster_depth[3u];
let _e238 = row_2;
let _e240 = texel_3;
param_93 = _e240;
param_94 = (_e237 + _e238);
let _e241 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e241;
let _e242 = within_1;
let _e243 = texel_3;
let _e248 = four_1;
param_95 = _e248;
param_96 = i32(((_e242 - (_e243 * 4f)) + 0.5f));
let _e249 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e249;
}
fn Clustered_u0028_() -> bool {
let _e213 = light_list_info.cluster_grid[3u];
return (_e213 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e265 = (*index_2);
if (_e265 < 8i) {
let _e267 = (*index_2);
let _e270 = frag_info.light_position[_e267];
position = _e270;
let _e271 = (*index_2);
let _e274 = frag_info.light_color[_e271];
color_1 = _e274;
let _e275 = (*index_2);
let _e278 = frag_info.light_direction[_e275];
direction = _e278;
let _e279 = (*index_2);
let _e282 = frag_info.light_cone[_e279];
cone = _e282;
} else {
let _e283 = (*index_2);
slot_5 = (_e283 - 8i);
let _e285 = Clustered_u0028_();
clustered = _e285;
let _e286 = clustered;
if _e286 {
let _e287 = slot_5;
param_97 = _e287;
let _e288 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e288;
} else {
let _e289 = slot_5;
param_98 = _e289;
let _e290 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e290;
}
let _e291 = local_29;
listRow = _e291;
let _e292 = listRow;
let _e296 = light_list_info.list[2u];
v_1 = ((_e292 + 0.5f) * _e296);
let _e300 = light_list_info.list[1u];
u_1 = _e300;
let _e301 = u_1;
let _e303 = v_1;
let _e305 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e301), _e303), 0f);
position = _e305;
let _e306 = u_1;
let _e308 = v_1;
let _e310 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e306), _e308), 0f);
color_1 = _e310;
let _e311 = u_1;
let _e313 = v_1;
let _e315 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e311), _e313), 0f);
direction = _e315;
let _e316 = u_1;
let _e318 = v_1;
let _e320 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e316), _e318), 0f);
cone = _e320;
let _e321 = clustered;
if _e321 {
let _e322 = listRow;
param_99 = _e322;
let _e323 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e323);
} else {
let _e325 = slot_5;
param_100 = _e325;
let _e326 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e326;
}
let _e327 = local_30;
let _e329 = color_1[3u];
color_1[3u] = (_e329 * _e327);
}
let _e333 = position[3u];
type_39 = _e333;
let _e334 = type_39;
if (_e334 > 15.5f) {
let _e337 = (*s_4).n;
light_3.l = _e337;
let _e340 = (*s_4).n;
light_3.h = _e340;
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 _e346 = light_3;
return _e346;
}
let _e347 = type_39;
if (_e347 > 2.5f) {
let _e349 = direction;
halfWidth_1 = _e349.xyz;
let _e351 = cone;
halfHeight_1 = _e351.xyz;
let _e353 = position;
let _e355 = v_world_position_1;
toCentre = (_e353.xyz - _e355);
let _e357 = toCentre;
let _e358 = halfWidth_1;
let _e360 = halfHeight_1;
corners_1[0i] = ((_e357 - _e358) - _e360);
let _e363 = toCentre;
let _e364 = halfWidth_1;
let _e366 = halfHeight_1;
corners_1[1i] = ((_e363 + _e364) - _e366);
let _e369 = toCentre;
let _e370 = halfWidth_1;
let _e372 = halfHeight_1;
corners_1[2i] = ((_e369 + _e370) + _e372);
let _e375 = toCentre;
let _e376 = halfWidth_1;
let _e378 = halfHeight_1;
corners_1[3i] = ((_e375 - _e376) + _e378);
let _e381 = toCentre;
let _e382 = halfWidth_1;
let _e383 = halfHeight_1;
behind = (dot(_e381, cross(_e382, _e383)) >= 0f);
let _e387 = behind;
if _e387 {
local_31 = 0f;
} else {
let _e388 = corners_1;
param_101 = _e388;
let _e390 = (*s_4).n;
param_102 = _e390;
let _e391 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e391;
}
let _e392 = local_31;
formFactor = _e392;
let _e393 = halfWidth_1;
let _e394 = halfHeight_1;
area = (length(cross(_e393, _e394)) * 4f);
let _e398 = area;
if (_e398 > 0.000000001f) {
let _e400 = area;
local_32 = (1f / _e400);
} else {
local_32 = 0f;
}
let _e402 = local_32;
radiance = _e402;
let _e403 = toCentre;
distance_2 = length(_e403);
let _e406 = direction[3u];
if (_e406 > 0f) {
let _e408 = distance_2;
let _e410 = direction[3u];
ratio_1 = (_e408 / _e410);
let _e412 = ratio_1;
let _e413 = ratio_1;
let _e415 = ratio_1;
let _e417 = ratio_1;
window_1 = clamp((1f - (((_e412 * _e413) * _e415) * _e417)), 0f, 1f);
let _e421 = window_1;
let _e422 = window_1;
let _e424 = radiance;
radiance = (_e424 * (_e421 * _e422));
}
let _e427 = (*s_4).v;
let _e430 = (*s_4).n;
mirror_1 = reflect(-(_e427), _e430);
let _e432 = position;
param_103 = _e432.xyz;
let _e434 = halfWidth_1;
param_104 = _e434;
let _e435 = halfHeight_1;
param_105 = _e435;
let _e436 = v_world_position_1;
param_106 = _e436;
let _e437 = mirror_1;
param_107 = _e437;
let _e438 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e438;
let _e439 = representative;
let _e440 = v_world_position_1;
toPoint = (_e439 - _e440);
let _e442 = toPoint;
pointDistance = length(_e442);
let _e444 = pointDistance;
if (_e444 > 0.000001f) {
let _e446 = toPoint;
let _e447 = pointDistance;
local_33 = (_e446 / vec3(_e447));
} else {
let _e451 = (*s_4).n;
local_33 = _e451;
}
let _e452 = local_33;
light_3.l = _e452;
let _e455 = light_3.l;
let _e457 = (*s_4).v;
light_3.h = normalize((_e455 + _e457));
let _e461 = formFactor;
light_3.n_dot_l = _e461;
let _e464 = (*s_4).n;
let _e466 = light_3.h;
light_3.n_dot_h = max(dot(_e464, _e466), 0f);
let _e471 = (*s_4).v;
let _e473 = light_3.h;
light_3.v_dot_h = max(dot(_e471, _e473), 0f);
let _e477 = color_1;
let _e480 = color_1[3u];
let _e482 = radiance;
light_3.radiance = ((_e477.xyz * _e480) * _e482);
let _e485 = light_3;
return _e485;
}
let _e486 = direction;
aim = normalize(_e486.xyz);
attenuation_1 = 1f;
let _e489 = type_39;
if (_e489 < 0.5f) {
let _e491 = aim;
light_3.l = -(_e491);
} else {
let _e494 = position;
let _e496 = v_world_position_1;
toLight_1 = (_e494.xyz - _e496);
let _e498 = toLight_1;
distance_3 = length(_e498);
let _e500 = distance_3;
if (_e500 < 0.000001f) {
let _e503 = (*s_4).n;
light_3.l = _e503;
let _e506 = (*s_4).n;
light_3.h = _e506;
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 _e512 = light_3;
return _e512;
}
let _e513 = toLight_1;
let _e514 = distance_3;
light_3.l = (_e513 / vec3(_e514));
let _e518 = distance_3;
param_108 = _e518;
let _e520 = direction[3u];
param_109 = _e520;
let _e521 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e521;
let _e522 = type_39;
if (_e522 > 1.5f) {
let _e524 = aim;
let _e526 = light_3.l;
cosAngle = dot(_e524, -(_e526));
let _e529 = cosAngle;
let _e531 = cone[1u];
let _e534 = cone[0u];
let _e536 = cone[1u];
ramp = clamp(((_e529 - _e531) / (_e534 - _e536)), 0f, 1f);
let _e540 = ramp;
let _e541 = ramp;
let _e543 = attenuation_1;
attenuation_1 = (_e543 * (_e540 * _e541));
}
}
let _e546 = light_3.l;
let _e548 = (*s_4).v;
light_3.h = normalize((_e546 + _e548));
let _e553 = (*s_4).n;
let _e555 = light_3.l;
light_3.n_dot_l = max(dot(_e553, _e555), 0f);
let _e560 = (*s_4).n;
let _e562 = light_3.h;
light_3.n_dot_h = max(dot(_e560, _e562), 0f);
let _e567 = (*s_4).v;
let _e569 = light_3.h;
light_3.v_dot_h = max(dot(_e567, _e569), 0f);
let _e573 = color_1;
let _e576 = color_1[3u];
let _e578 = attenuation_1;
light_3.radiance = ((_e573.xyz * _e576) * _e578);
let _e581 = light_3;
return _e581;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e226 = light_list_info.cluster_view_projection;
let _e227 = (*world_3);
clip_1 = (_e226 * vec4<f32>(_e227.x, _e227.y, _e227.z, 1f));
let _e233 = clip_1;
let _e236 = clip_1[3u];
ndc_1 = (_e233.xy / vec2(max(_e236, 0.000001f)));
let _e241 = light_list_info.cluster_grid;
grid = _e241.xyz;
let _e245 = light_list_info.cluster_depth[0u];
near_1 = _e245;
let _e247 = ndc_1[0u];
let _e251 = grid[0u];
let _e255 = grid[0u];
tx = clamp(floor((((_e247 * 0.5f) + 0.5f) * _e251)), 0f, (_e255 - 1f));
let _e259 = ndc_1[1u];
let _e263 = grid[1u];
let _e267 = grid[1u];
ty = clamp(floor((((_e259 * 0.5f) + 0.5f) * _e263)), 0f, (_e267 - 1f));
let _e271 = clip_1[3u];
let _e272 = near_1;
if (_e271 <= _e272) {
local_34 = 0f;
} else {
let _e275 = clip_1[3u];
let _e276 = near_1;
let _e281 = light_list_info.cluster_depth[1u];
let _e285 = grid[2u];
local_34 = clamp(floor((log((_e275 / _e276)) * _e281)), 0f, (_e285 - 1f));
}
let _e288 = local_34;
tz = _e288;
let _e289 = tx;
let _e290 = ty;
let _e292 = grid[0u];
let _e295 = tz;
let _e297 = grid[0u];
let _e300 = grid[1u];
cell_1 = ((_e289 + (_e290 * _e292)) + ((_e295 * _e297) * _e300));
let _e303 = cell_1;
row_3 = floor((_e303 / 4f));
let _e306 = cell_1;
let _e307 = row_3;
let _e312 = light_list_info.cluster_depth[2u];
let _e313 = row_3;
param_110 = (_e306 - (_e307 * 4f));
param_111 = (_e312 + _e313);
let _e315 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e315;
let _e317 = header[0u];
g_cluster_offset = _e317;
let _e319 = header[1u];
g_cluster_count = _e319;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e215 = light_list_info.list[0u];
tail = _e215;
let _e216 = Clustered_u0028_();
if _e216 {
let _e217 = v_world_position_1;
param_112 = _e217;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e218 = g_cluster_count;
tail = _e218;
}
let _e221 = frag_info.frame_params[1u];
let _e225 = tail;
return (clamp(i32((_e221 + 0.5f)), 0i, 8i) + clamp(i32((_e225 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e229 = LightCount_u0028_();
count_1 = _e229;
i_8 = 0i;
loop {
let _e230 = i_8;
if (_e230 < 32i) {
let _e232 = i_8;
let _e233 = count_1;
if (_e232 >= _e233) {
break;
}
let _e235 = i_8;
param_113 = _e235;
let _e236 = (*s_5);
param_114 = _e236;
let _e237 = 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_113), (¶m_114));
light_4 = _e237;
let _e239 = light_4.n_dot_l;
if (_e239 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e241 = i_8;
param_115 = _e241;
let _e242 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e242 {
let _e243 = (*s_5);
param_116 = _e243;
let _e244 = light_4;
param_117 = _e244;
let _e245 = i_8;
param_118 = _e245;
let _e246 = 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_116), (¶m_117), (¶m_118));
let _e247 = v_world_position_1;
param_119 = _e247;
let _e249 = (*s_5).n;
param_120 = _e249;
let _e250 = i_8;
param_121 = _e250;
let _e251 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e246 * _e251);
} else {
local_35 = 1f;
}
let _e253 = local_35;
visibility = _e253;
let _e254 = visibility;
if (_e254 <= 0f) {
continue;
}
let _e256 = (*s_5);
param_122 = _e256;
let _e257 = light_4;
param_123 = _e257;
let _e258 = 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_122), (¶m_123));
let _e260 = light_4.radiance;
let _e263 = light_4.n_dot_l;
let _e265 = visibility;
let _e267 = light_transmittance;
let _e269 = total_1;
total_1 = (_e269 + ((((_e258 * _e260) * _e263) * _e265) * _e267));
continue;
} else {
break;
}
continuing {
let _e271 = i_8;
i_8 = (_e271 + 1i);
}
}
let _e273 = total_1;
return _e273;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e212 = v_lightmap_uv_1;
let _e213 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e212);
texel_4 = _e213;
let _e214 = texel_4;
let _e217 = texel_4[3u];
return ((_e214.xyz * _e217) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e213 = frag_info.target_origin[1u];
return _e213;
}
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_6: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e213 = v_texcoord_1;
let _e214 = MaterialLodBias_u0028_();
let _e215 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e213, _e214);
orm = _e215.xyz;
let _e218 = (*s_6).metallic;
let _e220 = orm[2u];
(*s_6).metallic = clamp((_e218 * _e220), 0f, 1f);
let _e225 = (*s_6).roughness;
let _e227 = orm[1u];
(*s_6).roughness = clamp((_e225 * _e227), 0.02f, 1f);
return;
}
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_7: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_124: vec3<f32>;
let _e214 = v_texcoord_1;
let _e215 = MaterialLodBias_u0028_();
let _e216 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e214, _e215);
param_124 = _e216.xyz;
let _e218 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e218;
let _e219 = emissive;
let _e221 = frag_info.emissive;
let _e226 = frag_info.material2_[3u];
(*s_7).emissive = ((_e219 * _e221.xyz) * _e226);
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_8: ptr<function, Surface>) {
var occlusion: f32;
let _e213 = v_texcoord_1;
let _e214 = MaterialLodBias_u0028_();
let _e215 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e213, _e214);
occlusion = _e215.x;
let _e217 = occlusion;
let _e220 = frag_info.material2_[2u];
(*s_8).occlusion = mix(1f, _e217, clamp(_e220, 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_9: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e216 = v_texcoord_1;
let _e217 = MaterialLodBias_u0028_();
let _e218 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e216, _e217);
sampledTexel = _e218;
let _e219 = v_tangent_1;
t_2 = _e219.xyz;
let _e221 = t_2;
let _e223 = (*s_9).n;
let _e225 = (*s_9).n;
let _e226 = t_2;
t_2 = (_e221 - (_e223 * dot(_e225, _e226)));
let _e230 = t_2;
let _e231 = t_2;
if (dot(_e230, _e231) < 0.000000000001f) {
return;
}
let _e234 = t_2;
t_2 = normalize(_e234);
let _e237 = (*s_9).n;
let _e238 = t_2;
let _e241 = v_tangent_1[3u];
b_3 = (cross(_e237, _e238) * _e241);
let _e243 = gl_FrontFacing_1;
if !(_e243) {
let _e245 = t_2;
t_2 = -(_e245);
}
let _e247 = sampledTexel;
sampled = ((_e247.xyz * 2f) - vec3(1f));
let _e254 = frag_info.emissive[3u];
if (_e254 > 0.5f) {
let _e256 = sampled;
let _e258 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e256.xy, _e258.xy)), 0f));
}
let _e267 = frag_info.material2_[1u];
let _e268 = sampled;
let _e270 = (_e268.xy * _e267);
sampled[0u] = _e270.x;
sampled[1u] = _e270.y;
let _e275 = t_2;
let _e277 = sampled[0u];
let _e279 = b_3;
let _e281 = sampled[1u];
let _e285 = (*s_9).n;
let _e287 = sampled[2u];
(*s_9).n = normalize((((_e275 * _e277) + (_e279 * _e281)) + (_e285 * _e287)));
let _e293 = (*s_9).n;
let _e295 = (*s_9).v;
(*s_9).n_dot_v = max(dot(_e293, _e295), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e212 = (*texel_5);
let _e216 = irradiance_info.atlas;
let _e219 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e212 + vec2(0.5f)) * _e216.xy), 0f);
return _e219;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e225 = (*uv_6);
let _e226 = (*interior);
at_1 = ((vec2(1f) + (_e225 * _e226)) - vec2(0.5f));
let _e232 = at_1;
low = floor(_e232);
let _e234 = at_1;
let _e235 = low;
f = (_e234 - _e235);
let _e237 = (*corner);
let _e238 = low;
param_125 = (_e237 + _e238);
let _e240 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e240;
let _e241 = (*corner);
let _e242 = low;
param_126 = ((_e241 + _e242) + vec2<f32>(1f, 0f));
let _e245 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e245;
let _e246 = (*corner);
let _e247 = low;
param_127 = ((_e246 + _e247) + vec2<f32>(0f, 1f));
let _e250 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e250;
let _e251 = (*corner);
let _e252 = low;
param_128 = ((_e251 + _e252) + vec2<f32>(1f, 1f));
let _e255 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e255;
let _e256 = a_4;
let _e257 = b_4;
let _e259 = f[0u];
let _e262 = c_1;
let _e263 = d_4;
let _e265 = f[0u];
let _e269 = f[1u];
return mix(mix(_e256, _e257, vec4(_e259)), mix(_e262, _e263, vec4(_e265)), vec4(_e269));
}
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 _e216 = (*direction_1)[0u];
let _e219 = (*direction_1)[1u];
let _e223 = (*direction_1)[2u];
sum_1 = ((abs(_e216) + abs(_e219)) + abs(_e223));
let _e226 = sum_1;
if (_e226 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e228 = (*direction_1);
let _e229 = sum_1;
n_5 = (_e228 / vec3(_e229));
let _e232 = n_5;
xy = _e232.xy;
let _e235 = n_5[2u];
if (_e235 < 0f) {
let _e238 = n_5[1u];
let _e242 = n_5[0u];
let _e247 = n_5[0u];
let _e251 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e238)) * select(-1f, 1f, (_e242 >= 0f))), ((1f - abs(_e247)) * select(-1f, 1f, (_e251 >= 0f))));
}
let _e256 = xy;
return ((_e256 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e258 = irradiance_info.origin;
origin_2 = _e258.xyz;
let _e261 = irradiance_info.spacing;
spacing = _e261.xyz;
let _e264 = irradiance_info.counts;
counts = _e264.xyz;
let _e268 = irradiance_info.tiles[0u];
irradianceTile = _e268;
let _e271 = irradiance_info.tiles[1u];
depthTile = _e271;
let _e274 = irradiance_info.tiles[2u];
columns = _e274;
let _e277 = irradiance_info.tiles[3u];
momentsTop = _e277;
let _e278 = (*normal_1);
unit = normalize(_e278);
let _e280 = (*world_4);
let _e281 = unit;
let _e284 = irradiance_info.spacing[3u];
let _e287 = (*view_1);
let _e290 = irradiance_info.counts[3u];
biased = ((_e280 + (_e281 * _e284)) + (_e287 * _e290));
let _e293 = biased;
let _e294 = origin_2;
let _e296 = spacing;
grid_1 = ((_e293 - _e294) / _e296);
let _e298 = grid_1;
let _e300 = counts;
base = clamp(floor(_e298), vec3<f32>(0f, 0f, 0f), (_e300 - vec3(2f)));
let _e304 = grid_1;
let _e305 = base;
f_1 = clamp((_e304 - _e305), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e308 = corner_1;
if (_e308 < 8i) {
let _e310 = corner_1;
let _e313 = corner_1;
let _e318 = corner_1;
offset_3 = vec3<f32>(f32((_e310 & 1i)), f32(((_e313 >> bitcast<u32>(1i)) & 1i)), f32(((_e318 >> bitcast<u32>(2i)) & 1i)));
let _e324 = base;
let _e325 = offset_3;
cell_2 = (_e324 + _e325);
let _e328 = cell_2[2u];
let _e330 = counts[1u];
let _e333 = cell_2[1u];
let _e336 = counts[0u];
let _e339 = cell_2[0u];
probe = ((((_e328 * _e330) + _e333) * _e336) + _e339);
let _e341 = probe;
let _e342 = columns;
let _e347 = probe;
let _e348 = columns;
tile_4 = vec2<f32>((_e341 - (floor((_e341 / _e342)) * _e342)), floor((_e347 / _e348)));
let _e352 = tile_4;
let _e353 = irradianceTile;
irradianceCorner = (_e352 * (_e353 + 2f));
let _e357 = tile_4[0u];
let _e358 = depthTile;
let _e361 = momentsTop;
let _e363 = tile_4[1u];
let _e364 = depthTile;
momentCorner = vec2<f32>((_e357 * (_e358 + 2f)), (_e361 + (_e363 * (_e364 + 2f))));
let _e369 = irradianceCorner;
param_129 = (_e369 + vec2(1f));
let _e372 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e372.w < 0.5f) {
continue;
}
let _e375 = f_1;
let _e377 = f_1;
let _e378 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e375), _e377, _e378);
let _e381 = trilinear[0u];
let _e383 = trilinear[1u];
let _e386 = trilinear[2u];
weight_3 = max(((_e381 * _e383) * _e386), 0.001f);
let _e389 = origin_2;
let _e390 = spacing;
let _e391 = cell_2;
probePosition = (_e389 + (_e390 * _e391));
let _e394 = probePosition;
let _e395 = biased;
toProbe = (_e394 - _e395);
let _e397 = toProbe;
distance_4 = length(_e397);
let _e399 = distance_4;
if (_e399 > 0.000001f) {
let _e401 = toProbe;
let _e402 = distance_4;
direction_2 = (_e401 / vec3(_e402));
let _e405 = unit;
let _e406 = probePosition;
let _e407 = (*world_4);
facing = ((dot(_e405, normalize((_e406 - _e407))) * 0.5f) + 0.5f);
let _e413 = facing;
let _e414 = facing;
probeWeight = ((_e413 * _e414) + 0.2f);
let _e417 = direction_2;
param_130 = -(_e417);
let _e419 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e420 = momentCorner;
param_131 = _e420;
let _e421 = depthTile;
param_132 = _e421;
param_133 = _e419;
let _e422 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e422.xy;
chebyshev = 1f;
let _e424 = distance_4;
let _e426 = moments_3[0u];
if (_e424 > _e426) {
let _e429 = moments_3[1u];
let _e431 = moments_3[0u];
let _e433 = moments_3[0u];
variance_1 = max((_e429 - (_e431 * _e433)), 0.000001f);
let _e437 = distance_4;
let _e439 = moments_3[0u];
difference = (_e437 - _e439);
let _e441 = variance_1;
let _e442 = variance_1;
let _e443 = difference;
let _e444 = difference;
chebyshev = (_e441 / (_e442 + (_e443 * _e444)));
let _e448 = chebyshev;
let _e449 = chebyshev;
let _e451 = chebyshev;
chebyshev = ((_e448 * _e449) * _e451);
}
let _e453 = probeWeight;
let _e454 = chebyshev;
probeWeight = max((_e453 * max(_e454, 0.05f)), 0.000001f);
let _e458 = probeWeight;
if (_e458 < 0.2f) {
let _e460 = probeWeight;
let _e461 = probeWeight;
let _e464 = probeWeight;
probeWeight = (_e464 * ((_e460 * _e461) * 25f));
}
let _e466 = probeWeight;
let _e467 = weight_3;
weight_3 = (_e467 * _e466);
}
let _e469 = unit;
param_134 = _e469;
let _e470 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e471 = irradianceCorner;
param_135 = _e471;
let _e472 = irradianceTile;
param_136 = _e472;
param_137 = _e470;
let _e473 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e475 = weight_3;
let _e477 = total_2;
total_2 = (_e477 + (_e473.xyz * _e475));
let _e479 = weight_3;
let _e480 = weights;
weights = (_e480 + _e479);
continue;
} else {
break;
}
continuing {
let _e482 = corner_1;
corner_1 = (_e482 + 1i);
}
}
let _e484 = weights;
if (_e484 > 0f) {
let _e486 = total_2;
let _e487 = weights;
local_36 = (_e486 / vec3(_e487));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e490 = local_36;
return _e490;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e213 = irradiance_info.origin[3u];
return (_e213 > 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_10: ptr<function, Surface>) {
var param_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e218 = IrradianceEnabled_u0028_();
if _e218 {
let _e219 = v_world_position_1;
param_138 = _e219;
let _e221 = (*s_10).n;
param_139 = _e221;
let _e223 = (*s_10).v;
param_140 = _e223;
let _e224 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e227 = frag_info.material[2u];
(*s_10).ambient = (_e224 * _e227);
}
let _e230 = (*s_10);
param_141 = _e230;
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_141));
let _e231 = param_141;
(*s_10) = _e231;
let _e232 = (*s_10);
param_142 = _e232;
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_142));
let _e233 = param_142;
(*s_10) = _e233;
let _e234 = (*s_10);
param_143 = _e234;
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_143));
let _e235 = param_143;
(*s_10) = _e235;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e212 = Orthographic_u0028_();
if _e212 {
let _e214 = fog_info.forward;
local_37 = -(_e214.xyz);
} else {
let _e218 = fog_info.eye;
let _e220 = v_world_position_1;
local_37 = normalize((_e218.xyz - _e220));
}
let _e223 = local_37;
return _e223;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_11: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff: f32;
var edge: f32;
let _e217 = v_texcoord_1;
let _e218 = MaterialLodBias_u0028_();
let _e219 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e217, _e218);
texel_6 = _e219;
let _e220 = texel_6;
param_144 = _e220.xyz;
let _e222 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e224 = frag_info.base_color;
param_145 = _e224.xyz;
let _e226 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e228 = v_color_1;
s_11.albedo = ((_e222 * _e226) * _e228.xyz);
let _e233 = texel_6[3u];
let _e236 = frag_info.base_color[3u];
let _e239 = v_color_1[3u];
s_11.alpha = ((_e233 * _e236) * _e239);
let _e243 = s_11.albedo;
g_albedo = _e243;
let _e246 = frag_info.material2_[0u];
cutoff = _e246;
let _e247 = cutoff;
if (_e247 > 1f) {
let _e249 = cutoff;
edge = (_e249 - 1f);
let _e252 = s_11.alpha;
let _e253 = edge;
let _e256 = s_11.alpha;
let _e257 = fwidth(_e256);
s_11.alpha = clamp((((_e252 - _e253) / max(_e257, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e263 = cutoff;
if (_e263 >= 0f) {
s_11.alpha = 1f;
}
}
let _e266 = cutoff;
let _e268 = cutoff;
g_premultiply = ((_e266 < 0f) && (_e268 > -0.75f));
let _e271 = v_normal_1;
s_11.n = normalize(_e271);
let _e274 = gl_FrontFacing_1;
if !(_e274) {
let _e277 = s_11.n;
s_11.n = -(_e277);
}
let _e280 = TowardsEye_u0028_();
s_11.v = _e280;
let _e283 = s_11.n;
let _e285 = s_11.v;
s_11.n_dot_v = max(dot(_e283, _e285), 0.0001f);
let _e291 = frag_info.material[0u];
s_11.metallic = clamp(_e291, 0f, 1f);
let _e296 = frag_info.material[1u];
s_11.roughness = clamp(_e296, 0.02f, 1f);
let _e300 = frag_info.ambient_ground;
let _e303 = frag_info.ambient_sky;
let _e307 = s_11.n[1u];
let _e314 = frag_info.material[2u];
s_11.ambient = (mix(_e300.xyz, _e303.xyz, vec3(((_e307 * 0.5f) + 0.5f))) * _e314);
let _e319 = frag_info.frame_params[0u];
s_11.exposure = max(_e319, 0f);
s_11.occlusion = 1f;
s_11.emissive = vec3<f32>(0f, 0f, 0f);
let _e324 = s_11;
return _e324;
}
fn main_1() {
var s_12: Surface;
var param_146: Surface;
var param_147: Surface;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_148: Surface;
var param_149: Surface;
var param_150: vec3<f32>;
var param_151: vec3<f32>;
var param_152: f32;
var param_153: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e222 = ReadSurface_u0028_();
s_12 = _e222;
let _e223 = s_12;
param_146 = _e223;
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_146));
let _e224 = param_146;
s_12 = _e224;
let _e225 = s_12;
param_147 = _e225;
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_147));
let _e226 = param_147;
s_12 = _e226;
let _e228 = s_12.albedo;
let _e230 = s_12.ambient;
let _e231 = SampleLightmap_u0028_();
let _e235 = s_12.occlusion;
ambient = ((_e228 * (_e230 + _e231)) * _e235);
let _e237 = s_12;
param_148 = _e237;
let _e238 = 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_148));
let _e240 = s_12.occlusion;
let _e242 = ambient;
let _e245 = s_12.emissive;
lit_3 = (((_e238 * _e240) + _e242) + _e245);
let _e247 = s_12;
param_149 = _e247;
let _e248 = lit_3;
param_150 = _e248;
let _e249 = WriteDebugView_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_vf3_u003b((¶m_149), (¶m_150));
if _e249 {
return;
}
let _e250 = lit_3;
param_151 = _e250;
let _e252 = s_12.alpha;
param_152 = _e252;
let _e254 = s_12.roughness;
param_153 = _e254;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_151), (¶m_152), (¶m_153));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
'PbrOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e230 = v_world_position_1;
let _e232 = fog_info.eye;
let _e236 = fog_info.forward;
return dot((_e230 - _e232.xyz), _e236.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e235 = ViewDepth_u0028_();
z = abs(_e235);
let _e237 = z;
near = (_e237 / 5f);
let _e239 = z;
far = (_e239 / 200f);
let _e241 = far;
let _e242 = far;
let _e244 = far;
far3_ = ((_e241 * _e242) * _e244);
let _e246 = (*alpha);
let _e247 = near;
let _e248 = near;
let _e251 = far3_;
let _e252 = far3_;
return (_e246 * clamp((10f / ((0.00001f + (_e247 * _e248)) + (_e251 * _e252))), 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 _e239 = fog_info.forward[3u];
mode = _e239;
let _e240 = mode;
if (_e240 > 0.5f) {
let _e243 = frag_color[3u];
alpha_1 = _e243;
let _e244 = alpha_1;
param = _e244;
let _e245 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e245;
let _e246 = frag_color;
let _e248 = weight;
let _e249 = (_e246.xyz * _e248);
let _e250 = alpha_1;
let _e251 = weight;
accumulate = vec4<f32>(_e249.x, _e249.y, _e249.z, (_e250 * _e251));
let _e257 = mode;
let _e259 = mode;
revealage = ((_e257 > 1.5f) && (_e259 < 2.5f));
let _e262 = revealage;
if _e262 {
let _e263 = alpha_1;
local = vec4(_e263);
} else {
let _e265 = accumulate;
local = _e265;
}
let _e266 = local;
frag_color = _e266;
let _e267 = mode;
if (_e267 > 2.5f) {
let _e269 = alpha_1;
frag_surface = vec4(_e269);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e233 = (*n)[0u];
let _e236 = (*n)[1u];
let _e240 = (*n)[2u];
let _e243 = (*n);
(*n) = (_e243 / vec3(((abs(_e233) + abs(_e236)) + abs(_e240))));
let _e246 = (*n);
e = _e246.xy;
let _e249 = (*n)[2u];
if (_e249 < 0f) {
let _e251 = (*n);
let _e257 = (*n)[0u];
let _e261 = (*n)[1u];
e = ((vec2(1f) - abs(_e251.yx)) * vec2<f32>(select(-1f, 1f, (_e257 >= 0f)), select(-1f, 1f, (_e261 >= 0f))));
}
let _e266 = e;
return ((_e266 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e231 = (*linear);
let _e233 = (*linear);
let _e237 = (*linear);
return mix((_e231 * 12.92f), ((pow(_e233, 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), _e237));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e234 = g_albedo;
param_1 = clamp(_e234, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e236 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e236.x, _e236.y, _e236.z, 1f);
let _e241 = g_debug_surface_on;
if _e241 {
let _e242 = g_debug_surface;
let _e243 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e242.x, _e242.y, _e242.z, _e243);
return;
}
let _e248 = v_normal_1;
geometric = normalize(_e248);
let _e250 = gl_FrontFacing_1;
if !(_e250) {
let _e252 = geometric;
geometric = -(_e252);
}
let _e254 = geometric;
param_2 = _e254;
let _e255 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e256 = (*roughness);
let _e258 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e255.x, _e255.y, clamp(_e256, 0f, 1f), _e258);
return;
}
fn Orthographic_u0028_() -> bool {
let _e232 = fog_info.projection[0u];
return (_e232 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e231 = Orthographic_u0028_();
if _e231 {
let _e232 = ViewDepth_u0028_();
local_1 = max(_e232, 0f);
} else {
let _e234 = v_world_position_1;
let _e236 = fog_info.eye;
local_1 = distance(_e234, _e236.xyz);
}
let _e239 = local_1;
return _e239;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e238 = fog_info.fog[3u];
density = _e238;
let _e239 = density;
if (_e239 <= 0f) {
let _e241 = (*color);
return _e241;
}
let _e242 = EyeDistance_u0028_();
d = _e242;
let _e245 = fog_info.eye[3u];
falloff = _e245;
let _e246 = falloff;
if (_e246 > 0f) {
let _e248 = falloff;
let _e250 = v_world_position_1[1u];
let _e253 = fog_info.eye[1u];
k = (_e248 * (_e250 - _e253));
let _e256 = k;
if (abs(_e256) > 0.001f) {
let _e259 = k;
let _e263 = k;
local_2 = ((1f - exp(-(_e259))) / _e263);
} else {
let _e265 = k;
local_2 = (1f - (0.5f * _e265));
}
let _e268 = local_2;
let _e269 = density;
density = (_e269 * _e268);
}
let _e272 = fog_info.fog;
let _e274 = (*color);
let _e275 = density;
let _e277 = d;
return mix(_e272.xyz, _e274, vec3(clamp(exp((-(_e275) * _e277)), 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 _e236 = g_premultiply;
let _e237 = (*alpha_2);
weight_1 = select(1f, _e237, _e236);
let _e239 = (*linearColor);
param_3 = _e239;
let _e240 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e241 = weight_1;
let _e242 = (_e240 * _e241);
let _e243 = (*alpha_2);
let _e244 = g_pass_through;
frag_color = vec4<f32>(_e242.x, _e242.y, _e242.z, (_e243 * (1f - _e244)));
let _e251 = (*roughness_1);
param_4 = _e251;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e231 = (*srgb);
let _e234 = (*srgb);
let _e239 = (*srgb);
return mix((_e231 / vec3(12.92f)), pow(((_e234 + 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), _e239));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e233 = (*key);
hue = fract(((_e233 * 0.618034f) + 0.13f));
let _e237 = hue;
k_1 = clamp((abs(((fract((vec3(_e237) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e250 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e250, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2898_: bool;
let _e231 = (*c);
let _e232 = (*c);
let _e234 = any((_e231 != _e232));
phi_2898_ = _e234;
if !(_e234) {
let _e236 = (*c);
phi_2898_ = any((abs(_e236) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e241 = phi_2898_;
return _e241;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2988_: bool;
var phi_3256_: bool;
let _e273 = gl_FragCoord_1[0u];
let _e276 = frag_info.debug_view[1u];
if (_e273 < _e276) {
let _e280 = frag_info.debug_view[2u];
local_3 = _e280;
} else {
let _e283 = frag_info.debug_view[0u];
local_3 = _e283;
}
let _e284 = local_3;
view = _e284;
let _e285 = view;
if (_e285 < 0.5f) {
return false;
}
let _e287 = view;
code = i32((_e287 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e290 = v_normal_1;
geometric_n = normalize(_e290);
let _e292 = v_tangent_1;
let _e294 = geometric_n;
let _e295 = geometric_n;
let _e296 = v_tangent_1;
tangent = (_e292.xyz - (_e294 * dot(_e295, _e296.xyz)));
let _e301 = tangent;
let _e302 = tangent;
let _e304 = (dot(_e301, _e302) > 0.000000000001f);
phi_2988_ = _e304;
if _e304 {
let _e306 = v_tangent_1[3u];
phi_2988_ = (abs((abs(_e306) - 1f)) < 0.01f);
}
let _e312 = phi_2988_;
tangent_usable = _e312;
let _e315 = frag_info.debug_view[3u];
identity = _e315;
let _e316 = identity;
identity_object = floor((_e316 / 8192f));
let _e319 = identity;
let _e320 = identity_object;
identity_rest = (_e319 - (_e320 * 8192f));
let _e323 = identity_rest;
identity_material = floor((_e323 / 2f));
let _e326 = identity_rest;
let _e327 = identity_material;
normal_mapped = ((_e326 - (_e327 * 2f)) > 0.5f);
let _e331 = code;
if (_e331 == 1i) {
let _e334 = (*s).albedo;
param_5 = clamp(_e334, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e336 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e336;
} else {
let _e337 = code;
if (_e337 == 2i) {
let _e340 = (*s).n;
shown = ((_e340 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e343 = code;
if (_e343 == 3i) {
let _e346 = (*s).roughness;
shown = vec3(clamp(_e346, 0f, 1f));
} else {
let _e349 = code;
if (_e349 == 4i) {
let _e352 = (*s).metallic;
shown = vec3(clamp(_e352, 0f, 1f));
} else {
let _e355 = code;
if (_e355 == 5i) {
let _e358 = (*s).occlusion;
shown = vec3(clamp(_e358, 0f, 1f));
} else {
let _e361 = code;
if (_e361 == 6i) {
let _e364 = (*s).emissive;
param_6 = clamp(_e364, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e366 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e366;
} else {
let _e367 = code;
if (_e367 == 7i) {
let _e369 = v_texcoord_1;
let _e370 = fract(_e369);
shown = vec3<f32>(_e370.x, _e370.y, 0f);
} else {
let _e374 = code;
if (_e374 == 8i) {
let _e376 = (*lit);
param_7 = clamp(_e376, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e378 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e378, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e380 = (*lit);
param_8 = _e380;
let _e381 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e381 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e382 = grey;
local_4 = vec3((_e382 * 0.5f));
}
let _e385 = local_4;
shown = _e385;
} else {
let _e386 = code;
if (_e386 == 9i) {
let _e388 = tangent_usable;
if _e388 {
let _e389 = tangent;
local_5 = ((normalize(_e389) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e393 = local_5;
shown = _e393;
} else {
let _e394 = code;
if (_e394 == 10i) {
let _e396 = v_texcoord_1;
uv = _e396;
let _e397 = uv;
cell = floor((_e397 * 8f));
let _e401 = cell[0u];
let _e403 = cell[1u];
odd = (fract(((_e401 + _e403) * 0.5f)) * 2f);
let _e408 = uv;
within = fract(_e408);
let _e410 = odd;
let _e414 = within[0u];
let _e418 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e410)) * vec3<f32>((0.55f + (0.45f * _e414)), (0.55f + (0.45f * _e418)), 0.85f));
} else {
let _e423 = code;
if (_e423 == 11i) {
let _e425 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e425));
} else {
let _e428 = code;
if (_e428 == 12i) {
let _e430 = v_color_1;
param_9 = clamp(_e430.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e433 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e433;
} else {
let _e434 = code;
let _e436 = code;
if ((_e434 == 13i) || (_e436 == 14i)) {
let _e439 = code;
let _e441 = identity_object;
let _e442 = identity_material;
key_1 = select(_e442, _e441, (_e439 == 13i));
let _e444 = key_1;
param_10 = _e444;
let _e445 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e447 = (*s).n_dot_v;
shown = (_e445 * (0.55f + (0.45f * _e447)));
} else {
let _e451 = code;
if (_e451 == 15i) {
let _e454 = (*s).albedo;
param_11 = clamp(_e454, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e456 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e456;
let _e457 = srgb_1;
luma = dot(_e457, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e460 = (*s).metallic;
metal = (_e460 > 0.5f);
let _e462 = metal;
let _e464 = luma;
if (!(_e462) && (_e464 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e467 = metal;
let _e468 = !(_e467);
phi_3256_ = _e468;
if _e468 {
let _e470 = srgb_1[0u];
let _e472 = srgb_1[1u];
let _e474 = srgb_1[2u];
phi_3256_ = (max(_e470, max(_e472, _e474)) > 0.9411765f);
}
let _e479 = phi_3256_;
if _e479 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e480 = metal;
let _e481 = luma;
if (_e480 && (_e481 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e484 = luma;
local_8 = vec3(_e484);
}
let _e486 = local_8;
local_7 = _e486;
}
let _e487 = local_7;
local_6 = _e487;
}
let _e488 = local_6;
shown = _e488;
} else {
let _e489 = code;
if (_e489 == 16i) {
let _e492 = (*s).metallic;
m = _e492;
let _e493 = m;
let _e495 = m;
if ((_e493 > 0.05f) && (_e495 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e498 = m;
local_9 = vec3(select(0.15f, 1f, (_e498 > 0.5f)));
}
let _e502 = local_9;
shown = _e502;
} else {
let _e503 = code;
if (_e503 == 17i) {
let _e505 = normal_mapped;
if !(_e505) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e507 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e507));
}
let _e510 = local_10;
shown = _e510;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e511 = g_premultiply;
if _e511 {
let _e513 = (*s).alpha;
local_11 = _e513;
} else {
local_11 = 1f;
}
let _e514 = local_11;
weight_2 = _e514;
let _e515 = shown;
param_12 = _e515;
let _e516 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e517 = weight_2;
let _e518 = (_e516 * _e517);
let _e520 = (*s).alpha;
frag_color = vec4<f32>(_e518.x, _e518.y, _e518.z, _e520);
let _e526 = (*s).roughness;
param_13 = _e526;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m_1: f32;
var g: f32;
let _e234 = (*mu);
m_1 = (1f - _e234);
let _e236 = m_1;
let _e237 = m_1;
let _e238 = m_1;
let _e239 = m_1;
g = (_e236 * (0.05710853f + (_e237 * (0.49188188f + (_e238 * (-0.33218145f + (_e239 * 0.071443f)))))));
let _e247 = (*r);
let _e248 = g;
let _e251 = (*r);
return ((1f + (_e247 * _e248)) / (1f + (0.2877934f * _e251)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e232 = (*rho);
let _e233 = (*rho);
let _e235 = (*average);
let _e237 = (*rho);
let _e238 = (*average);
return (((_e232 * _e233) * _e235) / (vec3<f32>(1f, 1f, 1f) - (_e237 * (1f - _e238))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e231 = (*r_1);
let _e234 = (*r_1);
return ((1f + (0.07248821f * _e231)) / (1f + (0.2877934f * _e234)));
}
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_12: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_14: f32;
var multi: vec3<f32>;
var param_15: vec3<f32>;
var param_16: f32;
var param_17: f32;
var param_18: f32;
var param_19: f32;
var param_20: f32;
let _e249 = (*l_dot_v);
let _e250 = (*mu_i);
let _e251 = (*mu_o);
s_1 = (_e249 - (_e250 * _e251));
let _e254 = s_1;
if (_e254 > 0f) {
let _e256 = s_1;
let _e257 = (*mu_i);
let _e258 = (*mu_o);
local_12 = (_e256 / max(_e257, _e258));
} else {
let _e261 = s_1;
local_12 = _e261;
}
let _e262 = local_12;
s_over_t = _e262;
let _e263 = (*r_2);
af = (1f / (1f + (0.2877934f * _e263)));
let _e267 = (*rho_1);
let _e268 = af;
let _e269 = (*r_2);
let _e270 = s_over_t;
single = (_e267 * (_e268 * (1f + (_e269 * _e270))));
let _e275 = (*r_2);
param_14 = _e275;
let _e276 = FonAverage_u0028_f1_u003b((¶m_14));
average_1 = _e276;
let _e277 = (*rho_1);
param_15 = _e277;
let _e278 = average_1;
param_16 = _e278;
let _e279 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_15), (¶m_16));
let _e280 = (*mu_o);
param_17 = _e280;
let _e281 = (*r_2);
param_18 = _e281;
let _e282 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_17), (¶m_18));
let _e285 = (*mu_i);
param_19 = _e285;
let _e286 = (*r_2);
param_20 = _e286;
let _e287 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_19), (¶m_20));
let _e291 = average_1;
multi = (_e279 * ((max((1f - _e282), 0.0000001f) * max((1f - _e287), 0.0000001f)) / max((1f - _e291), 0.0000001f)));
let _e296 = single;
let _e297 = multi;
return ((_e296 + _e297) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e232 = frag_info.ambient_sky[3u];
return (_e232 > 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 _e234 = (*x);
let _e235 = (*y);
inTable = ((vec2<f32>(_e234, _e235) * 0.984375f) + vec2(0.0078125f));
let _e241 = inTable[0u];
let _e243 = inTable[1u];
let _e244 = (*table);
return vec2<f32>(_e241, ((_e243 + _e244) * 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_21: f32;
var param_22: f32;
var param_23: f32;
let _e236 = (*roughness_2);
let _e238 = (*n_dot_v);
param_21 = clamp(_e236, 0f, 1f);
param_22 = sqrt(clamp((1f - _e238), 0f, 1f));
param_23 = 1f;
let _e242 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_21), (¶m_22), (¶m_23));
let _e243 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e242, 0f);
dfg = _e243.xy;
let _e246 = dfg[0u];
let _e248 = dfg[1u];
let _e251 = dfg[1u];
return vec2<f32>((_e246 - _e248), _e251);
}
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_24: f32;
var param_25: f32;
var ess: f32;
let _e237 = (*s_2).roughness;
param_24 = max(_e237, 0.045f);
let _e240 = (*s_2).n_dot_v;
param_25 = _e240;
let _e241 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_24), (¶m_25));
ab = _e241;
let _e243 = ab[0u];
let _e245 = ab[1u];
ess = max((_e243 + _e245), 0.0001f);
let _e248 = (*f0_);
let _e249 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e248 * ((1f / _e249) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e232 = frag_info.target_origin[2u];
return (_e232 > 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 _e233 = (*v_dot_h);
f = pow((1f - _e233), 5f);
let _e236 = (*f0_1);
let _e237 = (*f0_1);
let _e239 = f;
return (_e236 + ((vec3<f32>(1f, 1f, 1f) - _e237) * _e239));
}
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 _e236 = (*alpha_3);
let _e237 = (*alpha_3);
a2_ = (_e236 * _e237);
let _e239 = (*n_dot_l);
let _e240 = (*n_dot_v_1);
let _e241 = (*n_dot_v_1);
let _e243 = a2_;
let _e246 = a2_;
lambda_v = (_e239 * sqrt((((_e240 * _e241) * (1f - _e243)) + _e246)));
let _e250 = (*n_dot_v_1);
let _e251 = (*n_dot_l);
let _e252 = (*n_dot_l);
let _e254 = a2_;
let _e257 = a2_;
lambda_l = (_e250 * sqrt((((_e251 * _e252) * (1f - _e254)) + _e257)));
let _e261 = lambda_v;
let _e262 = lambda_l;
return (0.5f / max((_e261 + _e262), 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_2: f32;
let _e234 = (*n_dot_h);
let _e235 = (*alpha_4);
a = (_e234 * _e235);
let _e237 = (*alpha_4);
let _e238 = (*n_dot_h);
let _e239 = (*n_dot_h);
let _e242 = a;
let _e243 = a;
k_2 = (_e237 / max(((1f - (_e238 * _e239)) + (_e242 * _e243)), 0.0000001f));
let _e248 = k_2;
let _e249 = k_2;
return ((_e248 * _e249) * 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_3: 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_26: f32;
var param_27: f32;
var vis: f32;
var param_28: f32;
var param_29: f32;
var param_30: f32;
var f_1: vec3<f32>;
var param_31: vec3<f32>;
var param_32: f32;
var specular: vec3<f32>;
var param_33: vec3<f32>;
var param_34: Surface;
var diffuse: vec3<f32>;
var param_35: vec3<f32>;
var param_36: f32;
var param_37: f32;
var param_38: f32;
var param_39: f32;
let _e256 = (*s_3).roughness;
lobe = max(_e256, 0.045f);
let _e258 = lobe;
let _e259 = lobe;
alpha_5 = (_e258 * _e259);
let _e262 = (*s_3).albedo;
let _e264 = (*s_3).metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e262, vec3(_e264));
let _e268 = (*s_3).albedo;
let _e270 = (*s_3).metallic;
diffuseColor = (_e268 * (1f - _e270));
let _e274 = (*light).n_dot_h;
param_26 = _e274;
let _e275 = alpha_5;
param_27 = _e275;
let _e276 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_26), (¶m_27));
d_1 = _e276;
let _e278 = (*s_3).n_dot_v;
param_28 = _e278;
let _e280 = (*light).n_dot_l;
param_29 = _e280;
let _e281 = alpha_5;
param_30 = _e281;
let _e282 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30));
vis = _e282;
let _e283 = f0_2;
param_31 = _e283;
let _e285 = (*light).v_dot_h;
param_32 = _e285;
let _e286 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_31), (¶m_32));
f_1 = _e286;
let _e287 = d_1;
let _e288 = vis;
let _e290 = f_1;
let _e294 = frag_info.material[3u];
specular = ((_e290 * (_e287 * _e288)) * _e294);
let _e297 = (*light).integrated;
if (_e297 > 0.5f) {
let _e301 = (*light).ltc[0u];
let _e302 = f0_2;
let _e305 = (*light).ltc[1u];
let _e307 = f0_2;
let _e312 = (*light).ltc[2u];
let _e318 = frag_info.material[3u];
let _e321 = (*light).n_dot_l;
specular = (((((_e302 * _e305) + ((vec3(1f) - _e307) * _e312)) * _e301) * _e318) / vec3(max(_e321, 0.000001f)));
}
let _e325 = EnergyCompensation_u0028_();
if _e325 {
let _e326 = f0_2;
param_33 = _e326;
let _e327 = (*s_3);
param_34 = _e327;
let _e328 = 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_33), (¶m_34));
let _e329 = specular;
specular = (_e329 * _e328);
}
let _e331 = diffuseColor;
let _e332 = f_1;
diffuse = ((_e331 * (vec3<f32>(1f, 1f, 1f) - _e332)) / vec3(3.1415927f));
let _e337 = EonDiffuse_u0028_();
if _e337 {
let _e339 = (*s_3).n;
let _e341 = (*light).l;
let _e345 = (*light).l;
let _e347 = (*s_3).v;
let _e349 = diffuseColor;
param_35 = _e349;
let _e351 = (*s_3).roughness;
param_36 = _e351;
param_37 = clamp(dot(_e339, _e341), 0.0001f, 1f);
let _e353 = (*s_3).n_dot_v;
param_38 = _e353;
param_39 = dot(_e345, _e347);
let _e354 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e355 = f_1;
diffuse = (_e354 * (vec3<f32>(1f, 1f, 1f) - _e355));
}
let _e358 = diffuse;
let _e359 = specular;
return ((_e358 + _e359) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e231 = (*i);
if (_e231 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e233 = (*i);
if (_e233 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e235 = (*i);
if (_e235 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e237 = (*i);
if (_e237 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e239 = (*i);
if (_e239 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e241 = (*i);
if (_e241 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e243 = (*i);
if (_e243 == 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_40: i32;
let _e236 = (*i_1);
param_40 = _e236;
let _e237 = PointShadowDiskTap_u0028_i1_u003b((¶m_40));
p = _e237;
let _e239 = p[0u];
let _e240 = (*ca);
let _e243 = p[1u];
let _e244 = (*sa);
let _e248 = p[0u];
let _e249 = (*sa);
let _e252 = p[1u];
let _e253 = (*ca);
let _e257 = (*radius);
return (vec2<f32>(((_e239 * _e240) - (_e243 * _e244)), ((_e248 * _e249) + (_e252 * _e253))) * _e257);
}
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_13: vec2<f32>;
var atlas: vec2<f32>;
let _e239 = point_shadow.params[0u];
inset = _e239;
let _e240 = (*uv_1);
let _e241 = (*offset);
let _e243 = inset;
let _e244 = inset;
local_13 = clamp((_e240 + _e241), vec2(_e243), vec2((1f - _e244)));
let _e249 = local_13;
let _e250 = (*tile);
atlas = ((_e249 + _e250) * vec2<f32>(0.16666667f, 0.16666667f));
let _e255 = point_shadow.params3_[0u];
if (_e255 > 0.5f) {
let _e258 = atlas[1u];
atlas[1u] = (1f - _e258);
}
let _e261 = atlas;
let _e262 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e261, 0f);
let _e264 = atlas;
let _e265 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e264, 0f);
let _e268 = (*range);
return (min(_e262.x, _e265.x) * _e268);
}
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_41: vec2<f32>;
var param_42: vec2<f32>;
var param_43: vec2<f32>;
var param_44: f32;
let _e240 = (*uv_2);
param_41 = _e240;
let _e241 = (*offset_1);
param_42 = _e241;
let _e242 = (*tile_1);
param_43 = _e242;
let _e243 = (*range_1);
param_44 = _e243;
let _e244 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_41), (¶m_42), (¶m_43), (¶m_44));
stored = _e244;
let _e245 = stored;
let _e246 = (*range_1);
if (_e245 >= (_e246 * 0.999f)) {
return 1f;
}
let _e249 = (*receiver);
let _e250 = stored;
return select(1f, 0f, (_e249 > _e250));
}
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_45: vec2<f32>;
var param_46: vec2<f32>;
var param_47: vec2<f32>;
var param_48: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_49: i32;
var param_50: f32;
var param_51: f32;
var param_52: f32;
var param_53: vec2<f32>;
var param_54: vec2<f32>;
var param_55: vec2<f32>;
var param_56: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e261 = point_shadow.params2_[1u];
lightRadius = _e261;
let _e264 = point_shadow.params2_[0u];
minRadius = _e264;
let _e267 = point_shadow.params2_[2u];
maxRadius = _e267;
let _e268 = lightRadius;
if (_e268 <= 0f) {
let _e270 = (*uv_3);
param_45 = _e270;
param_46 = vec2<f32>(0f, 0f);
let _e271 = (*tile_2);
param_47 = _e271;
let _e272 = (*range_2);
param_48 = _e272;
let _e273 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
(*blockerOut) = _e273;
let _e274 = minRadius;
return _e274;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e275 = i_2;
if (_e275 < 8i) {
let _e277 = i_2;
param_49 = _e277;
let _e278 = (*ca_1);
param_50 = _e278;
let _e279 = (*sa_1);
param_51 = _e279;
let _e280 = maxRadius;
param_52 = _e280;
let _e281 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52));
let _e282 = (*uv_3);
param_53 = _e282;
param_54 = _e281;
let _e283 = (*tile_2);
param_55 = _e283;
let _e284 = (*range_2);
param_56 = _e284;
let _e285 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56));
stored_1 = _e285;
let _e286 = stored_1;
let _e287 = (*range_2);
if (_e286 >= (_e287 * 0.999f)) {
continue;
}
let _e290 = stored_1;
let _e291 = (*receiver_1);
if (_e290 >= _e291) {
continue;
}
let _e293 = stored_1;
let _e294 = sum;
sum = (_e294 + _e293);
let _e296 = count;
count = (_e296 + 1f);
continue;
} else {
break;
}
continuing {
let _e298 = i_2;
i_2 = (_e298 + 1i);
}
}
let _e300 = count;
if (_e300 < 0.5f) {
return -1f;
}
let _e302 = sum;
let _e303 = count;
blocker = max((_e302 / _e303), 0.0001f);
let _e306 = blocker;
(*blockerOut) = _e306;
let _e307 = lightRadius;
let _e308 = (*receiver_1);
let _e309 = blocker;
let _e313 = blocker;
world = ((_e307 * max((_e308 - _e309), 0f)) / _e313);
let _e315 = world;
let _e316 = (*receiver_1);
let _e318 = (*tanHalf);
let _e321 = minRadius;
let _e322 = maxRadius;
return clamp((_e315 / ((2f * _e316) * _e318)), _e321, _e322);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_14: vec2<f32>;
let _e232 = (*rows);
if (_e232 > 0f) {
let _e235 = gl_FragCoord_1[0u];
let _e236 = (*rows);
let _e238 = gl_FragCoord_1[1u];
local_14 = vec2<f32>(_e235, (_e236 - _e238));
} else {
let _e241 = gl_FragCoord_1;
local_14 = _e241.xy;
}
let _e243 = local_14;
return _e243;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_57: 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_58: vec2<f32>;
var param_59: vec2<f32>;
var param_60: f32;
var param_61: f32;
var param_62: f32;
var param_63: f32;
var param_64: f32;
var param_65: f32;
var local_15: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_71: i32;
var param_72: f32;
var param_73: f32;
var param_74: f32;
var param_75: vec2<f32>;
var param_76: vec2<f32>;
var param_77: vec2<f32>;
var param_78: f32;
var param_79: f32;
var phi_2587_: bool;
var phi_2648_: bool;
let _e284 = (*lightIndex);
let _e288 = point_shadow.slots[_e284][0u];
slot = i32((_e288 + 0.5f));
let _e291 = (*lightIndex);
let _e295 = point_shadow.slots[_e291][0u];
if (_e295 < 0f) {
return 1f;
}
let _e299 = point_shadow.params[2u];
strength = _e299;
let _e300 = strength;
if (_e300 <= 0f) {
return 1f;
}
let _e302 = slot;
let _e305 = point_shadow.lights[_e302];
let _e307 = (*world_1);
toLight = (_e305.xyz - _e307);
let _e309 = toLight;
toLightLength = max(length(_e309), 0.000001f);
let _e312 = (*normal);
let _e313 = toLight;
let _e314 = toLightLength;
nDotL = max(dot(_e312, (_e313 / vec3(_e314))), 0.15f);
let _e319 = nDotL;
let _e320 = nDotL;
let _e325 = nDotL;
let _e326 = nDotL;
slope = min((sqrt(max((1f - (_e319 * _e320)), 0f)) / (_e325 * _e326)), 8f);
let _e330 = toLightLength;
let _e332 = (*lightIndex);
let _e336 = point_shadow.slots[_e332][2u];
let _e341 = point_shadow.params3_[1u];
texel = (((2f * _e330) * max(_e336, 0.0001f)) * _e341);
let _e343 = (*world_1);
let _e344 = (*normal);
let _e345 = texel;
let _e349 = point_shadow.params[3u];
let _e351 = slope;
origin = (_e343 + (((_e344 * _e345) * _e349) * (1f + _e351)));
let _e355 = origin;
let _e356 = slot;
let _e359 = point_shadow.lights[_e356];
toFragment = (_e355 - _e359.xyz);
let _e362 = toFragment;
distance_ = length(_e362);
let _e364 = slot;
let _e368 = point_shadow.lights[_e364][3u];
range_3 = max(_e368, 0.0001f);
let _e370 = distance_;
let _e371 = range_3;
if (_e370 >= _e371) {
return 1f;
}
face = 0i;
let _e373 = (*lightIndex);
let _e377 = point_shadow.slots[_e373][1u];
if (_e377 < 0.5f) {
let _e379 = toFragment;
a_1 = abs(_e379);
let _e382 = a_1[0u];
let _e384 = a_1[1u];
let _e385 = (_e382 >= _e384);
phi_2587_ = _e385;
if _e385 {
let _e387 = a_1[0u];
let _e389 = a_1[2u];
phi_2587_ = (_e387 >= _e389);
}
let _e392 = phi_2587_;
if _e392 {
let _e394 = toFragment[0u];
face = select(1i, 0i, (_e394 > 0f));
} else {
let _e398 = a_1[1u];
let _e400 = a_1[2u];
if (_e398 >= _e400) {
let _e403 = toFragment[1u];
face = select(3i, 2i, (_e403 > 0f));
} else {
let _e407 = toFragment[2u];
face = select(5i, 4i, (_e407 > 0f));
}
}
}
let _e410 = slot;
let _e412 = face;
let _e416 = point_shadow.faces[((_e410 * 6i) + _e412)];
let _e417 = origin;
clip = (_e416 * vec4<f32>(_e417.x, _e417.y, _e417.z, 1f));
let _e424 = clip[3u];
if (_e424 <= 0f) {
return 1f;
}
let _e426 = clip;
let _e429 = clip[3u];
ndc = (_e426.xy / vec2(_e429));
let _e433 = ndc[0u];
let _e435 = (abs(_e433) > 1f);
phi_2648_ = _e435;
if !(_e435) {
let _e438 = ndc[1u];
phi_2648_ = (abs(_e438) > 1f);
}
let _e442 = phi_2648_;
if _e442 {
return 1f;
}
let _e444 = ndc[0u];
let _e448 = ndc[1u];
uv_4 = vec2<f32>(((_e444 * 0.5f) + 0.5f), (0.5f - (_e448 * 0.5f)));
let _e452 = face;
let _e454 = slot;
tile_3 = vec2<f32>(f32(_e452), f32(_e454));
let _e457 = distance_;
let _e460 = point_shadow.params[1u];
receiver_2 = (_e457 - _e460);
let _e464 = frag_info.target_origin[0u];
param_57 = _e464;
let _e465 = FragCoordFromTop_u0028_f1_u003b((¶m_57));
noise = fract((52.982918f * fract(dot(_e465, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e470 = noise;
angle = (_e470 * 6.2831855f);
let _e472 = angle;
ca_2 = cos(_e472);
let _e474 = angle;
sa_2 = sin(_e474);
let _e476 = (*lightIndex);
let _e480 = point_shadow.slots[_e476][2u];
tanHalf_1 = max(_e480, 0.0001f);
blocker_1 = -1f;
let _e482 = uv_4;
param_58 = _e482;
let _e483 = tile_3;
param_59 = _e483;
let _e484 = range_3;
param_60 = _e484;
let _e485 = receiver_2;
param_61 = _e485;
let _e486 = ca_2;
param_62 = _e486;
let _e487 = sa_2;
param_63 = _e487;
let _e488 = tanHalf_1;
param_64 = _e488;
let _e489 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_58), (¶m_59), (¶m_60), (¶m_61), (¶m_62), (¶m_63), (¶m_64), (¶m_65));
let _e490 = param_65;
blocker_1 = _e490;
radius_1 = _e489;
let _e493 = point_shadow.params2_[3u];
if (_e493 > 0.5f) {
g_debug_surface_on = true;
let _e495 = radius_1;
if (_e495 < 0f) {
local_15 = vec3<f32>(0f, 0f, 1f);
} else {
let _e497 = radius_1;
let _e500 = point_shadow.params2_[2u];
let _e504 = blocker_1;
let _e505 = range_3;
local_15 = vec3<f32>(clamp((_e497 / max(_e500, 0.000001f)), 0f, 1f), clamp((_e504 / _e505), 0f, 1f), 0f);
}
let _e509 = local_15;
g_debug_surface = _e509;
}
let _e510 = radius_1;
if (_e510 < 0f) {
return 1f;
}
let _e512 = uv_4;
param_66 = _e512;
param_67 = vec2<f32>(0f, 0f);
let _e513 = tile_3;
param_68 = _e513;
let _e514 = range_3;
param_69 = _e514;
let _e515 = receiver_2;
param_70 = _e515;
let _e516 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70));
lit_1 = _e516;
let _e517 = radius_1;
if (_e517 > 0f) {
i_3 = 0i;
loop {
let _e519 = i_3;
if (_e519 < 8i) {
let _e521 = i_3;
param_71 = _e521;
let _e522 = ca_2;
param_72 = _e522;
let _e523 = sa_2;
param_73 = _e523;
let _e524 = radius_1;
param_74 = _e524;
let _e525 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_71), (¶m_72), (¶m_73), (¶m_74));
let _e526 = uv_4;
param_75 = _e526;
param_76 = _e525;
let _e527 = tile_3;
param_77 = _e527;
let _e528 = range_3;
param_78 = _e528;
let _e529 = receiver_2;
param_79 = _e529;
let _e530 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77), (¶m_78), (¶m_79));
let _e531 = lit_1;
lit_1 = (_e531 + _e530);
continue;
} else {
break;
}
continuing {
let _e533 = i_3;
i_3 = (_e533 + 1i);
}
}
let _e535 = lit_1;
lit_1 = (_e535 * 0.11111111f);
}
let _e537 = lit_1;
let _e538 = strength;
return mix(1f, _e537, clamp(_e538, 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 _e235 = (*i_4);
let _e238 = (*n_1);
r_3 = sqrt(((f32(_e235) + 0.5f) / f32(_e238)));
let _e242 = (*i_4);
let _e245 = (*turn);
theta = ((f32(_e242) * 2.3999631f) + _e245);
let _e247 = r_3;
let _e248 = theta;
let _e250 = theta;
return (vec2<f32>(cos(_e248), sin(_e250)) * _e247);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_80: f32;
let _e234 = frag_info.target_origin[0u];
param_80 = _e234;
let _e235 = FragCoordFromTop_u0028_f1_u003b((¶m_80));
let _e238 = frag_info.target_origin[3u];
at = (_e235 + vec2((5.588238f * max(_e238, 0f))));
let _e243 = at;
return fract((52.982918f * fract(dot(_e243, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_16: f32;
let _e233 = (*mode_1);
if (_e233 > 0.5f) {
let _e235 = (*stored_2);
local_16 = (1f - _e235);
} else {
let _e237 = (*stored_2);
local_16 = _e237;
}
let _e238 = local_16;
return _e238;
}
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 _e239 = (*moments)[1u];
let _e241 = (*moments)[0u];
let _e243 = (*moments)[0u];
let _e246 = (*minVariance);
variance = max((_e239 - (_e241 * _e243)), _e246);
let _e248 = (*t);
let _e250 = (*moments)[0u];
d_2 = (_e248 - _e250);
let _e252 = variance;
let _e253 = variance;
let _e254 = d_2;
let _e255 = d_2;
pMax = (_e252 / (_e253 + (_e254 * _e255)));
let _e259 = pMax;
let _e260 = (*bleed);
let _e262 = (*bleed);
reduced = clamp(((_e259 - _e260) / max((1f - _e262), 0.0001f)), 0f, 1f);
let _e267 = (*t);
let _e269 = (*moments)[0u];
let _e271 = reduced;
return select(_e271, 1f, (_e267 <= _e269));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_3: f32;
let _e232 = (*depth);
d_3 = ((2f * clamp(_e232, 0f, 1f)) - 1f);
let _e236 = d_3;
let _e239 = d_3;
return vec2<f32>(exp((40f * _e236)), -(exp((-5f * _e239))));
}
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_81: f32;
var scale: vec2<f32>;
var positive: f32;
var param_82: vec2<f32>;
var param_83: f32;
var param_84: f32;
var param_85: f32;
var negative: f32;
var param_86: vec2<f32>;
var param_87: f32;
var param_88: f32;
var param_89: f32;
let _e246 = (*depth_1);
param_81 = _e246;
let _e247 = EvsmWarp_u0028_f1_u003b((¶m_81));
warped = _e247;
let _e248 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e248);
let _e251 = scale[0u];
let _e253 = scale[0u];
let _e255 = (*moments_1);
param_82 = _e255.xy;
let _e258 = warped[0u];
param_83 = _e258;
param_84 = (_e251 * _e253);
let _e259 = (*bleed_1);
param_85 = _e259;
let _e260 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_82), (¶m_83), (¶m_84), (¶m_85));
positive = _e260;
let _e262 = scale[1u];
let _e264 = scale[1u];
let _e266 = (*moments_1);
param_86 = _e266.zw;
let _e269 = warped[1u];
param_87 = _e269;
param_88 = (_e262 * _e264);
let _e270 = (*bleed_1);
param_89 = _e270;
let _e271 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_86), (¶m_87), (¶m_88), (¶m_89));
negative = _e271;
let _e272 = positive;
let _e273 = negative;
return min(_e272, _e273);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e232 = (*depth_2);
stored_3 = max((1f - _e232), 0.000061035156f);
let _e235 = stored_3;
return exp2((floor(log2(_e235)) - 10f));
}
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_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var local_17: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_18: mat4x4<f32>;
var local_19: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_20: f32;
var local_21: f32;
var storage_: f32;
var param_90: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_91: vec4<f32>;
var param_92: f32;
var param_93: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var param_94: f32;
var param_95: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_96: i32;
var param_97: i32;
var param_98: f32;
var tapBias: f32;
var occluder_1: f32;
var param_99: f32;
var param_100: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_101: i32;
var param_102: i32;
var param_103: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_104: f32;
var param_105: f32;
var phi_4195_: bool;
var phi_4206_: bool;
var phi_4363_: bool;
var phi_4370_: bool;
var phi_4377_: bool;
let _e309 = frag_info.shadow_params[3u];
strength_1 = _e309;
let _e310 = strength_1;
if (_e310 <= 0f) {
return 1f;
}
let _e312 = (*lightIndex_1);
let _e315 = frag_info.frame_params[2u];
if (_e312 != i32(floor((_e315 + 0.5f)))) {
return 1f;
}
let _e322 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e322 + 0.5f));
let _e325 = Orthographic_u0028_();
if _e325 {
let _e326 = ViewDepth_u0028_();
local_17 = _e326;
} else {
let _e327 = v_world_position_1;
let _e329 = frag_info.camera_position;
local_17 = length((_e327 - _e329.xyz));
}
let _e333 = local_17;
viewDistance = _e333;
cascade = 0i;
let _e334 = cascadeCount;
let _e335 = (_e334 > 1i);
phi_4195_ = _e335;
if _e335 {
let _e336 = viewDistance;
let _e339 = frag_info.shadow_cascades[0u];
phi_4195_ = (_e336 > _e339);
}
let _e342 = phi_4195_;
if _e342 {
cascade = 1i;
}
let _e343 = cascadeCount;
let _e344 = (_e343 > 2i);
phi_4206_ = _e344;
if _e344 {
let _e345 = viewDistance;
let _e348 = frag_info.shadow_cascades[1u];
phi_4206_ = (_e345 > _e348);
}
let _e351 = phi_4206_;
if _e351 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e352 = attempt;
if (_e352 < 3i) {
let _e354 = cascade;
let _e355 = attempt;
which = (_e354 + _e355);
let _e357 = which;
let _e358 = cascadeCount;
if (_e357 >= _e358) {
break;
}
let _e360 = which;
if (_e360 == 0i) {
let _e363 = frag_info.shadow_matrix;
local_18 = _e363;
} else {
let _e364 = which;
if (_e364 == 1i) {
let _e367 = frag_info.shadow_matrix_far;
local_19 = _e367;
} else {
let _e369 = frag_info.shadow_matrix_farthest;
local_19 = _e369;
}
let _e370 = local_19;
local_18 = _e370;
}
let _e371 = local_18;
matrix = _e371;
let _e374 = matrix[0][0u];
let _e377 = matrix[1][0u];
let _e380 = matrix[2][0u];
axisX = vec3<f32>(_e374, _e377, _e380);
let _e384 = matrix[0][1u];
let _e387 = matrix[1][1u];
let _e390 = matrix[2][1u];
axisY = vec3<f32>(_e384, _e387, _e390);
let _e392 = axisX;
rowX = max(length(_e392), 0.000001f);
let _e395 = axisY;
rowY = max(length(_e395), 0.000001f);
let _e400 = frag_info.shadow_cascades[3u];
let _e402 = rowX;
texelMetres = ((2f * _e400) / _e402);
let _e406 = frag_info.shadow_cascades[3u];
let _e409 = (*s_4).n;
let _e410 = axisX;
let _e413 = rowX;
let _e414 = rowX;
let _e418 = (*s_4).n;
let _e419 = axisY;
let _e422 = rowY;
let _e423 = rowY;
reach = ((3f * _e406) * ((abs(dot(_e409, _e410)) / (_e413 * _e414)) + (abs(dot(_e418, _e419)) / (_e422 * _e423))));
let _e430 = frag_info.shadow_params[2u];
let _e431 = texelMetres;
flatOffset = min(_e430, _e431);
let _e433 = v_world_position_1;
let _e435 = (*s_4).n;
let _e436 = flatOffset;
let _e437 = reach;
origin_1 = (_e433 + (_e435 * (_e436 + _e437)));
let _e441 = matrix;
let _e442 = origin_1;
lightSpace = (_e441 * vec4<f32>(_e442.x, _e442.y, _e442.z, 1f));
let _e449 = lightSpace[3u];
if (_e449 <= 0f) {
continue;
}
let _e451 = lightSpace;
let _e454 = lightSpace[3u];
candidate = (_e451.xyz / vec3(_e454));
let _e458 = candidate[0u];
let _e462 = candidate[1u];
inTile = vec2<f32>(((_e458 * 0.5f) + 0.5f), (0.5f - (_e462 * 0.5f)));
let _e467 = inTile[0u];
let _e468 = (_e467 < 0f);
phi_4363_ = _e468;
if !(_e468) {
let _e471 = inTile[0u];
phi_4363_ = (_e471 > 1f);
}
let _e474 = phi_4363_;
phi_4370_ = _e474;
if !(_e474) {
let _e477 = inTile[1u];
phi_4370_ = (_e477 < 0f);
}
let _e480 = phi_4370_;
phi_4377_ = _e480;
if !(_e480) {
let _e483 = inTile[1u];
phi_4377_ = (_e483 > 1f);
}
let _e486 = phi_4377_;
if _e486 {
continue;
}
let _e488 = candidate[2u];
if (_e488 > 1f) {
let _e490 = which;
let _e491 = cascadeCount;
if (_e490 < (_e491 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e496 = inTile[0u];
let _e497 = which;
let _e500 = cascadeCount;
let _e504 = inTile[1u];
uv_5 = vec2<f32>(((_e496 + f32(_e497)) / f32(_e500)), _e504);
let _e506 = candidate;
projected = _e506;
let _e507 = which;
cascade = _e507;
let _e508 = texelMetres;
cascadeTexel = _e508;
let _e511 = matrix[0][2u];
let _e514 = matrix[1][2u];
let _e517 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e511, _e514, _e517)), 0.000001f));
let _e523 = (*s_4).n;
let _e526 = matrix[0][2u];
let _e529 = matrix[1][2u];
let _e532 = matrix[2][2u];
let _e536 = cascadeDepth;
cosSlope = clamp((abs(dot(_e523, vec3<f32>(_e526, _e529, _e532))) * _e536), 0.1f, 1f);
let _e539 = texelMetres;
let _e540 = cosSlope;
let _e541 = cosSlope;
let _e547 = cosSlope;
let _e549 = cascadeDepth;
receiverSlope = (((_e539 * sqrt(max((1f - (_e540 * _e541)), 0f))) / _e547) / _e549);
found = true;
break;
} else {
break;
}
continuing {
let _e551 = attempt;
attempt = (_e551 + 1i);
}
}
let _e553 = found;
if !(_e553) {
return 1f;
}
let _e555 = cascade;
if (_e555 == 0i) {
let _e559 = frag_info.shadow_bias[0u];
local_20 = _e559;
} else {
let _e560 = cascade;
if (_e560 == 1i) {
let _e564 = frag_info.shadow_bias[1u];
local_21 = _e564;
} else {
let _e567 = frag_info.shadow_bias[2u];
local_21 = _e567;
}
let _e568 = local_21;
local_20 = _e568;
}
let _e569 = local_20;
bias = _e569;
let _e572 = frag_info.shadow_params[1u];
storage_ = _e572;
let _e573 = storage_;
let _e575 = storage_;
if ((_e573 > 0.5f) && (_e575 < 1.5f)) {
let _e578 = bias;
let _e580 = projected[2u];
param_90 = _e580;
let _e581 = ShadowStoredStep_u0028_f1_u003b((¶m_90));
bias = max(_e578, _e581);
}
let _e585 = frag_info.shadow_params[0u];
let _e588 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e585, _e588);
let _e590 = cascade;
let _e592 = cascadeCount;
let _e596 = texel_1;
tileLo = (vec2<f32>((f32(_e590) / f32(_e592)), 0f) + (_e596 * 0.5f));
let _e599 = cascade;
let _e602 = cascadeCount;
let _e606 = texel_1;
tileHi = (vec2<f32>((f32((_e599 + 1i)) / f32(_e602)), 1f) - (_e606 * 0.5f));
let _e611 = frag_info.shadow_bias[3u];
if (_e611 > 0.5f) {
let _e613 = uv_5;
let _e614 = tileLo;
let _e615 = tileHi;
let _e617 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e613, _e614, _e615), 0f);
stored_4 = _e617;
let _e619 = stored_4[1u];
let _e622 = stored_4[2u];
let _e625 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e619), (1f - _e622), _e625), vec3(0f), vec3(4f));
let _e630 = through;
let _e631 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e630, vec3(clamp(_e631, 0f, 1f)));
}
let _e637 = frag_info.ambient_ground[3u];
softness = _e637;
lit_2 = 0f;
let _e638 = softness;
if (_e638 < 0f) {
let _e640 = uv_5;
let _e641 = tileLo;
let _e642 = tileHi;
let _e644 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e640, _e641, _e642), 0f);
moments_2 = _e644;
let _e646 = projected[2u];
let _e647 = bias;
let _e649 = softness;
let _e653 = moments_2;
param_91 = _e653;
param_92 = (_e646 - _e647);
param_93 = clamp((-(_e649) - 1f), 0f, 0.95f);
let _e654 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_91), (¶m_92), (¶m_93));
lit_2 = _e654;
} else {
let _e655 = softness;
if (_e655 <= 0f) {
y_1 = -1i;
loop {
let _e657 = y_1;
if (_e657 <= 1i) {
x_1 = -1i;
loop {
let _e659 = x_1;
if (_e659 <= 1i) {
let _e661 = uv_5;
let _e662 = x_1;
let _e664 = y_1;
let _e667 = texel_1;
let _e670 = tileLo;
let _e671 = tileHi;
let _e673 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e661 + (vec2<f32>(f32(_e662), f32(_e664)) * _e667)), _e670, _e671), 0f);
param_94 = _e673.x;
let _e675 = storage_;
param_95 = _e675;
let _e676 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_94), (¶m_95));
occluder = _e676;
let _e678 = projected[2u];
let _e679 = bias;
let _e681 = occluder;
let _e684 = lit_2;
lit_2 = (_e684 + select(1f, 0f, ((_e678 - _e679) > _e681)));
continue;
} else {
break;
}
continuing {
let _e686 = x_1;
x_1 = (_e686 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e688 = y_1;
y_1 = (_e688 + 1i);
}
}
let _e690 = lit_2;
lit_2 = (_e690 * 0.11111111f);
} else {
let _e692 = softness;
spread = tan(min(_e692, 0.5f));
let _e695 = ShadowNoise_u0028_();
turn_1 = (_e695 * 6.2831855f);
let _e697 = spread;
let _e699 = projected[2u];
let _e701 = cascadeDepth;
let _e703 = cascadeTexel;
searchRadius = clamp((((_e697 * _e699) * _e701) / _e703), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e706 = i_5;
if (_e706 < 16i) {
let _e708 = i_5;
param_96 = _e708;
param_97 = 16i;
let _e709 = turn_1;
param_98 = _e709;
let _e710 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_96), (¶m_97), (¶m_98));
disc = _e710;
let _e711 = bias;
let _e712 = disc;
let _e714 = searchRadius;
let _e718 = receiverSlope;
tapBias = (_e711 + (max(((length(_e712) * _e714) - 1.5f), 0f) * _e718));
let _e721 = uv_5;
let _e722 = disc;
let _e723 = texel_1;
let _e725 = searchRadius;
let _e728 = tileLo;
let _e729 = tileHi;
let _e731 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e721 + ((_e722 * _e723) * _e725)), _e728, _e729), 0f);
param_99 = _e731.x;
let _e733 = storage_;
param_100 = _e733;
let _e734 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_99), (¶m_100));
occluder_1 = _e734;
let _e736 = projected[2u];
let _e737 = tapBias;
let _e739 = occluder_1;
if ((_e736 - _e737) > _e739) {
let _e741 = occluder_1;
let _e742 = blockerSum;
blockerSum = (_e742 + _e741);
let _e744 = blockerCount;
blockerCount = (_e744 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e746 = i_5;
i_5 = (_e746 + 1i);
}
}
let _e748 = blockerCount;
if (_e748 <= 0f) {
return 1f;
}
let _e751 = projected[2u];
let _e752 = blockerSum;
let _e753 = blockerCount;
let _e757 = cascadeDepth;
gap = (max((_e751 - (_e752 / _e753)), 0f) * _e757);
let _e759 = spread;
let _e760 = gap;
let _e762 = cascadeTexel;
radius_2 = clamp(((_e759 * _e760) / _e762), 1f, 16f);
i_6 = 0i;
loop {
let _e765 = i_6;
if (_e765 < 16i) {
let _e767 = turn_1;
let _e769 = i_6;
param_101 = _e769;
param_102 = 16i;
param_103 = (_e767 + 1f);
let _e770 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_101), (¶m_102), (¶m_103));
disc_1 = _e770;
let _e771 = bias;
let _e772 = disc_1;
let _e774 = radius_2;
let _e778 = receiverSlope;
tapBias_1 = (_e771 + (max(((length(_e772) * _e774) - 1.5f), 0f) * _e778));
let _e781 = uv_5;
let _e782 = disc_1;
let _e783 = texel_1;
let _e785 = radius_2;
let _e788 = tileLo;
let _e789 = tileHi;
let _e791 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e781 + ((_e782 * _e783) * _e785)), _e788, _e789), 0f);
param_104 = _e791.x;
let _e793 = storage_;
param_105 = _e793;
let _e794 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_104), (¶m_105));
occluder_2 = _e794;
let _e796 = projected[2u];
let _e797 = tapBias_1;
let _e799 = occluder_2;
let _e802 = lit_2;
lit_2 = (_e802 + select(1f, 0f, ((_e796 - _e797) > _e799)));
continue;
} else {
break;
}
continuing {
let _e804 = i_6;
i_6 = (_e804 + 1i);
}
}
let _e806 = lit_2;
lit_2 = (_e806 * 0.0625f);
}
}
let _e808 = lit_2;
let _e809 = strength_1;
return mix(1f, _e808, clamp(_e809, 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_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_106: Surface;
var param_107: LightSample;
var param_108: i32;
let _e236 = (*s_5);
param_106 = _e236;
let _e237 = (*light_2);
param_107 = _e237;
let _e238 = (*index);
param_108 = _e238;
let _e239 = 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_106), (¶m_107), (¶m_108));
return _e239;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e231 = (*index_1);
return (_e231 < 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 _e235 = (*distance_1);
let _e236 = (*distance_1);
attenuation = (1f / max((_e235 * _e236), 0.0001f));
let _e240 = (*range_4);
if (_e240 > 0f) {
let _e242 = (*distance_1);
let _e243 = (*range_4);
ratio = (_e242 / _e243);
let _e245 = ratio;
let _e246 = ratio;
let _e248 = ratio;
let _e250 = ratio;
window = clamp((1f - (((_e245 * _e246) * _e248) * _e250)), 0f, 1f);
let _e254 = window;
let _e255 = window;
let _e257 = attenuation;
attenuation = (_e257 * (_e254 * _e255));
}
let _e259 = attenuation;
return _e259;
}
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_22: vec3<f32>;
let _e236 = (*a_2);
let _e237 = (*b);
axis = cross(_e236, _e237);
let _e239 = axis;
len = length(_e239);
let _e241 = (*a_2);
let _e242 = (*b);
angle_1 = acos(clamp(dot(_e241, _e242), -1f, 1f));
let _e246 = len;
if (_e246 > 0.000001f) {
let _e248 = axis;
let _e249 = angle_1;
let _e250 = len;
local_22 = (_e248 * (_e249 / (_e250 * 6.2831855f)));
} else {
local_22 = vec3<f32>(0f, 0f, 0f);
}
let _e254 = local_22;
return _e254;
}
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_6: vec2<f32>;
var inverse: vec4<f32>;
var param_109: f32;
var param_110: f32;
var param_111: f32;
var fit: vec4<f32>;
var param_112: f32;
var param_113: f32;
var param_114: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_23: 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_115: vec3<f32>;
var param_116: vec3<f32>;
var param_117: vec3<f32>;
var param_118: vec3<f32>;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: vec3<f32>;
var param_122: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_24: f32;
var sphere: f32;
var param_123: f32;
var param_124: f32;
var param_125: f32;
let _e268 = (*roughness_3);
let _e270 = (*n_2);
let _e271 = (*v);
uv_6 = vec2<f32>(clamp(_e268, 0f, 1f), sqrt(clamp((1f - dot(_e270, _e271)), 0f, 1f)));
let _e278 = uv_6[0u];
param_109 = _e278;
let _e280 = uv_6[1u];
param_110 = _e280;
param_111 = 0f;
let _e281 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_109), (¶m_110), (¶m_111));
let _e282 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e281, 0f);
inverse = _e282;
let _e284 = uv_6[0u];
param_112 = _e284;
let _e286 = uv_6[1u];
param_113 = _e286;
param_114 = 1f;
let _e287 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_112), (¶m_113), (¶m_114));
let _e288 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e287, 0f);
fit = _e288;
let _e289 = (*v);
let _e290 = (*n_2);
let _e291 = (*v);
let _e292 = (*n_2);
along = (_e289 - (_e290 * dot(_e291, _e292)));
let _e296 = along;
alongLength = length(_e296);
let _e298 = alongLength;
if (_e298 > 0.00001f) {
let _e300 = along;
let _e301 = alongLength;
local_23 = (_e300 / vec3(_e301));
} else {
let _e304 = (*n_2);
let _e306 = (*n_2)[2u];
local_23 = normalize(cross(_e304, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e306) < 0.999f)))));
}
let _e313 = local_23;
t1_ = _e313;
let _e314 = (*n_2);
let _e315 = t1_;
t2_ = cross(_e314, _e315);
let _e318 = inverse[0u];
let _e320 = inverse[1u];
let _e321 = vec3<f32>(_e318, 0f, _e320);
let _e323 = inverse[2u];
let _e325 = inverse[3u];
let _e326 = vec3<f32>(_e323, 0f, _e325);
minv = mat3x3<f32>(vec3<f32>(_e321.x, _e321.y, _e321.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e326.x, _e326.y, _e326.z));
i_7 = 0i;
loop {
let _e340 = i_7;
if (_e340 < 4i) {
let _e342 = i_7;
let _e344 = (*corners)[_e342];
p_1 = _e344;
let _e345 = i_7;
let _e346 = minv;
let _e347 = p_1;
let _e348 = t1_;
let _e350 = p_1;
let _e351 = t2_;
let _e353 = p_1;
let _e354 = (*n_2);
l[_e345] = normalize((_e346 * vec3<f32>(dot(_e347, _e348), dot(_e350, _e351), dot(_e353, _e354))));
continue;
} else {
break;
}
continuing {
let _e360 = i_7;
i_7 = (_e360 + 1i);
}
}
let _e363 = l[0i];
param_115 = _e363;
let _e365 = l[1i];
param_116 = _e365;
let _e366 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_115), (¶m_116));
let _e368 = l[1i];
param_117 = _e368;
let _e370 = l[2i];
param_118 = _e370;
let _e371 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_117), (¶m_118));
let _e374 = l[2i];
param_119 = _e374;
let _e376 = l[3i];
param_120 = _e376;
let _e377 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_119), (¶m_120));
let _e380 = l[3i];
param_121 = _e380;
let _e382 = l[0i];
param_122 = _e382;
let _e383 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_121), (¶m_122));
f_2 = -((((_e366 + _e371) + _e377) + _e383));
let _e386 = f_2;
len_1 = length(_e386);
let _e388 = len_1;
if (_e388 > 0.000000001f) {
let _e391 = f_2[2u];
let _e392 = len_1;
local_24 = (_e391 / _e392);
} else {
local_24 = 0f;
}
let _e394 = local_24;
z_1 = _e394;
let _e395 = z_1;
let _e398 = len_1;
param_123 = ((_e395 * 0.5f) + 0.5f);
param_124 = clamp(_e398, 0f, 1f);
param_125 = 1f;
let _e400 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125));
let _e401 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e400, 0f);
sphere = _e401.w;
let _e403 = len_1;
let _e404 = sphere;
let _e408 = fit[0u];
let _e410 = fit[1u];
return vec3<f32>(max((_e403 * _e404), 0f), _e408, _e410);
}
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_25: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e247 = (*halfWidth);
let _e248 = (*halfHeight);
n_3 = cross(_e247, _e248);
let _e250 = n_3;
nLen = length(_e250);
let _e252 = nLen;
if (_e252 < 0.000000000001f) {
let _e254 = (*centre);
return _e254;
}
let _e255 = nLen;
let _e256 = n_3;
n_3 = (_e256 / vec3(_e255));
let _e259 = (*centre);
let _e260 = (*world_2);
toPlane = (_e259 - _e260);
let _e262 = (*mirror);
let _e263 = n_3;
denom = dot(_e262, _e263);
let _e265 = denom;
if (abs(_e265) < 0.00001f) {
let _e268 = toPlane;
let _e269 = n_3;
let _e270 = toPlane;
let _e271 = n_3;
onPlane = (_e268 - (_e269 * dot(_e270, _e271)));
} else {
let _e275 = toPlane;
let _e276 = n_3;
let _e278 = denom;
t_1 = (dot(_e275, _e276) / _e278);
let _e280 = t_1;
if (_e280 > 0f) {
let _e282 = (*mirror);
let _e283 = t_1;
local_25 = (_e282 * _e283);
} else {
let _e285 = toPlane;
let _e286 = n_3;
let _e287 = toPlane;
let _e288 = n_3;
local_25 = (_e285 - (_e286 * dot(_e287, _e288)));
}
let _e292 = local_25;
onPlane = _e292;
}
let _e293 = onPlane;
let _e294 = toPlane;
offset_2 = (_e293 - _e294);
let _e296 = (*halfWidth);
let _e297 = (*halfWidth);
wLen2_ = max(dot(_e296, _e297), 0.000000000001f);
let _e300 = (*halfHeight);
let _e301 = (*halfHeight);
hLen2_ = max(dot(_e300, _e301), 0.000000000001f);
let _e304 = offset_2;
let _e305 = (*halfWidth);
let _e307 = wLen2_;
u = clamp((dot(_e304, _e305) / _e307), -1f, 1f);
let _e310 = offset_2;
let _e311 = (*halfHeight);
let _e313 = hLen2_;
v_1 = clamp((dot(_e310, _e311) / _e313), -1f, 1f);
let _e316 = (*centre);
let _e317 = (*halfWidth);
let _e318 = u;
let _e321 = (*halfHeight);
let _e322 = v_1;
return ((_e316 + (_e317 * _e318)) + (_e321 * _e322));
}
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_26: f32;
let _e239 = (*a_3);
let _e240 = (*a_3);
ua = (_e239 / vec3(max(length(_e240), 0.000000000001f)));
let _e245 = (*b_1);
let _e246 = (*b_1);
ub = (_e245 / vec3(max(length(_e246), 0.000000000001f)));
let _e251 = ua;
let _e252 = ub;
angle_2 = acos(clamp(dot(_e251, _e252), -1f, 1f));
let _e256 = ua;
let _e257 = ub;
axis_1 = cross(_e256, _e257);
let _e259 = axis_1;
len_2 = length(_e259);
let _e261 = len_2;
if (_e261 > 0.000001f) {
let _e263 = angle_2;
let _e264 = axis_1;
let _e265 = (*n_4);
let _e268 = len_2;
local_26 = ((_e263 * dot(_e264, _e265)) / _e268);
} else {
local_26 = 0f;
}
let _e270 = local_26;
return _e270;
}
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_27: i32;
var ha: f32;
var hb: f32;
var d_4: f32;
var q: vec3<f32>;
var local_28: f32;
var aAbove: bool;
var bAbove: bool;
var local_29: f32;
var param_126: vec3<f32>;
var param_127: vec3<f32>;
var param_128: vec3<f32>;
var param_129: vec3<f32>;
var param_130: vec3<f32>;
var param_131: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e253 = i_8;
if (_e253 < 4i) {
let _e255 = i_8;
let _e257 = (*corners_1)[_e255];
a_4 = _e257;
let _e258 = i_8;
if (_e258 == 3i) {
local_27 = 0i;
} else {
let _e260 = i_8;
local_27 = (_e260 + 1i);
}
let _e262 = local_27;
let _e264 = (*corners_1)[_e262];
b_2 = _e264;
let _e265 = a_4;
let _e266 = (*n_5);
ha = dot(_e265, _e266);
let _e268 = b_2;
let _e269 = (*n_5);
hb = dot(_e268, _e269);
let _e271 = ha;
let _e272 = hb;
d_4 = (_e271 - _e272);
let _e274 = a_4;
let _e275 = b_2;
let _e276 = a_4;
let _e278 = d_4;
if (abs(_e278) > 0.000000000001f) {
let _e281 = ha;
let _e282 = d_4;
local_28 = (_e281 / _e282);
} else {
local_28 = 0f;
}
let _e284 = local_28;
q = (_e274 + ((_e275 - _e276) * _e284));
let _e287 = ha;
aAbove = (_e287 > 0f);
let _e289 = hb;
bAbove = (_e289 > 0f);
let _e291 = aAbove;
let _e292 = bAbove;
if (_e291 || _e292) {
let _e294 = aAbove;
let _e295 = a_4;
let _e296 = q;
let _e299 = bAbove;
let _e300 = b_2;
let _e301 = q;
param_126 = select(_e296, _e295, vec3(_e294));
param_127 = select(_e301, _e300, vec3(_e299));
let _e304 = (*n_5);
param_128 = _e304;
let _e305 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_126), (¶m_127), (¶m_128));
local_29 = _e305;
} else {
local_29 = 0f;
}
let _e306 = local_29;
let _e307 = total;
total = (_e307 + _e306);
let _e309 = aAbove;
let _e310 = bAbove;
let _e313 = q;
let _e314 = exit;
exit = select(_e314, _e313, vec3((_e309 && !(_e310))));
let _e317 = aAbove;
let _e319 = bAbove;
let _e321 = q;
let _e322 = entry;
entry = select(_e322, _e321, vec3((!(_e317) && _e319)));
continue;
} else {
break;
}
continuing {
let _e325 = i_8;
i_8 = (_e325 + 1i);
}
}
let _e327 = exit;
param_129 = _e327;
let _e328 = entry;
param_130 = _e328;
let _e329 = (*n_5);
param_131 = _e329;
let _e330 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_129), (¶m_130), (¶m_131));
let _e331 = total;
total = (_e331 + _e330);
let _e333 = total;
return max((-(_e333) * 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_30: f32;
var local_31: f32;
var local_32: f32;
let _e236 = (*slot_1);
let _e237 = (*slot_1);
lane = (_e236 - ((_e237 / 4i) * 4i));
let _e241 = lane;
if (_e241 == 0i) {
let _e244 = (*four)[0u];
local_30 = _e244;
} else {
let _e245 = lane;
if (_e245 == 1i) {
let _e248 = (*four)[1u];
local_31 = _e248;
} else {
let _e249 = lane;
if (_e249 == 2i) {
let _e252 = (*four)[2u];
local_32 = _e252;
} else {
let _e254 = (*four)[3u];
local_32 = _e254;
}
let _e255 = local_32;
local_31 = _e255;
}
let _e256 = local_31;
local_30 = _e256;
}
let _e257 = local_30;
return _e257;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_132: vec4<f32>;
var param_133: i32;
let _e233 = (*slot_2);
let _e237 = light_list_info.scales[(_e233 / 4i)];
param_132 = _e237;
let _e238 = (*slot_2);
param_133 = _e238;
let _e239 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_132), (¶m_133));
return _e239;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e235 = light_list_info.slot_rows[0i];
let _e236 = (*row);
a_5 = abs((_e235 - vec4(_e236)));
let _e242 = light_list_info.slot_rows[1i];
let _e243 = (*row);
b_3 = abs((_e242 - vec4(_e243)));
let _e248 = a_5[0u];
let _e250 = a_5[1u];
let _e253 = a_5[2u];
let _e255 = a_5[3u];
let _e259 = b_3[0u];
let _e261 = b_3[1u];
let _e264 = b_3[2u];
let _e266 = b_3[3u];
return (min(min(min(_e248, _e250), min(_e253, _e255)), min(min(_e259, _e261), min(_e264, _e266))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_134: vec4<f32>;
var param_135: i32;
let _e233 = (*slot_3);
let _e237 = light_list_info.indices[(_e233 / 4i)];
param_134 = _e237;
let _e238 = (*slot_3);
param_135 = _e238;
let _e239 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_134), (¶m_135));
return _e239;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e232 = (*texel_2);
let _e236 = light_list_info.list[1u];
let _e238 = (*row_1);
let _e242 = light_list_info.list[2u];
let _e245 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e232 + 0.5f) * _e236), ((_e238 + 0.5f) * _e242)), 0f);
return _e245;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_136: f32;
var param_137: f32;
var param_138: vec4<f32>;
var param_139: i32;
let _e240 = g_cluster_offset;
let _e241 = (*slot_4);
entry_1 = (_e240 + f32(_e241));
let _e244 = entry_1;
row_2 = floor((_e244 / 16f));
let _e247 = entry_1;
let _e248 = row_2;
within_1 = (_e247 - (_e248 * 16f));
let _e251 = within_1;
texel_3 = floor((_e251 / 4f));
let _e256 = light_list_info.cluster_depth[3u];
let _e257 = row_2;
let _e259 = texel_3;
param_136 = _e259;
param_137 = (_e256 + _e257);
let _e260 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_136), (¶m_137));
four_1 = _e260;
let _e261 = within_1;
let _e262 = texel_3;
let _e267 = four_1;
param_138 = _e267;
param_139 = i32(((_e261 - (_e262 * 4f)) + 0.5f));
let _e268 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_138), (¶m_139));
return _e268;
}
fn Clustered_u0028_() -> bool {
let _e232 = light_list_info.cluster_grid[3u];
return (_e232 > 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_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_33: f32;
var param_140: i32;
var param_141: i32;
var v_2: f32;
var u_1: f32;
var local_34: f32;
var param_142: f32;
var param_143: 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_35: f32;
var param_144: array<vec3<f32>, 4>;
var param_145: vec3<f32>;
var area: f32;
var radiance: f32;
var local_36: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_146: vec3<f32>;
var param_147: vec3<f32>;
var param_148: vec3<f32>;
var param_149: vec3<f32>;
var param_150: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_37: vec3<f32>;
var param_151: vec3<f32>;
var param_152: vec3<f32>;
var param_153: f32;
var param_154: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_155: f32;
var param_156: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e288 = (*index_2);
if (_e288 < 8i) {
let _e290 = (*index_2);
let _e293 = frag_info.light_position[_e290];
position = _e293;
let _e294 = (*index_2);
let _e297 = frag_info.light_color[_e294];
color_1 = _e297;
let _e298 = (*index_2);
let _e301 = frag_info.light_direction[_e298];
direction = _e301;
let _e302 = (*index_2);
let _e305 = frag_info.light_cone[_e302];
cone = _e305;
} else {
let _e306 = (*index_2);
slot_5 = (_e306 - 8i);
let _e308 = Clustered_u0028_();
clustered = _e308;
let _e309 = clustered;
if _e309 {
let _e310 = slot_5;
param_140 = _e310;
let _e311 = ClusterRow_u0028_i1_u003b((¶m_140));
local_33 = _e311;
} else {
let _e312 = slot_5;
param_141 = _e312;
let _e313 = LightListRow_u0028_i1_u003b((¶m_141));
local_33 = _e313;
}
let _e314 = local_33;
listRow = _e314;
let _e315 = listRow;
let _e319 = light_list_info.list[2u];
v_2 = ((_e315 + 0.5f) * _e319);
let _e323 = light_list_info.list[1u];
u_1 = _e323;
let _e324 = u_1;
let _e326 = v_2;
let _e328 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e324), _e326), 0f);
position = _e328;
let _e329 = u_1;
let _e331 = v_2;
let _e333 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e329), _e331), 0f);
color_1 = _e333;
let _e334 = u_1;
let _e336 = v_2;
let _e338 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e334), _e336), 0f);
direction = _e338;
let _e339 = u_1;
let _e341 = v_2;
let _e343 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e339), _e341), 0f);
cone = _e343;
let _e344 = clustered;
if _e344 {
let _e345 = listRow;
param_142 = _e345;
let _e346 = InSlots_u0028_f1_u003b((¶m_142));
local_34 = select(1f, 0f, _e346);
} else {
let _e348 = slot_5;
param_143 = _e348;
let _e349 = LightListScale_u0028_i1_u003b((¶m_143));
local_34 = _e349;
}
let _e350 = local_34;
let _e352 = color_1[3u];
color_1[3u] = (_e352 * _e350);
}
let _e356 = position[3u];
type_42 = _e356;
let _e357 = type_42;
if (_e357 > 15.5f) {
let _e360 = (*s_6).n;
light_3.l = _e360;
let _e363 = (*s_6).n;
light_3.h = _e363;
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 _e369 = light_3;
return _e369;
}
let _e370 = type_42;
if (_e370 > 2.5f) {
let _e372 = direction;
halfWidth_1 = _e372.xyz;
let _e374 = cone;
halfHeight_1 = _e374.xyz;
let _e376 = position;
let _e378 = v_world_position_1;
toCentre = (_e376.xyz - _e378);
let _e380 = toCentre;
let _e381 = halfWidth_1;
let _e383 = halfHeight_1;
corners_2[0i] = ((_e380 - _e381) - _e383);
let _e386 = toCentre;
let _e387 = halfWidth_1;
let _e389 = halfHeight_1;
corners_2[1i] = ((_e386 + _e387) - _e389);
let _e392 = toCentre;
let _e393 = halfWidth_1;
let _e395 = halfHeight_1;
corners_2[2i] = ((_e392 + _e393) + _e395);
let _e398 = toCentre;
let _e399 = halfWidth_1;
let _e401 = halfHeight_1;
corners_2[3i] = ((_e398 - _e399) + _e401);
let _e404 = toCentre;
let _e405 = halfWidth_1;
let _e406 = halfHeight_1;
behind = (dot(_e404, cross(_e405, _e406)) >= 0f);
let _e410 = behind;
if _e410 {
local_35 = 0f;
} else {
let _e411 = corners_2;
param_144 = _e411;
let _e413 = (*s_6).n;
param_145 = _e413;
let _e414 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_144), (¶m_145));
local_35 = _e414;
}
let _e415 = local_35;
formFactor = _e415;
let _e416 = halfWidth_1;
let _e417 = halfHeight_1;
area = (length(cross(_e416, _e417)) * 4f);
let _e421 = area;
if (_e421 > 0.000000001f) {
let _e423 = area;
local_36 = (1f / _e423);
} else {
local_36 = 0f;
}
let _e425 = local_36;
radiance = _e425;
let _e426 = toCentre;
distance_2 = length(_e426);
let _e429 = direction[3u];
if (_e429 > 0f) {
let _e431 = distance_2;
let _e433 = direction[3u];
ratio_1 = (_e431 / _e433);
let _e435 = ratio_1;
let _e436 = ratio_1;
let _e438 = ratio_1;
let _e440 = ratio_1;
window_1 = clamp((1f - (((_e435 * _e436) * _e438) * _e440)), 0f, 1f);
let _e444 = window_1;
let _e445 = window_1;
let _e447 = radiance;
radiance = (_e447 * (_e444 * _e445));
}
let _e450 = (*s_6).v;
let _e453 = (*s_6).n;
mirror_1 = reflect(-(_e450), _e453);
let _e455 = position;
param_146 = _e455.xyz;
let _e457 = halfWidth_1;
param_147 = _e457;
let _e458 = halfHeight_1;
param_148 = _e458;
let _e459 = v_world_position_1;
param_149 = _e459;
let _e460 = mirror_1;
param_150 = _e460;
let _e461 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_146), (¶m_147), (¶m_148), (¶m_149), (¶m_150));
representative = _e461;
let _e462 = representative;
let _e463 = v_world_position_1;
toPoint = (_e462 - _e463);
let _e465 = toPoint;
pointDistance = length(_e465);
let _e467 = pointDistance;
if (_e467 > 0.000001f) {
let _e469 = toPoint;
let _e470 = pointDistance;
local_37 = (_e469 / vec3(_e470));
} else {
let _e474 = (*s_6).n;
local_37 = _e474;
}
let _e475 = local_37;
light_3.l = _e475;
let _e478 = light_3.l;
let _e480 = (*s_6).v;
light_3.h = normalize((_e478 + _e480));
let _e484 = formFactor;
light_3.n_dot_l = _e484;
let _e487 = (*s_6).n;
let _e489 = light_3.h;
light_3.n_dot_h = max(dot(_e487, _e489), 0f);
let _e494 = (*s_6).v;
let _e496 = light_3.h;
light_3.v_dot_h = max(dot(_e494, _e496), 0f);
let _e500 = color_1;
let _e503 = color_1[3u];
let _e505 = radiance;
light_3.radiance = ((_e500.xyz * _e503) * _e505);
light_3.integrated = 1f;
let _e510 = (*s_6).n;
param_151 = _e510;
let _e512 = (*s_6).v;
param_152 = _e512;
let _e514 = (*s_6).roughness;
param_153 = _e514;
let _e515 = corners_2;
param_154 = _e515;
let _e516 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_151), (¶m_152), (¶m_153), (¶m_154));
light_3.ltc = _e516;
let _e518 = light_3;
return _e518;
}
let _e519 = direction;
aim = normalize(_e519.xyz);
attenuation_1 = 1f;
let _e522 = type_42;
if (_e522 < 0.5f) {
let _e524 = aim;
light_3.l = -(_e524);
} else {
let _e527 = position;
let _e529 = v_world_position_1;
toLight_1 = (_e527.xyz - _e529);
let _e531 = toLight_1;
distance_3 = length(_e531);
let _e533 = distance_3;
if (_e533 < 0.000001f) {
let _e536 = (*s_6).n;
light_3.l = _e536;
let _e539 = (*s_6).n;
light_3.h = _e539;
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 _e545 = light_3;
return _e545;
}
let _e546 = toLight_1;
let _e547 = distance_3;
light_3.l = (_e546 / vec3(_e547));
let _e551 = distance_3;
param_155 = _e551;
let _e553 = direction[3u];
param_156 = _e553;
let _e554 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_155), (¶m_156));
attenuation_1 = _e554;
let _e555 = type_42;
if (_e555 > 1.5f) {
let _e557 = aim;
let _e559 = light_3.l;
cosAngle = dot(_e557, -(_e559));
let _e562 = cosAngle;
let _e564 = cone[1u];
let _e567 = cone[0u];
let _e569 = cone[1u];
ramp = clamp(((_e562 - _e564) / (_e567 - _e569)), 0f, 1f);
let _e573 = ramp;
let _e574 = ramp;
let _e576 = attenuation_1;
attenuation_1 = (_e576 * (_e573 * _e574));
}
}
let _e579 = light_3.l;
let _e581 = (*s_6).v;
light_3.h = normalize((_e579 + _e581));
let _e586 = (*s_6).n;
let _e588 = light_3.l;
light_3.n_dot_l = max(dot(_e586, _e588), 0f);
let _e593 = (*s_6).n;
let _e595 = light_3.h;
light_3.n_dot_h = max(dot(_e593, _e595), 0f);
let _e600 = (*s_6).v;
let _e602 = light_3.h;
light_3.v_dot_h = max(dot(_e600, _e602), 0f);
let _e606 = color_1;
let _e609 = color_1[3u];
let _e611 = attenuation_1;
light_3.radiance = ((_e606.xyz * _e609) * _e611);
let _e614 = light_3;
return _e614;
}
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_38: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_157: f32;
var param_158: f32;
let _e245 = light_list_info.cluster_view_projection;
let _e246 = (*world_3);
clip_1 = (_e245 * vec4<f32>(_e246.x, _e246.y, _e246.z, 1f));
let _e252 = clip_1;
let _e255 = clip_1[3u];
ndc_1 = (_e252.xy / vec2(max(_e255, 0.000001f)));
let _e260 = light_list_info.cluster_grid;
grid = _e260.xyz;
let _e264 = light_list_info.cluster_depth[0u];
near_1 = _e264;
let _e266 = ndc_1[0u];
let _e270 = grid[0u];
let _e274 = grid[0u];
tx = clamp(floor((((_e266 * 0.5f) + 0.5f) * _e270)), 0f, (_e274 - 1f));
let _e278 = ndc_1[1u];
let _e282 = grid[1u];
let _e286 = grid[1u];
ty = clamp(floor((((_e278 * 0.5f) + 0.5f) * _e282)), 0f, (_e286 - 1f));
let _e290 = clip_1[3u];
let _e291 = near_1;
if (_e290 <= _e291) {
local_38 = 0f;
} else {
let _e294 = clip_1[3u];
let _e295 = near_1;
let _e300 = light_list_info.cluster_depth[1u];
let _e304 = grid[2u];
local_38 = clamp(floor((log((_e294 / _e295)) * _e300)), 0f, (_e304 - 1f));
}
let _e307 = local_38;
tz = _e307;
let _e308 = tx;
let _e309 = ty;
let _e311 = grid[0u];
let _e314 = tz;
let _e316 = grid[0u];
let _e319 = grid[1u];
cell_1 = ((_e308 + (_e309 * _e311)) + ((_e314 * _e316) * _e319));
let _e322 = cell_1;
row_3 = floor((_e322 / 4f));
let _e325 = cell_1;
let _e326 = row_3;
let _e331 = light_list_info.cluster_depth[2u];
let _e332 = row_3;
param_157 = (_e325 - (_e326 * 4f));
param_158 = (_e331 + _e332);
let _e334 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_157), (¶m_158));
header = _e334;
let _e336 = header[0u];
g_cluster_offset = _e336;
let _e338 = header[1u];
g_cluster_count = _e338;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_159: vec3<f32>;
let _e234 = light_list_info.list[0u];
tail = _e234;
let _e235 = Clustered_u0028_();
if _e235 {
let _e236 = v_world_position_1;
param_159 = _e236;
FindCluster_u0028_vf3_u003b((¶m_159));
let _e237 = g_cluster_count;
tail = _e237;
}
let _e240 = frag_info.frame_params[1u];
let _e244 = tail;
return (clamp(i32((_e240 + 0.5f)), 0i, 8i) + clamp(i32((_e244 + 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_4: LightSample;
var param_160: i32;
var param_161: Surface;
var visibility: f32;
var param_162: i32;
var local_39: f32;
var param_163: Surface;
var param_164: LightSample;
var param_165: i32;
var param_166: vec3<f32>;
var param_167: vec3<f32>;
var param_168: i32;
var param_169: Surface;
var param_170: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e248 = LightCount_u0028_();
count_1 = _e248;
i_9 = 0i;
loop {
let _e249 = i_9;
if (_e249 < 32i) {
let _e251 = i_9;
let _e252 = count_1;
if (_e251 >= _e252) {
break;
}
let _e254 = i_9;
param_160 = _e254;
let _e255 = (*s_7);
param_161 = _e255;
let _e256 = 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_160), (¶m_161));
light_4 = _e256;
let _e258 = light_4.n_dot_l;
if (_e258 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e260 = i_9;
param_162 = _e260;
let _e261 = LightHasShadow_u0028_i1_u003b((¶m_162));
if _e261 {
let _e262 = (*s_7);
param_163 = _e262;
let _e263 = light_4;
param_164 = _e263;
let _e264 = i_9;
param_165 = _e264;
let _e265 = 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_163), (¶m_164), (¶m_165));
let _e266 = v_world_position_1;
param_166 = _e266;
let _e268 = (*s_7).n;
param_167 = _e268;
let _e269 = i_9;
param_168 = _e269;
let _e270 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_166), (¶m_167), (¶m_168));
local_39 = (_e265 * _e270);
} else {
local_39 = 1f;
}
let _e272 = local_39;
visibility = _e272;
let _e273 = visibility;
if (_e273 <= 0f) {
continue;
}
let _e275 = (*s_7);
param_169 = _e275;
let _e276 = light_4;
param_170 = _e276;
let _e277 = 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_169), (¶m_170));
let _e279 = light_4.radiance;
let _e282 = light_4.n_dot_l;
let _e284 = visibility;
let _e286 = light_transmittance;
let _e288 = total_1;
total_1 = (_e288 + ((((_e277 * _e279) * _e282) * _e284) * _e286));
continue;
} else {
break;
}
continuing {
let _e290 = i_9;
i_9 = (_e290 + 1i);
}
}
let _e292 = total_1;
return _e292;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e231 = v_lightmap_uv_1;
let _e232 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e231);
texel_4 = _e232;
let _e233 = texel_4;
let _e236 = texel_4[3u];
return ((_e233.xyz * _e236) * 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_171: f32;
var param_172: f32;
var param_173: f32;
var param_174: vec3<f32>;
var param_175: f32;
let _e239 = (*mu_1);
param_171 = _e239;
let _e240 = (*r_4);
param_172 = _e240;
let _e241 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_171), (¶m_172));
e_1 = _e241;
let _e242 = (*rho_2);
let _e243 = e_1;
let _e245 = (*r_4);
param_173 = _e245;
let _e246 = FonAverage_u0028_f1_u003b((¶m_173));
let _e247 = (*rho_2);
param_174 = _e247;
param_175 = _e246;
let _e248 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_174), (¶m_175));
let _e249 = e_1;
return ((_e242 * _e243) + (_e248 * (1f - _e249)));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e232 = frag_info.target_origin[1u];
return _e232;
}
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_8: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e232 = v_texcoord_1;
let _e233 = MaterialLodBias_u0028_();
let _e234 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e232, _e233);
orm = _e234.xyz;
let _e237 = (*s_8).metallic;
let _e239 = orm[2u];
(*s_8).metallic = clamp((_e237 * _e239), 0f, 1f);
let _e244 = (*s_8).roughness;
let _e246 = orm[1u];
(*s_8).roughness = clamp((_e244 * _e246), 0.02f, 1f);
return;
}
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_9: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_176: vec3<f32>;
let _e233 = v_texcoord_1;
let _e234 = MaterialLodBias_u0028_();
let _e235 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e233, _e234);
param_176 = _e235.xyz;
let _e237 = SrgbToLinear_u0028_vf3_u003b((¶m_176));
emissive = _e237;
let _e238 = emissive;
let _e240 = frag_info.emissive;
let _e245 = frag_info.material2_[3u];
(*s_9).emissive = ((_e238 * _e240.xyz) * _e245);
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_10: ptr<function, Surface>) {
var occlusion: f32;
let _e232 = v_texcoord_1;
let _e233 = MaterialLodBias_u0028_();
let _e234 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e232, _e233);
occlusion = _e234.x;
let _e236 = occlusion;
let _e239 = frag_info.material2_[2u];
(*s_10).occlusion = mix(1f, _e236, clamp(_e239, 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_11: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_4: vec3<f32>;
var sampled: vec3<f32>;
let _e235 = v_texcoord_1;
let _e236 = MaterialLodBias_u0028_();
let _e237 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e235, _e236);
sampledTexel = _e237;
let _e238 = v_tangent_1;
t_2 = _e238.xyz;
let _e240 = t_2;
let _e242 = (*s_11).n;
let _e244 = (*s_11).n;
let _e245 = t_2;
t_2 = (_e240 - (_e242 * dot(_e244, _e245)));
let _e249 = t_2;
let _e250 = t_2;
if (dot(_e249, _e250) < 0.000000000001f) {
return;
}
let _e253 = t_2;
t_2 = normalize(_e253);
let _e256 = (*s_11).n;
let _e257 = t_2;
let _e260 = v_tangent_1[3u];
b_4 = (cross(_e256, _e257) * _e260);
let _e262 = gl_FrontFacing_1;
if !(_e262) {
let _e264 = t_2;
t_2 = -(_e264);
}
let _e266 = sampledTexel;
sampled = ((_e266.xyz * 2f) - vec3(1f));
let _e273 = frag_info.emissive[3u];
if (_e273 > 0.5f) {
let _e275 = sampled;
let _e277 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e275.xy, _e277.xy)), 0f));
}
let _e286 = frag_info.material2_[1u];
let _e287 = sampled;
let _e289 = (_e287.xy * _e286);
sampled[0u] = _e289.x;
sampled[1u] = _e289.y;
let _e294 = t_2;
let _e296 = sampled[0u];
let _e298 = b_4;
let _e300 = sampled[1u];
let _e304 = (*s_11).n;
let _e306 = sampled[2u];
(*s_11).n = normalize((((_e294 * _e296) + (_e298 * _e300)) + (_e304 * _e306)));
let _e312 = (*s_11).n;
let _e314 = (*s_11).v;
(*s_11).n_dot_v = max(dot(_e312, _e314), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e231 = (*texel_5);
let _e235 = irradiance_info.atlas;
let _e238 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e231 + vec2(0.5f)) * _e235.xy), 0f);
return _e238;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_7: 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_177: vec2<f32>;
var b_5: vec4<f32>;
var param_178: vec2<f32>;
var c_1: vec4<f32>;
var param_179: vec2<f32>;
var d_5: vec4<f32>;
var param_180: vec2<f32>;
let _e244 = (*uv_7);
let _e245 = (*interior);
at_1 = ((vec2(1f) + (_e244 * _e245)) - vec2(0.5f));
let _e251 = at_1;
low = floor(_e251);
let _e253 = at_1;
let _e254 = low;
f_3 = (_e253 - _e254);
let _e256 = (*corner);
let _e257 = low;
param_177 = (_e256 + _e257);
let _e259 = AtlasTexel_u0028_vf2_u003b((¶m_177));
a_6 = _e259;
let _e260 = (*corner);
let _e261 = low;
param_178 = ((_e260 + _e261) + vec2<f32>(1f, 0f));
let _e264 = AtlasTexel_u0028_vf2_u003b((¶m_178));
b_5 = _e264;
let _e265 = (*corner);
let _e266 = low;
param_179 = ((_e265 + _e266) + vec2<f32>(0f, 1f));
let _e269 = AtlasTexel_u0028_vf2_u003b((¶m_179));
c_1 = _e269;
let _e270 = (*corner);
let _e271 = low;
param_180 = ((_e270 + _e271) + vec2<f32>(1f, 1f));
let _e274 = AtlasTexel_u0028_vf2_u003b((¶m_180));
d_5 = _e274;
let _e275 = a_6;
let _e276 = b_5;
let _e278 = f_3[0u];
let _e281 = c_1;
let _e282 = d_5;
let _e284 = f_3[0u];
let _e288 = f_3[1u];
return mix(mix(_e275, _e276, vec4(_e278)), mix(_e281, _e282, vec4(_e284)), vec4(_e288));
}
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 _e235 = (*direction_1)[0u];
let _e238 = (*direction_1)[1u];
let _e242 = (*direction_1)[2u];
sum_1 = ((abs(_e235) + abs(_e238)) + abs(_e242));
let _e245 = sum_1;
if (_e245 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e247 = (*direction_1);
let _e248 = sum_1;
n_6 = (_e247 / vec3(_e248));
let _e251 = n_6;
xy = _e251.xy;
let _e254 = n_6[2u];
if (_e254 < 0f) {
let _e257 = n_6[1u];
let _e261 = n_6[0u];
let _e266 = n_6[0u];
let _e270 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e257)) * select(-1f, 1f, (_e261 >= 0f))), ((1f - abs(_e266)) * select(-1f, 1f, (_e270 >= 0f))));
}
let _e275 = xy;
return ((_e275 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_181: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_182: vec3<f32>;
var param_183: vec2<f32>;
var param_184: f32;
var param_185: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_186: vec3<f32>;
var param_187: vec2<f32>;
var param_188: f32;
var param_189: vec2<f32>;
var local_40: vec3<f32>;
let _e277 = irradiance_info.origin;
origin_2 = _e277.xyz;
let _e280 = irradiance_info.spacing;
spacing = _e280.xyz;
let _e283 = irradiance_info.counts;
counts = _e283.xyz;
let _e287 = irradiance_info.tiles[0u];
irradianceTile = _e287;
let _e290 = irradiance_info.tiles[1u];
depthTile = _e290;
let _e293 = irradiance_info.tiles[2u];
columns = _e293;
let _e296 = irradiance_info.tiles[3u];
momentsTop = _e296;
let _e297 = (*normal_1);
unit = normalize(_e297);
let _e299 = (*world_4);
let _e300 = unit;
let _e303 = irradiance_info.spacing[3u];
let _e306 = (*view_1);
let _e309 = irradiance_info.counts[3u];
biased = ((_e299 + (_e300 * _e303)) + (_e306 * _e309));
let _e312 = biased;
let _e313 = origin_2;
let _e315 = spacing;
grid_1 = ((_e312 - _e313) / _e315);
let _e317 = grid_1;
let _e319 = counts;
base = clamp(floor(_e317), vec3<f32>(0f, 0f, 0f), (_e319 - vec3(2f)));
let _e323 = grid_1;
let _e324 = base;
f_4 = clamp((_e323 - _e324), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e327 = corner_1;
if (_e327 < 8i) {
let _e329 = corner_1;
let _e332 = corner_1;
let _e337 = corner_1;
offset_3 = vec3<f32>(f32((_e329 & 1i)), f32(((_e332 >> bitcast<u32>(1i)) & 1i)), f32(((_e337 >> bitcast<u32>(2i)) & 1i)));
let _e343 = base;
let _e344 = offset_3;
cell_2 = (_e343 + _e344);
let _e347 = cell_2[2u];
let _e349 = counts[1u];
let _e352 = cell_2[1u];
let _e355 = counts[0u];
let _e358 = cell_2[0u];
probe = ((((_e347 * _e349) + _e352) * _e355) + _e358);
let _e360 = probe;
let _e361 = columns;
let _e366 = probe;
let _e367 = columns;
tile_4 = vec2<f32>((_e360 - (floor((_e360 / _e361)) * _e361)), floor((_e366 / _e367)));
let _e371 = tile_4;
let _e372 = irradianceTile;
irradianceCorner = (_e371 * (_e372 + 2f));
let _e376 = tile_4[0u];
let _e377 = depthTile;
let _e380 = momentsTop;
let _e382 = tile_4[1u];
let _e383 = depthTile;
momentCorner = vec2<f32>((_e376 * (_e377 + 2f)), (_e380 + (_e382 * (_e383 + 2f))));
let _e388 = irradianceCorner;
param_181 = (_e388 + vec2(1f));
let _e391 = AtlasTexel_u0028_vf2_u003b((¶m_181));
if (_e391.w < 0.5f) {
continue;
}
let _e394 = f_4;
let _e396 = f_4;
let _e397 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e394), _e396, _e397);
let _e400 = trilinear[0u];
let _e402 = trilinear[1u];
let _e405 = trilinear[2u];
weight_3 = max(((_e400 * _e402) * _e405), 0.001f);
let _e408 = origin_2;
let _e409 = spacing;
let _e410 = cell_2;
probePosition = (_e408 + (_e409 * _e410));
let _e413 = probePosition;
let _e414 = biased;
toProbe = (_e413 - _e414);
let _e416 = toProbe;
distance_4 = length(_e416);
let _e418 = distance_4;
if (_e418 > 0.000001f) {
let _e420 = toProbe;
let _e421 = distance_4;
direction_2 = (_e420 / vec3(_e421));
let _e424 = unit;
let _e425 = probePosition;
let _e426 = (*world_4);
facing = ((dot(_e424, normalize((_e425 - _e426))) * 0.5f) + 0.5f);
let _e432 = facing;
let _e433 = facing;
probeWeight = ((_e432 * _e433) + 0.2f);
let _e436 = direction_2;
param_182 = -(_e436);
let _e438 = ProbeOctahedral_u0028_vf3_u003b((¶m_182));
let _e439 = momentCorner;
param_183 = _e439;
let _e440 = depthTile;
param_184 = _e440;
param_185 = _e438;
let _e441 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_183), (¶m_184), (¶m_185));
moments_3 = _e441.xy;
chebyshev = 1f;
let _e443 = distance_4;
let _e445 = moments_3[0u];
if (_e443 > _e445) {
let _e448 = moments_3[1u];
let _e450 = moments_3[0u];
let _e452 = moments_3[0u];
variance_1 = max((_e448 - (_e450 * _e452)), 0.000001f);
let _e456 = distance_4;
let _e458 = moments_3[0u];
difference = (_e456 - _e458);
let _e460 = variance_1;
let _e461 = variance_1;
let _e462 = difference;
let _e463 = difference;
chebyshev = (_e460 / (_e461 + (_e462 * _e463)));
let _e467 = chebyshev;
let _e468 = chebyshev;
let _e470 = chebyshev;
chebyshev = ((_e467 * _e468) * _e470);
}
let _e472 = probeWeight;
let _e473 = chebyshev;
probeWeight = max((_e472 * max(_e473, 0.05f)), 0.000001f);
let _e477 = probeWeight;
if (_e477 < 0.2f) {
let _e479 = probeWeight;
let _e480 = probeWeight;
let _e483 = probeWeight;
probeWeight = (_e483 * ((_e479 * _e480) * 25f));
}
let _e485 = probeWeight;
let _e486 = weight_3;
weight_3 = (_e486 * _e485);
}
let _e488 = unit;
param_186 = _e488;
let _e489 = ProbeOctahedral_u0028_vf3_u003b((¶m_186));
let _e490 = irradianceCorner;
param_187 = _e490;
let _e491 = irradianceTile;
param_188 = _e491;
param_189 = _e489;
let _e492 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_187), (¶m_188), (¶m_189));
let _e494 = weight_3;
let _e496 = total_2;
total_2 = (_e496 + (_e492.xyz * _e494));
let _e498 = weight_3;
let _e499 = weights;
weights = (_e499 + _e498);
continue;
} else {
break;
}
continuing {
let _e501 = corner_1;
corner_1 = (_e501 + 1i);
}
}
let _e503 = weights;
if (_e503 > 0f) {
let _e505 = total_2;
let _e506 = weights;
local_40 = (_e505 / vec3(_e506));
} else {
local_40 = vec3<f32>(0f, 0f, 0f);
}
let _e509 = local_40;
return _e509;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e232 = irradiance_info.origin[3u];
return (_e232 > 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_12: ptr<function, Surface>) {
var param_190: vec3<f32>;
var param_191: vec3<f32>;
var param_192: vec3<f32>;
var param_193: Surface;
var param_194: Surface;
var param_195: Surface;
let _e237 = IrradianceEnabled_u0028_();
if _e237 {
let _e238 = v_world_position_1;
param_190 = _e238;
let _e240 = (*s_12).n;
param_191 = _e240;
let _e242 = (*s_12).v;
param_192 = _e242;
let _e243 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_190), (¶m_191), (¶m_192));
let _e246 = frag_info.material[2u];
(*s_12).ambient = (_e243 * _e246);
}
let _e249 = (*s_12);
param_193 = _e249;
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_193));
let _e250 = param_193;
(*s_12) = _e250;
let _e251 = (*s_12);
param_194 = _e251;
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_194));
let _e252 = param_194;
(*s_12) = _e252;
let _e253 = (*s_12);
param_195 = _e253;
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_195));
let _e254 = param_195;
(*s_12) = _e254;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_41: vec3<f32>;
let _e231 = Orthographic_u0028_();
if _e231 {
let _e233 = fog_info.forward;
local_41 = -(_e233.xyz);
} else {
let _e237 = fog_info.eye;
let _e239 = v_world_position_1;
local_41 = normalize((_e237.xyz - _e239));
}
let _e242 = local_41;
return _e242;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_13: Surface;
var param_196: vec3<f32>;
var param_197: vec3<f32>;
var cutoff: f32;
var edge: f32;
let _e236 = v_texcoord_1;
let _e237 = MaterialLodBias_u0028_();
let _e238 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e236, _e237);
texel_6 = _e238;
let _e239 = texel_6;
param_196 = _e239.xyz;
let _e241 = SrgbToLinear_u0028_vf3_u003b((¶m_196));
let _e243 = frag_info.base_color;
param_197 = _e243.xyz;
let _e245 = SrgbToLinear_u0028_vf3_u003b((¶m_197));
let _e247 = v_color_1;
s_13.albedo = ((_e241 * _e245) * _e247.xyz);
let _e252 = texel_6[3u];
let _e255 = frag_info.base_color[3u];
let _e258 = v_color_1[3u];
s_13.alpha = ((_e252 * _e255) * _e258);
let _e262 = s_13.albedo;
g_albedo = _e262;
let _e265 = frag_info.material2_[0u];
cutoff = _e265;
let _e266 = cutoff;
if (_e266 > 1f) {
let _e268 = cutoff;
edge = (_e268 - 1f);
let _e271 = s_13.alpha;
let _e272 = edge;
let _e275 = s_13.alpha;
let _e276 = fwidth(_e275);
s_13.alpha = clamp((((_e271 - _e272) / max(_e276, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e282 = cutoff;
if (_e282 >= 0f) {
s_13.alpha = 1f;
}
}
let _e285 = cutoff;
let _e287 = cutoff;
g_premultiply = ((_e285 < 0f) && (_e287 > -0.75f));
let _e290 = v_normal_1;
s_13.n = normalize(_e290);
let _e293 = gl_FrontFacing_1;
if !(_e293) {
let _e296 = s_13.n;
s_13.n = -(_e296);
}
let _e299 = TowardsEye_u0028_();
s_13.v = _e299;
let _e302 = s_13.n;
let _e304 = s_13.v;
s_13.n_dot_v = max(dot(_e302, _e304), 0.0001f);
let _e310 = frag_info.material[0u];
s_13.metallic = clamp(_e310, 0f, 1f);
let _e315 = frag_info.material[1u];
s_13.roughness = clamp(_e315, 0.02f, 1f);
let _e319 = frag_info.ambient_ground;
let _e322 = frag_info.ambient_sky;
let _e326 = s_13.n[1u];
let _e333 = frag_info.material[2u];
s_13.ambient = (mix(_e319.xyz, _e322.xyz, vec3(((_e326 * 0.5f) + 0.5f))) * _e333);
let _e338 = frag_info.frame_params[0u];
s_13.exposure = max(_e338, 0f);
s_13.occlusion = 1f;
s_13.emissive = vec3<f32>(0f, 0f, 0f);
let _e343 = s_13;
return _e343;
}
fn main_1() {
var s_14: Surface;
var param_198: Surface;
var param_199: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_200: vec3<f32>;
var param_201: f32;
var param_202: 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_203: f32;
var param_204: f32;
var single_1: vec3<f32>;
var specular_1: vec3<f32>;
var missed: f32;
var average_2: vec3<f32>;
var multiple: vec3<f32>;
var lit_3: vec3<f32>;
var param_205: Surface;
var param_206: Surface;
var param_207: vec3<f32>;
var param_208: vec3<f32>;
var param_209: f32;
var param_210: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e259 = ReadSurface_u0028_();
s_14 = _e259;
let _e260 = s_14;
param_198 = _e260;
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_198));
let _e261 = param_198;
s_14 = _e261;
let _e262 = s_14;
param_199 = _e262;
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_199));
let _e263 = param_199;
s_14 = _e263;
let _e265 = s_14.metallic;
metallic = clamp(_e265, 0f, 1f);
let _e268 = s_14.albedo;
let _e269 = metallic;
diffuseColor_1 = (_e268 * (1f - _e269));
let _e272 = EonDiffuse_u0028_();
if _e272 {
let _e273 = diffuseColor_1;
param_200 = _e273;
let _e275 = s_14.roughness;
param_201 = _e275;
let _e277 = s_14.n_dot_v;
param_202 = _e277;
let _e278 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_200), (¶m_201), (¶m_202));
diffuseColor_1 = _e278;
}
let _e279 = diffuseColor_1;
let _e281 = s_14.ambient;
let _e284 = s_14.occlusion;
ambient = ((_e279 * _e281) * _e284);
let _e288 = frag_info.frame_params[3u];
levels = _e288;
let _e289 = levels;
if (_e289 > 0f) {
let _e292 = s_14.albedo;
let _e293 = metallic;
f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e292, vec3(_e293));
let _e297 = s_14.v;
let _e300 = s_14.n;
reflected = reflect(-(_e297), _e300);
let _e303 = s_14.n;
let _e304 = levels;
let _e305 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e303, _e304);
irradiance = _e305.xyz;
let _e307 = reflected;
let _e309 = s_14.roughness;
let _e310 = levels;
let _e312 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e307, (_e309 * _e310));
prefiltered = _e312.xyz;
let _e315 = s_14.roughness;
param_203 = _e315;
let _e317 = s_14.n_dot_v;
param_204 = _e317;
let _e318 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_203), (¶m_204));
ab_1 = _e318;
let _e319 = f0_3;
let _e321 = ab_1[0u];
let _e324 = ab_1[1u];
single_1 = ((_e319 * _e321) + vec3(_e324));
let _e327 = prefiltered;
let _e328 = single_1;
specular_1 = (_e327 * _e328);
let _e330 = EnergyCompensation_u0028_();
if _e330 {
let _e332 = ab_1[0u];
let _e334 = ab_1[1u];
missed = (1f - (_e332 + _e334));
let _e337 = f0_3;
let _e338 = f0_3;
average_2 = (_e337 + ((vec3<f32>(1f, 1f, 1f) - _e338) / vec3(21f)));
let _e343 = single_1;
let _e344 = average_2;
let _e346 = missed;
let _e347 = average_2;
multiple = ((_e343 * _e344) / (vec3<f32>(1f, 1f, 1f) - (_e347 * _e346)));
let _e351 = multiple;
let _e352 = missed;
let _e354 = irradiance;
let _e356 = specular_1;
specular_1 = (_e356 + ((_e351 * _e352) * _e354));
}
let _e358 = diffuseColor_1;
let _e359 = irradiance;
let _e361 = specular_1;
let _e365 = frag_info.material[2u];
let _e368 = s_14.occlusion;
ambient = ((((_e358 * _e359) + _e361) * _e365) * _e368);
}
let _e370 = diffuseColor_1;
let _e371 = SampleLightmap_u0028_();
let _e374 = s_14.occlusion;
let _e376 = ambient;
ambient = (_e376 + ((_e370 * _e371) * _e374));
let _e378 = s_14;
param_205 = _e378;
let _e379 = 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_205));
let _e381 = s_14.occlusion;
let _e383 = ambient;
let _e386 = s_14.emissive;
lit_3 = (((_e379 * _e381) + _e383) + _e386);
let _e388 = s_14;
param_206 = _e388;
let _e389 = lit_3;
param_207 = _e389;
let _e390 = WriteDebugView_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_vf3_u003b((¶m_206), (¶m_207));
if _e390 {
return;
}
let _e391 = lit_3;
param_208 = _e391;
let _e393 = s_14.alpha;
param_209 = _e393;
let _e395 = s_14.roughness;
param_210 = _e395;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_208), (¶m_209), (¶m_210));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
'PbrLayeredOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<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> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e297 = v_world_position_1;
let _e299 = fog_info.eye;
let _e303 = fog_info.forward;
return dot((_e297 - _e299.xyz), _e303.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e302 = ViewDepth_u0028_();
z = abs(_e302);
let _e304 = z;
near = (_e304 / 5f);
let _e306 = z;
far = (_e306 / 200f);
let _e308 = far;
let _e309 = far;
let _e311 = far;
far3_ = ((_e308 * _e309) * _e311);
let _e313 = (*alpha);
let _e314 = near;
let _e315 = near;
let _e318 = far3_;
let _e319 = far3_;
return (_e313 * clamp((10f / ((0.00001f + (_e314 * _e315)) + (_e318 * _e319))), 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 _e306 = fog_info.forward[3u];
mode = _e306;
let _e307 = mode;
if (_e307 > 0.5f) {
let _e310 = frag_color[3u];
alpha_1 = _e310;
let _e311 = alpha_1;
param = _e311;
let _e312 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e312;
let _e313 = frag_color;
let _e315 = weight;
let _e316 = (_e313.xyz * _e315);
let _e317 = alpha_1;
let _e318 = weight;
accumulate = vec4<f32>(_e316.x, _e316.y, _e316.z, (_e317 * _e318));
let _e324 = mode;
let _e326 = mode;
revealage = ((_e324 > 1.5f) && (_e326 < 2.5f));
let _e329 = revealage;
if _e329 {
let _e330 = alpha_1;
local = vec4(_e330);
} else {
let _e332 = accumulate;
local = _e332;
}
let _e333 = local;
frag_color = _e333;
let _e334 = mode;
if (_e334 > 2.5f) {
let _e336 = alpha_1;
frag_surface = vec4(_e336);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e300 = (*n)[0u];
let _e303 = (*n)[1u];
let _e307 = (*n)[2u];
let _e310 = (*n);
(*n) = (_e310 / vec3(((abs(_e300) + abs(_e303)) + abs(_e307))));
let _e313 = (*n);
e = _e313.xy;
let _e316 = (*n)[2u];
if (_e316 < 0f) {
let _e318 = (*n);
let _e324 = (*n)[0u];
let _e328 = (*n)[1u];
e = ((vec2(1f) - abs(_e318.yx)) * vec2<f32>(select(-1f, 1f, (_e324 >= 0f)), select(-1f, 1f, (_e328 >= 0f))));
}
let _e333 = e;
return ((_e333 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e298 = (*linear);
let _e300 = (*linear);
let _e304 = (*linear);
return mix((_e298 * 12.92f), ((pow(_e300, 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), _e304));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e301 = g_albedo;
param_1 = clamp(_e301, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e303 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e303.x, _e303.y, _e303.z, 1f);
let _e308 = g_debug_surface_on;
if _e308 {
let _e309 = g_debug_surface;
let _e310 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e309.x, _e309.y, _e309.z, _e310);
return;
}
let _e315 = v_normal_1;
geometric = normalize(_e315);
let _e317 = gl_FrontFacing_1;
if !(_e317) {
let _e319 = geometric;
geometric = -(_e319);
}
let _e321 = geometric;
param_2 = _e321;
let _e322 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e323 = (*roughness);
let _e325 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e322.x, _e322.y, clamp(_e323, 0f, 1f), _e325);
return;
}
fn Orthographic_u0028_() -> bool {
let _e299 = fog_info.projection[0u];
return (_e299 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e298 = Orthographic_u0028_();
if _e298 {
let _e299 = ViewDepth_u0028_();
local_1 = max(_e299, 0f);
} else {
let _e301 = v_world_position_1;
let _e303 = fog_info.eye;
local_1 = distance(_e301, _e303.xyz);
}
let _e306 = local_1;
return _e306;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e305 = fog_info.fog[3u];
density = _e305;
let _e306 = density;
if (_e306 <= 0f) {
let _e308 = (*color);
return _e308;
}
let _e309 = EyeDistance_u0028_();
d = _e309;
let _e312 = fog_info.eye[3u];
falloff = _e312;
let _e313 = falloff;
if (_e313 > 0f) {
let _e315 = falloff;
let _e317 = v_world_position_1[1u];
let _e320 = fog_info.eye[1u];
k = (_e315 * (_e317 - _e320));
let _e323 = k;
if (abs(_e323) > 0.001f) {
let _e326 = k;
let _e330 = k;
local_2 = ((1f - exp(-(_e326))) / _e330);
} else {
let _e332 = k;
local_2 = (1f - (0.5f * _e332));
}
let _e335 = local_2;
let _e336 = density;
density = (_e336 * _e335);
}
let _e339 = fog_info.fog;
let _e341 = (*color);
let _e342 = density;
let _e344 = d;
return mix(_e339.xyz, _e341, vec3(clamp(exp((-(_e342) * _e344)), 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 _e303 = g_premultiply;
let _e304 = (*alpha_2);
weight_1 = select(1f, _e304, _e303);
let _e306 = (*linearColor);
param_3 = _e306;
let _e307 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e308 = weight_1;
let _e309 = (_e307 * _e308);
let _e310 = (*alpha_2);
let _e311 = g_pass_through;
frag_color = vec4<f32>(_e309.x, _e309.y, _e309.z, (_e310 * (1f - _e311)));
let _e318 = (*roughness_1);
param_4 = _e318;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e298 = (*srgb);
let _e301 = (*srgb);
let _e306 = (*srgb);
return mix((_e298 / vec3(12.92f)), pow(((_e301 + 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), _e306));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e300 = (*key);
hue = fract(((_e300 * 0.618034f) + 0.13f));
let _e304 = hue;
k_1 = clamp((abs(((fract((vec3(_e304) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e317 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e317, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_3011_: bool;
let _e298 = (*c);
let _e299 = (*c);
let _e301 = any((_e298 != _e299));
phi_3011_ = _e301;
if !(_e301) {
let _e303 = (*c);
phi_3011_ = any((abs(_e303) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e308 = phi_3011_;
return _e308;
}
fn MapUv_u0028_i1_u003b(slot: ptr<function, i32>) -> vec2<f32> {
var uvw: vec3<f32>;
let _e299 = v_texcoord_1;
uvw = vec3<f32>(_e299.x, _e299.y, 1f);
let _e303 = (*slot);
let _e307 = layer_info.uv_transform[(_e303 * 2i)];
let _e309 = uvw;
let _e311 = (*slot);
let _e316 = layer_info.uv_transform[((_e311 * 2i) + 1i)];
let _e318 = uvw;
return vec2<f32>(dot(_e307.xyz, _e309), dot(_e316.xyz, _e318));
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var param_7: i32;
var grey: f32;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var param_10: i32;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_11: vec3<f32>;
var key_1: f32;
var param_12: f32;
var srgb_1: vec3<f32>;
var param_13: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_14: vec3<f32>;
var param_15: f32;
var phi_3101_: bool;
var phi_3371_: bool;
let _e342 = gl_FragCoord_1[0u];
let _e345 = frag_info.debug_view[1u];
if (_e342 < _e345) {
let _e349 = frag_info.debug_view[2u];
local_3 = _e349;
} else {
let _e352 = frag_info.debug_view[0u];
local_3 = _e352;
}
let _e353 = local_3;
view = _e353;
let _e354 = view;
if (_e354 < 0.5f) {
return false;
}
let _e356 = view;
code = i32((_e356 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e359 = v_normal_1;
geometric_n = normalize(_e359);
let _e361 = v_tangent_1;
let _e363 = geometric_n;
let _e364 = geometric_n;
let _e365 = v_tangent_1;
tangent = (_e361.xyz - (_e363 * dot(_e364, _e365.xyz)));
let _e370 = tangent;
let _e371 = tangent;
let _e373 = (dot(_e370, _e371) > 0.000000000001f);
phi_3101_ = _e373;
if _e373 {
let _e375 = v_tangent_1[3u];
phi_3101_ = (abs((abs(_e375) - 1f)) < 0.01f);
}
let _e381 = phi_3101_;
tangent_usable = _e381;
let _e384 = frag_info.debug_view[3u];
identity = _e384;
let _e385 = identity;
identity_object = floor((_e385 / 8192f));
let _e388 = identity;
let _e389 = identity_object;
identity_rest = (_e388 - (_e389 * 8192f));
let _e392 = identity_rest;
identity_material = floor((_e392 / 2f));
let _e395 = identity_rest;
let _e396 = identity_material;
normal_mapped = ((_e395 - (_e396 * 2f)) > 0.5f);
let _e400 = code;
if (_e400 == 1i) {
let _e403 = (*s).albedo;
param_5 = clamp(_e403, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e405 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e405;
} else {
let _e406 = code;
if (_e406 == 2i) {
let _e409 = (*s).n;
shown = ((_e409 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e412 = code;
if (_e412 == 3i) {
let _e415 = (*s).roughness;
shown = vec3(clamp(_e415, 0f, 1f));
} else {
let _e418 = code;
if (_e418 == 4i) {
let _e421 = (*s).metallic;
shown = vec3(clamp(_e421, 0f, 1f));
} else {
let _e424 = code;
if (_e424 == 5i) {
let _e427 = (*s).occlusion;
shown = vec3(clamp(_e427, 0f, 1f));
} else {
let _e430 = code;
if (_e430 == 6i) {
let _e433 = (*s).emissive;
param_6 = clamp(_e433, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e435 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e435;
} else {
let _e436 = code;
if (_e436 == 7i) {
param_7 = 0i;
let _e438 = MapUv_u0028_i1_u003b((¶m_7));
let _e439 = fract(_e438);
shown = vec3<f32>(_e439.x, _e439.y, 0f);
} else {
let _e443 = code;
if (_e443 == 8i) {
let _e445 = (*lit);
param_8 = clamp(_e445, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e447 = LinearToSrgb_u0028_vf3_u003b((¶m_8));
grey = dot(_e447, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e449 = (*lit);
param_9 = _e449;
let _e450 = NonFinite_u0028_vf3_u003b((¶m_9));
if _e450 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e451 = grey;
local_4 = vec3((_e451 * 0.5f));
}
let _e454 = local_4;
shown = _e454;
} else {
let _e455 = code;
if (_e455 == 9i) {
let _e457 = tangent_usable;
if _e457 {
let _e458 = tangent;
local_5 = ((normalize(_e458) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e462 = local_5;
shown = _e462;
} else {
let _e463 = code;
if (_e463 == 10i) {
param_10 = 0i;
let _e465 = MapUv_u0028_i1_u003b((¶m_10));
uv = _e465;
let _e466 = uv;
cell = floor((_e466 * 8f));
let _e470 = cell[0u];
let _e472 = cell[1u];
odd = (fract(((_e470 + _e472) * 0.5f)) * 2f);
let _e477 = uv;
within = fract(_e477);
let _e479 = odd;
let _e483 = within[0u];
let _e487 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e479)) * vec3<f32>((0.55f + (0.45f * _e483)), (0.55f + (0.45f * _e487)), 0.85f));
} else {
let _e492 = code;
if (_e492 == 11i) {
let _e494 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e494));
} else {
let _e497 = code;
if (_e497 == 12i) {
let _e499 = v_color_1;
param_11 = clamp(_e499.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e502 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
shown = _e502;
} else {
let _e503 = code;
let _e505 = code;
if ((_e503 == 13i) || (_e505 == 14i)) {
let _e508 = code;
let _e510 = identity_object;
let _e511 = identity_material;
key_1 = select(_e511, _e510, (_e508 == 13i));
let _e513 = key_1;
param_12 = _e513;
let _e514 = DebugIdentityColour_u0028_f1_u003b((¶m_12));
let _e516 = (*s).n_dot_v;
shown = (_e514 * (0.55f + (0.45f * _e516)));
} else {
let _e520 = code;
if (_e520 == 15i) {
let _e523 = (*s).albedo;
param_13 = clamp(_e523, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e525 = LinearToSrgb_u0028_vf3_u003b((¶m_13));
srgb_1 = _e525;
let _e526 = srgb_1;
luma = dot(_e526, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e529 = (*s).metallic;
metal = (_e529 > 0.5f);
let _e531 = metal;
let _e533 = luma;
if (!(_e531) && (_e533 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e536 = metal;
let _e537 = !(_e536);
phi_3371_ = _e537;
if _e537 {
let _e539 = srgb_1[0u];
let _e541 = srgb_1[1u];
let _e543 = srgb_1[2u];
phi_3371_ = (max(_e539, max(_e541, _e543)) > 0.9411765f);
}
let _e548 = phi_3371_;
if _e548 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e549 = metal;
let _e550 = luma;
if (_e549 && (_e550 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e553 = luma;
local_8 = vec3(_e553);
}
let _e555 = local_8;
local_7 = _e555;
}
let _e556 = local_7;
local_6 = _e556;
}
let _e557 = local_6;
shown = _e557;
} else {
let _e558 = code;
if (_e558 == 16i) {
let _e561 = (*s).metallic;
m = _e561;
let _e562 = m;
let _e564 = m;
if ((_e562 > 0.05f) && (_e564 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e567 = m;
local_9 = vec3(select(0.15f, 1f, (_e567 > 0.5f)));
}
let _e571 = local_9;
shown = _e571;
} else {
let _e572 = code;
if (_e572 == 17i) {
let _e574 = normal_mapped;
if !(_e574) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e576 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e576));
}
let _e579 = local_10;
shown = _e579;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e580 = g_premultiply;
if _e580 {
let _e582 = (*s).alpha;
local_11 = _e582;
} else {
local_11 = 1f;
}
let _e583 = local_11;
weight_2 = _e583;
let _e584 = shown;
param_14 = _e584;
let _e585 = SrgbToLinear_u0028_vf3_u003b((¶m_14));
let _e586 = weight_2;
let _e587 = (_e585 * _e586);
let _e589 = (*s).alpha;
frag_color = vec4<f32>(_e587.x, _e587.y, _e587.z, _e589);
let _e595 = (*s).roughness;
param_15 = _e595;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_15));
WriteWeightedBlended_u0028_();
return true;
}
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 _e303 = (*alpha_3);
let _e304 = (*alpha_3);
a2_ = (_e303 * _e304);
let _e306 = (*n_dot_l);
let _e307 = (*n_dot_v);
let _e308 = (*n_dot_v);
let _e310 = a2_;
let _e313 = a2_;
lambda_v = (_e306 * sqrt((((_e307 * _e308) * (1f - _e310)) + _e313)));
let _e317 = (*n_dot_v);
let _e318 = (*n_dot_l);
let _e319 = (*n_dot_l);
let _e321 = a2_;
let _e324 = a2_;
lambda_l = (_e317 * sqrt((((_e318 * _e319) * (1f - _e321)) + _e324)));
let _e328 = lambda_v;
let _e329 = lambda_l;
return (0.5f / max((_e328 + _e329), 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_2: f32;
let _e301 = (*n_dot_h);
let _e302 = (*alpha_4);
a = (_e301 * _e302);
let _e304 = (*alpha_4);
let _e305 = (*n_dot_h);
let _e306 = (*n_dot_h);
let _e309 = a;
let _e310 = a;
k_2 = (_e304 / max(((1f - (_e305 * _e306)) + (_e309 * _e310)), 0.0000001f));
let _e315 = k_2;
let _e316 = k_2;
return ((_e315 * _e316) * 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_12: vec3<f32>;
let _e303 = (*a_1);
let _e304 = (*b);
axis = cross(_e303, _e304);
let _e306 = axis;
len = length(_e306);
let _e308 = (*a_1);
let _e309 = (*b);
angle = acos(clamp(dot(_e308, _e309), -1f, 1f));
let _e313 = len;
if (_e313 > 0.000001f) {
let _e315 = axis;
let _e316 = angle;
let _e317 = len;
local_12 = (_e315 * (_e316 / (_e317 * 6.2831855f)));
} else {
local_12 = vec3<f32>(0f, 0f, 0f);
}
let _e321 = local_12;
return _e321;
}
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 _e301 = (*x);
let _e302 = (*y);
inTable = ((vec2<f32>(_e301, _e302) * 0.984375f) + vec2(0.0078125f));
let _e308 = inTable[0u];
let _e310 = inTable[1u];
let _e311 = (*table);
return vec2<f32>(_e308, ((_e310 + _e311) * 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_1: vec2<f32>;
var inverse: vec4<f32>;
var param_16: f32;
var param_17: f32;
var param_18: f32;
var fit: vec4<f32>;
var param_19: f32;
var param_20: f32;
var param_21: f32;
var along: vec3<f32>;
var alongLength: f32;
var t1_: vec3<f32>;
var local_13: 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_22: vec3<f32>;
var param_23: vec3<f32>;
var param_24: vec3<f32>;
var param_25: vec3<f32>;
var param_26: vec3<f32>;
var param_27: vec3<f32>;
var param_28: vec3<f32>;
var param_29: vec3<f32>;
var len_1: f32;
var z_1: f32;
var local_14: f32;
var sphere: f32;
var param_30: f32;
var param_31: f32;
var param_32: f32;
let _e335 = (*roughness_2);
let _e337 = (*n_1);
let _e338 = (*v);
uv_1 = vec2<f32>(clamp(_e335, 0f, 1f), sqrt(clamp((1f - dot(_e337, _e338)), 0f, 1f)));
let _e345 = uv_1[0u];
param_16 = _e345;
let _e347 = uv_1[1u];
param_17 = _e347;
param_18 = 0f;
let _e348 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18));
let _e349 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e348, 0f);
inverse = _e349;
let _e351 = uv_1[0u];
param_19 = _e351;
let _e353 = uv_1[1u];
param_20 = _e353;
param_21 = 1f;
let _e354 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21));
let _e355 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e354, 0f);
fit = _e355;
let _e356 = (*v);
let _e357 = (*n_1);
let _e358 = (*v);
let _e359 = (*n_1);
along = (_e356 - (_e357 * dot(_e358, _e359)));
let _e363 = along;
alongLength = length(_e363);
let _e365 = alongLength;
if (_e365 > 0.00001f) {
let _e367 = along;
let _e368 = alongLength;
local_13 = (_e367 / vec3(_e368));
} else {
let _e371 = (*n_1);
let _e373 = (*n_1)[2u];
local_13 = normalize(cross(_e371, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e373) < 0.999f)))));
}
let _e380 = local_13;
t1_ = _e380;
let _e381 = (*n_1);
let _e382 = t1_;
t2_ = cross(_e381, _e382);
let _e385 = inverse[0u];
let _e387 = inverse[1u];
let _e388 = vec3<f32>(_e385, 0f, _e387);
let _e390 = inverse[2u];
let _e392 = inverse[3u];
let _e393 = vec3<f32>(_e390, 0f, _e392);
minv = mat3x3<f32>(vec3<f32>(_e388.x, _e388.y, _e388.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e393.x, _e393.y, _e393.z));
i = 0i;
loop {
let _e407 = i;
if (_e407 < 4i) {
let _e409 = i;
let _e411 = (*corners)[_e409];
p = _e411;
let _e412 = i;
let _e413 = minv;
let _e414 = p;
let _e415 = t1_;
let _e417 = p;
let _e418 = t2_;
let _e420 = p;
let _e421 = (*n_1);
l[_e412] = normalize((_e413 * vec3<f32>(dot(_e414, _e415), dot(_e417, _e418), dot(_e420, _e421))));
continue;
} else {
break;
}
continuing {
let _e427 = i;
i = (_e427 + 1i);
}
}
let _e430 = l[0i];
param_22 = _e430;
let _e432 = l[1i];
param_23 = _e432;
let _e433 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_22), (¶m_23));
let _e435 = l[1i];
param_24 = _e435;
let _e437 = l[2i];
param_25 = _e437;
let _e438 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_24), (¶m_25));
let _e441 = l[2i];
param_26 = _e441;
let _e443 = l[3i];
param_27 = _e443;
let _e444 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_26), (¶m_27));
let _e447 = l[3i];
param_28 = _e447;
let _e449 = l[0i];
param_29 = _e449;
let _e450 = LtcEdge_u0028_vf3_u003b_vf3_u003b((¶m_28), (¶m_29));
f = -((((_e433 + _e438) + _e444) + _e450));
let _e453 = f;
len_1 = length(_e453);
let _e455 = len_1;
if (_e455 > 0.000000001f) {
let _e458 = f[2u];
let _e459 = len_1;
local_14 = (_e458 / _e459);
} else {
local_14 = 0f;
}
let _e461 = local_14;
z_1 = _e461;
let _e462 = z_1;
let _e465 = len_1;
param_30 = ((_e462 * 0.5f) + 0.5f);
param_31 = clamp(_e465, 0f, 1f);
param_32 = 1f;
let _e467 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_30), (¶m_31), (¶m_32));
let _e468 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e467, 0f);
sphere = _e468.w;
let _e470 = len_1;
let _e471 = sphere;
let _e475 = fit[0u];
let _e477 = fit[1u];
return vec3<f32>(max((_e470 * _e471), 0f), _e475, _e477);
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
var ltc: vec3<f32>;
var param_33: vec3<f32>;
var param_34: vec3<f32>;
var param_35: f32;
var param_36: 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_37: f32;
var param_38: f32;
var vis: f32;
var param_39: f32;
var param_40: f32;
var param_41: f32;
var f_1: f32;
let _e317 = (*light).integrated;
if (_e317 > 0.5f) {
let _e319 = g_coat_n;
param_33 = _e319;
let _e321 = (*s_1).v;
param_34 = _e321;
let _e322 = g_coat_roughness;
param_35 = _e322;
let _e323 = g_rect_corners;
param_36 = _e323;
let _e324 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
ltc = _e324;
let _e326 = ltc[0u];
let _e328 = ltc[1u];
let _e331 = ltc[2u];
let _e337 = frag_info.material[3u];
let _e340 = (*light).n_dot_l;
return (((_e326 * ((0.04f * _e328) + (0.96f * _e331))) * _e337) / max(_e340, 0.000001f));
}
let _e343 = g_coat_roughness;
lobe = max(_e343, 0.045f);
let _e345 = lobe;
let _e346 = lobe;
alpha_5 = (_e345 * _e346);
let _e348 = g_coat_n;
let _e350 = (*light).l;
n_dot_l_1 = max(dot(_e348, _e350), 0f);
let _e353 = g_coat_n;
let _e355 = (*light).h;
n_dot_h_1 = max(dot(_e353, _e355), 0f);
let _e358 = n_dot_h_1;
param_37 = _e358;
let _e359 = alpha_5;
param_38 = _e359;
let _e360 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_37), (¶m_38));
d_1 = _e360;
let _e361 = g_coat_n_dot_v;
param_39 = _e361;
let _e362 = n_dot_l_1;
param_40 = _e362;
let _e363 = alpha_5;
param_41 = _e363;
let _e364 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_39), (¶m_40), (¶m_41));
vis = _e364;
let _e366 = (*light).v_dot_h;
f_1 = (0.04f + (0.96f * pow((1f - _e366), 5f)));
let _e371 = d_1;
let _e372 = vis;
let _e374 = f_1;
let _e378 = frag_info.material[3u];
let _e380 = n_dot_l_1;
let _e383 = (*light).n_dot_l;
return (((((_e371 * _e372) * _e374) * _e378) * _e380) / max(_e383, 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 _e299 = (*n_dot_l_2);
let _e300 = (*n_dot_v_1);
let _e302 = (*n_dot_l_2);
let _e303 = (*n_dot_v_1);
return (1f / (4f * ((_e299 + _e300) - (_e302 * _e303))));
}
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 _e301 = (*roughness_3);
let _e302 = (*roughness_3);
inv_alpha = (1f / (_e301 * _e302));
let _e305 = (*n_dot_h_2);
let _e306 = (*n_dot_h_2);
sin2h = max((1f - (_e305 * _e306)), 0.0078125f);
let _e310 = inv_alpha;
let _e312 = sin2h;
let _e313 = inv_alpha;
return (((2f + _e310) * pow(_e312, (_e313 * 0.5f))) / 6.2831855f);
}
fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
var m_1: f32;
var g: f32;
let _e301 = (*mu);
m_1 = (1f - _e301);
let _e303 = m_1;
let _e304 = m_1;
let _e305 = m_1;
let _e306 = m_1;
g = (_e303 * (0.05710853f + (_e304 * (0.49188188f + (_e305 * (-0.33218145f + (_e306 * 0.071443f)))))));
let _e314 = (*r);
let _e315 = g;
let _e318 = (*r);
return ((1f + (_e314 * _e315)) / (1f + (0.2877934f * _e318)));
}
fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
let _e299 = (*rho);
let _e300 = (*rho);
let _e302 = (*average);
let _e304 = (*rho);
let _e305 = (*average);
return (((_e299 * _e300) * _e302) / (vec3<f32>(1f, 1f, 1f) - (_e304 * (1f - _e305))));
}
fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
let _e298 = (*r_1);
let _e301 = (*r_1);
return ((1f + (0.07248821f * _e298)) / (1f + (0.2877934f * _e301)));
}
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_2: f32;
var s_over_t: f32;
var local_15: f32;
var af: f32;
var single: vec3<f32>;
var average_1: f32;
var param_42: f32;
var multi: vec3<f32>;
var param_43: vec3<f32>;
var param_44: f32;
var param_45: f32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
let _e316 = (*l_dot_v);
let _e317 = (*mu_i);
let _e318 = (*mu_o);
s_2 = (_e316 - (_e317 * _e318));
let _e321 = s_2;
if (_e321 > 0f) {
let _e323 = s_2;
let _e324 = (*mu_i);
let _e325 = (*mu_o);
local_15 = (_e323 / max(_e324, _e325));
} else {
let _e328 = s_2;
local_15 = _e328;
}
let _e329 = local_15;
s_over_t = _e329;
let _e330 = (*r_2);
af = (1f / (1f + (0.2877934f * _e330)));
let _e334 = (*rho_1);
let _e335 = af;
let _e336 = (*r_2);
let _e337 = s_over_t;
single = (_e334 * (_e335 * (1f + (_e336 * _e337))));
let _e342 = (*r_2);
param_42 = _e342;
let _e343 = FonAverage_u0028_f1_u003b((¶m_42));
average_1 = _e343;
let _e344 = (*rho_1);
param_43 = _e344;
let _e345 = average_1;
param_44 = _e345;
let _e346 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_43), (¶m_44));
let _e347 = (*mu_o);
param_45 = _e347;
let _e348 = (*r_2);
param_46 = _e348;
let _e349 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_45), (¶m_46));
let _e352 = (*mu_i);
param_47 = _e352;
let _e353 = (*r_2);
param_48 = _e353;
let _e354 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_47), (¶m_48));
let _e358 = average_1;
multi = (_e346 * ((max((1f - _e349), 0.0000001f) * max((1f - _e354), 0.0000001f)) / max((1f - _e358), 0.0000001f)));
let _e363 = single;
let _e364 = multi;
return ((_e363 + _e364) / vec3(3.1415927f));
}
fn EonDiffuse_u0028_() -> bool {
let _e299 = frag_info.ambient_sky[3u];
return (_e299 > 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_49: f32;
var param_50: f32;
var param_51: f32;
let _e303 = (*roughness_4);
let _e305 = (*n_dot_v_2);
param_49 = clamp(_e303, 0f, 1f);
param_50 = sqrt(clamp((1f - _e305), 0f, 1f));
param_51 = 1f;
let _e309 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51));
let _e310 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e309, 0f);
dfg = _e310.xy;
let _e313 = dfg[0u];
let _e315 = dfg[1u];
let _e318 = dfg[1u];
return vec2<f32>((_e313 - _e315), _e318);
}
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_3: ptr<function, Surface>) -> vec3<f32> {
var ab: vec2<f32>;
var param_52: f32;
var param_53: f32;
var ess: f32;
let _e304 = (*s_3).roughness;
param_52 = max(_e304, 0.045f);
let _e307 = (*s_3).n_dot_v;
param_53 = _e307;
let _e308 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_52), (¶m_53));
ab = _e308;
let _e310 = ab[0u];
let _e312 = ab[1u];
ess = max((_e310 + _e312), 0.0001f);
let _e315 = (*f0_);
let _e316 = ess;
return (vec3<f32>(1f, 1f, 1f) + (_e315 * ((1f / _e316) - 1f)));
}
fn EnergyCompensation_u0028_() -> bool {
let _e299 = frag_info.target_origin[2u];
return (_e299 > 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 _e301 = (*v_dot_h);
f_2 = pow((1f - _e301), 5f);
let _e304 = (*f0_1);
let _e305 = (*f90_);
let _e306 = (*f0_1);
let _e308 = f_2;
return (_e304 + ((_e305 - _e306) * _e308));
}
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 _e307 = (*n_dot_l_3);
let _e308 = (*at);
let _e309 = (*t_dot_v);
let _e311 = (*ab_1);
let _e312 = (*b_dot_v);
let _e314 = (*n_dot_v_3);
ggx_v = (_e307 * length(vec3<f32>((_e308 * _e309), (_e311 * _e312), _e314)));
let _e318 = (*n_dot_v_3);
let _e319 = (*at);
let _e320 = (*t_dot_l);
let _e322 = (*ab_1);
let _e323 = (*b_dot_l);
let _e325 = (*n_dot_l_3);
ggx_l = (_e318 * length(vec3<f32>((_e319 * _e320), (_e322 * _e323), _e325)));
let _e329 = ggx_v;
let _e330 = ggx_l;
return clamp((0.5f / max((_e329 + _e330), 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 _e305 = (*at_1);
let _e306 = (*ab_2);
a2_1 = (_e305 * _e306);
let _e308 = (*ab_2);
let _e309 = (*t_dot_h);
let _e311 = (*at_1);
let _e312 = (*b_dot_h);
let _e314 = a2_1;
let _e315 = (*n_dot_h_3);
f_3 = vec3<f32>((_e308 * _e309), (_e311 * _e312), (_e314 * _e315));
let _e318 = a2_1;
let _e319 = f_3;
let _e320 = f_3;
w2_ = (_e318 / max(dot(_e319, _e320), 0.000000000001f));
let _e324 = a2_1;
let _e325 = w2_;
let _e327 = w2_;
return (((_e324 * _e325) * _e327) / 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_4: 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_54: f32;
var param_55: f32;
var vis_1: f32;
var param_56: f32;
var param_57: f32;
var param_58: f32;
var at_2: f32;
var ab_3: f32;
var param_59: f32;
var param_60: f32;
var param_61: f32;
var param_62: f32;
var param_63: f32;
var param_64: f32;
var param_65: f32;
var param_66: f32;
var param_67: f32;
var param_68: f32;
var param_69: f32;
var param_70: f32;
var param_71: f32;
var f_4: vec3<f32>;
var param_72: vec3<f32>;
var param_73: vec3<f32>;
var param_74: f32;
var specular: vec3<f32>;
var param_75: vec3<f32>;
var param_76: Surface;
var diffuse: vec3<f32>;
var param_77: vec3<f32>;
var param_78: f32;
var param_79: f32;
var param_80: f32;
var param_81: f32;
var sheen: vec3<f32>;
var param_82: f32;
var param_83: f32;
var param_84: f32;
var param_85: f32;
var param_86: Surface;
var param_87: LightSample;
let _e347 = (*s_4).roughness;
lobe_1 = max(_e347, 0.045f);
let _e349 = lobe_1;
let _e350 = lobe_1;
alpha_6 = (_e349 * _e350);
let _e352 = g_f0_dielectric;
let _e354 = (*s_4).albedo;
let _e356 = (*s_4).metallic;
f0_2 = mix(_e352, _e354, vec3(_e356));
let _e359 = g_f90_;
let _e361 = (*s_4).metallic;
f90_1 = vec3(mix(_e359, 1f, _e361));
let _e365 = (*s_4).albedo;
let _e367 = (*s_4).metallic;
diffuseColor = (_e365 * (1f - _e367));
let _e371 = (*light_1).n_dot_h;
param_54 = _e371;
let _e372 = alpha_6;
param_55 = _e372;
let _e373 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_54), (¶m_55));
d_2 = _e373;
let _e375 = (*s_4).n_dot_v;
param_56 = _e375;
let _e377 = (*light_1).n_dot_l;
param_57 = _e377;
let _e378 = alpha_6;
param_58 = _e378;
let _e379 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58));
vis_1 = _e379;
let _e380 = g_aniso;
if (_e380 > 0f) {
let _e382 = alpha_6;
let _e383 = g_aniso;
let _e384 = g_aniso;
at_2 = mix(_e382, 1f, (_e383 * _e384));
let _e387 = alpha_6;
ab_3 = max(_e387, 0.001f);
let _e389 = g_aniso_t;
let _e391 = (*light_1).h;
let _e393 = g_aniso_b;
let _e395 = (*light_1).h;
let _e398 = (*light_1).n_dot_h;
param_59 = _e398;
param_60 = dot(_e389, _e391);
param_61 = dot(_e393, _e395);
let _e399 = at_2;
param_62 = _e399;
let _e400 = ab_3;
param_63 = _e400;
let _e401 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_59), (¶m_60), (¶m_61), (¶m_62), (¶m_63));
d_2 = _e401;
let _e402 = g_aniso_b;
let _e404 = (*s_4).v;
let _e406 = g_aniso_t;
let _e408 = (*s_4).v;
let _e410 = g_aniso_t;
let _e412 = (*light_1).l;
let _e414 = g_aniso_b;
let _e416 = (*light_1).l;
let _e419 = (*light_1).n_dot_l;
param_64 = _e419;
let _e421 = (*s_4).n_dot_v;
param_65 = _e421;
param_66 = dot(_e402, _e404);
param_67 = dot(_e406, _e408);
param_68 = dot(_e410, _e412);
param_69 = dot(_e414, _e416);
let _e422 = at_2;
param_70 = _e422;
let _e423 = ab_3;
param_71 = _e423;
let _e424 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_64), (¶m_65), (¶m_66), (¶m_67), (¶m_68), (¶m_69), (¶m_70), (¶m_71));
vis_1 = _e424;
}
let _e425 = f0_2;
param_72 = _e425;
let _e426 = f90_1;
param_73 = _e426;
let _e428 = (*light_1).v_dot_h;
param_74 = _e428;
let _e429 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_72), (¶m_73), (¶m_74));
f_4 = _e429;
let _e430 = f_4;
let _e431 = g_irid_fresnel;
let _e432 = g_iridescence;
f_4 = mix(_e430, _e431, vec3(_e432));
let _e435 = d_2;
let _e436 = vis_1;
let _e438 = f_4;
let _e442 = frag_info.material[3u];
specular = ((_e438 * (_e435 * _e436)) * _e442);
let _e445 = (*light_1).integrated;
if (_e445 > 0.5f) {
let _e449 = (*light_1).ltc[0u];
let _e450 = f0_2;
let _e453 = (*light_1).ltc[1u];
let _e455 = f90_1;
let _e456 = f0_2;
let _e460 = (*light_1).ltc[2u];
let _e466 = frag_info.material[3u];
let _e469 = (*light_1).n_dot_l;
specular = (((((_e450 * _e453) + ((_e455 - _e456) * _e460)) * _e449) * _e466) / vec3(max(_e469, 0.000001f)));
}
let _e473 = EnergyCompensation_u0028_();
if _e473 {
let _e474 = f0_2;
param_75 = _e474;
let _e475 = (*s_4);
param_76 = _e475;
let _e476 = 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_75), (¶m_76));
let _e477 = specular;
specular = (_e477 * _e476);
}
let _e479 = diffuseColor;
let _e480 = f_4;
diffuse = ((_e479 * (vec3<f32>(1f, 1f, 1f) - _e480)) / vec3(3.1415927f));
let _e485 = EonDiffuse_u0028_();
if _e485 {
let _e487 = (*s_4).n;
let _e489 = (*light_1).l;
let _e493 = (*light_1).l;
let _e495 = (*s_4).v;
let _e497 = diffuseColor;
param_77 = _e497;
let _e499 = (*s_4).roughness;
param_78 = _e499;
param_79 = clamp(dot(_e487, _e489), 0.0001f, 1f);
let _e501 = (*s_4).n_dot_v;
param_80 = _e501;
param_81 = dot(_e493, _e495);
let _e502 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_77), (¶m_78), (¶m_79), (¶m_80), (¶m_81));
let _e503 = f_4;
diffuse = (_e502 * (vec3<f32>(1f, 1f, 1f) - _e503));
}
let _e506 = g_transmission;
let _e508 = diffuse;
diffuse = (_e508 * (1f - _e506));
let _e510 = g_sheen;
let _e511 = g_sheen_roughness;
param_82 = _e511;
let _e513 = (*light_1).n_dot_h;
param_83 = _e513;
let _e514 = D_Charlie_u0028_f1_u003b_f1_u003b((¶m_82), (¶m_83));
let _e517 = (*s_4).n;
let _e519 = (*light_1).l;
let _e523 = (*s_4).n_dot_v;
param_84 = _e523;
param_85 = clamp(dot(_e517, _e519), 0f, 1f);
let _e524 = V_Neubelt_u0028_f1_u003b_f1_u003b((¶m_84), (¶m_85));
sheen = ((_e510 * _e514) * _e524);
let _e526 = diffuse;
let _e527 = specular;
let _e529 = g_sheen_scale;
let _e531 = sheen;
let _e533 = g_coat_through;
let _e535 = g_coat;
let _e536 = (*s_4);
param_86 = _e536;
let _e537 = (*light_1);
param_87 = _e537;
let _e538 = 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_86), (¶m_87));
return ((((((_e526 + _e527) * _e529) + _e531) * _e533) + vec3((_e535 * _e538))) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
let _e298 = (*i_1);
if (_e298 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e300 = (*i_1);
if (_e300 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e302 = (*i_1);
if (_e302 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e304 = (*i_1);
if (_e304 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e306 = (*i_1);
if (_e306 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e308 = (*i_1);
if (_e308 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e310 = (*i_1);
if (_e310 == 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_88: i32;
let _e303 = (*i_2);
param_88 = _e303;
let _e304 = PointShadowDiskTap_u0028_i1_u003b((¶m_88));
p_1 = _e304;
let _e306 = p_1[0u];
let _e307 = (*ca);
let _e310 = p_1[1u];
let _e311 = (*sa);
let _e315 = p_1[0u];
let _e316 = (*sa);
let _e319 = p_1[1u];
let _e320 = (*ca);
let _e324 = (*radius);
return (vec2<f32>(((_e306 * _e307) - (_e310 * _e311)), ((_e315 * _e316) + (_e319 * _e320))) * _e324);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local_16: vec2<f32>;
var atlas: vec2<f32>;
let _e306 = point_shadow.params[0u];
inset = _e306;
let _e307 = (*uv_2);
let _e308 = (*offset);
let _e310 = inset;
let _e311 = inset;
local_16 = clamp((_e307 + _e308), vec2(_e310), vec2((1f - _e311)));
let _e316 = local_16;
let _e317 = (*tile);
atlas = ((_e316 + _e317) * vec2<f32>(0.16666667f, 0.16666667f));
let _e322 = point_shadow.params3_[0u];
if (_e322 > 0.5f) {
let _e325 = atlas[1u];
atlas[1u] = (1f - _e325);
}
let _e328 = atlas;
let _e329 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e328, 0f);
let _e331 = atlas;
let _e332 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e331, 0f);
let _e335 = (*range);
return (min(_e329.x, _e332.x) * _e335);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_3: 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_89: vec2<f32>;
var param_90: vec2<f32>;
var param_91: vec2<f32>;
var param_92: f32;
let _e307 = (*uv_3);
param_89 = _e307;
let _e308 = (*offset_1);
param_90 = _e308;
let _e309 = (*tile_1);
param_91 = _e309;
let _e310 = (*range_1);
param_92 = _e310;
let _e311 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_89), (¶m_90), (¶m_91), (¶m_92));
stored = _e311;
let _e312 = stored;
let _e313 = (*range_1);
if (_e312 >= (_e313 * 0.999f)) {
return 1f;
}
let _e316 = (*receiver);
let _e317 = stored;
return select(1f, 0f, (_e316 > _e317));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_4: 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_93: vec2<f32>;
var param_94: vec2<f32>;
var param_95: vec2<f32>;
var param_96: f32;
var sum: f32;
var count: f32;
var i_3: i32;
var stored_1: f32;
var param_97: i32;
var param_98: f32;
var param_99: f32;
var param_100: f32;
var param_101: vec2<f32>;
var param_102: vec2<f32>;
var param_103: vec2<f32>;
var param_104: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e328 = point_shadow.params2_[1u];
lightRadius = _e328;
let _e331 = point_shadow.params2_[0u];
minRadius = _e331;
let _e334 = point_shadow.params2_[2u];
maxRadius = _e334;
let _e335 = lightRadius;
if (_e335 <= 0f) {
let _e337 = (*uv_4);
param_93 = _e337;
param_94 = vec2<f32>(0f, 0f);
let _e338 = (*tile_2);
param_95 = _e338;
let _e339 = (*range_2);
param_96 = _e339;
let _e340 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_93), (¶m_94), (¶m_95), (¶m_96));
(*blockerOut) = _e340;
let _e341 = minRadius;
return _e341;
}
sum = 0f;
count = 0f;
i_3 = 0i;
loop {
let _e342 = i_3;
if (_e342 < 8i) {
let _e344 = i_3;
param_97 = _e344;
let _e345 = (*ca_1);
param_98 = _e345;
let _e346 = (*sa_1);
param_99 = _e346;
let _e347 = maxRadius;
param_100 = _e347;
let _e348 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_97), (¶m_98), (¶m_99), (¶m_100));
let _e349 = (*uv_4);
param_101 = _e349;
param_102 = _e348;
let _e350 = (*tile_2);
param_103 = _e350;
let _e351 = (*range_2);
param_104 = _e351;
let _e352 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_101), (¶m_102), (¶m_103), (¶m_104));
stored_1 = _e352;
let _e353 = stored_1;
let _e354 = (*range_2);
if (_e353 >= (_e354 * 0.999f)) {
continue;
}
let _e357 = stored_1;
let _e358 = (*receiver_1);
if (_e357 >= _e358) {
continue;
}
let _e360 = stored_1;
let _e361 = sum;
sum = (_e361 + _e360);
let _e363 = count;
count = (_e363 + 1f);
continue;
} else {
break;
}
continuing {
let _e365 = i_3;
i_3 = (_e365 + 1i);
}
}
let _e367 = count;
if (_e367 < 0.5f) {
return -1f;
}
let _e369 = sum;
let _e370 = count;
blocker = max((_e369 / _e370), 0.0001f);
let _e373 = blocker;
(*blockerOut) = _e373;
let _e374 = lightRadius;
let _e375 = (*receiver_1);
let _e376 = blocker;
let _e380 = blocker;
world = ((_e374 * max((_e375 - _e376), 0f)) / _e380);
let _e382 = world;
let _e383 = (*receiver_1);
let _e385 = (*tanHalf);
let _e388 = minRadius;
let _e389 = maxRadius;
return clamp((_e382 / ((2f * _e383) * _e385)), _e388, _e389);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_17: vec2<f32>;
let _e299 = (*rows);
if (_e299 > 0f) {
let _e302 = gl_FragCoord_1[0u];
let _e303 = (*rows);
let _e305 = gl_FragCoord_1[1u];
local_17 = vec2<f32>(_e302, (_e303 - _e305));
} else {
let _e308 = gl_FragCoord_1;
local_17 = _e308.xy;
}
let _e310 = local_17;
return _e310;
}
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_1: 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_5: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_105: 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_106: vec2<f32>;
var param_107: vec2<f32>;
var param_108: f32;
var param_109: f32;
var param_110: f32;
var param_111: f32;
var param_112: f32;
var param_113: f32;
var local_18: vec3<f32>;
var lit_1: f32;
var param_114: vec2<f32>;
var param_115: vec2<f32>;
var param_116: vec2<f32>;
var param_117: f32;
var param_118: f32;
var i_4: i32;
var param_119: i32;
var param_120: f32;
var param_121: f32;
var param_122: f32;
var param_123: vec2<f32>;
var param_124: vec2<f32>;
var param_125: vec2<f32>;
var param_126: f32;
var param_127: f32;
var phi_2700_: bool;
var phi_2761_: bool;
let _e351 = (*lightIndex);
let _e355 = point_shadow.slots[_e351][0u];
slot_1 = i32((_e355 + 0.5f));
let _e358 = (*lightIndex);
let _e362 = point_shadow.slots[_e358][0u];
if (_e362 < 0f) {
return 1f;
}
let _e366 = point_shadow.params[2u];
strength = _e366;
let _e367 = strength;
if (_e367 <= 0f) {
return 1f;
}
let _e369 = slot_1;
let _e372 = point_shadow.lights[_e369];
let _e374 = (*world_1);
toLight = (_e372.xyz - _e374);
let _e376 = toLight;
toLightLength = max(length(_e376), 0.000001f);
let _e379 = (*normal);
let _e380 = toLight;
let _e381 = toLightLength;
nDotL = max(dot(_e379, (_e380 / vec3(_e381))), 0.15f);
let _e386 = nDotL;
let _e387 = nDotL;
let _e392 = nDotL;
let _e393 = nDotL;
slope = min((sqrt(max((1f - (_e386 * _e387)), 0f)) / (_e392 * _e393)), 8f);
let _e397 = toLightLength;
let _e399 = (*lightIndex);
let _e403 = point_shadow.slots[_e399][2u];
let _e408 = point_shadow.params3_[1u];
texel = (((2f * _e397) * max(_e403, 0.0001f)) * _e408);
let _e410 = (*world_1);
let _e411 = (*normal);
let _e412 = texel;
let _e416 = point_shadow.params[3u];
let _e418 = slope;
origin = (_e410 + (((_e411 * _e412) * _e416) * (1f + _e418)));
let _e422 = origin;
let _e423 = slot_1;
let _e426 = point_shadow.lights[_e423];
toFragment = (_e422 - _e426.xyz);
let _e429 = toFragment;
distance_ = length(_e429);
let _e431 = slot_1;
let _e435 = point_shadow.lights[_e431][3u];
range_3 = max(_e435, 0.0001f);
let _e437 = distance_;
let _e438 = range_3;
if (_e437 >= _e438) {
return 1f;
}
face = 0i;
let _e440 = (*lightIndex);
let _e444 = point_shadow.slots[_e440][1u];
if (_e444 < 0.5f) {
let _e446 = toFragment;
a_2 = abs(_e446);
let _e449 = a_2[0u];
let _e451 = a_2[1u];
let _e452 = (_e449 >= _e451);
phi_2700_ = _e452;
if _e452 {
let _e454 = a_2[0u];
let _e456 = a_2[2u];
phi_2700_ = (_e454 >= _e456);
}
let _e459 = phi_2700_;
if _e459 {
let _e461 = toFragment[0u];
face = select(1i, 0i, (_e461 > 0f));
} else {
let _e465 = a_2[1u];
let _e467 = a_2[2u];
if (_e465 >= _e467) {
let _e470 = toFragment[1u];
face = select(3i, 2i, (_e470 > 0f));
} else {
let _e474 = toFragment[2u];
face = select(5i, 4i, (_e474 > 0f));
}
}
}
let _e477 = slot_1;
let _e479 = face;
let _e483 = point_shadow.faces[((_e477 * 6i) + _e479)];
let _e484 = origin;
clip = (_e483 * vec4<f32>(_e484.x, _e484.y, _e484.z, 1f));
let _e491 = clip[3u];
if (_e491 <= 0f) {
return 1f;
}
let _e493 = clip;
let _e496 = clip[3u];
ndc = (_e493.xy / vec2(_e496));
let _e500 = ndc[0u];
let _e502 = (abs(_e500) > 1f);
phi_2761_ = _e502;
if !(_e502) {
let _e505 = ndc[1u];
phi_2761_ = (abs(_e505) > 1f);
}
let _e509 = phi_2761_;
if _e509 {
return 1f;
}
let _e511 = ndc[0u];
let _e515 = ndc[1u];
uv_5 = vec2<f32>(((_e511 * 0.5f) + 0.5f), (0.5f - (_e515 * 0.5f)));
let _e519 = face;
let _e521 = slot_1;
tile_3 = vec2<f32>(f32(_e519), f32(_e521));
let _e524 = distance_;
let _e527 = point_shadow.params[1u];
receiver_2 = (_e524 - _e527);
let _e531 = frag_info.target_origin[0u];
param_105 = _e531;
let _e532 = FragCoordFromTop_u0028_f1_u003b((¶m_105));
noise = fract((52.982918f * fract(dot(_e532, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e537 = noise;
angle_1 = (_e537 * 6.2831855f);
let _e539 = angle_1;
ca_2 = cos(_e539);
let _e541 = angle_1;
sa_2 = sin(_e541);
let _e543 = (*lightIndex);
let _e547 = point_shadow.slots[_e543][2u];
tanHalf_1 = max(_e547, 0.0001f);
blocker_1 = -1f;
let _e549 = uv_5;
param_106 = _e549;
let _e550 = tile_3;
param_107 = _e550;
let _e551 = range_3;
param_108 = _e551;
let _e552 = receiver_2;
param_109 = _e552;
let _e553 = ca_2;
param_110 = _e553;
let _e554 = sa_2;
param_111 = _e554;
let _e555 = tanHalf_1;
param_112 = _e555;
let _e556 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_106), (¶m_107), (¶m_108), (¶m_109), (¶m_110), (¶m_111), (¶m_112), (¶m_113));
let _e557 = param_113;
blocker_1 = _e557;
radius_1 = _e556;
let _e560 = point_shadow.params2_[3u];
if (_e560 > 0.5f) {
g_debug_surface_on = true;
let _e562 = radius_1;
if (_e562 < 0f) {
local_18 = vec3<f32>(0f, 0f, 1f);
} else {
let _e564 = radius_1;
let _e567 = point_shadow.params2_[2u];
let _e571 = blocker_1;
let _e572 = range_3;
local_18 = vec3<f32>(clamp((_e564 / max(_e567, 0.000001f)), 0f, 1f), clamp((_e571 / _e572), 0f, 1f), 0f);
}
let _e576 = local_18;
g_debug_surface = _e576;
}
let _e577 = radius_1;
if (_e577 < 0f) {
return 1f;
}
let _e579 = uv_5;
param_114 = _e579;
param_115 = vec2<f32>(0f, 0f);
let _e580 = tile_3;
param_116 = _e580;
let _e581 = range_3;
param_117 = _e581;
let _e582 = receiver_2;
param_118 = _e582;
let _e583 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_114), (¶m_115), (¶m_116), (¶m_117), (¶m_118));
lit_1 = _e583;
let _e584 = radius_1;
if (_e584 > 0f) {
i_4 = 0i;
loop {
let _e586 = i_4;
if (_e586 < 8i) {
let _e588 = i_4;
param_119 = _e588;
let _e589 = ca_2;
param_120 = _e589;
let _e590 = sa_2;
param_121 = _e590;
let _e591 = radius_1;
param_122 = _e591;
let _e592 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_119), (¶m_120), (¶m_121), (¶m_122));
let _e593 = uv_5;
param_123 = _e593;
param_124 = _e592;
let _e594 = tile_3;
param_125 = _e594;
let _e595 = range_3;
param_126 = _e595;
let _e596 = receiver_2;
param_127 = _e596;
let _e597 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_123), (¶m_124), (¶m_125), (¶m_126), (¶m_127));
let _e598 = lit_1;
lit_1 = (_e598 + _e597);
continue;
} else {
break;
}
continuing {
let _e600 = i_4;
i_4 = (_e600 + 1i);
}
}
let _e602 = lit_1;
lit_1 = (_e602 * 0.11111111f);
}
let _e604 = lit_1;
let _e605 = strength;
return mix(1f, _e604, clamp(_e605, 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 _e302 = (*i_5);
let _e305 = (*n_2);
r_3 = sqrt(((f32(_e302) + 0.5f) / f32(_e305)));
let _e309 = (*i_5);
let _e312 = (*turn);
theta = ((f32(_e309) * 2.3999631f) + _e312);
let _e314 = r_3;
let _e315 = theta;
let _e317 = theta;
return (vec2<f32>(cos(_e315), sin(_e317)) * _e314);
}
fn ShadowNoise_u0028_() -> f32 {
var at_3: vec2<f32>;
var param_128: f32;
let _e301 = frag_info.target_origin[0u];
param_128 = _e301;
let _e302 = FragCoordFromTop_u0028_f1_u003b((¶m_128));
let _e305 = frag_info.target_origin[3u];
at_3 = (_e302 + vec2((5.588238f * max(_e305, 0f))));
let _e310 = at_3;
return fract((52.982918f * fract(dot(_e310, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_19: f32;
let _e300 = (*mode_1);
if (_e300 > 0.5f) {
let _e302 = (*stored_2);
local_19 = (1f - _e302);
} else {
let _e304 = (*stored_2);
local_19 = _e304;
}
let _e305 = local_19;
return _e305;
}
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 _e306 = (*moments)[1u];
let _e308 = (*moments)[0u];
let _e310 = (*moments)[0u];
let _e313 = (*minVariance);
variance = max((_e306 - (_e308 * _e310)), _e313);
let _e315 = (*t);
let _e317 = (*moments)[0u];
d_3 = (_e315 - _e317);
let _e319 = variance;
let _e320 = variance;
let _e321 = d_3;
let _e322 = d_3;
pMax = (_e319 / (_e320 + (_e321 * _e322)));
let _e326 = pMax;
let _e327 = (*bleed);
let _e329 = (*bleed);
reduced = clamp(((_e326 - _e327) / max((1f - _e329), 0.0001f)), 0f, 1f);
let _e334 = (*t);
let _e336 = (*moments)[0u];
let _e338 = reduced;
return select(_e338, 1f, (_e334 <= _e336));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_4: f32;
let _e299 = (*depth);
d_4 = ((2f * clamp(_e299, 0f, 1f)) - 1f);
let _e303 = d_4;
let _e306 = d_4;
return vec2<f32>(exp((40f * _e303)), -(exp((-5f * _e306))));
}
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_129: f32;
var scale: vec2<f32>;
var positive: f32;
var param_130: vec2<f32>;
var param_131: f32;
var param_132: f32;
var param_133: f32;
var negative: f32;
var param_134: vec2<f32>;
var param_135: f32;
var param_136: f32;
var param_137: f32;
let _e313 = (*depth_1);
param_129 = _e313;
let _e314 = EvsmWarp_u0028_f1_u003b((¶m_129));
warped = _e314;
let _e315 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e315);
let _e318 = scale[0u];
let _e320 = scale[0u];
let _e322 = (*moments_1);
param_130 = _e322.xy;
let _e325 = warped[0u];
param_131 = _e325;
param_132 = (_e318 * _e320);
let _e326 = (*bleed_1);
param_133 = _e326;
let _e327 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_130), (¶m_131), (¶m_132), (¶m_133));
positive = _e327;
let _e329 = scale[1u];
let _e331 = scale[1u];
let _e333 = (*moments_1);
param_134 = _e333.zw;
let _e336 = warped[1u];
param_135 = _e336;
param_136 = (_e329 * _e331);
let _e337 = (*bleed_1);
param_137 = _e337;
let _e338 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_134), (¶m_135), (¶m_136), (¶m_137));
negative = _e338;
let _e339 = positive;
let _e340 = negative;
return min(_e339, _e340);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e299 = (*depth_2);
stored_3 = max((1f - _e299), 0.000061035156f);
let _e302 = stored_3;
return exp2((floor(log2(_e302)) - 10f));
}
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_5: 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 local_20: f32;
var cascade: i32;
var uv_6: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_21: mat4x4<f32>;
var local_22: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_23: f32;
var local_24: f32;
var storage_: f32;
var param_138: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_139: vec4<f32>;
var param_140: f32;
var param_141: f32;
var y_1: i32;
var x_1: i32;
var occluder: f32;
var param_142: f32;
var param_143: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_6: i32;
var disc: vec2<f32>;
var param_144: i32;
var param_145: i32;
var param_146: f32;
var tapBias: f32;
var occluder_1: f32;
var param_147: f32;
var param_148: f32;
var gap: f32;
var radius_2: f32;
var i_7: i32;
var disc_1: vec2<f32>;
var param_149: i32;
var param_150: i32;
var param_151: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_152: f32;
var param_153: f32;
var phi_4413_: bool;
var phi_4424_: bool;
var phi_4581_: bool;
var phi_4588_: bool;
var phi_4595_: bool;
let _e376 = frag_info.shadow_params[3u];
strength_1 = _e376;
let _e377 = strength_1;
if (_e377 <= 0f) {
return 1f;
}
let _e379 = (*lightIndex_1);
let _e382 = frag_info.frame_params[2u];
if (_e379 != i32(floor((_e382 + 0.5f)))) {
return 1f;
}
let _e389 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e389 + 0.5f));
let _e392 = Orthographic_u0028_();
if _e392 {
let _e393 = ViewDepth_u0028_();
local_20 = _e393;
} else {
let _e394 = v_world_position_1;
let _e396 = frag_info.camera_position;
local_20 = length((_e394 - _e396.xyz));
}
let _e400 = local_20;
viewDistance = _e400;
cascade = 0i;
let _e401 = cascadeCount;
let _e402 = (_e401 > 1i);
phi_4413_ = _e402;
if _e402 {
let _e403 = viewDistance;
let _e406 = frag_info.shadow_cascades[0u];
phi_4413_ = (_e403 > _e406);
}
let _e409 = phi_4413_;
if _e409 {
cascade = 1i;
}
let _e410 = cascadeCount;
let _e411 = (_e410 > 2i);
phi_4424_ = _e411;
if _e411 {
let _e412 = viewDistance;
let _e415 = frag_info.shadow_cascades[1u];
phi_4424_ = (_e412 > _e415);
}
let _e418 = phi_4424_;
if _e418 {
cascade = 2i;
}
uv_6 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e419 = attempt;
if (_e419 < 3i) {
let _e421 = cascade;
let _e422 = attempt;
which = (_e421 + _e422);
let _e424 = which;
let _e425 = cascadeCount;
if (_e424 >= _e425) {
break;
}
let _e427 = which;
if (_e427 == 0i) {
let _e430 = frag_info.shadow_matrix;
local_21 = _e430;
} else {
let _e431 = which;
if (_e431 == 1i) {
let _e434 = frag_info.shadow_matrix_far;
local_22 = _e434;
} else {
let _e436 = frag_info.shadow_matrix_farthest;
local_22 = _e436;
}
let _e437 = local_22;
local_21 = _e437;
}
let _e438 = local_21;
matrix = _e438;
let _e441 = matrix[0][0u];
let _e444 = matrix[1][0u];
let _e447 = matrix[2][0u];
axisX = vec3<f32>(_e441, _e444, _e447);
let _e451 = matrix[0][1u];
let _e454 = matrix[1][1u];
let _e457 = matrix[2][1u];
axisY = vec3<f32>(_e451, _e454, _e457);
let _e459 = axisX;
rowX = max(length(_e459), 0.000001f);
let _e462 = axisY;
rowY = max(length(_e462), 0.000001f);
let _e467 = frag_info.shadow_cascades[3u];
let _e469 = rowX;
texelMetres = ((2f * _e467) / _e469);
let _e473 = frag_info.shadow_cascades[3u];
let _e476 = (*s_5).n;
let _e477 = axisX;
let _e480 = rowX;
let _e481 = rowX;
let _e485 = (*s_5).n;
let _e486 = axisY;
let _e489 = rowY;
let _e490 = rowY;
reach = ((3f * _e473) * ((abs(dot(_e476, _e477)) / (_e480 * _e481)) + (abs(dot(_e485, _e486)) / (_e489 * _e490))));
let _e497 = frag_info.shadow_params[2u];
let _e498 = texelMetres;
flatOffset = min(_e497, _e498);
let _e500 = v_world_position_1;
let _e502 = (*s_5).n;
let _e503 = flatOffset;
let _e504 = reach;
origin_1 = (_e500 + (_e502 * (_e503 + _e504)));
let _e508 = matrix;
let _e509 = origin_1;
lightSpace = (_e508 * vec4<f32>(_e509.x, _e509.y, _e509.z, 1f));
let _e516 = lightSpace[3u];
if (_e516 <= 0f) {
continue;
}
let _e518 = lightSpace;
let _e521 = lightSpace[3u];
candidate = (_e518.xyz / vec3(_e521));
let _e525 = candidate[0u];
let _e529 = candidate[1u];
inTile = vec2<f32>(((_e525 * 0.5f) + 0.5f), (0.5f - (_e529 * 0.5f)));
let _e534 = inTile[0u];
let _e535 = (_e534 < 0f);
phi_4581_ = _e535;
if !(_e535) {
let _e538 = inTile[0u];
phi_4581_ = (_e538 > 1f);
}
let _e541 = phi_4581_;
phi_4588_ = _e541;
if !(_e541) {
let _e544 = inTile[1u];
phi_4588_ = (_e544 < 0f);
}
let _e547 = phi_4588_;
phi_4595_ = _e547;
if !(_e547) {
let _e550 = inTile[1u];
phi_4595_ = (_e550 > 1f);
}
let _e553 = phi_4595_;
if _e553 {
continue;
}
let _e555 = candidate[2u];
if (_e555 > 1f) {
let _e557 = which;
let _e558 = cascadeCount;
if (_e557 < (_e558 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e563 = inTile[0u];
let _e564 = which;
let _e567 = cascadeCount;
let _e571 = inTile[1u];
uv_6 = vec2<f32>(((_e563 + f32(_e564)) / f32(_e567)), _e571);
let _e573 = candidate;
projected = _e573;
let _e574 = which;
cascade = _e574;
let _e575 = texelMetres;
cascadeTexel = _e575;
let _e578 = matrix[0][2u];
let _e581 = matrix[1][2u];
let _e584 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e578, _e581, _e584)), 0.000001f));
let _e590 = (*s_5).n;
let _e593 = matrix[0][2u];
let _e596 = matrix[1][2u];
let _e599 = matrix[2][2u];
let _e603 = cascadeDepth;
cosSlope = clamp((abs(dot(_e590, vec3<f32>(_e593, _e596, _e599))) * _e603), 0.1f, 1f);
let _e606 = texelMetres;
let _e607 = cosSlope;
let _e608 = cosSlope;
let _e614 = cosSlope;
let _e616 = cascadeDepth;
receiverSlope = (((_e606 * sqrt(max((1f - (_e607 * _e608)), 0f))) / _e614) / _e616);
found = true;
break;
} else {
break;
}
continuing {
let _e618 = attempt;
attempt = (_e618 + 1i);
}
}
let _e620 = found;
if !(_e620) {
return 1f;
}
let _e622 = cascade;
if (_e622 == 0i) {
let _e626 = frag_info.shadow_bias[0u];
local_23 = _e626;
} else {
let _e627 = cascade;
if (_e627 == 1i) {
let _e631 = frag_info.shadow_bias[1u];
local_24 = _e631;
} else {
let _e634 = frag_info.shadow_bias[2u];
local_24 = _e634;
}
let _e635 = local_24;
local_23 = _e635;
}
let _e636 = local_23;
bias = _e636;
let _e639 = frag_info.shadow_params[1u];
storage_ = _e639;
let _e640 = storage_;
let _e642 = storage_;
if ((_e640 > 0.5f) && (_e642 < 1.5f)) {
let _e645 = bias;
let _e647 = projected[2u];
param_138 = _e647;
let _e648 = ShadowStoredStep_u0028_f1_u003b((¶m_138));
bias = max(_e645, _e648);
}
let _e652 = frag_info.shadow_params[0u];
let _e655 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e652, _e655);
let _e657 = cascade;
let _e659 = cascadeCount;
let _e663 = texel_1;
tileLo = (vec2<f32>((f32(_e657) / f32(_e659)), 0f) + (_e663 * 0.5f));
let _e666 = cascade;
let _e669 = cascadeCount;
let _e673 = texel_1;
tileHi = (vec2<f32>((f32((_e666 + 1i)) / f32(_e669)), 1f) - (_e673 * 0.5f));
let _e678 = frag_info.shadow_bias[3u];
if (_e678 > 0.5f) {
let _e680 = uv_6;
let _e681 = tileLo;
let _e682 = tileHi;
let _e684 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e680, _e681, _e682), 0f);
stored_4 = _e684;
let _e686 = stored_4[1u];
let _e689 = stored_4[2u];
let _e692 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e686), (1f - _e689), _e692), vec3(0f), vec3(4f));
let _e697 = through;
let _e698 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e697, vec3(clamp(_e698, 0f, 1f)));
}
let _e704 = frag_info.ambient_ground[3u];
softness = _e704;
lit_2 = 0f;
let _e705 = softness;
if (_e705 < 0f) {
let _e707 = uv_6;
let _e708 = tileLo;
let _e709 = tileHi;
let _e711 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e707, _e708, _e709), 0f);
moments_2 = _e711;
let _e713 = projected[2u];
let _e714 = bias;
let _e716 = softness;
let _e720 = moments_2;
param_139 = _e720;
param_140 = (_e713 - _e714);
param_141 = clamp((-(_e716) - 1f), 0f, 0.95f);
let _e721 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_139), (¶m_140), (¶m_141));
lit_2 = _e721;
} else {
let _e722 = softness;
if (_e722 <= 0f) {
y_1 = -1i;
loop {
let _e724 = y_1;
if (_e724 <= 1i) {
x_1 = -1i;
loop {
let _e726 = x_1;
if (_e726 <= 1i) {
let _e728 = uv_6;
let _e729 = x_1;
let _e731 = y_1;
let _e734 = texel_1;
let _e737 = tileLo;
let _e738 = tileHi;
let _e740 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e728 + (vec2<f32>(f32(_e729), f32(_e731)) * _e734)), _e737, _e738), 0f);
param_142 = _e740.x;
let _e742 = storage_;
param_143 = _e742;
let _e743 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_142), (¶m_143));
occluder = _e743;
let _e745 = projected[2u];
let _e746 = bias;
let _e748 = occluder;
let _e751 = lit_2;
lit_2 = (_e751 + select(1f, 0f, ((_e745 - _e746) > _e748)));
continue;
} else {
break;
}
continuing {
let _e753 = x_1;
x_1 = (_e753 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e755 = y_1;
y_1 = (_e755 + 1i);
}
}
let _e757 = lit_2;
lit_2 = (_e757 * 0.11111111f);
} else {
let _e759 = softness;
spread = tan(min(_e759, 0.5f));
let _e762 = ShadowNoise_u0028_();
turn_1 = (_e762 * 6.2831855f);
let _e764 = spread;
let _e766 = projected[2u];
let _e768 = cascadeDepth;
let _e770 = cascadeTexel;
searchRadius = clamp((((_e764 * _e766) * _e768) / _e770), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_6 = 0i;
loop {
let _e773 = i_6;
if (_e773 < 16i) {
let _e775 = i_6;
param_144 = _e775;
param_145 = 16i;
let _e776 = turn_1;
param_146 = _e776;
let _e777 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_144), (¶m_145), (¶m_146));
disc = _e777;
let _e778 = bias;
let _e779 = disc;
let _e781 = searchRadius;
let _e785 = receiverSlope;
tapBias = (_e778 + (max(((length(_e779) * _e781) - 1.5f), 0f) * _e785));
let _e788 = uv_6;
let _e789 = disc;
let _e790 = texel_1;
let _e792 = searchRadius;
let _e795 = tileLo;
let _e796 = tileHi;
let _e798 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e788 + ((_e789 * _e790) * _e792)), _e795, _e796), 0f);
param_147 = _e798.x;
let _e800 = storage_;
param_148 = _e800;
let _e801 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_147), (¶m_148));
occluder_1 = _e801;
let _e803 = projected[2u];
let _e804 = tapBias;
let _e806 = occluder_1;
if ((_e803 - _e804) > _e806) {
let _e808 = occluder_1;
let _e809 = blockerSum;
blockerSum = (_e809 + _e808);
let _e811 = blockerCount;
blockerCount = (_e811 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e813 = i_6;
i_6 = (_e813 + 1i);
}
}
let _e815 = blockerCount;
if (_e815 <= 0f) {
return 1f;
}
let _e818 = projected[2u];
let _e819 = blockerSum;
let _e820 = blockerCount;
let _e824 = cascadeDepth;
gap = (max((_e818 - (_e819 / _e820)), 0f) * _e824);
let _e826 = spread;
let _e827 = gap;
let _e829 = cascadeTexel;
radius_2 = clamp(((_e826 * _e827) / _e829), 1f, 16f);
i_7 = 0i;
loop {
let _e832 = i_7;
if (_e832 < 16i) {
let _e834 = turn_1;
let _e836 = i_7;
param_149 = _e836;
param_150 = 16i;
param_151 = (_e834 + 1f);
let _e837 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_149), (¶m_150), (¶m_151));
disc_1 = _e837;
let _e838 = bias;
let _e839 = disc_1;
let _e841 = radius_2;
let _e845 = receiverSlope;
tapBias_1 = (_e838 + (max(((length(_e839) * _e841) - 1.5f), 0f) * _e845));
let _e848 = uv_6;
let _e849 = disc_1;
let _e850 = texel_1;
let _e852 = radius_2;
let _e855 = tileLo;
let _e856 = tileHi;
let _e858 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e848 + ((_e849 * _e850) * _e852)), _e855, _e856), 0f);
param_152 = _e858.x;
let _e860 = storage_;
param_153 = _e860;
let _e861 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_152), (¶m_153));
occluder_2 = _e861;
let _e863 = projected[2u];
let _e864 = tapBias_1;
let _e866 = occluder_2;
let _e869 = lit_2;
lit_2 = (_e869 + select(1f, 0f, ((_e863 - _e864) > _e866)));
continue;
} else {
break;
}
continuing {
let _e871 = i_7;
i_7 = (_e871 + 1i);
}
}
let _e873 = lit_2;
lit_2 = (_e873 * 0.0625f);
}
}
let _e875 = lit_2;
let _e876 = strength_1;
return mix(1f, _e875, clamp(_e876, 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_6: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_154: Surface;
var param_155: LightSample;
var param_156: i32;
let _e303 = (*s_6);
param_154 = _e303;
let _e304 = (*light_3);
param_155 = _e304;
let _e305 = (*index);
param_156 = _e305;
let _e306 = 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_154), (¶m_155), (¶m_156));
return _e306;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e298 = (*index_1);
return (_e298 < 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 _e302 = (*distance_1);
let _e303 = (*distance_1);
attenuation = (1f / max((_e302 * _e303), 0.0001f));
let _e307 = (*range_4);
if (_e307 > 0f) {
let _e309 = (*distance_1);
let _e310 = (*range_4);
ratio = (_e309 / _e310);
let _e312 = ratio;
let _e313 = ratio;
let _e315 = ratio;
let _e317 = ratio;
window = clamp((1f - (((_e312 * _e313) * _e315) * _e317)), 0f, 1f);
let _e321 = window;
let _e322 = window;
let _e324 = attenuation;
attenuation = (_e324 * (_e321 * _e322));
}
let _e326 = attenuation;
return _e326;
}
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_25: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v_1: f32;
let _e314 = (*halfWidth);
let _e315 = (*halfHeight);
n_3 = cross(_e314, _e315);
let _e317 = n_3;
nLen = length(_e317);
let _e319 = nLen;
if (_e319 < 0.000000000001f) {
let _e321 = (*centre);
return _e321;
}
let _e322 = nLen;
let _e323 = n_3;
n_3 = (_e323 / vec3(_e322));
let _e326 = (*centre);
let _e327 = (*world_2);
toPlane = (_e326 - _e327);
let _e329 = (*mirror);
let _e330 = n_3;
denom = dot(_e329, _e330);
let _e332 = denom;
if (abs(_e332) < 0.00001f) {
let _e335 = toPlane;
let _e336 = n_3;
let _e337 = toPlane;
let _e338 = n_3;
onPlane = (_e335 - (_e336 * dot(_e337, _e338)));
} else {
let _e342 = toPlane;
let _e343 = n_3;
let _e345 = denom;
t_1 = (dot(_e342, _e343) / _e345);
let _e347 = t_1;
if (_e347 > 0f) {
let _e349 = (*mirror);
let _e350 = t_1;
local_25 = (_e349 * _e350);
} else {
let _e352 = toPlane;
let _e353 = n_3;
let _e354 = toPlane;
let _e355 = n_3;
local_25 = (_e352 - (_e353 * dot(_e354, _e355)));
}
let _e359 = local_25;
onPlane = _e359;
}
let _e360 = onPlane;
let _e361 = toPlane;
offset_2 = (_e360 - _e361);
let _e363 = (*halfWidth);
let _e364 = (*halfWidth);
wLen2_ = max(dot(_e363, _e364), 0.000000000001f);
let _e367 = (*halfHeight);
let _e368 = (*halfHeight);
hLen2_ = max(dot(_e367, _e368), 0.000000000001f);
let _e371 = offset_2;
let _e372 = (*halfWidth);
let _e374 = wLen2_;
u = clamp((dot(_e371, _e372) / _e374), -1f, 1f);
let _e377 = offset_2;
let _e378 = (*halfHeight);
let _e380 = hLen2_;
v_1 = clamp((dot(_e377, _e378) / _e380), -1f, 1f);
let _e383 = (*centre);
let _e384 = (*halfWidth);
let _e385 = u;
let _e388 = (*halfHeight);
let _e389 = v_1;
return ((_e383 + (_e384 * _e385)) + (_e388 * _e389));
}
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_26: f32;
let _e306 = (*a_3);
let _e307 = (*a_3);
ua = (_e306 / vec3(max(length(_e307), 0.000000000001f)));
let _e312 = (*b_1);
let _e313 = (*b_1);
ub = (_e312 / vec3(max(length(_e313), 0.000000000001f)));
let _e318 = ua;
let _e319 = ub;
angle_2 = acos(clamp(dot(_e318, _e319), -1f, 1f));
let _e323 = ua;
let _e324 = ub;
axis_1 = cross(_e323, _e324);
let _e326 = axis_1;
len_2 = length(_e326);
let _e328 = len_2;
if (_e328 > 0.000001f) {
let _e330 = angle_2;
let _e331 = axis_1;
let _e332 = (*n_4);
let _e335 = len_2;
local_26 = ((_e330 * dot(_e331, _e332)) / _e335);
} else {
local_26 = 0f;
}
let _e337 = local_26;
return _e337;
}
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_27: i32;
var ha: f32;
var hb: f32;
var d_5: f32;
var q: vec3<f32>;
var local_28: f32;
var aAbove: bool;
var bAbove: bool;
var local_29: f32;
var param_157: vec3<f32>;
var param_158: vec3<f32>;
var param_159: vec3<f32>;
var param_160: vec3<f32>;
var param_161: vec3<f32>;
var param_162: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_8 = 0i;
loop {
let _e320 = i_8;
if (_e320 < 4i) {
let _e322 = i_8;
let _e324 = (*corners_1)[_e322];
a_4 = _e324;
let _e325 = i_8;
if (_e325 == 3i) {
local_27 = 0i;
} else {
let _e327 = i_8;
local_27 = (_e327 + 1i);
}
let _e329 = local_27;
let _e331 = (*corners_1)[_e329];
b_2 = _e331;
let _e332 = a_4;
let _e333 = (*n_5);
ha = dot(_e332, _e333);
let _e335 = b_2;
let _e336 = (*n_5);
hb = dot(_e335, _e336);
let _e338 = ha;
let _e339 = hb;
d_5 = (_e338 - _e339);
let _e341 = a_4;
let _e342 = b_2;
let _e343 = a_4;
let _e345 = d_5;
if (abs(_e345) > 0.000000000001f) {
let _e348 = ha;
let _e349 = d_5;
local_28 = (_e348 / _e349);
} else {
local_28 = 0f;
}
let _e351 = local_28;
q = (_e341 + ((_e342 - _e343) * _e351));
let _e354 = ha;
aAbove = (_e354 > 0f);
let _e356 = hb;
bAbove = (_e356 > 0f);
let _e358 = aAbove;
let _e359 = bAbove;
if (_e358 || _e359) {
let _e361 = aAbove;
let _e362 = a_4;
let _e363 = q;
let _e366 = bAbove;
let _e367 = b_2;
let _e368 = q;
param_157 = select(_e363, _e362, vec3(_e361));
param_158 = select(_e368, _e367, vec3(_e366));
let _e371 = (*n_5);
param_159 = _e371;
let _e372 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_157), (¶m_158), (¶m_159));
local_29 = _e372;
} else {
local_29 = 0f;
}
let _e373 = local_29;
let _e374 = total;
total = (_e374 + _e373);
let _e376 = aAbove;
let _e377 = bAbove;
let _e380 = q;
let _e381 = exit;
exit = select(_e381, _e380, vec3((_e376 && !(_e377))));
let _e384 = aAbove;
let _e386 = bAbove;
let _e388 = q;
let _e389 = entry;
entry = select(_e389, _e388, vec3((!(_e384) && _e386)));
continue;
} else {
break;
}
continuing {
let _e392 = i_8;
i_8 = (_e392 + 1i);
}
}
let _e394 = exit;
param_160 = _e394;
let _e395 = entry;
param_161 = _e395;
let _e396 = (*n_5);
param_162 = _e396;
let _e397 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_160), (¶m_161), (¶m_162));
let _e398 = total;
total = (_e398 + _e397);
let _e400 = total;
return max((-(_e400) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2: ptr<function, i32>) -> f32 {
var lane: i32;
var local_30: f32;
var local_31: f32;
var local_32: f32;
let _e303 = (*slot_2);
let _e304 = (*slot_2);
lane = (_e303 - ((_e304 / 4i) * 4i));
let _e308 = lane;
if (_e308 == 0i) {
let _e311 = (*four)[0u];
local_30 = _e311;
} else {
let _e312 = lane;
if (_e312 == 1i) {
let _e315 = (*four)[1u];
local_31 = _e315;
} else {
let _e316 = lane;
if (_e316 == 2i) {
let _e319 = (*four)[2u];
local_32 = _e319;
} else {
let _e321 = (*four)[3u];
local_32 = _e321;
}
let _e322 = local_32;
local_31 = _e322;
}
let _e323 = local_31;
local_30 = _e323;
}
let _e324 = local_30;
return _e324;
}
fn LightListScale_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_163: vec4<f32>;
var param_164: i32;
let _e300 = (*slot_3);
let _e304 = light_list_info.scales[(_e300 / 4i)];
param_163 = _e304;
let _e305 = (*slot_3);
param_164 = _e305;
let _e306 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_163), (¶m_164));
return _e306;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_5: vec4<f32>;
var b_3: vec4<f32>;
let _e302 = light_list_info.slot_rows[0i];
let _e303 = (*row);
a_5 = abs((_e302 - vec4(_e303)));
let _e309 = light_list_info.slot_rows[1i];
let _e310 = (*row);
b_3 = abs((_e309 - vec4(_e310)));
let _e315 = a_5[0u];
let _e317 = a_5[1u];
let _e320 = a_5[2u];
let _e322 = a_5[3u];
let _e326 = b_3[0u];
let _e328 = b_3[1u];
let _e331 = b_3[2u];
let _e333 = b_3[3u];
return (min(min(min(_e315, _e317), min(_e320, _e322)), min(min(_e326, _e328), min(_e331, _e333))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var param_165: vec4<f32>;
var param_166: i32;
let _e300 = (*slot_4);
let _e304 = light_list_info.indices[(_e300 / 4i)];
param_165 = _e304;
let _e305 = (*slot_4);
param_166 = _e305;
let _e306 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_165), (¶m_166));
return _e306;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e299 = (*texel_2);
let _e303 = light_list_info.list[1u];
let _e305 = (*row_1);
let _e309 = light_list_info.list[2u];
let _e312 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e299 + 0.5f) * _e303), ((_e305 + 0.5f) * _e309)), 0f);
return _e312;
}
fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_167: f32;
var param_168: f32;
var param_169: vec4<f32>;
var param_170: i32;
let _e307 = g_cluster_offset;
let _e308 = (*slot_5);
entry_1 = (_e307 + f32(_e308));
let _e311 = entry_1;
row_2 = floor((_e311 / 16f));
let _e314 = entry_1;
let _e315 = row_2;
within_1 = (_e314 - (_e315 * 16f));
let _e318 = within_1;
texel_3 = floor((_e318 / 4f));
let _e323 = light_list_info.cluster_depth[3u];
let _e324 = row_2;
let _e326 = texel_3;
param_167 = _e326;
param_168 = (_e323 + _e324);
let _e327 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_167), (¶m_168));
four_1 = _e327;
let _e328 = within_1;
let _e329 = texel_3;
let _e334 = four_1;
param_169 = _e334;
param_170 = i32(((_e328 - (_e329 * 4f)) + 0.5f));
let _e335 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_169), (¶m_170));
return _e335;
}
fn Clustered_u0028_() -> bool {
let _e299 = light_list_info.cluster_grid[3u];
return (_e299 > 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_7: 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_6: i32;
var clustered: bool;
var listRow: f32;
var local_33: f32;
var param_171: i32;
var param_172: i32;
var v_2: f32;
var u_1: f32;
var local_34: f32;
var param_173: f32;
var param_174: 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_35: f32;
var param_175: array<vec3<f32>, 4>;
var param_176: vec3<f32>;
var area: f32;
var radiance: f32;
var local_36: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_177: vec3<f32>;
var param_178: vec3<f32>;
var param_179: vec3<f32>;
var param_180: vec3<f32>;
var param_181: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_37: vec3<f32>;
var param_182: vec3<f32>;
var param_183: vec3<f32>;
var param_184: f32;
var param_185: array<vec3<f32>, 4>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_186: f32;
var param_187: f32;
var cosAngle: f32;
var ramp: f32;
light_4.integrated = 0f;
light_4.ltc = vec3<f32>(0f, 0f, 0f);
let _e355 = (*index_2);
if (_e355 < 8i) {
let _e357 = (*index_2);
let _e360 = frag_info.light_position[_e357];
position = _e360;
let _e361 = (*index_2);
let _e364 = frag_info.light_color[_e361];
color_1 = _e364;
let _e365 = (*index_2);
let _e368 = frag_info.light_direction[_e365];
direction = _e368;
let _e369 = (*index_2);
let _e372 = frag_info.light_cone[_e369];
cone = _e372;
} else {
let _e373 = (*index_2);
slot_6 = (_e373 - 8i);
let _e375 = Clustered_u0028_();
clustered = _e375;
let _e376 = clustered;
if _e376 {
let _e377 = slot_6;
param_171 = _e377;
let _e378 = ClusterRow_u0028_i1_u003b((¶m_171));
local_33 = _e378;
} else {
let _e379 = slot_6;
param_172 = _e379;
let _e380 = LightListRow_u0028_i1_u003b((¶m_172));
local_33 = _e380;
}
let _e381 = local_33;
listRow = _e381;
let _e382 = listRow;
let _e386 = light_list_info.list[2u];
v_2 = ((_e382 + 0.5f) * _e386);
let _e390 = light_list_info.list[1u];
u_1 = _e390;
let _e391 = u_1;
let _e393 = v_2;
let _e395 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e391), _e393), 0f);
position = _e395;
let _e396 = u_1;
let _e398 = v_2;
let _e400 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e396), _e398), 0f);
color_1 = _e400;
let _e401 = u_1;
let _e403 = v_2;
let _e405 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e401), _e403), 0f);
direction = _e405;
let _e406 = u_1;
let _e408 = v_2;
let _e410 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e406), _e408), 0f);
cone = _e410;
let _e411 = clustered;
if _e411 {
let _e412 = listRow;
param_173 = _e412;
let _e413 = InSlots_u0028_f1_u003b((¶m_173));
local_34 = select(1f, 0f, _e413);
} else {
let _e415 = slot_6;
param_174 = _e415;
let _e416 = LightListScale_u0028_i1_u003b((¶m_174));
local_34 = _e416;
}
let _e417 = local_34;
let _e419 = color_1[3u];
color_1[3u] = (_e419 * _e417);
}
let _e423 = position[3u];
type_45 = _e423;
let _e424 = type_45;
if (_e424 > 15.5f) {
let _e427 = (*s_7).n;
light_4.l = _e427;
let _e430 = (*s_7).n;
light_4.h = _e430;
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 _e436 = light_4;
return _e436;
}
let _e437 = type_45;
if (_e437 > 2.5f) {
let _e439 = direction;
halfWidth_1 = _e439.xyz;
let _e441 = cone;
halfHeight_1 = _e441.xyz;
let _e443 = position;
let _e445 = v_world_position_1;
toCentre = (_e443.xyz - _e445);
let _e447 = toCentre;
let _e448 = halfWidth_1;
let _e450 = halfHeight_1;
corners_2[0i] = ((_e447 - _e448) - _e450);
let _e453 = toCentre;
let _e454 = halfWidth_1;
let _e456 = halfHeight_1;
corners_2[1i] = ((_e453 + _e454) - _e456);
let _e459 = toCentre;
let _e460 = halfWidth_1;
let _e462 = halfHeight_1;
corners_2[2i] = ((_e459 + _e460) + _e462);
let _e465 = toCentre;
let _e466 = halfWidth_1;
let _e468 = halfHeight_1;
corners_2[3i] = ((_e465 - _e466) + _e468);
let _e471 = toCentre;
let _e472 = halfWidth_1;
let _e473 = halfHeight_1;
behind = (dot(_e471, cross(_e472, _e473)) >= 0f);
let _e477 = behind;
if _e477 {
local_35 = 0f;
} else {
let _e478 = corners_2;
param_175 = _e478;
let _e480 = (*s_7).n;
param_176 = _e480;
let _e481 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_175), (¶m_176));
local_35 = _e481;
}
let _e482 = local_35;
formFactor = _e482;
let _e483 = halfWidth_1;
let _e484 = halfHeight_1;
area = (length(cross(_e483, _e484)) * 4f);
let _e488 = area;
if (_e488 > 0.000000001f) {
let _e490 = area;
local_36 = (1f / _e490);
} else {
local_36 = 0f;
}
let _e492 = local_36;
radiance = _e492;
let _e493 = toCentre;
distance_2 = length(_e493);
let _e496 = direction[3u];
if (_e496 > 0f) {
let _e498 = distance_2;
let _e500 = direction[3u];
ratio_1 = (_e498 / _e500);
let _e502 = ratio_1;
let _e503 = ratio_1;
let _e505 = ratio_1;
let _e507 = ratio_1;
window_1 = clamp((1f - (((_e502 * _e503) * _e505) * _e507)), 0f, 1f);
let _e511 = window_1;
let _e512 = window_1;
let _e514 = radiance;
radiance = (_e514 * (_e511 * _e512));
}
let _e517 = (*s_7).v;
let _e520 = (*s_7).n;
mirror_1 = reflect(-(_e517), _e520);
let _e522 = position;
param_177 = _e522.xyz;
let _e524 = halfWidth_1;
param_178 = _e524;
let _e525 = halfHeight_1;
param_179 = _e525;
let _e526 = v_world_position_1;
param_180 = _e526;
let _e527 = mirror_1;
param_181 = _e527;
let _e528 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_177), (¶m_178), (¶m_179), (¶m_180), (¶m_181));
representative = _e528;
let _e529 = representative;
let _e530 = v_world_position_1;
toPoint = (_e529 - _e530);
let _e532 = toPoint;
pointDistance = length(_e532);
let _e534 = pointDistance;
if (_e534 > 0.000001f) {
let _e536 = toPoint;
let _e537 = pointDistance;
local_37 = (_e536 / vec3(_e537));
} else {
let _e541 = (*s_7).n;
local_37 = _e541;
}
let _e542 = local_37;
light_4.l = _e542;
let _e545 = light_4.l;
let _e547 = (*s_7).v;
light_4.h = normalize((_e545 + _e547));
let _e551 = formFactor;
light_4.n_dot_l = _e551;
let _e554 = (*s_7).n;
let _e556 = light_4.h;
light_4.n_dot_h = max(dot(_e554, _e556), 0f);
let _e561 = (*s_7).v;
let _e563 = light_4.h;
light_4.v_dot_h = max(dot(_e561, _e563), 0f);
let _e567 = color_1;
let _e570 = color_1[3u];
let _e572 = radiance;
light_4.radiance = ((_e567.xyz * _e570) * _e572);
light_4.integrated = 1f;
let _e577 = (*s_7).n;
param_182 = _e577;
let _e579 = (*s_7).v;
param_183 = _e579;
let _e581 = (*s_7).roughness;
param_184 = _e581;
let _e582 = corners_2;
param_185 = _e582;
let _e583 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((¶m_182), (¶m_183), (¶m_184), (¶m_185));
light_4.ltc = _e583;
let _e585 = corners_2;
g_rect_corners = _e585;
let _e586 = light_4;
return _e586;
}
let _e587 = direction;
aim = normalize(_e587.xyz);
attenuation_1 = 1f;
let _e590 = type_45;
if (_e590 < 0.5f) {
let _e592 = aim;
light_4.l = -(_e592);
} else {
let _e595 = position;
let _e597 = v_world_position_1;
toLight_1 = (_e595.xyz - _e597);
let _e599 = toLight_1;
distance_3 = length(_e599);
let _e601 = distance_3;
if (_e601 < 0.000001f) {
let _e604 = (*s_7).n;
light_4.l = _e604;
let _e607 = (*s_7).n;
light_4.h = _e607;
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 _e613 = light_4;
return _e613;
}
let _e614 = toLight_1;
let _e615 = distance_3;
light_4.l = (_e614 / vec3(_e615));
let _e619 = distance_3;
param_186 = _e619;
let _e621 = direction[3u];
param_187 = _e621;
let _e622 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_186), (¶m_187));
attenuation_1 = _e622;
let _e623 = type_45;
if (_e623 > 1.5f) {
let _e625 = aim;
let _e627 = light_4.l;
cosAngle = dot(_e625, -(_e627));
let _e630 = cosAngle;
let _e632 = cone[1u];
let _e635 = cone[0u];
let _e637 = cone[1u];
ramp = clamp(((_e630 - _e632) / (_e635 - _e637)), 0f, 1f);
let _e641 = ramp;
let _e642 = ramp;
let _e644 = attenuation_1;
attenuation_1 = (_e644 * (_e641 * _e642));
}
}
let _e647 = light_4.l;
let _e649 = (*s_7).v;
light_4.h = normalize((_e647 + _e649));
let _e654 = (*s_7).n;
let _e656 = light_4.l;
light_4.n_dot_l = max(dot(_e654, _e656), 0f);
let _e661 = (*s_7).n;
let _e663 = light_4.h;
light_4.n_dot_h = max(dot(_e661, _e663), 0f);
let _e668 = (*s_7).v;
let _e670 = light_4.h;
light_4.v_dot_h = max(dot(_e668, _e670), 0f);
let _e674 = color_1;
let _e677 = color_1[3u];
let _e679 = attenuation_1;
light_4.radiance = ((_e674.xyz * _e677) * _e679);
let _e682 = light_4;
return _e682;
}
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_38: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_188: f32;
var param_189: f32;
let _e312 = light_list_info.cluster_view_projection;
let _e313 = (*world_3);
clip_1 = (_e312 * vec4<f32>(_e313.x, _e313.y, _e313.z, 1f));
let _e319 = clip_1;
let _e322 = clip_1[3u];
ndc_1 = (_e319.xy / vec2(max(_e322, 0.000001f)));
let _e327 = light_list_info.cluster_grid;
grid = _e327.xyz;
let _e331 = light_list_info.cluster_depth[0u];
near_1 = _e331;
let _e333 = ndc_1[0u];
let _e337 = grid[0u];
let _e341 = grid[0u];
tx = clamp(floor((((_e333 * 0.5f) + 0.5f) * _e337)), 0f, (_e341 - 1f));
let _e345 = ndc_1[1u];
let _e349 = grid[1u];
let _e353 = grid[1u];
ty = clamp(floor((((_e345 * 0.5f) + 0.5f) * _e349)), 0f, (_e353 - 1f));
let _e357 = clip_1[3u];
let _e358 = near_1;
if (_e357 <= _e358) {
local_38 = 0f;
} else {
let _e361 = clip_1[3u];
let _e362 = near_1;
let _e367 = light_list_info.cluster_depth[1u];
let _e371 = grid[2u];
local_38 = clamp(floor((log((_e361 / _e362)) * _e367)), 0f, (_e371 - 1f));
}
let _e374 = local_38;
tz = _e374;
let _e375 = tx;
let _e376 = ty;
let _e378 = grid[0u];
let _e381 = tz;
let _e383 = grid[0u];
let _e386 = grid[1u];
cell_1 = ((_e375 + (_e376 * _e378)) + ((_e381 * _e383) * _e386));
let _e389 = cell_1;
row_3 = floor((_e389 / 4f));
let _e392 = cell_1;
let _e393 = row_3;
let _e398 = light_list_info.cluster_depth[2u];
let _e399 = row_3;
param_188 = (_e392 - (_e393 * 4f));
param_189 = (_e398 + _e399);
let _e401 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_188), (¶m_189));
header = _e401;
let _e403 = header[0u];
g_cluster_offset = _e403;
let _e405 = header[1u];
g_cluster_count = _e405;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_190: vec3<f32>;
let _e301 = light_list_info.list[0u];
tail = _e301;
let _e302 = Clustered_u0028_();
if _e302 {
let _e303 = v_world_position_1;
param_190 = _e303;
FindCluster_u0028_vf3_u003b((¶m_190));
let _e304 = g_cluster_count;
tail = _e304;
}
let _e307 = frag_info.frame_params[1u];
let _e311 = tail;
return (clamp(i32((_e307 + 0.5f)), 0i, 8i) + clamp(i32((_e311 + 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_8: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_9: i32;
var light_5: LightSample;
var param_191: i32;
var param_192: Surface;
var visibility: f32;
var param_193: i32;
var local_39: f32;
var param_194: Surface;
var param_195: LightSample;
var param_196: i32;
var param_197: vec3<f32>;
var param_198: vec3<f32>;
var param_199: i32;
var param_200: Surface;
var param_201: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e315 = LightCount_u0028_();
count_1 = _e315;
i_9 = 0i;
loop {
let _e316 = i_9;
if (_e316 < 32i) {
let _e318 = i_9;
let _e319 = count_1;
if (_e318 >= _e319) {
break;
}
let _e321 = i_9;
param_191 = _e321;
let _e322 = (*s_8);
param_192 = _e322;
let _e323 = 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_191), (¶m_192));
light_5 = _e323;
let _e325 = light_5.n_dot_l;
if (_e325 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e327 = i_9;
param_193 = _e327;
let _e328 = LightHasShadow_u0028_i1_u003b((¶m_193));
if _e328 {
let _e329 = (*s_8);
param_194 = _e329;
let _e330 = light_5;
param_195 = _e330;
let _e331 = i_9;
param_196 = _e331;
let _e332 = 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_194), (¶m_195), (¶m_196));
let _e333 = v_world_position_1;
param_197 = _e333;
let _e335 = (*s_8).n;
param_198 = _e335;
let _e336 = i_9;
param_199 = _e336;
let _e337 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_197), (¶m_198), (¶m_199));
local_39 = (_e332 * _e337);
} else {
local_39 = 1f;
}
let _e339 = local_39;
visibility = _e339;
let _e340 = visibility;
if (_e340 <= 0f) {
continue;
}
let _e342 = (*s_8);
param_200 = _e342;
let _e343 = light_5;
param_201 = _e343;
let _e344 = 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_200), (¶m_201));
let _e346 = light_5.radiance;
let _e349 = light_5.n_dot_l;
let _e351 = visibility;
let _e353 = light_transmittance;
let _e355 = total_1;
total_1 = (_e355 + ((((_e344 * _e346) * _e349) * _e351) * _e353));
continue;
} else {
break;
}
continuing {
let _e357 = i_9;
i_9 = (_e357 + 1i);
}
}
let _e359 = total_1;
return _e359;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e298 = v_lightmap_uv_1;
let _e299 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e298);
texel_4 = _e299;
let _e300 = texel_4;
let _e303 = texel_4[3u];
return ((_e300.xyz * _e303) * 8f);
}
fn SceneColourLevel_u0028_vf2_u003b_i1_u003b(uv_7: 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 _e302 = (*level);
let _e305 = layer_info.scene_levels[_e302];
rect = _e305;
let _e307 = layer_info.scene_colour;
inset_1 = (_e307.yz * 0.5f);
let _e310 = rect;
let _e312 = (*uv_7);
let _e313 = rect;
let _e316 = inset_1;
let _e317 = rect;
let _e319 = inset_1;
let _e321 = inset_1;
at_4 = (_e310.xy + clamp((_e312 * _e313.zw), _e316, max((_e317.zw - _e319), _e321)));
let _e325 = at_4;
let _e326 = textureSampleLevel(scene_colour_texture_tex, scene_colour_texture_smp, _e325, 0f);
return _e326.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_1: vec2<f32>;
var uv_8: vec2<f32>;
var top: f32;
var level_1: f32;
var lower: f32;
var near_2: vec3<f32>;
var param_202: vec2<f32>;
var param_203: i32;
var far_1: vec3<f32>;
var param_204: vec2<f32>;
var param_205: i32;
let _e313 = layer_info.scene_view_projection;
let _e314 = (*world_4);
clip_2 = (_e313 * vec4<f32>(_e314.x, _e314.y, _e314.z, 1f));
let _e320 = clip_2;
let _e323 = clip_2[3u];
ndc_2 = (_e320.xy / vec2(max(_e323, 0.000001f)));
let _e328 = ndc_2[0u];
let _e332 = ndc_2[1u];
view_1 = clamp(vec2<f32>(((_e328 * 0.5f) + 0.5f), (0.5f - (_e332 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
let _e338 = layer_info.scene_viewport;
let _e340 = view_1;
let _e342 = layer_info.scene_viewport;
uv_8 = (_e338.xy + (_e340 * _e342.zw));
let _e348 = layer_info.scene_colour[0u];
top = (_e348 - 1f);
let _e350 = (*lod);
let _e351 = top;
level_1 = clamp(_e350, 0f, _e351);
let _e353 = level_1;
lower = floor(_e353);
let _e355 = lower;
let _e357 = uv_8;
param_202 = _e357;
param_203 = i32(_e355);
let _e358 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_202), (¶m_203));
near_2 = _e358;
let _e359 = lower;
let _e361 = top;
let _e364 = uv_8;
param_204 = _e364;
param_205 = i32(min((_e359 + 1f), _e361));
let _e365 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((¶m_204), (¶m_205));
far_1 = _e365;
let _e366 = near_2;
let _e367 = far_1;
let _e368 = level_1;
let _e369 = lower;
return mix(_e366, _e367, vec3((_e368 - _e369)));
}
fn IorInfinite_u0028_() -> bool {
let _e299 = layer_info.coat[2u];
return (_e299 == 0f);
}
fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
var local_40: f32;
let _e299 = IorInfinite_u0028_();
if _e299 {
local_40 = 0f;
} else {
let _e300 = (*ior);
let _e305 = layer_info.transmission[3u];
local_40 = (((_e300 - 1f) * 0.025f) * _e305);
}
let _e307 = local_40;
return _e307;
}
fn RefractionIor_u0028_() -> f32 {
var local_41: f32;
let _e298 = IorInfinite_u0028_();
if _e298 {
local_41 = 10000f;
} else {
let _e301 = layer_info.coat[2u];
local_41 = max(_e301, 1f);
}
let _e303 = local_41;
return _e303;
}
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_9: ptr<function, Surface>) -> vec3<f32> {
var ior_1: f32;
var spread_1: f32;
var param_206: f32;
var width: f32;
var lod_1: f32;
var thin: bool;
var red: vec3<f32>;
var local_42: vec3<f32>;
var green: vec3<f32>;
var local_43: vec3<f32>;
var blue: vec3<f32>;
var local_44: vec3<f32>;
var param_207: vec3<f32>;
var param_208: f32;
var param_209: vec3<f32>;
var param_210: f32;
var param_211: vec3<f32>;
var param_212: f32;
let _e316 = RefractionIor_u0028_();
ior_1 = _e316;
let _e317 = ior_1;
param_206 = _e317;
let _e318 = DispersionSpread_u0028_f1_u003b((¶m_206));
spread_1 = _e318;
let _e322 = layer_info.scene_levels[0i][2u];
let _e325 = layer_info.scene_colour[1u];
width = (_e322 / max(_e325, 0.000000001f));
let _e328 = width;
let _e332 = (*s_9).roughness;
let _e334 = ior_1;
lod_1 = ((log2(max(_e328, 1f)) * _e332) * clamp(((_e334 * 2f) - 2f), 0f, 1f));
let _e339 = g_thickness;
thin = (_e339 <= 0f);
let _e341 = thin;
if _e341 {
let _e343 = (*s_9).v;
local_42 = -(_e343);
} else {
let _e346 = (*s_9).v;
let _e349 = (*s_9).n;
let _e350 = ior_1;
let _e351 = spread_1;
local_42 = refract(-(_e346), _e349, (1f / max((_e350 - _e351), 1f)));
}
let _e356 = local_42;
red = _e356;
let _e357 = thin;
if _e357 {
let _e359 = (*s_9).v;
local_43 = -(_e359);
} else {
let _e362 = (*s_9).v;
let _e365 = (*s_9).n;
let _e366 = ior_1;
local_43 = refract(-(_e362), _e365, (1f / _e366));
}
let _e369 = local_43;
green = _e369;
let _e370 = thin;
if _e370 {
let _e372 = (*s_9).v;
local_44 = -(_e372);
} else {
let _e375 = (*s_9).v;
let _e378 = (*s_9).n;
let _e379 = ior_1;
let _e380 = spread_1;
local_44 = refract(-(_e375), _e378, (1f / (_e379 + _e380)));
}
let _e384 = local_44;
blue = _e384;
let _e385 = v_world_position_1;
let _e386 = red;
let _e387 = g_thickness;
param_207 = (_e385 + (_e386 * _e387));
let _e390 = lod_1;
param_208 = _e390;
let _e391 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_207), (¶m_208));
let _e393 = v_world_position_1;
let _e394 = green;
let _e395 = g_thickness;
param_209 = (_e393 + (_e394 * _e395));
let _e398 = lod_1;
param_210 = _e398;
let _e399 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_209), (¶m_210));
let _e401 = v_world_position_1;
let _e402 = blue;
let _e403 = g_thickness;
param_211 = (_e401 + (_e402 * _e403));
let _e406 = lod_1;
param_212 = _e406;
let _e407 = SceneColourAt_u0028_vf3_u003b_f1_u003b((¶m_211), (¶m_212));
return vec3<f32>(_e391.x, _e399.y, _e407.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_10: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
var ior_2: f32;
var spread_2: f32;
var param_213: f32;
var lod_2: f32;
var thin_1: bool;
var red_1: vec3<f32>;
var local_45: vec3<f32>;
var green_1: vec3<f32>;
var local_46: vec3<f32>;
var blue_1: vec3<f32>;
var local_47: vec3<f32>;
let _e310 = RefractionIor_u0028_();
ior_2 = _e310;
let _e311 = ior_2;
param_213 = _e311;
let _e312 = DispersionSpread_u0028_f1_u003b((¶m_213));
spread_2 = _e312;
let _e314 = (*s_10).roughness;
let _e315 = ior_2;
let _e320 = (*levels);
lod_2 = ((_e314 * clamp(((_e315 * 2f) - 2f), 0f, 1f)) * _e320);
let _e322 = g_thickness;
thin_1 = (_e322 <= 0f);
let _e324 = thin_1;
if _e324 {
let _e326 = (*s_10).v;
local_45 = -(_e326);
} else {
let _e329 = (*s_10).v;
let _e332 = (*s_10).n;
let _e333 = ior_2;
let _e334 = spread_2;
local_45 = refract(-(_e329), _e332, (1f / max((_e333 - _e334), 1f)));
}
let _e339 = local_45;
red_1 = _e339;
let _e340 = thin_1;
if _e340 {
let _e342 = (*s_10).v;
local_46 = -(_e342);
} else {
let _e345 = (*s_10).v;
let _e348 = (*s_10).n;
let _e349 = ior_2;
local_46 = refract(-(_e345), _e348, (1f / _e349));
}
let _e352 = local_46;
green_1 = _e352;
let _e353 = thin_1;
if _e353 {
let _e355 = (*s_10).v;
local_47 = -(_e355);
} else {
let _e358 = (*s_10).v;
let _e361 = (*s_10).n;
let _e362 = ior_2;
let _e363 = spread_2;
local_47 = refract(-(_e358), _e361, (1f / (_e362 + _e363)));
}
let _e367 = local_47;
blue_1 = _e367;
let _e368 = red_1;
let _e369 = lod_2;
let _e370 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e368, _e369);
let _e372 = green_1;
let _e373 = lod_2;
let _e374 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e372, _e373);
let _e376 = blue_1;
let _e377 = lod_2;
let _e378 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e376, _e377);
return vec3<f32>(_e370.x, _e374.y, _e378.z);
}
fn SceneColourBound_u0028_() -> bool {
let _e299 = layer_info.scene_colour[0u];
return (_e299 > 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_214: f32;
var param_215: f32;
var param_216: f32;
var param_217: vec3<f32>;
var param_218: f32;
let _e306 = (*mu_1);
param_214 = _e306;
let _e307 = (*r_4);
param_215 = _e307;
let _e308 = FonAlbedo_u0028_f1_u003b_f1_u003b((¶m_214), (¶m_215));
e_1 = _e308;
let _e309 = (*rho_2);
let _e310 = e_1;
let _e312 = (*r_4);
param_216 = _e312;
let _e313 = FonAverage_u0028_f1_u003b((¶m_216));
let _e314 = (*rho_2);
param_217 = _e314;
param_218 = _e313;
let _e315 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((¶m_217), (¶m_218));
let _e316 = e_1;
return ((_e309 * _e310) + (_e315 * (1f - _e316)));
}
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 _e304 = (*opd);
phase = ((6.2831855f * _e304) * 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 _e307 = val;
let _e308 = variance_1;
let _e312 = pos;
let _e313 = phase;
let _e315 = (*shift);
let _e319 = phase;
let _e320 = phase;
let _e323 = variance_1;
xyz = (((_e307 * sqrt((_e308 * 6.2831855f))) * cos(((_e312 * _e313) + _e315))) * exp((_e323 * -((_e319 * _e320)))));
let _e327 = phase;
let _e330 = (*shift)[0u];
let _e334 = phase;
let _e336 = phase;
let _e341 = xyz[0u];
xyz[0u] = (_e341 + ((0.00000001644083f * cos(((2239900f * _e327) + _e330))) * exp(((-4528200000f * _e334) * _e336))));
let _e344 = xyz;
xyz = (_e344 / vec3(0.00000010685f));
let _e347 = 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)) * _e347);
}
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_2: i32;
var param_219: f32;
var param_220: vec3<f32>;
var local_48: vec3<f32>;
let _e326 = (*film);
let _e327 = (*thickness);
eta2_ = mix(1f, _e326, smoothstep(0f, 0.03f, _e327));
let _e330 = (*cos1_);
let _e331 = (*cos1_);
let _e334 = eta2_;
let _e335 = eta2_;
sin2Sq = ((1f - (_e330 * _e331)) / (_e334 * _e335));
let _e338 = sin2Sq;
cos2Sq = (1f - _e338);
let _e340 = cos2Sq;
cos2_ = sqrt(max(_e340, 0f));
let _e343 = eta2_;
let _e345 = eta2_;
r0_ = ((_e343 - 1f) / (_e345 + 1f));
let _e348 = r0_;
let _e349 = r0_;
let _e351 = r0_;
let _e352 = r0_;
let _e355 = (*cos1_);
r12_ = ((_e348 * _e349) + ((1f - (_e351 * _e352)) * pow((1f - _e355), 5f)));
let _e360 = r12_;
t121_ = (1f - _e360);
let _e362 = eta2_;
phi12_ = select(0f, 3.1415927f, (_e362 < 1f));
let _e365 = phi12_;
phi21_ = (3.1415927f - _e365);
let _e367 = (*base);
sqrtBase = sqrt(clamp(_e367, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
let _e370 = sqrtBase;
let _e372 = sqrtBase;
baseIor = ((vec3<f32>(1f, 1f, 1f) + _e370) / (vec3<f32>(1f, 1f, 1f) - _e372));
let _e375 = baseIor;
let _e376 = eta2_;
let _e379 = baseIor;
let _e380 = eta2_;
r1_ = ((_e375 - vec3(_e376)) / (_e379 + vec3(_e380)));
let _e384 = r1_;
let _e385 = r1_;
r1_ = (_e385 * _e384);
let _e387 = r1_;
let _e388 = r1_;
let _e390 = cos2_;
r23_ = (_e387 + ((vec3<f32>(1f, 1f, 1f) - _e388) * pow((1f - _e390), 5f)));
let _e396 = baseIor[0u];
let _e397 = eta2_;
let _e401 = baseIor[1u];
let _e402 = eta2_;
let _e406 = baseIor[2u];
let _e407 = eta2_;
phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e396 < _e397)), select(0f, 3.1415927f, (_e401 < _e402)), select(0f, 3.1415927f, (_e406 < _e407)));
let _e411 = eta2_;
let _e413 = (*thickness);
let _e415 = cos2_;
opd_1 = (((2f * _e411) * _e413) * _e415);
let _e417 = phi21_;
let _e419 = phi23_;
phi = (vec3(_e417) + _e419);
let _e421 = r12_;
let _e422 = r23_;
r123_ = clamp((_e422 * _e421), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
let _e425 = r123_;
rootR123_ = sqrt(_e425);
let _e427 = t121_;
let _e428 = t121_;
let _e430 = r23_;
let _e432 = r123_;
rs = ((_e430 * (_e427 * _e428)) / (vec3<f32>(1f, 1f, 1f) - _e432));
let _e435 = r12_;
let _e437 = rs;
total_2 = (vec3(_e435) + _e437);
let _e439 = rs;
let _e440 = t121_;
cm = (_e439 - vec3(_e440));
m_2 = 1i;
loop {
let _e443 = m_2;
if (_e443 <= 2i) {
let _e445 = rootR123_;
let _e446 = cm;
cm = (_e446 * _e445);
let _e448 = cm;
let _e450 = m_2;
let _e452 = opd_1;
let _e454 = m_2;
let _e456 = phi;
param_219 = (f32(_e450) * _e452);
param_220 = (_e456 * f32(_e454));
let _e458 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((¶m_219), (¶m_220));
let _e460 = total_2;
total_2 = (_e460 + ((_e448 * 2f) * _e458));
continue;
} else {
break;
}
continuing {
let _e462 = m_2;
m_2 = (_e462 + 1i);
}
}
let _e464 = cos2Sq;
if (_e464 < 0f) {
local_48 = vec3<f32>(1f, 1f, 1f);
} else {
let _e466 = total_2;
local_48 = max(_e466, vec3<f32>(0f, 0f, 0f));
}
let _e468 = local_48;
return _e468;
}
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_11: ptr<function, Surface>) {
var f0_3: vec3<f32>;
var param_221: f32;
var param_222: f32;
var param_223: f32;
var param_224: vec3<f32>;
let _e303 = g_f0_dielectric;
let _e305 = (*s_11).albedo;
let _e307 = (*s_11).metallic;
f0_3 = mix(_e303, _e305, vec3(clamp(_e307, 0f, 1f)));
let _e313 = layer_info.iridescence[1u];
param_221 = _e313;
let _e315 = (*s_11).n_dot_v;
param_222 = _e315;
let _e318 = layer_info.iridescence[2u];
param_223 = _e318;
let _e319 = f0_3;
param_224 = _e319;
let _e320 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((¶m_221), (¶m_222), (¶m_223), (¶m_224));
g_irid_fresnel = _e320;
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_12: ptr<function, Surface>) {
var param_225: f32;
var param_226: f32;
var param_227: f32;
var t_2: vec3<f32>;
var usable: bool;
var local_49: vec3<f32>;
var b_4: vec3<f32>;
var turn_2: vec2<f32>;
var along_1: vec3<f32>;
var local_50: f32;
var local_51: vec3<f32>;
var phi_5354_: bool;
let _e310 = (*s_12).n_dot_v;
let _e314 = g_sheen_roughness;
param_225 = _e314;
param_226 = sqrt(clamp((1f - _e310), 0f, 1f));
param_227 = 1f;
let _e315 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_225), (¶m_226), (¶m_227));
let _e316 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e315, 0f);
g_sheen_albedo = _e316.z;
let _e319 = g_sheen[0u];
let _e321 = g_sheen[1u];
let _e324 = g_sheen[2u];
let _e326 = g_sheen_albedo;
g_sheen_scale = (1f - (max(max(_e319, _e321), _e324) * _e326));
let _e329 = v_tangent_1;
let _e332 = (*s_12).n;
let _e334 = (*s_12).n;
let _e335 = v_tangent_1;
t_2 = (_e329.xyz - (_e332 * dot(_e334, _e335.xyz)));
let _e340 = t_2;
let _e341 = t_2;
usable = (dot(_e340, _e341) > 0.000000000001f);
let _e344 = usable;
if _e344 {
let _e345 = t_2;
local_49 = normalize(_e345);
} else {
local_49 = vec3<f32>(1f, 0f, 0f);
}
let _e347 = local_49;
t_2 = _e347;
let _e349 = (*s_12).n;
let _e350 = t_2;
let _e353 = v_tangent_1[3u];
b_4 = (cross(_e349, _e350) * _e353);
let _e355 = gl_FrontFacing_1;
if !(_e355) {
let _e357 = t_2;
t_2 = -(_e357);
}
let _e360 = layer_info.anisotropy;
turn_2 = _e360.yz;
let _e362 = t_2;
let _e364 = turn_2[0u];
let _e366 = b_4;
let _e368 = turn_2[1u];
along_1 = ((_e362 * _e364) + (_e366 * _e368));
let _e371 = usable;
phi_5354_ = _e371;
if _e371 {
let _e372 = along_1;
let _e373 = along_1;
phi_5354_ = (dot(_e372, _e373) > 0.000000000001f);
}
let _e377 = phi_5354_;
if _e377 {
let _e380 = layer_info.anisotropy[0u];
local_50 = clamp(_e380, 0f, 1f);
} else {
local_50 = 0f;
}
let _e382 = local_50;
g_aniso = _e382;
let _e383 = g_aniso;
if (_e383 > 0f) {
let _e385 = along_1;
local_51 = normalize(_e385);
} else {
let _e387 = t_2;
local_51 = _e387;
}
let _e388 = local_51;
g_aniso_t = _e388;
let _e390 = (*s_12).n;
let _e391 = g_aniso_t;
g_aniso_b = cross(_e390, _e391);
return;
}
fn MaterialLodBias_u0028_() -> f32 {
let _e299 = frag_info.target_origin[1u];
return _e299;
}
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_13: ptr<function, Surface>) {
var orm: vec3<f32>;
var param_228: i32;
param_228 = 1i;
let _e300 = MapUv_u0028_i1_u003b((¶m_228));
let _e301 = MaterialLodBias_u0028_();
let _e302 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e300, _e301);
orm = _e302.xyz;
let _e305 = (*s_13).metallic;
let _e307 = orm[2u];
(*s_13).metallic = clamp((_e305 * _e307), 0f, 1f);
let _e312 = (*s_13).roughness;
let _e314 = orm[1u];
(*s_13).roughness = clamp((_e312 * _e314), 0.02f, 1f);
return;
}
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_14: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_229: i32;
var param_230: vec3<f32>;
param_229 = 4i;
let _e301 = MapUv_u0028_i1_u003b((¶m_229));
let _e302 = MaterialLodBias_u0028_();
let _e303 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e301, _e302);
param_230 = _e303.xyz;
let _e305 = SrgbToLinear_u0028_vf3_u003b((¶m_230));
emissive = _e305;
let _e306 = emissive;
let _e308 = frag_info.emissive;
let _e313 = frag_info.material2_[3u];
(*s_14).emissive = ((_e306 * _e308.xyz) * _e313);
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_15: ptr<function, Surface>) {
var occlusion: f32;
var param_231: i32;
param_231 = 3i;
let _e300 = MapUv_u0028_i1_u003b((¶m_231));
let _e301 = MaterialLodBias_u0028_();
let _e302 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e300, _e301);
occlusion = _e302.x;
let _e304 = occlusion;
let _e307 = frag_info.material2_[2u];
(*s_15).occlusion = mix(1f, _e304, clamp(_e307, 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 _e300 = (*slot_7);
let _e304 = layer_info.uv_transform[(_e300 * 2i)];
u_2 = _e304;
let _e305 = (*slot_7);
let _e310 = layer_info.uv_transform[((_e305 * 2i) + 1i)];
v_3 = _e310;
let _e312 = u_2[0u];
let _e314 = u_2[1u];
let _e316 = v_3[0u];
let _e318 = v_3[1u];
return vec4<f32>(_e312, _e314, _e316, _e318);
}
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_16: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var param_232: i32;
var t_3: vec3<f32>;
var b_5: vec3<f32>;
var m_3: vec4<f32>;
var param_233: i32;
var det: f32;
var flip: f32;
var front: vec3<f32>;
var local_52: vec3<f32>;
var turned: vec3<f32>;
var turns: bool;
var local_53: vec3<f32>;
var local_54: vec3<f32>;
var sampled: vec3<f32>;
var phi_4061_: bool;
var phi_4068_: bool;
var phi_4075_: bool;
var phi_4082_: bool;
param_232 = 2i;
let _e313 = MapUv_u0028_i1_u003b((¶m_232));
let _e314 = MaterialLodBias_u0028_();
let _e315 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e313, _e314);
sampledTexel = _e315;
let _e316 = v_tangent_1;
t_3 = _e316.xyz;
let _e318 = t_3;
let _e320 = (*s_16).n;
let _e322 = (*s_16).n;
let _e323 = t_3;
t_3 = (_e318 - (_e320 * dot(_e322, _e323)));
let _e327 = t_3;
let _e328 = t_3;
if (dot(_e327, _e328) < 0.000000000001f) {
return;
}
let _e331 = t_3;
t_3 = normalize(_e331);
let _e334 = (*s_16).n;
let _e335 = t_3;
let _e338 = v_tangent_1[3u];
b_5 = (cross(_e334, _e335) * _e338);
param_233 = 2i;
let _e340 = MapMatrix_u0028_i1_u003b((¶m_233));
m_3 = _e340;
let _e342 = m_3[0u];
let _e344 = m_3[3u];
let _e347 = m_3[1u];
let _e349 = m_3[2u];
det = ((_e342 * _e344) - (_e347 * _e349));
let _e352 = det;
flip = select(1f, -1f, (_e352 < 0f));
let _e355 = gl_FrontFacing_1;
if _e355 {
let _e356 = b_5;
local_52 = _e356;
} else {
let _e357 = b_5;
local_52 = -(_e357);
}
let _e359 = local_52;
front = _e359;
let _e360 = t_3;
let _e362 = m_3[3u];
let _e364 = front;
let _e366 = m_3[2u];
let _e369 = flip;
turned = (((_e360 * _e362) + (_e364 * _e366)) * _e369);
let _e372 = m_3[1u];
let _e373 = (_e372 != 0f);
phi_4061_ = _e373;
if !(_e373) {
let _e376 = m_3[2u];
phi_4061_ = (_e376 != 0f);
}
let _e379 = phi_4061_;
phi_4068_ = _e379;
if !(_e379) {
let _e382 = m_3[0u];
phi_4068_ = (_e382 < 0f);
}
let _e385 = phi_4068_;
phi_4075_ = _e385;
if !(_e385) {
let _e388 = m_3[3u];
phi_4075_ = (_e388 < 0f);
}
let _e391 = phi_4075_;
phi_4082_ = _e391;
if _e391 {
let _e392 = turned;
let _e393 = turned;
phi_4082_ = (dot(_e392, _e393) > 0.000000000001f);
}
let _e397 = phi_4082_;
turns = _e397;
let _e398 = turns;
if _e398 {
let _e399 = turned;
local_53 = normalize(_e399);
} else {
let _e401 = t_3;
local_53 = _e401;
}
let _e402 = local_53;
t_3 = _e402;
let _e403 = turns;
if _e403 {
let _e405 = (*s_16).n;
let _e406 = t_3;
let _e409 = v_tangent_1[3u];
let _e411 = flip;
local_54 = ((cross(_e405, _e406) * _e409) * _e411);
} else {
let _e413 = b_5;
local_54 = _e413;
}
let _e414 = local_54;
b_5 = _e414;
let _e415 = gl_FrontFacing_1;
if !(_e415) {
let _e417 = t_3;
t_3 = -(_e417);
}
let _e419 = sampledTexel;
sampled = ((_e419.xyz * 2f) - vec3(1f));
let _e426 = frag_info.emissive[3u];
if (_e426 > 0.5f) {
let _e428 = sampled;
let _e430 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e428.xy, _e430.xy)), 0f));
}
let _e439 = frag_info.material2_[1u];
let _e440 = sampled;
let _e442 = (_e440.xy * _e439);
sampled[0u] = _e442.x;
sampled[1u] = _e442.y;
let _e447 = t_3;
let _e449 = sampled[0u];
let _e451 = b_5;
let _e453 = sampled[1u];
let _e457 = (*s_16).n;
let _e459 = sampled[2u];
(*s_16).n = normalize((((_e447 * _e449) + (_e451 * _e453)) + (_e457 * _e459)));
let _e465 = (*s_16).n;
let _e467 = (*s_16).v;
(*s_16).n_dot_v = max(dot(_e465, _e467), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e298 = (*texel_5);
let _e302 = irradiance_info.atlas;
let _e305 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e298 + vec2(0.5f)) * _e302.xy), 0f);
return _e305;
}
fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_9: 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_234: vec2<f32>;
var b_6: vec4<f32>;
var param_235: vec2<f32>;
var c_1: vec4<f32>;
var param_236: vec2<f32>;
var d_6: vec4<f32>;
var param_237: vec2<f32>;
let _e311 = (*uv_9);
let _e312 = (*interior);
at_5 = ((vec2(1f) + (_e311 * _e312)) - vec2(0.5f));
let _e318 = at_5;
low = floor(_e318);
let _e320 = at_5;
let _e321 = low;
f_5 = (_e320 - _e321);
let _e323 = (*corner);
let _e324 = low;
param_234 = (_e323 + _e324);
let _e326 = AtlasTexel_u0028_vf2_u003b((¶m_234));
a_6 = _e326;
let _e327 = (*corner);
let _e328 = low;
param_235 = ((_e327 + _e328) + vec2<f32>(1f, 0f));
let _e331 = AtlasTexel_u0028_vf2_u003b((¶m_235));
b_6 = _e331;
let _e332 = (*corner);
let _e333 = low;
param_236 = ((_e332 + _e333) + vec2<f32>(0f, 1f));
let _e336 = AtlasTexel_u0028_vf2_u003b((¶m_236));
c_1 = _e336;
let _e337 = (*corner);
let _e338 = low;
param_237 = ((_e337 + _e338) + vec2<f32>(1f, 1f));
let _e341 = AtlasTexel_u0028_vf2_u003b((¶m_237));
d_6 = _e341;
let _e342 = a_6;
let _e343 = b_6;
let _e345 = f_5[0u];
let _e348 = c_1;
let _e349 = d_6;
let _e351 = f_5[0u];
let _e355 = f_5[1u];
return mix(mix(_e342, _e343, vec4(_e345)), mix(_e348, _e349, vec4(_e351)), vec4(_e355));
}
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 _e302 = (*direction_1)[0u];
let _e305 = (*direction_1)[1u];
let _e309 = (*direction_1)[2u];
sum_1 = ((abs(_e302) + abs(_e305)) + abs(_e309));
let _e312 = sum_1;
if (_e312 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e314 = (*direction_1);
let _e315 = sum_1;
n_6 = (_e314 / vec3(_e315));
let _e318 = n_6;
xy = _e318.xy;
let _e321 = n_6[2u];
if (_e321 < 0f) {
let _e324 = n_6[1u];
let _e328 = n_6[0u];
let _e333 = n_6[0u];
let _e337 = n_6[1u];
xy = vec2<f32>(((1f - abs(_e324)) * select(-1f, 1f, (_e328 >= 0f))), ((1f - abs(_e333)) * select(-1f, 1f, (_e337 >= 0f))));
}
let _e342 = xy;
return ((_e342 * 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_2: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_238: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_239: vec3<f32>;
var param_240: vec2<f32>;
var param_241: f32;
var param_242: vec2<f32>;
var chebyshev: f32;
var variance_2: f32;
var difference: f32;
var param_243: vec3<f32>;
var param_244: vec2<f32>;
var param_245: f32;
var param_246: vec2<f32>;
var local_55: vec3<f32>;
let _e344 = irradiance_info.origin;
origin_2 = _e344.xyz;
let _e347 = irradiance_info.spacing;
spacing = _e347.xyz;
let _e350 = irradiance_info.counts;
counts = _e350.xyz;
let _e354 = irradiance_info.tiles[0u];
irradianceTile = _e354;
let _e357 = irradiance_info.tiles[1u];
depthTile = _e357;
let _e360 = irradiance_info.tiles[2u];
columns = _e360;
let _e363 = irradiance_info.tiles[3u];
momentsTop = _e363;
let _e364 = (*normal_1);
unit = normalize(_e364);
let _e366 = (*world_5);
let _e367 = unit;
let _e370 = irradiance_info.spacing[3u];
let _e373 = (*view_2);
let _e376 = irradiance_info.counts[3u];
biased = ((_e366 + (_e367 * _e370)) + (_e373 * _e376));
let _e379 = biased;
let _e380 = origin_2;
let _e382 = spacing;
grid_1 = ((_e379 - _e380) / _e382);
let _e384 = grid_1;
let _e386 = counts;
base_1 = clamp(floor(_e384), vec3<f32>(0f, 0f, 0f), (_e386 - vec3(2f)));
let _e390 = grid_1;
let _e391 = base_1;
f_6 = clamp((_e390 - _e391), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_3 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e394 = corner_1;
if (_e394 < 8i) {
let _e396 = corner_1;
let _e399 = corner_1;
let _e404 = corner_1;
offset_3 = vec3<f32>(f32((_e396 & 1i)), f32(((_e399 >> bitcast<u32>(1i)) & 1i)), f32(((_e404 >> bitcast<u32>(2i)) & 1i)));
let _e410 = base_1;
let _e411 = offset_3;
cell_2 = (_e410 + _e411);
let _e414 = cell_2[2u];
let _e416 = counts[1u];
let _e419 = cell_2[1u];
let _e422 = counts[0u];
let _e425 = cell_2[0u];
probe = ((((_e414 * _e416) + _e419) * _e422) + _e425);
let _e427 = probe;
let _e428 = columns;
let _e433 = probe;
let _e434 = columns;
tile_4 = vec2<f32>((_e427 - (floor((_e427 / _e428)) * _e428)), floor((_e433 / _e434)));
let _e438 = tile_4;
let _e439 = irradianceTile;
irradianceCorner = (_e438 * (_e439 + 2f));
let _e443 = tile_4[0u];
let _e444 = depthTile;
let _e447 = momentsTop;
let _e449 = tile_4[1u];
let _e450 = depthTile;
momentCorner = vec2<f32>((_e443 * (_e444 + 2f)), (_e447 + (_e449 * (_e450 + 2f))));
let _e455 = irradianceCorner;
param_238 = (_e455 + vec2(1f));
let _e458 = AtlasTexel_u0028_vf2_u003b((¶m_238));
if (_e458.w < 0.5f) {
continue;
}
let _e461 = f_6;
let _e463 = f_6;
let _e464 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e461), _e463, _e464);
let _e467 = trilinear[0u];
let _e469 = trilinear[1u];
let _e472 = trilinear[2u];
weight_3 = max(((_e467 * _e469) * _e472), 0.001f);
let _e475 = origin_2;
let _e476 = spacing;
let _e477 = cell_2;
probePosition = (_e475 + (_e476 * _e477));
let _e480 = probePosition;
let _e481 = biased;
toProbe = (_e480 - _e481);
let _e483 = toProbe;
distance_4 = length(_e483);
let _e485 = distance_4;
if (_e485 > 0.000001f) {
let _e487 = toProbe;
let _e488 = distance_4;
direction_2 = (_e487 / vec3(_e488));
let _e491 = unit;
let _e492 = probePosition;
let _e493 = (*world_5);
facing = ((dot(_e491, normalize((_e492 - _e493))) * 0.5f) + 0.5f);
let _e499 = facing;
let _e500 = facing;
probeWeight = ((_e499 * _e500) + 0.2f);
let _e503 = direction_2;
param_239 = -(_e503);
let _e505 = ProbeOctahedral_u0028_vf3_u003b((¶m_239));
let _e506 = momentCorner;
param_240 = _e506;
let _e507 = depthTile;
param_241 = _e507;
param_242 = _e505;
let _e508 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_240), (¶m_241), (¶m_242));
moments_3 = _e508.xy;
chebyshev = 1f;
let _e510 = distance_4;
let _e512 = moments_3[0u];
if (_e510 > _e512) {
let _e515 = moments_3[1u];
let _e517 = moments_3[0u];
let _e519 = moments_3[0u];
variance_2 = max((_e515 - (_e517 * _e519)), 0.000001f);
let _e523 = distance_4;
let _e525 = moments_3[0u];
difference = (_e523 - _e525);
let _e527 = variance_2;
let _e528 = variance_2;
let _e529 = difference;
let _e530 = difference;
chebyshev = (_e527 / (_e528 + (_e529 * _e530)));
let _e534 = chebyshev;
let _e535 = chebyshev;
let _e537 = chebyshev;
chebyshev = ((_e534 * _e535) * _e537);
}
let _e539 = probeWeight;
let _e540 = chebyshev;
probeWeight = max((_e539 * max(_e540, 0.05f)), 0.000001f);
let _e544 = probeWeight;
if (_e544 < 0.2f) {
let _e546 = probeWeight;
let _e547 = probeWeight;
let _e550 = probeWeight;
probeWeight = (_e550 * ((_e546 * _e547) * 25f));
}
let _e552 = probeWeight;
let _e553 = weight_3;
weight_3 = (_e553 * _e552);
}
let _e555 = unit;
param_243 = _e555;
let _e556 = ProbeOctahedral_u0028_vf3_u003b((¶m_243));
let _e557 = irradianceCorner;
param_244 = _e557;
let _e558 = irradianceTile;
param_245 = _e558;
param_246 = _e556;
let _e559 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_244), (¶m_245), (¶m_246));
let _e561 = weight_3;
let _e563 = total_3;
total_3 = (_e563 + (_e559.xyz * _e561));
let _e565 = weight_3;
let _e566 = weights;
weights = (_e566 + _e565);
continue;
} else {
break;
}
continuing {
let _e568 = corner_1;
corner_1 = (_e568 + 1i);
}
}
let _e570 = weights;
if (_e570 > 0f) {
let _e572 = total_3;
let _e573 = weights;
local_55 = (_e572 / vec3(_e573));
} else {
local_55 = vec3<f32>(0f, 0f, 0f);
}
let _e576 = local_55;
return _e576;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e299 = irradiance_info.origin[3u];
return (_e299 > 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_17: ptr<function, Surface>) {
var param_247: vec3<f32>;
var param_248: vec3<f32>;
var param_249: vec3<f32>;
var param_250: Surface;
var param_251: Surface;
var param_252: Surface;
let _e304 = IrradianceEnabled_u0028_();
if _e304 {
let _e305 = v_world_position_1;
param_247 = _e305;
let _e307 = (*s_17).n;
param_248 = _e307;
let _e309 = (*s_17).v;
param_249 = _e309;
let _e310 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_247), (¶m_248), (¶m_249));
let _e313 = frag_info.material[2u];
(*s_17).ambient = (_e310 * _e313);
}
let _e316 = (*s_17);
param_250 = _e316;
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_250));
let _e317 = param_250;
(*s_17) = _e317;
let _e318 = (*s_17);
param_251 = _e318;
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_251));
let _e319 = param_251;
(*s_17) = _e319;
let _e320 = (*s_17);
param_252 = _e320;
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_252));
let _e321 = param_252;
(*s_17) = _e321;
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_18: ptr<function, Surface>) {
var coatTexel: vec4<f32>;
var sheenTexel: vec4<f32>;
var param_253: vec3<f32>;
var ior_3: f32;
var r_5: f32;
var local_56: f32;
var bent: vec3<f32>;
var distance_5: f32;
var local_57: vec3<f32>;
var fc: f32;
let _e308 = v_texcoord_1;
let _e309 = MaterialLodBias_u0028_();
let _e310 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e308, _e309);
coatTexel = _e310;
let _e311 = v_texcoord_1;
let _e312 = MaterialLodBias_u0028_();
let _e313 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e311, _e312);
sheenTexel = _e313;
let _e315 = layer_info.sheen;
let _e317 = sheenTexel;
param_253 = _e317.xyz;
let _e319 = SrgbToLinear_u0028_vf3_u003b((¶m_253));
g_sheen = (_e315.xyz * _e319);
let _e323 = layer_info.sheen[3u];
let _e325 = sheenTexel[3u];
g_sheen_roughness = clamp((_e323 * _e325), 0.07f, 1f);
let _e330 = layer_info.coat[2u];
ior_3 = max(_e330, 1f);
let _e332 = IorInfinite_u0028_();
if _e332 {
local_56 = 1f;
} else {
let _e333 = ior_3;
let _e335 = ior_3;
local_56 = ((_e333 - 1f) / (_e335 + 1f));
}
let _e338 = local_56;
r_5 = _e338;
let _e339 = r_5;
let _e340 = r_5;
let _e344 = layer_info.specular;
let _e350 = layer_info.specular[3u];
g_f0_dielectric = (min((vec3((_e339 * _e340)) * _e344.xyz), vec3<f32>(1f, 1f, 1f)) * _e350);
let _e354 = layer_info.specular[3u];
g_f90_ = _e354;
let _e357 = layer_info.coat[0u];
let _e359 = coatTexel[0u];
g_coat = clamp((_e357 * _e359), 0f, 1f);
let _e364 = layer_info.coat[1u];
let _e366 = coatTexel[1u];
g_coat_roughness = clamp((_e364 * _e366), 0.02f, 1f);
let _e371 = layer_info.transmission[0u];
let _e373 = coatTexel[2u];
g_transmission = clamp((_e371 * _e373), 0f, 1f);
let _e378 = layer_info.transmission[1u];
let _e380 = coatTexel[3u];
g_thickness = max((_e378 * _e380), 0f);
let _e385 = layer_info.attenuation[3u];
let _e387 = g_thickness;
if ((_e385 > 0.5f) && (_e387 > 0f)) {
let _e391 = (*s_18).v;
let _e394 = (*s_18).n;
let _e395 = RefractionIor_u0028_();
bent = refract(-(_e391), _e394, (1f / _e395));
let _e398 = g_thickness;
let _e400 = (*s_18).n;
let _e401 = bent;
let _e406 = g_thickness;
g_thickness = max((_e398 * max(-(dot(_e400, _e401)), 0f)), (0.0001f * _e406));
}
let _e411 = layer_info.transmission[2u];
distance_5 = _e411;
let _e412 = distance_5;
if (_e412 > 0f) {
let _e415 = layer_info.attenuation;
let _e418 = g_thickness;
let _e419 = distance_5;
local_57 = pow(max(_e415.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e418 / _e419)));
} else {
local_57 = vec3<f32>(1f, 1f, 1f);
}
let _e423 = local_57;
g_transmittance = _e423;
let _e426 = layer_info.iridescence[0u];
g_iridescence = clamp(_e426, 0f, 1f);
let _e429 = (*s_18).n;
g_coat_n = _e429;
let _e431 = (*s_18).n;
let _e433 = (*s_18).v;
g_coat_n_dot_v = max(dot(_e431, _e433), 0.0001f);
let _e436 = g_coat_n_dot_v;
fc = (0.04f + (0.96f * pow((1f - _e436), 5f)));
let _e441 = g_coat;
let _e442 = fc;
g_coat_through = (1f - (_e441 * _e442));
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_58: vec3<f32>;
let _e298 = Orthographic_u0028_();
if _e298 {
let _e300 = fog_info.forward;
local_58 = -(_e300.xyz);
} else {
let _e304 = fog_info.eye;
let _e306 = v_world_position_1;
local_58 = normalize((_e304.xyz - _e306));
}
let _e309 = local_58;
return _e309;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var param_254: i32;
var s_19: Surface;
var param_255: vec3<f32>;
var param_256: vec3<f32>;
var cutoff: f32;
var edge: f32;
param_254 = 0i;
let _e304 = MapUv_u0028_i1_u003b((¶m_254));
let _e305 = MaterialLodBias_u0028_();
let _e306 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e304, _e305);
texel_6 = _e306;
let _e307 = texel_6;
param_255 = _e307.xyz;
let _e309 = SrgbToLinear_u0028_vf3_u003b((¶m_255));
let _e311 = frag_info.base_color;
param_256 = _e311.xyz;
let _e313 = SrgbToLinear_u0028_vf3_u003b((¶m_256));
let _e315 = v_color_1;
s_19.albedo = ((_e309 * _e313) * _e315.xyz);
let _e320 = texel_6[3u];
let _e323 = frag_info.base_color[3u];
let _e326 = v_color_1[3u];
s_19.alpha = ((_e320 * _e323) * _e326);
let _e330 = s_19.albedo;
g_albedo = _e330;
let _e333 = frag_info.material2_[0u];
cutoff = _e333;
let _e334 = cutoff;
if (_e334 > 1f) {
let _e336 = cutoff;
edge = (_e336 - 1f);
let _e339 = s_19.alpha;
let _e340 = edge;
let _e343 = s_19.alpha;
let _e344 = fwidth(_e343);
s_19.alpha = clamp((((_e339 - _e340) / max(_e344, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e350 = cutoff;
if (_e350 >= 0f) {
s_19.alpha = 1f;
}
}
let _e353 = cutoff;
let _e355 = cutoff;
g_premultiply = ((_e353 < 0f) && (_e355 > -0.75f));
let _e358 = v_normal_1;
s_19.n = normalize(_e358);
let _e361 = gl_FrontFacing_1;
if !(_e361) {
let _e364 = s_19.n;
s_19.n = -(_e364);
}
let _e367 = TowardsEye_u0028_();
s_19.v = _e367;
let _e370 = s_19.n;
let _e372 = s_19.v;
s_19.n_dot_v = max(dot(_e370, _e372), 0.0001f);
let _e378 = frag_info.material[0u];
s_19.metallic = clamp(_e378, 0f, 1f);
let _e383 = frag_info.material[1u];
s_19.roughness = clamp(_e383, 0.02f, 1f);
let _e387 = frag_info.ambient_ground;
let _e390 = frag_info.ambient_sky;
let _e394 = s_19.n[1u];
let _e401 = frag_info.material[2u];
s_19.ambient = (mix(_e387.xyz, _e390.xyz, vec3(((_e394 * 0.5f) + 0.5f))) * _e401);
let _e406 = frag_info.frame_params[0u];
s_19.exposure = max(_e406, 0f);
s_19.occlusion = 1f;
s_19.emissive = vec3<f32>(0f, 0f, 0f);
let _e411 = s_19;
return _e411;
}
fn main_1() {
var s_20: Surface;
var param_257: Surface;
var param_258: Surface;
var param_259: Surface;
var param_260: Surface;
var param_261: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var param_262: vec3<f32>;
var param_263: f32;
var param_264: 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_1: 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_265: f32;
var param_266: 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_1: vec3<f32>;
var local_59: vec3<f32>;
var param_267: Surface;
var param_268: f32;
var coatPrefiltered: vec3<f32>;
var coatAb: vec2<f32>;
var param_269: f32;
var param_270: f32;
var sceneAb: vec2<f32>;
var param_271: f32;
var param_272: f32;
var sceneReflects: vec3<f32>;
var passes: vec3<f32>;
var param_273: Surface;
var sheenAmbient: vec3<f32>;
var lit_3: vec3<f32>;
var param_274: Surface;
var param_275: Surface;
var param_276: vec3<f32>;
var param_277: vec3<f32>;
var param_278: f32;
var param_279: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
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);
g_pane = false;
let _e353 = ReadSurface_u0028_();
s_20 = _e353;
let _e354 = s_20;
param_257 = _e354;
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_257));
let _e355 = s_20;
param_258 = _e355;
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_258));
let _e356 = param_258;
s_20 = _e356;
let _e357 = s_20;
param_259 = _e357;
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_259));
let _e358 = param_259;
s_20 = _e358;
let _e359 = s_20;
param_260 = _e359;
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_260));
let _e360 = s_20;
param_261 = _e360;
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_261));
let _e362 = s_20.metallic;
metallic = clamp(_e362, 0f, 1f);
let _e365 = s_20.albedo;
let _e366 = metallic;
diffuseColor_1 = (_e365 * (1f - _e366));
let _e369 = EonDiffuse_u0028_();
if _e369 {
let _e370 = diffuseColor_1;
param_262 = _e370;
let _e372 = s_20.roughness;
param_263 = _e372;
let _e374 = s_20.n_dot_v;
param_264 = _e374;
let _e375 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_262), (¶m_263), (¶m_264));
diffuseColor_1 = _e375;
}
let _e376 = diffuseColor_1;
let _e378 = s_20.ambient;
let _e381 = s_20.occlusion;
ambient = ((_e376 * _e378) * _e381);
let _e383 = g_premultiply;
let _e384 = g_transmission;
let _e387 = g_thickness;
g_pane = ((_e383 && (_e384 > 0f)) && (_e387 <= 0f));
let _e390 = SceneColourBound_u0028_();
let _e391 = g_pane;
let _e393 = g_transmittance;
let _e396 = g_transmission;
let _e399 = ambient;
ambient = (_e399 * mix(vec3<f32>(1f, 1f, 1f), select(_e393, vec3<f32>(0f, 0f, 0f), vec3((_e390 || _e391))), vec3(_e396)));
let _e403 = frag_info.frame_params[3u];
levels_1 = _e403;
coatAmbient = vec3<f32>(0f, 0f, 0f);
let _e405 = s_20.ambient;
sheenIncoming = _e405;
let _e406 = levels_1;
if (_e406 > 0f) {
let _e408 = g_f0_dielectric;
let _e410 = s_20.albedo;
let _e411 = metallic;
f0_4 = mix(_e408, _e410, vec3(_e411));
let _e414 = g_f90_;
let _e415 = metallic;
f90_2 = mix(_e414, 1f, _e415);
let _e418 = s_20.n;
bent_1 = _e418;
let _e419 = g_aniso;
if (_e419 > 0f) {
let _e421 = g_aniso_t;
let _e423 = s_20.v;
across = cross(_e421, _e423);
let _e425 = across;
let _e426 = g_aniso_t;
anisoN = cross(_e425, _e426);
let _e428 = g_aniso;
let _e430 = s_20.roughness;
bend = (1f - (_e428 * (1f - _e430)));
let _e434 = bend;
let _e435 = bend;
let _e437 = bend;
let _e439 = bend;
bend4_ = (((_e434 * _e435) * _e437) * _e439);
let _e441 = anisoN;
let _e443 = s_20.n;
let _e444 = bend4_;
bent_1 = normalize(mix(_e441, _e443, vec3(_e444)));
}
let _e449 = s_20.v;
let _e451 = bent_1;
reflected = reflect(-(_e449), _e451);
let _e454 = s_20.n;
let _e455 = levels_1;
let _e456 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e454, _e455);
irradiance = _e456.xyz;
let _e458 = reflected;
let _e460 = s_20.roughness;
let _e461 = levels_1;
let _e463 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e458, (_e460 * _e461));
prefiltered = _e463.xyz;
let _e466 = s_20.roughness;
param_265 = _e466;
let _e468 = s_20.n_dot_v;
param_266 = _e468;
let _e469 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_265), (¶m_266));
ab_4 = _e469;
let _e470 = f0_4;
let _e471 = g_irid_fresnel;
let _e472 = g_iridescence;
let _e476 = ab_4[0u];
let _e478 = f90_2;
let _e480 = ab_4[1u];
single_1 = ((mix(_e470, _e471, vec3(_e472)) * _e476) + vec3((_e478 * _e480)));
let _e484 = prefiltered;
let _e485 = single_1;
specular_1 = (_e484 * _e485);
let _e487 = EnergyCompensation_u0028_();
if _e487 {
let _e489 = ab_4[0u];
let _e491 = ab_4[1u];
missed = (1f - (_e489 + _e491));
let _e494 = f0_4;
let _e495 = f0_4;
average_2 = (_e494 + ((vec3<f32>(1f, 1f, 1f) - _e495) / vec3(21f)));
let _e500 = single_1;
let _e501 = average_2;
let _e503 = missed;
let _e504 = average_2;
multiple = ((_e500 * _e501) / (vec3<f32>(1f, 1f, 1f) - (_e504 * _e503)));
let _e508 = multiple;
let _e509 = missed;
let _e511 = irradiance;
let _e513 = specular_1;
specular_1 = (_e513 + ((_e508 * _e509) * _e511));
}
let _e515 = diffuseColor_1;
let _e516 = irradiance;
let _e518 = specular_1;
let _e522 = frag_info.material[2u];
let _e525 = s_20.occlusion;
ambient = ((((_e515 * _e516) + _e518) * _e522) * _e525);
let _e527 = g_f0_dielectric;
let _e528 = g_irid_fresnel;
let _e529 = g_iridescence;
let _e533 = ab_4[0u];
let _e535 = g_f90_;
let _e537 = ab_4[1u];
reflects = ((mix(_e527, _e528, vec3(_e529)) * _e533) + vec3((_e535 * _e537)));
let _e541 = SceneColourBound_u0028_();
let _e542 = g_pane;
if (_e541 || _e542) {
local_59 = vec3<f32>(0f, 0f, 0f);
} else {
let _e544 = s_20;
param_267 = _e544;
let _e545 = levels_1;
param_268 = _e545;
let _e546 = 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_267), (¶m_268));
let _e547 = g_transmittance;
let _e549 = reflects;
local_59 = ((_e546 * _e547) * (vec3<f32>(1f, 1f, 1f) - min(_e549, vec3<f32>(1f, 1f, 1f))));
}
let _e553 = local_59;
through_1 = _e553;
let _e554 = diffuseColor_1;
let _e555 = through_1;
let _e556 = irradiance;
let _e559 = g_transmission;
let _e563 = frag_info.material[2u];
let _e566 = s_20.occlusion;
let _e568 = ambient;
ambient = (_e568 + ((((_e554 * (_e555 - _e556)) * _e559) * _e563) * _e566));
let _e571 = s_20.v;
let _e573 = g_coat_n;
let _e575 = g_coat_roughness;
let _e576 = levels_1;
let _e578 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e571), _e573), (_e575 * _e576));
coatPrefiltered = _e578.xyz;
let _e580 = g_coat_roughness;
param_269 = _e580;
let _e581 = g_coat_n_dot_v;
param_270 = _e581;
let _e582 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_269), (¶m_270));
coatAb = _e582;
let _e583 = coatPrefiltered;
let _e585 = coatAb[0u];
let _e588 = coatAb[1u];
let _e591 = g_coat;
let _e595 = frag_info.material[2u];
let _e598 = s_20.occlusion;
coatAmbient = ((((_e583 * ((0.04f * _e585) + _e588)) * _e591) * _e595) * _e598);
let _e601 = s_20.n;
let _e602 = g_sheen_roughness;
let _e603 = levels_1;
let _e605 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e601, (_e602 * _e603));
let _e609 = frag_info.material[2u];
sheenIncoming = (_e605.xyz * _e609);
}
let _e612 = s_20.roughness;
param_271 = _e612;
let _e614 = s_20.n_dot_v;
param_272 = _e614;
let _e615 = EnvBrdf_u0028_f1_u003b_f1_u003b((¶m_271), (¶m_272));
sceneAb = _e615;
let _e616 = g_f0_dielectric;
let _e617 = g_irid_fresnel;
let _e618 = g_iridescence;
let _e622 = sceneAb[0u];
let _e624 = g_f90_;
let _e626 = sceneAb[1u];
sceneReflects = ((mix(_e616, _e617, vec3(_e618)) * _e622) + vec3((_e624 * _e626)));
let _e630 = diffuseColor_1;
let _e631 = g_transmittance;
let _e633 = sceneReflects;
let _e637 = g_transmission;
passes = (((_e630 * _e631) * (vec3<f32>(1f, 1f, 1f) - min(_e633, vec3<f32>(1f, 1f, 1f)))) * _e637);
let _e639 = g_pane;
if _e639 {
let _e641 = passes[0u];
let _e643 = passes[1u];
let _e646 = passes[2u];
g_pass_through = clamp((((_e641 + _e643) + _e646) / 3f), 0f, 1f);
} else {
let _e650 = SceneColourBound_u0028_();
if _e650 {
let _e651 = s_20;
param_273 = _e651;
let _e652 = 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_273));
let _e653 = passes;
let _e655 = ambient;
ambient = (_e655 + (_e652 * _e653));
}
}
let _e657 = diffuseColor_1;
let _e658 = SampleLightmap_u0028_();
let _e661 = s_20.occlusion;
let _e663 = ambient;
ambient = (_e663 + ((_e657 * _e658) * _e661));
let _e665 = g_sheen;
let _e666 = g_sheen_albedo;
let _e668 = sheenIncoming;
let _e671 = s_20.occlusion;
sheenAmbient = (((_e665 * _e666) * _e668) * _e671);
let _e673 = s_20;
param_274 = _e673;
let _e674 = 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_274));
let _e676 = s_20.occlusion;
let _e678 = ambient;
let _e679 = g_sheen_scale;
let _e681 = sheenAmbient;
let _e684 = s_20.emissive;
let _e686 = g_coat_through;
let _e689 = coatAmbient;
lit_3 = (((_e674 * _e676) + ((((_e678 * _e679) + _e681) + _e684) * _e686)) + _e689);
let _e691 = s_20;
param_275 = _e691;
let _e692 = lit_3;
param_276 = _e692;
let _e693 = WriteDebugView_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_vf3_u003b((¶m_275), (¶m_276));
if _e693 {
return;
}
let _e694 = lit_3;
param_277 = _e694;
let _e696 = s_20.alpha;
param_278 = _e696;
let _e698 = s_20.roughness;
param_279 = _e698;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_277), (¶m_278), (¶m_279));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(5) 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_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
'ToonOpaque': 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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;
@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 _e210 = v_world_position_1;
let _e212 = fog_info.eye;
let _e216 = fog_info.forward;
return dot((_e210 - _e212.xyz), _e216.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e215 = ViewDepth_u0028_();
z = abs(_e215);
let _e217 = z;
near = (_e217 / 5f);
let _e219 = z;
far = (_e219 / 200f);
let _e221 = far;
let _e222 = far;
let _e224 = far;
far3_ = ((_e221 * _e222) * _e224);
let _e226 = (*alpha);
let _e227 = near;
let _e228 = near;
let _e231 = far3_;
let _e232 = far3_;
return (_e226 * clamp((10f / ((0.00001f + (_e227 * _e228)) + (_e231 * _e232))), 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 _e219 = fog_info.forward[3u];
mode = _e219;
let _e220 = mode;
if (_e220 > 0.5f) {
let _e223 = frag_color[3u];
alpha_1 = _e223;
let _e224 = alpha_1;
param = _e224;
let _e225 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e225;
let _e226 = frag_color;
let _e228 = weight;
let _e229 = (_e226.xyz * _e228);
let _e230 = alpha_1;
let _e231 = weight;
accumulate = vec4<f32>(_e229.x, _e229.y, _e229.z, (_e230 * _e231));
let _e237 = mode;
let _e239 = mode;
revealage = ((_e237 > 1.5f) && (_e239 < 2.5f));
let _e242 = revealage;
if _e242 {
let _e243 = alpha_1;
local = vec4(_e243);
} else {
let _e245 = accumulate;
local = _e245;
}
let _e246 = local;
frag_color = _e246;
let _e247 = mode;
if (_e247 > 2.5f) {
let _e249 = alpha_1;
frag_surface = vec4(_e249);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e213 = (*n)[0u];
let _e216 = (*n)[1u];
let _e220 = (*n)[2u];
let _e223 = (*n);
(*n) = (_e223 / vec3(((abs(_e213) + abs(_e216)) + abs(_e220))));
let _e226 = (*n);
e = _e226.xy;
let _e229 = (*n)[2u];
if (_e229 < 0f) {
let _e231 = (*n);
let _e237 = (*n)[0u];
let _e241 = (*n)[1u];
e = ((vec2(1f) - abs(_e231.yx)) * vec2<f32>(select(-1f, 1f, (_e237 >= 0f)), select(-1f, 1f, (_e241 >= 0f))));
}
let _e246 = e;
return ((_e246 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e211 = (*linear);
let _e213 = (*linear);
let _e217 = (*linear);
return mix((_e211 * 12.92f), ((pow(_e213, 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), _e217));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e214 = g_albedo;
param_1 = clamp(_e214, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e216 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e216.x, _e216.y, _e216.z, 1f);
let _e221 = g_debug_surface_on;
if _e221 {
let _e222 = g_debug_surface;
let _e223 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e222.x, _e222.y, _e222.z, _e223);
return;
}
let _e228 = v_normal_1;
geometric = normalize(_e228);
let _e230 = gl_FrontFacing_1;
if !(_e230) {
let _e232 = geometric;
geometric = -(_e232);
}
let _e234 = geometric;
param_2 = _e234;
let _e235 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e236 = (*roughness);
let _e238 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e235.x, _e235.y, clamp(_e236, 0f, 1f), _e238);
return;
}
fn Orthographic_u0028_() -> bool {
let _e212 = fog_info.projection[0u];
return (_e212 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e211 = Orthographic_u0028_();
if _e211 {
let _e212 = ViewDepth_u0028_();
local_1 = max(_e212, 0f);
} else {
let _e214 = v_world_position_1;
let _e216 = fog_info.eye;
local_1 = distance(_e214, _e216.xyz);
}
let _e219 = local_1;
return _e219;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e218 = fog_info.fog[3u];
density = _e218;
let _e219 = density;
if (_e219 <= 0f) {
let _e221 = (*color);
return _e221;
}
let _e222 = EyeDistance_u0028_();
d = _e222;
let _e225 = fog_info.eye[3u];
falloff = _e225;
let _e226 = falloff;
if (_e226 > 0f) {
let _e228 = falloff;
let _e230 = v_world_position_1[1u];
let _e233 = fog_info.eye[1u];
k = (_e228 * (_e230 - _e233));
let _e236 = k;
if (abs(_e236) > 0.001f) {
let _e239 = k;
let _e243 = k;
local_2 = ((1f - exp(-(_e239))) / _e243);
} else {
let _e245 = k;
local_2 = (1f - (0.5f * _e245));
}
let _e248 = local_2;
let _e249 = density;
density = (_e249 * _e248);
}
let _e252 = fog_info.fog;
let _e254 = (*color);
let _e255 = density;
let _e257 = d;
return mix(_e252.xyz, _e254, vec3(clamp(exp((-(_e255) * _e257)), 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 _e216 = g_premultiply;
let _e217 = (*alpha_2);
weight_1 = select(1f, _e217, _e216);
let _e219 = (*linearColor);
param_3 = _e219;
let _e220 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e221 = weight_1;
let _e222 = (_e220 * _e221);
let _e223 = (*alpha_2);
let _e224 = g_pass_through;
frag_color = vec4<f32>(_e222.x, _e222.y, _e222.z, (_e223 * (1f - _e224)));
let _e231 = (*roughness_1);
param_4 = _e231;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e211 = (*srgb);
let _e214 = (*srgb);
let _e219 = (*srgb);
return mix((_e211 / vec3(12.92f)), pow(((_e214 + 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), _e219));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e213 = (*key);
hue = fract(((_e213 * 0.618034f) + 0.13f));
let _e217 = hue;
k_1 = clamp((abs(((fract((vec3(_e217) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e230 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e230, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2559_: bool;
let _e211 = (*c);
let _e212 = (*c);
let _e214 = any((_e211 != _e212));
phi_2559_ = _e214;
if !(_e214) {
let _e216 = (*c);
phi_2559_ = any((abs(_e216) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e221 = phi_2559_;
return _e221;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2649_: bool;
var phi_2917_: bool;
let _e253 = gl_FragCoord_1[0u];
let _e256 = frag_info.debug_view[1u];
if (_e253 < _e256) {
let _e260 = frag_info.debug_view[2u];
local_3 = _e260;
} else {
let _e263 = frag_info.debug_view[0u];
local_3 = _e263;
}
let _e264 = local_3;
view = _e264;
let _e265 = view;
if (_e265 < 0.5f) {
return false;
}
let _e267 = view;
code = i32((_e267 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e270 = v_normal_1;
geometric_n = normalize(_e270);
let _e272 = v_tangent_1;
let _e274 = geometric_n;
let _e275 = geometric_n;
let _e276 = v_tangent_1;
tangent = (_e272.xyz - (_e274 * dot(_e275, _e276.xyz)));
let _e281 = tangent;
let _e282 = tangent;
let _e284 = (dot(_e281, _e282) > 0.000000000001f);
phi_2649_ = _e284;
if _e284 {
let _e286 = v_tangent_1[3u];
phi_2649_ = (abs((abs(_e286) - 1f)) < 0.01f);
}
let _e292 = phi_2649_;
tangent_usable = _e292;
let _e295 = frag_info.debug_view[3u];
identity = _e295;
let _e296 = identity;
identity_object = floor((_e296 / 8192f));
let _e299 = identity;
let _e300 = identity_object;
identity_rest = (_e299 - (_e300 * 8192f));
let _e303 = identity_rest;
identity_material = floor((_e303 / 2f));
let _e306 = identity_rest;
let _e307 = identity_material;
normal_mapped = ((_e306 - (_e307 * 2f)) > 0.5f);
let _e311 = code;
if (_e311 == 1i) {
let _e314 = (*s).albedo;
param_5 = clamp(_e314, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e316 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e316;
} else {
let _e317 = code;
if (_e317 == 2i) {
let _e320 = (*s).n;
shown = ((_e320 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e323 = code;
if (_e323 == 3i) {
let _e326 = (*s).roughness;
shown = vec3(clamp(_e326, 0f, 1f));
} else {
let _e329 = code;
if (_e329 == 4i) {
let _e332 = (*s).metallic;
shown = vec3(clamp(_e332, 0f, 1f));
} else {
let _e335 = code;
if (_e335 == 5i) {
let _e338 = (*s).occlusion;
shown = vec3(clamp(_e338, 0f, 1f));
} else {
let _e341 = code;
if (_e341 == 6i) {
let _e344 = (*s).emissive;
param_6 = clamp(_e344, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e346 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e346;
} else {
let _e347 = code;
if (_e347 == 7i) {
let _e349 = v_texcoord_1;
let _e350 = fract(_e349);
shown = vec3<f32>(_e350.x, _e350.y, 0f);
} else {
let _e354 = code;
if (_e354 == 8i) {
let _e356 = (*lit);
param_7 = clamp(_e356, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e358 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e358, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e360 = (*lit);
param_8 = _e360;
let _e361 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e361 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e362 = grey;
local_4 = vec3((_e362 * 0.5f));
}
let _e365 = local_4;
shown = _e365;
} else {
let _e366 = code;
if (_e366 == 9i) {
let _e368 = tangent_usable;
if _e368 {
let _e369 = tangent;
local_5 = ((normalize(_e369) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e373 = local_5;
shown = _e373;
} else {
let _e374 = code;
if (_e374 == 10i) {
let _e376 = v_texcoord_1;
uv = _e376;
let _e377 = uv;
cell = floor((_e377 * 8f));
let _e381 = cell[0u];
let _e383 = cell[1u];
odd = (fract(((_e381 + _e383) * 0.5f)) * 2f);
let _e388 = uv;
within = fract(_e388);
let _e390 = odd;
let _e394 = within[0u];
let _e398 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e390)) * vec3<f32>((0.55f + (0.45f * _e394)), (0.55f + (0.45f * _e398)), 0.85f));
} else {
let _e403 = code;
if (_e403 == 11i) {
let _e405 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e405));
} else {
let _e408 = code;
if (_e408 == 12i) {
let _e410 = v_color_1;
param_9 = clamp(_e410.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e413 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e413;
} else {
let _e414 = code;
let _e416 = code;
if ((_e414 == 13i) || (_e416 == 14i)) {
let _e419 = code;
let _e421 = identity_object;
let _e422 = identity_material;
key_1 = select(_e422, _e421, (_e419 == 13i));
let _e424 = key_1;
param_10 = _e424;
let _e425 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e427 = (*s).n_dot_v;
shown = (_e425 * (0.55f + (0.45f * _e427)));
} else {
let _e431 = code;
if (_e431 == 15i) {
let _e434 = (*s).albedo;
param_11 = clamp(_e434, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e436 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e436;
let _e437 = srgb_1;
luma = dot(_e437, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e440 = (*s).metallic;
metal = (_e440 > 0.5f);
let _e442 = metal;
let _e444 = luma;
if (!(_e442) && (_e444 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e447 = metal;
let _e448 = !(_e447);
phi_2917_ = _e448;
if _e448 {
let _e450 = srgb_1[0u];
let _e452 = srgb_1[1u];
let _e454 = srgb_1[2u];
phi_2917_ = (max(_e450, max(_e452, _e454)) > 0.9411765f);
}
let _e459 = phi_2917_;
if _e459 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e460 = metal;
let _e461 = luma;
if (_e460 && (_e461 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e464 = luma;
local_8 = vec3(_e464);
}
let _e466 = local_8;
local_7 = _e466;
}
let _e467 = local_7;
local_6 = _e467;
}
let _e468 = local_6;
shown = _e468;
} else {
let _e469 = code;
if (_e469 == 16i) {
let _e472 = (*s).metallic;
m = _e472;
let _e473 = m;
let _e475 = m;
if ((_e473 > 0.05f) && (_e475 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e478 = m;
local_9 = vec3(select(0.15f, 1f, (_e478 > 0.5f)));
}
let _e482 = local_9;
shown = _e482;
} else {
let _e483 = code;
if (_e483 == 17i) {
let _e485 = normal_mapped;
if !(_e485) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e487 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e487));
}
let _e490 = local_10;
shown = _e490;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e491 = g_premultiply;
if _e491 {
let _e493 = (*s).alpha;
local_11 = _e493;
} else {
local_11 = 1f;
}
let _e494 = local_11;
weight_2 = _e494;
let _e495 = shown;
param_12 = _e495;
let _e496 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e497 = weight_2;
let _e498 = (_e496 * _e497);
let _e500 = (*s).alpha;
frag_color = vec4<f32>(_e498.x, _e498.y, _e498.z, _e500);
let _e506 = (*s).roughness;
param_13 = _e506;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var bands: f32;
var quantized: f32;
var fraction: f32;
var ramp: f32;
let _e217 = (*s_1).roughness;
bands = mix(5f, 2f, _e217);
let _e220 = (*light).n_dot_l;
let _e221 = bands;
let _e224 = bands;
quantized = (floor((_e220 * _e221)) / _e224);
let _e227 = (*light).n_dot_l;
let _e228 = bands;
fraction = fract((_e227 * _e228));
let _e231 = fraction;
let _e233 = bands;
let _e235 = quantized;
quantized = (_e235 + (smoothstep(0.85f, 1f, _e231) / _e233));
let _e237 = quantized;
let _e239 = (*light).n_dot_l;
ramp = (_e237 / max(_e239, 0.001f));
let _e243 = (*s_1).albedo;
let _e244 = ramp;
return (_e243 * _e244);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e211 = (*i);
if (_e211 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e213 = (*i);
if (_e213 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e215 = (*i);
if (_e215 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e217 = (*i);
if (_e217 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e219 = (*i);
if (_e219 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e221 = (*i);
if (_e221 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e223 = (*i);
if (_e223 == 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_14: i32;
let _e216 = (*i_1);
param_14 = _e216;
let _e217 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e217;
let _e219 = p[0u];
let _e220 = (*ca);
let _e223 = p[1u];
let _e224 = (*sa);
let _e228 = p[0u];
let _e229 = (*sa);
let _e232 = p[1u];
let _e233 = (*ca);
let _e237 = (*radius);
return (vec2<f32>(((_e219 * _e220) - (_e223 * _e224)), ((_e228 * _e229) + (_e232 * _e233))) * _e237);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e219 = point_shadow.params[0u];
inset = _e219;
let _e220 = (*uv_1);
let _e221 = (*offset);
let _e223 = inset;
let _e224 = inset;
local_12 = clamp((_e220 + _e221), vec2(_e223), vec2((1f - _e224)));
let _e229 = local_12;
let _e230 = (*tile);
atlas = ((_e229 + _e230) * vec2<f32>(0.16666667f, 0.16666667f));
let _e235 = point_shadow.params3_[0u];
if (_e235 > 0.5f) {
let _e238 = atlas[1u];
atlas[1u] = (1f - _e238);
}
let _e241 = atlas;
let _e242 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e241, 0f);
let _e244 = atlas;
let _e245 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e244, 0f);
let _e248 = (*range);
return (min(_e242.x, _e245.x) * _e248);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e220 = (*uv_2);
param_15 = _e220;
let _e221 = (*offset_1);
param_16 = _e221;
let _e222 = (*tile_1);
param_17 = _e222;
let _e223 = (*range_1);
param_18 = _e223;
let _e224 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e224;
let _e225 = stored;
let _e226 = (*range_1);
if (_e225 >= (_e226 * 0.999f)) {
return 1f;
}
let _e229 = (*receiver);
let _e230 = stored;
return select(1f, 0f, (_e229 > _e230));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e241 = point_shadow.params2_[1u];
lightRadius = _e241;
let _e244 = point_shadow.params2_[0u];
minRadius = _e244;
let _e247 = point_shadow.params2_[2u];
maxRadius = _e247;
let _e248 = lightRadius;
if (_e248 <= 0f) {
let _e250 = (*uv_3);
param_19 = _e250;
param_20 = vec2<f32>(0f, 0f);
let _e251 = (*tile_2);
param_21 = _e251;
let _e252 = (*range_2);
param_22 = _e252;
let _e253 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e253;
let _e254 = minRadius;
return _e254;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e255 = i_2;
if (_e255 < 8i) {
let _e257 = i_2;
param_23 = _e257;
let _e258 = (*ca_1);
param_24 = _e258;
let _e259 = (*sa_1);
param_25 = _e259;
let _e260 = maxRadius;
param_26 = _e260;
let _e261 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e262 = (*uv_3);
param_27 = _e262;
param_28 = _e261;
let _e263 = (*tile_2);
param_29 = _e263;
let _e264 = (*range_2);
param_30 = _e264;
let _e265 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e265;
let _e266 = stored_1;
let _e267 = (*range_2);
if (_e266 >= (_e267 * 0.999f)) {
continue;
}
let _e270 = stored_1;
let _e271 = (*receiver_1);
if (_e270 >= _e271) {
continue;
}
let _e273 = stored_1;
let _e274 = sum;
sum = (_e274 + _e273);
let _e276 = count;
count = (_e276 + 1f);
continue;
} else {
break;
}
continuing {
let _e278 = i_2;
i_2 = (_e278 + 1i);
}
}
let _e280 = count;
if (_e280 < 0.5f) {
return -1f;
}
let _e282 = sum;
let _e283 = count;
blocker = max((_e282 / _e283), 0.0001f);
let _e286 = blocker;
(*blockerOut) = _e286;
let _e287 = lightRadius;
let _e288 = (*receiver_1);
let _e289 = blocker;
let _e293 = blocker;
world = ((_e287 * max((_e288 - _e289), 0f)) / _e293);
let _e295 = world;
let _e296 = (*receiver_1);
let _e298 = (*tanHalf);
let _e301 = minRadius;
let _e302 = maxRadius;
return clamp((_e295 / ((2f * _e296) * _e298)), _e301, _e302);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e212 = (*rows);
if (_e212 > 0f) {
let _e215 = gl_FragCoord_1[0u];
let _e216 = (*rows);
let _e218 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e215, (_e216 - _e218));
} else {
let _e221 = gl_FragCoord_1;
local_13 = _e221.xy;
}
let _e223 = local_13;
return _e223;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2246_: bool;
var phi_2307_: bool;
let _e264 = (*lightIndex);
let _e268 = point_shadow.slots[_e264][0u];
slot = i32((_e268 + 0.5f));
let _e271 = (*lightIndex);
let _e275 = point_shadow.slots[_e271][0u];
if (_e275 < 0f) {
return 1f;
}
let _e279 = point_shadow.params[2u];
strength = _e279;
let _e280 = strength;
if (_e280 <= 0f) {
return 1f;
}
let _e282 = slot;
let _e285 = point_shadow.lights[_e282];
let _e287 = (*world_1);
toLight = (_e285.xyz - _e287);
let _e289 = toLight;
toLightLength = max(length(_e289), 0.000001f);
let _e292 = (*normal);
let _e293 = toLight;
let _e294 = toLightLength;
nDotL = max(dot(_e292, (_e293 / vec3(_e294))), 0.15f);
let _e299 = nDotL;
let _e300 = nDotL;
let _e305 = nDotL;
let _e306 = nDotL;
slope = min((sqrt(max((1f - (_e299 * _e300)), 0f)) / (_e305 * _e306)), 8f);
let _e310 = toLightLength;
let _e312 = (*lightIndex);
let _e316 = point_shadow.slots[_e312][2u];
let _e321 = point_shadow.params3_[1u];
texel = (((2f * _e310) * max(_e316, 0.0001f)) * _e321);
let _e323 = (*world_1);
let _e324 = (*normal);
let _e325 = texel;
let _e329 = point_shadow.params[3u];
let _e331 = slope;
origin = (_e323 + (((_e324 * _e325) * _e329) * (1f + _e331)));
let _e335 = origin;
let _e336 = slot;
let _e339 = point_shadow.lights[_e336];
toFragment = (_e335 - _e339.xyz);
let _e342 = toFragment;
distance_ = length(_e342);
let _e344 = slot;
let _e348 = point_shadow.lights[_e344][3u];
range_3 = max(_e348, 0.0001f);
let _e350 = distance_;
let _e351 = range_3;
if (_e350 >= _e351) {
return 1f;
}
face = 0i;
let _e353 = (*lightIndex);
let _e357 = point_shadow.slots[_e353][1u];
if (_e357 < 0.5f) {
let _e359 = toFragment;
a = abs(_e359);
let _e362 = a[0u];
let _e364 = a[1u];
let _e365 = (_e362 >= _e364);
phi_2246_ = _e365;
if _e365 {
let _e367 = a[0u];
let _e369 = a[2u];
phi_2246_ = (_e367 >= _e369);
}
let _e372 = phi_2246_;
if _e372 {
let _e374 = toFragment[0u];
face = select(1i, 0i, (_e374 > 0f));
} else {
let _e378 = a[1u];
let _e380 = a[2u];
if (_e378 >= _e380) {
let _e383 = toFragment[1u];
face = select(3i, 2i, (_e383 > 0f));
} else {
let _e387 = toFragment[2u];
face = select(5i, 4i, (_e387 > 0f));
}
}
}
let _e390 = slot;
let _e392 = face;
let _e396 = point_shadow.faces[((_e390 * 6i) + _e392)];
let _e397 = origin;
clip = (_e396 * vec4<f32>(_e397.x, _e397.y, _e397.z, 1f));
let _e404 = clip[3u];
if (_e404 <= 0f) {
return 1f;
}
let _e406 = clip;
let _e409 = clip[3u];
ndc = (_e406.xy / vec2(_e409));
let _e413 = ndc[0u];
let _e415 = (abs(_e413) > 1f);
phi_2307_ = _e415;
if !(_e415) {
let _e418 = ndc[1u];
phi_2307_ = (abs(_e418) > 1f);
}
let _e422 = phi_2307_;
if _e422 {
return 1f;
}
let _e424 = ndc[0u];
let _e428 = ndc[1u];
uv_4 = vec2<f32>(((_e424 * 0.5f) + 0.5f), (0.5f - (_e428 * 0.5f)));
let _e432 = face;
let _e434 = slot;
tile_3 = vec2<f32>(f32(_e432), f32(_e434));
let _e437 = distance_;
let _e440 = point_shadow.params[1u];
receiver_2 = (_e437 - _e440);
let _e444 = frag_info.target_origin[0u];
param_31 = _e444;
let _e445 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e445, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e450 = noise;
angle = (_e450 * 6.2831855f);
let _e452 = angle;
ca_2 = cos(_e452);
let _e454 = angle;
sa_2 = sin(_e454);
let _e456 = (*lightIndex);
let _e460 = point_shadow.slots[_e456][2u];
tanHalf_1 = max(_e460, 0.0001f);
blocker_1 = -1f;
let _e462 = uv_4;
param_32 = _e462;
let _e463 = tile_3;
param_33 = _e463;
let _e464 = range_3;
param_34 = _e464;
let _e465 = receiver_2;
param_35 = _e465;
let _e466 = ca_2;
param_36 = _e466;
let _e467 = sa_2;
param_37 = _e467;
let _e468 = tanHalf_1;
param_38 = _e468;
let _e469 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e470 = param_39;
blocker_1 = _e470;
radius_1 = _e469;
let _e473 = point_shadow.params2_[3u];
if (_e473 > 0.5f) {
g_debug_surface_on = true;
let _e475 = radius_1;
if (_e475 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e477 = radius_1;
let _e480 = point_shadow.params2_[2u];
let _e484 = blocker_1;
let _e485 = range_3;
local_14 = vec3<f32>(clamp((_e477 / max(_e480, 0.000001f)), 0f, 1f), clamp((_e484 / _e485), 0f, 1f), 0f);
}
let _e489 = local_14;
g_debug_surface = _e489;
}
let _e490 = radius_1;
if (_e490 < 0f) {
return 1f;
}
let _e492 = uv_4;
param_40 = _e492;
param_41 = vec2<f32>(0f, 0f);
let _e493 = tile_3;
param_42 = _e493;
let _e494 = range_3;
param_43 = _e494;
let _e495 = receiver_2;
param_44 = _e495;
let _e496 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e496;
let _e497 = radius_1;
if (_e497 > 0f) {
i_3 = 0i;
loop {
let _e499 = i_3;
if (_e499 < 8i) {
let _e501 = i_3;
param_45 = _e501;
let _e502 = ca_2;
param_46 = _e502;
let _e503 = sa_2;
param_47 = _e503;
let _e504 = radius_1;
param_48 = _e504;
let _e505 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e506 = uv_4;
param_49 = _e506;
param_50 = _e505;
let _e507 = tile_3;
param_51 = _e507;
let _e508 = range_3;
param_52 = _e508;
let _e509 = receiver_2;
param_53 = _e509;
let _e510 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e511 = lit_1;
lit_1 = (_e511 + _e510);
continue;
} else {
break;
}
continuing {
let _e513 = i_3;
i_3 = (_e513 + 1i);
}
}
let _e515 = lit_1;
lit_1 = (_e515 * 0.11111111f);
}
let _e517 = lit_1;
let _e518 = strength;
return mix(1f, _e517, clamp(_e518, 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 _e215 = (*i_4);
let _e218 = (*n_1);
r = sqrt(((f32(_e215) + 0.5f) / f32(_e218)));
let _e222 = (*i_4);
let _e225 = (*turn);
theta = ((f32(_e222) * 2.3999631f) + _e225);
let _e227 = r;
let _e228 = theta;
let _e230 = theta;
return (vec2<f32>(cos(_e228), sin(_e230)) * _e227);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e214 = frag_info.target_origin[0u];
param_54 = _e214;
let _e215 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e218 = frag_info.target_origin[3u];
at = (_e215 + vec2((5.588238f * max(_e218, 0f))));
let _e223 = at;
return fract((52.982918f * fract(dot(_e223, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e213 = (*mode_1);
if (_e213 > 0.5f) {
let _e215 = (*stored_2);
local_15 = (1f - _e215);
} else {
let _e217 = (*stored_2);
local_15 = _e217;
}
let _e218 = local_15;
return _e218;
}
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 _e219 = (*moments)[1u];
let _e221 = (*moments)[0u];
let _e223 = (*moments)[0u];
let _e226 = (*minVariance);
variance = max((_e219 - (_e221 * _e223)), _e226);
let _e228 = (*t);
let _e230 = (*moments)[0u];
d_1 = (_e228 - _e230);
let _e232 = variance;
let _e233 = variance;
let _e234 = d_1;
let _e235 = d_1;
pMax = (_e232 / (_e233 + (_e234 * _e235)));
let _e239 = pMax;
let _e240 = (*bleed);
let _e242 = (*bleed);
reduced = clamp(((_e239 - _e240) / max((1f - _e242), 0.0001f)), 0f, 1f);
let _e247 = (*t);
let _e249 = (*moments)[0u];
let _e251 = reduced;
return select(_e251, 1f, (_e247 <= _e249));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e212 = (*depth);
d_2 = ((2f * clamp(_e212, 0f, 1f)) - 1f);
let _e216 = d_2;
let _e219 = d_2;
return vec2<f32>(exp((40f * _e216)), -(exp((-5f * _e219))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e226 = (*depth_1);
param_55 = _e226;
let _e227 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e227;
let _e228 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e228);
let _e231 = scale[0u];
let _e233 = scale[0u];
let _e235 = (*moments_1);
param_56 = _e235.xy;
let _e238 = warped[0u];
param_57 = _e238;
param_58 = (_e231 * _e233);
let _e239 = (*bleed_1);
param_59 = _e239;
let _e240 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e240;
let _e242 = scale[1u];
let _e244 = scale[1u];
let _e246 = (*moments_1);
param_60 = _e246.zw;
let _e249 = warped[1u];
param_61 = _e249;
param_62 = (_e242 * _e244);
let _e250 = (*bleed_1);
param_63 = _e250;
let _e251 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e251;
let _e252 = positive;
let _e253 = negative;
return min(_e252, _e253);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e212 = (*depth_2);
stored_3 = max((1f - _e212), 0.000061035156f);
let _e215 = stored_3;
return exp2((floor(log2(_e215)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3856_: bool;
var phi_3867_: bool;
var phi_4024_: bool;
var phi_4031_: bool;
var phi_4038_: bool;
let _e289 = frag_info.shadow_params[3u];
strength_1 = _e289;
let _e290 = strength_1;
if (_e290 <= 0f) {
return 1f;
}
let _e292 = (*lightIndex_1);
let _e295 = frag_info.frame_params[2u];
if (_e292 != i32(floor((_e295 + 0.5f)))) {
return 1f;
}
let _e302 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e302 + 0.5f));
let _e305 = Orthographic_u0028_();
if _e305 {
let _e306 = ViewDepth_u0028_();
local_16 = _e306;
} else {
let _e307 = v_world_position_1;
let _e309 = frag_info.camera_position;
local_16 = length((_e307 - _e309.xyz));
}
let _e313 = local_16;
viewDistance = _e313;
cascade = 0i;
let _e314 = cascadeCount;
let _e315 = (_e314 > 1i);
phi_3856_ = _e315;
if _e315 {
let _e316 = viewDistance;
let _e319 = frag_info.shadow_cascades[0u];
phi_3856_ = (_e316 > _e319);
}
let _e322 = phi_3856_;
if _e322 {
cascade = 1i;
}
let _e323 = cascadeCount;
let _e324 = (_e323 > 2i);
phi_3867_ = _e324;
if _e324 {
let _e325 = viewDistance;
let _e328 = frag_info.shadow_cascades[1u];
phi_3867_ = (_e325 > _e328);
}
let _e331 = phi_3867_;
if _e331 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e332 = attempt;
if (_e332 < 3i) {
let _e334 = cascade;
let _e335 = attempt;
which = (_e334 + _e335);
let _e337 = which;
let _e338 = cascadeCount;
if (_e337 >= _e338) {
break;
}
let _e340 = which;
if (_e340 == 0i) {
let _e343 = frag_info.shadow_matrix;
local_17 = _e343;
} else {
let _e344 = which;
if (_e344 == 1i) {
let _e347 = frag_info.shadow_matrix_far;
local_18 = _e347;
} else {
let _e349 = frag_info.shadow_matrix_farthest;
local_18 = _e349;
}
let _e350 = local_18;
local_17 = _e350;
}
let _e351 = local_17;
matrix = _e351;
let _e354 = matrix[0][0u];
let _e357 = matrix[1][0u];
let _e360 = matrix[2][0u];
axisX = vec3<f32>(_e354, _e357, _e360);
let _e364 = matrix[0][1u];
let _e367 = matrix[1][1u];
let _e370 = matrix[2][1u];
axisY = vec3<f32>(_e364, _e367, _e370);
let _e372 = axisX;
rowX = max(length(_e372), 0.000001f);
let _e375 = axisY;
rowY = max(length(_e375), 0.000001f);
let _e380 = frag_info.shadow_cascades[3u];
let _e382 = rowX;
texelMetres = ((2f * _e380) / _e382);
let _e386 = frag_info.shadow_cascades[3u];
let _e389 = (*s_2).n;
let _e390 = axisX;
let _e393 = rowX;
let _e394 = rowX;
let _e398 = (*s_2).n;
let _e399 = axisY;
let _e402 = rowY;
let _e403 = rowY;
reach = ((3f * _e386) * ((abs(dot(_e389, _e390)) / (_e393 * _e394)) + (abs(dot(_e398, _e399)) / (_e402 * _e403))));
let _e410 = frag_info.shadow_params[2u];
let _e411 = texelMetres;
flatOffset = min(_e410, _e411);
let _e413 = v_world_position_1;
let _e415 = (*s_2).n;
let _e416 = flatOffset;
let _e417 = reach;
origin_1 = (_e413 + (_e415 * (_e416 + _e417)));
let _e421 = matrix;
let _e422 = origin_1;
lightSpace = (_e421 * vec4<f32>(_e422.x, _e422.y, _e422.z, 1f));
let _e429 = lightSpace[3u];
if (_e429 <= 0f) {
continue;
}
let _e431 = lightSpace;
let _e434 = lightSpace[3u];
candidate = (_e431.xyz / vec3(_e434));
let _e438 = candidate[0u];
let _e442 = candidate[1u];
inTile = vec2<f32>(((_e438 * 0.5f) + 0.5f), (0.5f - (_e442 * 0.5f)));
let _e447 = inTile[0u];
let _e448 = (_e447 < 0f);
phi_4024_ = _e448;
if !(_e448) {
let _e451 = inTile[0u];
phi_4024_ = (_e451 > 1f);
}
let _e454 = phi_4024_;
phi_4031_ = _e454;
if !(_e454) {
let _e457 = inTile[1u];
phi_4031_ = (_e457 < 0f);
}
let _e460 = phi_4031_;
phi_4038_ = _e460;
if !(_e460) {
let _e463 = inTile[1u];
phi_4038_ = (_e463 > 1f);
}
let _e466 = phi_4038_;
if _e466 {
continue;
}
let _e468 = candidate[2u];
if (_e468 > 1f) {
let _e470 = which;
let _e471 = cascadeCount;
if (_e470 < (_e471 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e476 = inTile[0u];
let _e477 = which;
let _e480 = cascadeCount;
let _e484 = inTile[1u];
uv_5 = vec2<f32>(((_e476 + f32(_e477)) / f32(_e480)), _e484);
let _e486 = candidate;
projected = _e486;
let _e487 = which;
cascade = _e487;
let _e488 = texelMetres;
cascadeTexel = _e488;
let _e491 = matrix[0][2u];
let _e494 = matrix[1][2u];
let _e497 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e491, _e494, _e497)), 0.000001f));
let _e503 = (*s_2).n;
let _e506 = matrix[0][2u];
let _e509 = matrix[1][2u];
let _e512 = matrix[2][2u];
let _e516 = cascadeDepth;
cosSlope = clamp((abs(dot(_e503, vec3<f32>(_e506, _e509, _e512))) * _e516), 0.1f, 1f);
let _e519 = texelMetres;
let _e520 = cosSlope;
let _e521 = cosSlope;
let _e527 = cosSlope;
let _e529 = cascadeDepth;
receiverSlope = (((_e519 * sqrt(max((1f - (_e520 * _e521)), 0f))) / _e527) / _e529);
found = true;
break;
} else {
break;
}
continuing {
let _e531 = attempt;
attempt = (_e531 + 1i);
}
}
let _e533 = found;
if !(_e533) {
return 1f;
}
let _e535 = cascade;
if (_e535 == 0i) {
let _e539 = frag_info.shadow_bias[0u];
local_19 = _e539;
} else {
let _e540 = cascade;
if (_e540 == 1i) {
let _e544 = frag_info.shadow_bias[1u];
local_20 = _e544;
} else {
let _e547 = frag_info.shadow_bias[2u];
local_20 = _e547;
}
let _e548 = local_20;
local_19 = _e548;
}
let _e549 = local_19;
bias = _e549;
let _e552 = frag_info.shadow_params[1u];
storage_ = _e552;
let _e553 = storage_;
let _e555 = storage_;
if ((_e553 > 0.5f) && (_e555 < 1.5f)) {
let _e558 = bias;
let _e560 = projected[2u];
param_64 = _e560;
let _e561 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e558, _e561);
}
let _e565 = frag_info.shadow_params[0u];
let _e568 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e565, _e568);
let _e570 = cascade;
let _e572 = cascadeCount;
let _e576 = texel_1;
tileLo = (vec2<f32>((f32(_e570) / f32(_e572)), 0f) + (_e576 * 0.5f));
let _e579 = cascade;
let _e582 = cascadeCount;
let _e586 = texel_1;
tileHi = (vec2<f32>((f32((_e579 + 1i)) / f32(_e582)), 1f) - (_e586 * 0.5f));
let _e591 = frag_info.shadow_bias[3u];
if (_e591 > 0.5f) {
let _e593 = uv_5;
let _e594 = tileLo;
let _e595 = tileHi;
let _e597 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e593, _e594, _e595), 0f);
stored_4 = _e597;
let _e599 = stored_4[1u];
let _e602 = stored_4[2u];
let _e605 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e599), (1f - _e602), _e605), vec3(0f), vec3(4f));
let _e610 = through;
let _e611 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e610, vec3(clamp(_e611, 0f, 1f)));
}
let _e617 = frag_info.ambient_ground[3u];
softness = _e617;
lit_2 = 0f;
let _e618 = softness;
if (_e618 < 0f) {
let _e620 = uv_5;
let _e621 = tileLo;
let _e622 = tileHi;
let _e624 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e620, _e621, _e622), 0f);
moments_2 = _e624;
let _e626 = projected[2u];
let _e627 = bias;
let _e629 = softness;
let _e633 = moments_2;
param_65 = _e633;
param_66 = (_e626 - _e627);
param_67 = clamp((-(_e629) - 1f), 0f, 0.95f);
let _e634 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e634;
} else {
let _e635 = softness;
if (_e635 <= 0f) {
y = -1i;
loop {
let _e637 = y;
if (_e637 <= 1i) {
x = -1i;
loop {
let _e639 = x;
if (_e639 <= 1i) {
let _e641 = uv_5;
let _e642 = x;
let _e644 = y;
let _e647 = texel_1;
let _e650 = tileLo;
let _e651 = tileHi;
let _e653 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e641 + (vec2<f32>(f32(_e642), f32(_e644)) * _e647)), _e650, _e651), 0f);
param_68 = _e653.x;
let _e655 = storage_;
param_69 = _e655;
let _e656 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e656;
let _e658 = projected[2u];
let _e659 = bias;
let _e661 = occluder;
let _e664 = lit_2;
lit_2 = (_e664 + select(1f, 0f, ((_e658 - _e659) > _e661)));
continue;
} else {
break;
}
continuing {
let _e666 = x;
x = (_e666 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e668 = y;
y = (_e668 + 1i);
}
}
let _e670 = lit_2;
lit_2 = (_e670 * 0.11111111f);
} else {
let _e672 = softness;
spread = tan(min(_e672, 0.5f));
let _e675 = ShadowNoise_u0028_();
turn_1 = (_e675 * 6.2831855f);
let _e677 = spread;
let _e679 = projected[2u];
let _e681 = cascadeDepth;
let _e683 = cascadeTexel;
searchRadius = clamp((((_e677 * _e679) * _e681) / _e683), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e686 = i_5;
if (_e686 < 16i) {
let _e688 = i_5;
param_70 = _e688;
param_71 = 16i;
let _e689 = turn_1;
param_72 = _e689;
let _e690 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e690;
let _e691 = bias;
let _e692 = disc;
let _e694 = searchRadius;
let _e698 = receiverSlope;
tapBias = (_e691 + (max(((length(_e692) * _e694) - 1.5f), 0f) * _e698));
let _e701 = uv_5;
let _e702 = disc;
let _e703 = texel_1;
let _e705 = searchRadius;
let _e708 = tileLo;
let _e709 = tileHi;
let _e711 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e701 + ((_e702 * _e703) * _e705)), _e708, _e709), 0f);
param_73 = _e711.x;
let _e713 = storage_;
param_74 = _e713;
let _e714 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e714;
let _e716 = projected[2u];
let _e717 = tapBias;
let _e719 = occluder_1;
if ((_e716 - _e717) > _e719) {
let _e721 = occluder_1;
let _e722 = blockerSum;
blockerSum = (_e722 + _e721);
let _e724 = blockerCount;
blockerCount = (_e724 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e726 = i_5;
i_5 = (_e726 + 1i);
}
}
let _e728 = blockerCount;
if (_e728 <= 0f) {
return 1f;
}
let _e731 = projected[2u];
let _e732 = blockerSum;
let _e733 = blockerCount;
let _e737 = cascadeDepth;
gap = (max((_e731 - (_e732 / _e733)), 0f) * _e737);
let _e739 = spread;
let _e740 = gap;
let _e742 = cascadeTexel;
radius_2 = clamp(((_e739 * _e740) / _e742), 1f, 16f);
i_6 = 0i;
loop {
let _e745 = i_6;
if (_e745 < 16i) {
let _e747 = turn_1;
let _e749 = i_6;
param_75 = _e749;
param_76 = 16i;
param_77 = (_e747 + 1f);
let _e750 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e750;
let _e751 = bias;
let _e752 = disc_1;
let _e754 = radius_2;
let _e758 = receiverSlope;
tapBias_1 = (_e751 + (max(((length(_e752) * _e754) - 1.5f), 0f) * _e758));
let _e761 = uv_5;
let _e762 = disc_1;
let _e763 = texel_1;
let _e765 = radius_2;
let _e768 = tileLo;
let _e769 = tileHi;
let _e771 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e761 + ((_e762 * _e763) * _e765)), _e768, _e769), 0f);
param_78 = _e771.x;
let _e773 = storage_;
param_79 = _e773;
let _e774 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e774;
let _e776 = projected[2u];
let _e777 = tapBias_1;
let _e779 = occluder_2;
let _e782 = lit_2;
lit_2 = (_e782 + select(1f, 0f, ((_e776 - _e777) > _e779)));
continue;
} else {
break;
}
continuing {
let _e784 = i_6;
i_6 = (_e784 + 1i);
}
}
let _e786 = lit_2;
lit_2 = (_e786 * 0.0625f);
}
}
let _e788 = lit_2;
let _e789 = strength_1;
return mix(1f, _e788, clamp(_e789, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e216 = (*s_3);
param_80 = _e216;
let _e217 = (*light_2);
param_81 = _e217;
let _e218 = (*index);
param_82 = _e218;
let _e219 = 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_80), (¶m_81), (¶m_82));
return _e219;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e211 = (*index_1);
return (_e211 < 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 _e215 = (*distance_1);
let _e216 = (*distance_1);
attenuation = (1f / max((_e215 * _e216), 0.0001f));
let _e220 = (*range_4);
if (_e220 > 0f) {
let _e222 = (*distance_1);
let _e223 = (*range_4);
ratio = (_e222 / _e223);
let _e225 = ratio;
let _e226 = ratio;
let _e228 = ratio;
let _e230 = ratio;
window = clamp((1f - (((_e225 * _e226) * _e228) * _e230)), 0f, 1f);
let _e234 = window;
let _e235 = window;
let _e237 = attenuation;
attenuation = (_e237 * (_e234 * _e235));
}
let _e239 = attenuation;
return _e239;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e227 = (*halfWidth);
let _e228 = (*halfHeight);
n_2 = cross(_e227, _e228);
let _e230 = n_2;
nLen = length(_e230);
let _e232 = nLen;
if (_e232 < 0.000000000001f) {
let _e234 = (*centre);
return _e234;
}
let _e235 = nLen;
let _e236 = n_2;
n_2 = (_e236 / vec3(_e235));
let _e239 = (*centre);
let _e240 = (*world_2);
toPlane = (_e239 - _e240);
let _e242 = (*mirror);
let _e243 = n_2;
denom = dot(_e242, _e243);
let _e245 = denom;
if (abs(_e245) < 0.00001f) {
let _e248 = toPlane;
let _e249 = n_2;
let _e250 = toPlane;
let _e251 = n_2;
onPlane = (_e248 - (_e249 * dot(_e250, _e251)));
} else {
let _e255 = toPlane;
let _e256 = n_2;
let _e258 = denom;
t_1 = (dot(_e255, _e256) / _e258);
let _e260 = t_1;
if (_e260 > 0f) {
let _e262 = (*mirror);
let _e263 = t_1;
local_21 = (_e262 * _e263);
} else {
let _e265 = toPlane;
let _e266 = n_2;
let _e267 = toPlane;
let _e268 = n_2;
local_21 = (_e265 - (_e266 * dot(_e267, _e268)));
}
let _e272 = local_21;
onPlane = _e272;
}
let _e273 = onPlane;
let _e274 = toPlane;
offset_2 = (_e273 - _e274);
let _e276 = (*halfWidth);
let _e277 = (*halfWidth);
wLen2_ = max(dot(_e276, _e277), 0.000000000001f);
let _e280 = (*halfHeight);
let _e281 = (*halfHeight);
hLen2_ = max(dot(_e280, _e281), 0.000000000001f);
let _e284 = offset_2;
let _e285 = (*halfWidth);
let _e287 = wLen2_;
u = clamp((dot(_e284, _e285) / _e287), -1f, 1f);
let _e290 = offset_2;
let _e291 = (*halfHeight);
let _e293 = hLen2_;
v = clamp((dot(_e290, _e291) / _e293), -1f, 1f);
let _e296 = (*centre);
let _e297 = (*halfWidth);
let _e298 = u;
let _e301 = (*halfHeight);
let _e302 = v;
return ((_e296 + (_e297 * _e298)) + (_e301 * _e302));
}
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_22: f32;
let _e219 = (*a_1);
let _e220 = (*a_1);
ua = (_e219 / vec3(max(length(_e220), 0.000000000001f)));
let _e225 = (*b);
let _e226 = (*b);
ub = (_e225 / vec3(max(length(_e226), 0.000000000001f)));
let _e231 = ua;
let _e232 = ub;
angle_1 = acos(clamp(dot(_e231, _e232), -1f, 1f));
let _e236 = ua;
let _e237 = ub;
axis = cross(_e236, _e237);
let _e239 = axis;
len = length(_e239);
let _e241 = len;
if (_e241 > 0.000001f) {
let _e243 = angle_1;
let _e244 = axis;
let _e245 = (*n_3);
let _e248 = len;
local_22 = ((_e243 * dot(_e244, _e245)) / _e248);
} else {
local_22 = 0f;
}
let _e250 = local_22;
return _e250;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e233 = i_7;
if (_e233 < 4i) {
let _e235 = i_7;
let _e237 = (*corners)[_e235];
a_2 = _e237;
let _e238 = i_7;
if (_e238 == 3i) {
local_23 = 0i;
} else {
let _e240 = i_7;
local_23 = (_e240 + 1i);
}
let _e242 = local_23;
let _e244 = (*corners)[_e242];
b_1 = _e244;
let _e245 = a_2;
let _e246 = (*n_4);
ha = dot(_e245, _e246);
let _e248 = b_1;
let _e249 = (*n_4);
hb = dot(_e248, _e249);
let _e251 = ha;
let _e252 = hb;
d_3 = (_e251 - _e252);
let _e254 = a_2;
let _e255 = b_1;
let _e256 = a_2;
let _e258 = d_3;
if (abs(_e258) > 0.000000000001f) {
let _e261 = ha;
let _e262 = d_3;
local_24 = (_e261 / _e262);
} else {
local_24 = 0f;
}
let _e264 = local_24;
q = (_e254 + ((_e255 - _e256) * _e264));
let _e267 = ha;
aAbove = (_e267 > 0f);
let _e269 = hb;
bAbove = (_e269 > 0f);
let _e271 = aAbove;
let _e272 = bAbove;
if (_e271 || _e272) {
let _e274 = aAbove;
let _e275 = a_2;
let _e276 = q;
let _e279 = bAbove;
let _e280 = b_1;
let _e281 = q;
param_83 = select(_e276, _e275, vec3(_e274));
param_84 = select(_e281, _e280, vec3(_e279));
let _e284 = (*n_4);
param_85 = _e284;
let _e285 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e285;
} else {
local_25 = 0f;
}
let _e286 = local_25;
let _e287 = total;
total = (_e287 + _e286);
let _e289 = aAbove;
let _e290 = bAbove;
let _e293 = q;
let _e294 = exit;
exit = select(_e294, _e293, vec3((_e289 && !(_e290))));
let _e297 = aAbove;
let _e299 = bAbove;
let _e301 = q;
let _e302 = entry;
entry = select(_e302, _e301, vec3((!(_e297) && _e299)));
continue;
} else {
break;
}
continuing {
let _e305 = i_7;
i_7 = (_e305 + 1i);
}
}
let _e307 = exit;
param_86 = _e307;
let _e308 = entry;
param_87 = _e308;
let _e309 = (*n_4);
param_88 = _e309;
let _e310 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e311 = total;
total = (_e311 + _e310);
let _e313 = total;
return max((-(_e313) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e216 = (*slot_1);
let _e217 = (*slot_1);
lane = (_e216 - ((_e217 / 4i) * 4i));
let _e221 = lane;
if (_e221 == 0i) {
let _e224 = (*four)[0u];
local_26 = _e224;
} else {
let _e225 = lane;
if (_e225 == 1i) {
let _e228 = (*four)[1u];
local_27 = _e228;
} else {
let _e229 = lane;
if (_e229 == 2i) {
let _e232 = (*four)[2u];
local_28 = _e232;
} else {
let _e234 = (*four)[3u];
local_28 = _e234;
}
let _e235 = local_28;
local_27 = _e235;
}
let _e236 = local_27;
local_26 = _e236;
}
let _e237 = local_26;
return _e237;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e213 = (*slot_2);
let _e217 = light_list_info.scales[(_e213 / 4i)];
param_89 = _e217;
let _e218 = (*slot_2);
param_90 = _e218;
let _e219 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e219;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e215 = light_list_info.slot_rows[0i];
let _e216 = (*row);
a_3 = abs((_e215 - vec4(_e216)));
let _e222 = light_list_info.slot_rows[1i];
let _e223 = (*row);
b_2 = abs((_e222 - vec4(_e223)));
let _e228 = a_3[0u];
let _e230 = a_3[1u];
let _e233 = a_3[2u];
let _e235 = a_3[3u];
let _e239 = b_2[0u];
let _e241 = b_2[1u];
let _e244 = b_2[2u];
let _e246 = b_2[3u];
return (min(min(min(_e228, _e230), min(_e233, _e235)), min(min(_e239, _e241), min(_e244, _e246))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e213 = (*slot_3);
let _e217 = light_list_info.indices[(_e213 / 4i)];
param_91 = _e217;
let _e218 = (*slot_3);
param_92 = _e218;
let _e219 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e219;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e212 = (*texel_2);
let _e216 = light_list_info.list[1u];
let _e218 = (*row_1);
let _e222 = light_list_info.list[2u];
let _e225 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e212 + 0.5f) * _e216), ((_e218 + 0.5f) * _e222)), 0f);
return _e225;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e220 = g_cluster_offset;
let _e221 = (*slot_4);
entry_1 = (_e220 + f32(_e221));
let _e224 = entry_1;
row_2 = floor((_e224 / 16f));
let _e227 = entry_1;
let _e228 = row_2;
within_1 = (_e227 - (_e228 * 16f));
let _e231 = within_1;
texel_3 = floor((_e231 / 4f));
let _e236 = light_list_info.cluster_depth[3u];
let _e237 = row_2;
let _e239 = texel_3;
param_93 = _e239;
param_94 = (_e236 + _e237);
let _e240 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e240;
let _e241 = within_1;
let _e242 = texel_3;
let _e247 = four_1;
param_95 = _e247;
param_96 = i32(((_e241 - (_e242 * 4f)) + 0.5f));
let _e248 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e248;
}
fn Clustered_u0028_() -> bool {
let _e212 = light_list_info.cluster_grid[3u];
return (_e212 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp_1: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e264 = (*index_2);
if (_e264 < 8i) {
let _e266 = (*index_2);
let _e269 = frag_info.light_position[_e266];
position = _e269;
let _e270 = (*index_2);
let _e273 = frag_info.light_color[_e270];
color_1 = _e273;
let _e274 = (*index_2);
let _e277 = frag_info.light_direction[_e274];
direction = _e277;
let _e278 = (*index_2);
let _e281 = frag_info.light_cone[_e278];
cone = _e281;
} else {
let _e282 = (*index_2);
slot_5 = (_e282 - 8i);
let _e284 = Clustered_u0028_();
clustered = _e284;
let _e285 = clustered;
if _e285 {
let _e286 = slot_5;
param_97 = _e286;
let _e287 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e287;
} else {
let _e288 = slot_5;
param_98 = _e288;
let _e289 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e289;
}
let _e290 = local_29;
listRow = _e290;
let _e291 = listRow;
let _e295 = light_list_info.list[2u];
v_1 = ((_e291 + 0.5f) * _e295);
let _e299 = light_list_info.list[1u];
u_1 = _e299;
let _e300 = u_1;
let _e302 = v_1;
let _e304 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e300), _e302), 0f);
position = _e304;
let _e305 = u_1;
let _e307 = v_1;
let _e309 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e305), _e307), 0f);
color_1 = _e309;
let _e310 = u_1;
let _e312 = v_1;
let _e314 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e310), _e312), 0f);
direction = _e314;
let _e315 = u_1;
let _e317 = v_1;
let _e319 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e315), _e317), 0f);
cone = _e319;
let _e320 = clustered;
if _e320 {
let _e321 = listRow;
param_99 = _e321;
let _e322 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e322);
} else {
let _e324 = slot_5;
param_100 = _e324;
let _e325 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e325;
}
let _e326 = local_30;
let _e328 = color_1[3u];
color_1[3u] = (_e328 * _e326);
}
let _e332 = position[3u];
type_39 = _e332;
let _e333 = type_39;
if (_e333 > 15.5f) {
let _e336 = (*s_4).n;
light_3.l = _e336;
let _e339 = (*s_4).n;
light_3.h = _e339;
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 _e345 = light_3;
return _e345;
}
let _e346 = type_39;
if (_e346 > 2.5f) {
let _e348 = direction;
halfWidth_1 = _e348.xyz;
let _e350 = cone;
halfHeight_1 = _e350.xyz;
let _e352 = position;
let _e354 = v_world_position_1;
toCentre = (_e352.xyz - _e354);
let _e356 = toCentre;
let _e357 = halfWidth_1;
let _e359 = halfHeight_1;
corners_1[0i] = ((_e356 - _e357) - _e359);
let _e362 = toCentre;
let _e363 = halfWidth_1;
let _e365 = halfHeight_1;
corners_1[1i] = ((_e362 + _e363) - _e365);
let _e368 = toCentre;
let _e369 = halfWidth_1;
let _e371 = halfHeight_1;
corners_1[2i] = ((_e368 + _e369) + _e371);
let _e374 = toCentre;
let _e375 = halfWidth_1;
let _e377 = halfHeight_1;
corners_1[3i] = ((_e374 - _e375) + _e377);
let _e380 = toCentre;
let _e381 = halfWidth_1;
let _e382 = halfHeight_1;
behind = (dot(_e380, cross(_e381, _e382)) >= 0f);
let _e386 = behind;
if _e386 {
local_31 = 0f;
} else {
let _e387 = corners_1;
param_101 = _e387;
let _e389 = (*s_4).n;
param_102 = _e389;
let _e390 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e390;
}
let _e391 = local_31;
formFactor = _e391;
let _e392 = halfWidth_1;
let _e393 = halfHeight_1;
area = (length(cross(_e392, _e393)) * 4f);
let _e397 = area;
if (_e397 > 0.000000001f) {
let _e399 = area;
local_32 = (1f / _e399);
} else {
local_32 = 0f;
}
let _e401 = local_32;
radiance = _e401;
let _e402 = toCentre;
distance_2 = length(_e402);
let _e405 = direction[3u];
if (_e405 > 0f) {
let _e407 = distance_2;
let _e409 = direction[3u];
ratio_1 = (_e407 / _e409);
let _e411 = ratio_1;
let _e412 = ratio_1;
let _e414 = ratio_1;
let _e416 = ratio_1;
window_1 = clamp((1f - (((_e411 * _e412) * _e414) * _e416)), 0f, 1f);
let _e420 = window_1;
let _e421 = window_1;
let _e423 = radiance;
radiance = (_e423 * (_e420 * _e421));
}
let _e426 = (*s_4).v;
let _e429 = (*s_4).n;
mirror_1 = reflect(-(_e426), _e429);
let _e431 = position;
param_103 = _e431.xyz;
let _e433 = halfWidth_1;
param_104 = _e433;
let _e434 = halfHeight_1;
param_105 = _e434;
let _e435 = v_world_position_1;
param_106 = _e435;
let _e436 = mirror_1;
param_107 = _e436;
let _e437 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e437;
let _e438 = representative;
let _e439 = v_world_position_1;
toPoint = (_e438 - _e439);
let _e441 = toPoint;
pointDistance = length(_e441);
let _e443 = pointDistance;
if (_e443 > 0.000001f) {
let _e445 = toPoint;
let _e446 = pointDistance;
local_33 = (_e445 / vec3(_e446));
} else {
let _e450 = (*s_4).n;
local_33 = _e450;
}
let _e451 = local_33;
light_3.l = _e451;
let _e454 = light_3.l;
let _e456 = (*s_4).v;
light_3.h = normalize((_e454 + _e456));
let _e460 = formFactor;
light_3.n_dot_l = _e460;
let _e463 = (*s_4).n;
let _e465 = light_3.h;
light_3.n_dot_h = max(dot(_e463, _e465), 0f);
let _e470 = (*s_4).v;
let _e472 = light_3.h;
light_3.v_dot_h = max(dot(_e470, _e472), 0f);
let _e476 = color_1;
let _e479 = color_1[3u];
let _e481 = radiance;
light_3.radiance = ((_e476.xyz * _e479) * _e481);
let _e484 = light_3;
return _e484;
}
let _e485 = direction;
aim = normalize(_e485.xyz);
attenuation_1 = 1f;
let _e488 = type_39;
if (_e488 < 0.5f) {
let _e490 = aim;
light_3.l = -(_e490);
} else {
let _e493 = position;
let _e495 = v_world_position_1;
toLight_1 = (_e493.xyz - _e495);
let _e497 = toLight_1;
distance_3 = length(_e497);
let _e499 = distance_3;
if (_e499 < 0.000001f) {
let _e502 = (*s_4).n;
light_3.l = _e502;
let _e505 = (*s_4).n;
light_3.h = _e505;
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 _e511 = light_3;
return _e511;
}
let _e512 = toLight_1;
let _e513 = distance_3;
light_3.l = (_e512 / vec3(_e513));
let _e517 = distance_3;
param_108 = _e517;
let _e519 = direction[3u];
param_109 = _e519;
let _e520 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e520;
let _e521 = type_39;
if (_e521 > 1.5f) {
let _e523 = aim;
let _e525 = light_3.l;
cosAngle = dot(_e523, -(_e525));
let _e528 = cosAngle;
let _e530 = cone[1u];
let _e533 = cone[0u];
let _e535 = cone[1u];
ramp_1 = clamp(((_e528 - _e530) / (_e533 - _e535)), 0f, 1f);
let _e539 = ramp_1;
let _e540 = ramp_1;
let _e542 = attenuation_1;
attenuation_1 = (_e542 * (_e539 * _e540));
}
}
let _e545 = light_3.l;
let _e547 = (*s_4).v;
light_3.h = normalize((_e545 + _e547));
let _e552 = (*s_4).n;
let _e554 = light_3.l;
light_3.n_dot_l = max(dot(_e552, _e554), 0f);
let _e559 = (*s_4).n;
let _e561 = light_3.h;
light_3.n_dot_h = max(dot(_e559, _e561), 0f);
let _e566 = (*s_4).v;
let _e568 = light_3.h;
light_3.v_dot_h = max(dot(_e566, _e568), 0f);
let _e572 = color_1;
let _e575 = color_1[3u];
let _e577 = attenuation_1;
light_3.radiance = ((_e572.xyz * _e575) * _e577);
let _e580 = light_3;
return _e580;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e225 = light_list_info.cluster_view_projection;
let _e226 = (*world_3);
clip_1 = (_e225 * vec4<f32>(_e226.x, _e226.y, _e226.z, 1f));
let _e232 = clip_1;
let _e235 = clip_1[3u];
ndc_1 = (_e232.xy / vec2(max(_e235, 0.000001f)));
let _e240 = light_list_info.cluster_grid;
grid = _e240.xyz;
let _e244 = light_list_info.cluster_depth[0u];
near_1 = _e244;
let _e246 = ndc_1[0u];
let _e250 = grid[0u];
let _e254 = grid[0u];
tx = clamp(floor((((_e246 * 0.5f) + 0.5f) * _e250)), 0f, (_e254 - 1f));
let _e258 = ndc_1[1u];
let _e262 = grid[1u];
let _e266 = grid[1u];
ty = clamp(floor((((_e258 * 0.5f) + 0.5f) * _e262)), 0f, (_e266 - 1f));
let _e270 = clip_1[3u];
let _e271 = near_1;
if (_e270 <= _e271) {
local_34 = 0f;
} else {
let _e274 = clip_1[3u];
let _e275 = near_1;
let _e280 = light_list_info.cluster_depth[1u];
let _e284 = grid[2u];
local_34 = clamp(floor((log((_e274 / _e275)) * _e280)), 0f, (_e284 - 1f));
}
let _e287 = local_34;
tz = _e287;
let _e288 = tx;
let _e289 = ty;
let _e291 = grid[0u];
let _e294 = tz;
let _e296 = grid[0u];
let _e299 = grid[1u];
cell_1 = ((_e288 + (_e289 * _e291)) + ((_e294 * _e296) * _e299));
let _e302 = cell_1;
row_3 = floor((_e302 / 4f));
let _e305 = cell_1;
let _e306 = row_3;
let _e311 = light_list_info.cluster_depth[2u];
let _e312 = row_3;
param_110 = (_e305 - (_e306 * 4f));
param_111 = (_e311 + _e312);
let _e314 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e314;
let _e316 = header[0u];
g_cluster_offset = _e316;
let _e318 = header[1u];
g_cluster_count = _e318;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e214 = light_list_info.list[0u];
tail = _e214;
let _e215 = Clustered_u0028_();
if _e215 {
let _e216 = v_world_position_1;
param_112 = _e216;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e217 = g_cluster_count;
tail = _e217;
}
let _e220 = frag_info.frame_params[1u];
let _e224 = tail;
return (clamp(i32((_e220 + 0.5f)), 0i, 8i) + clamp(i32((_e224 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e228 = LightCount_u0028_();
count_1 = _e228;
i_8 = 0i;
loop {
let _e229 = i_8;
if (_e229 < 32i) {
let _e231 = i_8;
let _e232 = count_1;
if (_e231 >= _e232) {
break;
}
let _e234 = i_8;
param_113 = _e234;
let _e235 = (*s_5);
param_114 = _e235;
let _e236 = 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_113), (¶m_114));
light_4 = _e236;
let _e238 = light_4.n_dot_l;
if (_e238 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e240 = i_8;
param_115 = _e240;
let _e241 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e241 {
let _e242 = (*s_5);
param_116 = _e242;
let _e243 = light_4;
param_117 = _e243;
let _e244 = i_8;
param_118 = _e244;
let _e245 = 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_116), (¶m_117), (¶m_118));
let _e246 = v_world_position_1;
param_119 = _e246;
let _e248 = (*s_5).n;
param_120 = _e248;
let _e249 = i_8;
param_121 = _e249;
let _e250 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e245 * _e250);
} else {
local_35 = 1f;
}
let _e252 = local_35;
visibility = _e252;
let _e253 = visibility;
if (_e253 <= 0f) {
continue;
}
let _e255 = (*s_5);
param_122 = _e255;
let _e256 = light_4;
param_123 = _e256;
let _e257 = 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_122), (¶m_123));
let _e259 = light_4.radiance;
let _e262 = light_4.n_dot_l;
let _e264 = visibility;
let _e266 = light_transmittance;
let _e268 = total_1;
total_1 = (_e268 + ((((_e257 * _e259) * _e262) * _e264) * _e266));
continue;
} else {
break;
}
continuing {
let _e270 = i_8;
i_8 = (_e270 + 1i);
}
}
let _e272 = total_1;
return _e272;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_4: vec4<f32>;
let _e211 = v_lightmap_uv_1;
let _e212 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e211);
texel_4 = _e212;
let _e213 = texel_4;
let _e216 = texel_4[3u];
return ((_e213.xyz * _e216) * 8f);
}
fn MaterialLodBias_u0028_() -> f32 {
let _e212 = frag_info.target_origin[1u];
return _e212;
}
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_6: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e212 = v_texcoord_1;
let _e213 = MaterialLodBias_u0028_();
let _e214 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e212, _e213);
orm = _e214.xyz;
let _e217 = (*s_6).metallic;
let _e219 = orm[2u];
(*s_6).metallic = clamp((_e217 * _e219), 0f, 1f);
let _e224 = (*s_6).roughness;
let _e226 = orm[1u];
(*s_6).roughness = clamp((_e224 * _e226), 0.02f, 1f);
return;
}
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_7: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_124: vec3<f32>;
let _e213 = v_texcoord_1;
let _e214 = MaterialLodBias_u0028_();
let _e215 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e213, _e214);
param_124 = _e215.xyz;
let _e217 = SrgbToLinear_u0028_vf3_u003b((¶m_124));
emissive = _e217;
let _e218 = emissive;
let _e220 = frag_info.emissive;
let _e225 = frag_info.material2_[3u];
(*s_7).emissive = ((_e218 * _e220.xyz) * _e225);
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_8: ptr<function, Surface>) {
var occlusion: f32;
let _e212 = v_texcoord_1;
let _e213 = MaterialLodBias_u0028_();
let _e214 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e212, _e213);
occlusion = _e214.x;
let _e216 = occlusion;
let _e219 = frag_info.material2_[2u];
(*s_8).occlusion = mix(1f, _e216, clamp(_e219, 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_9: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_2: vec3<f32>;
var b_3: vec3<f32>;
var sampled: vec3<f32>;
let _e215 = v_texcoord_1;
let _e216 = MaterialLodBias_u0028_();
let _e217 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e215, _e216);
sampledTexel = _e217;
let _e218 = v_tangent_1;
t_2 = _e218.xyz;
let _e220 = t_2;
let _e222 = (*s_9).n;
let _e224 = (*s_9).n;
let _e225 = t_2;
t_2 = (_e220 - (_e222 * dot(_e224, _e225)));
let _e229 = t_2;
let _e230 = t_2;
if (dot(_e229, _e230) < 0.000000000001f) {
return;
}
let _e233 = t_2;
t_2 = normalize(_e233);
let _e236 = (*s_9).n;
let _e237 = t_2;
let _e240 = v_tangent_1[3u];
b_3 = (cross(_e236, _e237) * _e240);
let _e242 = gl_FrontFacing_1;
if !(_e242) {
let _e244 = t_2;
t_2 = -(_e244);
}
let _e246 = sampledTexel;
sampled = ((_e246.xyz * 2f) - vec3(1f));
let _e253 = frag_info.emissive[3u];
if (_e253 > 0.5f) {
let _e255 = sampled;
let _e257 = sampled;
sampled[2u] = sqrt(max((1f - dot(_e255.xy, _e257.xy)), 0f));
}
let _e266 = frag_info.material2_[1u];
let _e267 = sampled;
let _e269 = (_e267.xy * _e266);
sampled[0u] = _e269.x;
sampled[1u] = _e269.y;
let _e274 = t_2;
let _e276 = sampled[0u];
let _e278 = b_3;
let _e280 = sampled[1u];
let _e284 = (*s_9).n;
let _e286 = sampled[2u];
(*s_9).n = normalize((((_e274 * _e276) + (_e278 * _e280)) + (_e284 * _e286)));
let _e292 = (*s_9).n;
let _e294 = (*s_9).v;
(*s_9).n_dot_v = max(dot(_e292, _e294), 0.0001f);
return;
}
fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e211 = (*texel_5);
let _e215 = irradiance_info.atlas;
let _e218 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e211 + vec2(0.5f)) * _e215.xy), 0f);
return _e218;
}
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: vec2<f32>;
var a_4: vec4<f32>;
var param_125: vec2<f32>;
var b_4: vec4<f32>;
var param_126: vec2<f32>;
var c_1: vec4<f32>;
var param_127: vec2<f32>;
var d_4: vec4<f32>;
var param_128: vec2<f32>;
let _e224 = (*uv_6);
let _e225 = (*interior);
at_1 = ((vec2(1f) + (_e224 * _e225)) - vec2(0.5f));
let _e231 = at_1;
low = floor(_e231);
let _e233 = at_1;
let _e234 = low;
f = (_e233 - _e234);
let _e236 = (*corner);
let _e237 = low;
param_125 = (_e236 + _e237);
let _e239 = AtlasTexel_u0028_vf2_u003b((¶m_125));
a_4 = _e239;
let _e240 = (*corner);
let _e241 = low;
param_126 = ((_e240 + _e241) + vec2<f32>(1f, 0f));
let _e244 = AtlasTexel_u0028_vf2_u003b((¶m_126));
b_4 = _e244;
let _e245 = (*corner);
let _e246 = low;
param_127 = ((_e245 + _e246) + vec2<f32>(0f, 1f));
let _e249 = AtlasTexel_u0028_vf2_u003b((¶m_127));
c_1 = _e249;
let _e250 = (*corner);
let _e251 = low;
param_128 = ((_e250 + _e251) + vec2<f32>(1f, 1f));
let _e254 = AtlasTexel_u0028_vf2_u003b((¶m_128));
d_4 = _e254;
let _e255 = a_4;
let _e256 = b_4;
let _e258 = f[0u];
let _e261 = c_1;
let _e262 = d_4;
let _e264 = f[0u];
let _e268 = f[1u];
return mix(mix(_e255, _e256, vec4(_e258)), mix(_e261, _e262, vec4(_e264)), vec4(_e268));
}
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 _e215 = (*direction_1)[0u];
let _e218 = (*direction_1)[1u];
let _e222 = (*direction_1)[2u];
sum_1 = ((abs(_e215) + abs(_e218)) + abs(_e222));
let _e225 = sum_1;
if (_e225 <= 0f) {
return vec2<f32>(0.5f, 0.5f);
}
let _e227 = (*direction_1);
let _e228 = sum_1;
n_5 = (_e227 / vec3(_e228));
let _e231 = n_5;
xy = _e231.xy;
let _e234 = n_5[2u];
if (_e234 < 0f) {
let _e237 = n_5[1u];
let _e241 = n_5[0u];
let _e246 = n_5[0u];
let _e250 = n_5[1u];
xy = vec2<f32>(((1f - abs(_e237)) * select(-1f, 1f, (_e241 >= 0f))), ((1f - abs(_e246)) * select(-1f, 1f, (_e250 >= 0f))));
}
let _e255 = xy;
return ((_e255 * 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_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: 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_2: vec3<f32>;
var probe: f32;
var tile_4: vec2<f32>;
var irradianceCorner: vec2<f32>;
var momentCorner: vec2<f32>;
var param_129: vec2<f32>;
var trilinear: vec3<f32>;
var weight_3: 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_130: vec3<f32>;
var param_131: vec2<f32>;
var param_132: f32;
var param_133: vec2<f32>;
var chebyshev: f32;
var variance_1: f32;
var difference: f32;
var param_134: vec3<f32>;
var param_135: vec2<f32>;
var param_136: f32;
var param_137: vec2<f32>;
var local_36: vec3<f32>;
let _e257 = irradiance_info.origin;
origin_2 = _e257.xyz;
let _e260 = irradiance_info.spacing;
spacing = _e260.xyz;
let _e263 = irradiance_info.counts;
counts = _e263.xyz;
let _e267 = irradiance_info.tiles[0u];
irradianceTile = _e267;
let _e270 = irradiance_info.tiles[1u];
depthTile = _e270;
let _e273 = irradiance_info.tiles[2u];
columns = _e273;
let _e276 = irradiance_info.tiles[3u];
momentsTop = _e276;
let _e277 = (*normal_1);
unit = normalize(_e277);
let _e279 = (*world_4);
let _e280 = unit;
let _e283 = irradiance_info.spacing[3u];
let _e286 = (*view_1);
let _e289 = irradiance_info.counts[3u];
biased = ((_e279 + (_e280 * _e283)) + (_e286 * _e289));
let _e292 = biased;
let _e293 = origin_2;
let _e295 = spacing;
grid_1 = ((_e292 - _e293) / _e295);
let _e297 = grid_1;
let _e299 = counts;
base = clamp(floor(_e297), vec3<f32>(0f, 0f, 0f), (_e299 - vec3(2f)));
let _e303 = grid_1;
let _e304 = base;
f_1 = clamp((_e303 - _e304), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
total_2 = vec3<f32>(0f, 0f, 0f);
weights = 0f;
corner_1 = 0i;
loop {
let _e307 = corner_1;
if (_e307 < 8i) {
let _e309 = corner_1;
let _e312 = corner_1;
let _e317 = corner_1;
offset_3 = vec3<f32>(f32((_e309 & 1i)), f32(((_e312 >> bitcast<u32>(1i)) & 1i)), f32(((_e317 >> bitcast<u32>(2i)) & 1i)));
let _e323 = base;
let _e324 = offset_3;
cell_2 = (_e323 + _e324);
let _e327 = cell_2[2u];
let _e329 = counts[1u];
let _e332 = cell_2[1u];
let _e335 = counts[0u];
let _e338 = cell_2[0u];
probe = ((((_e327 * _e329) + _e332) * _e335) + _e338);
let _e340 = probe;
let _e341 = columns;
let _e346 = probe;
let _e347 = columns;
tile_4 = vec2<f32>((_e340 - (floor((_e340 / _e341)) * _e341)), floor((_e346 / _e347)));
let _e351 = tile_4;
let _e352 = irradianceTile;
irradianceCorner = (_e351 * (_e352 + 2f));
let _e356 = tile_4[0u];
let _e357 = depthTile;
let _e360 = momentsTop;
let _e362 = tile_4[1u];
let _e363 = depthTile;
momentCorner = vec2<f32>((_e356 * (_e357 + 2f)), (_e360 + (_e362 * (_e363 + 2f))));
let _e368 = irradianceCorner;
param_129 = (_e368 + vec2(1f));
let _e371 = AtlasTexel_u0028_vf2_u003b((¶m_129));
if (_e371.w < 0.5f) {
continue;
}
let _e374 = f_1;
let _e376 = f_1;
let _e377 = offset_3;
trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e374), _e376, _e377);
let _e380 = trilinear[0u];
let _e382 = trilinear[1u];
let _e385 = trilinear[2u];
weight_3 = max(((_e380 * _e382) * _e385), 0.001f);
let _e388 = origin_2;
let _e389 = spacing;
let _e390 = cell_2;
probePosition = (_e388 + (_e389 * _e390));
let _e393 = probePosition;
let _e394 = biased;
toProbe = (_e393 - _e394);
let _e396 = toProbe;
distance_4 = length(_e396);
let _e398 = distance_4;
if (_e398 > 0.000001f) {
let _e400 = toProbe;
let _e401 = distance_4;
direction_2 = (_e400 / vec3(_e401));
let _e404 = unit;
let _e405 = probePosition;
let _e406 = (*world_4);
facing = ((dot(_e404, normalize((_e405 - _e406))) * 0.5f) + 0.5f);
let _e412 = facing;
let _e413 = facing;
probeWeight = ((_e412 * _e413) + 0.2f);
let _e416 = direction_2;
param_130 = -(_e416);
let _e418 = ProbeOctahedral_u0028_vf3_u003b((¶m_130));
let _e419 = momentCorner;
param_131 = _e419;
let _e420 = depthTile;
param_132 = _e420;
param_133 = _e418;
let _e421 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_131), (¶m_132), (¶m_133));
moments_3 = _e421.xy;
chebyshev = 1f;
let _e423 = distance_4;
let _e425 = moments_3[0u];
if (_e423 > _e425) {
let _e428 = moments_3[1u];
let _e430 = moments_3[0u];
let _e432 = moments_3[0u];
variance_1 = max((_e428 - (_e430 * _e432)), 0.000001f);
let _e436 = distance_4;
let _e438 = moments_3[0u];
difference = (_e436 - _e438);
let _e440 = variance_1;
let _e441 = variance_1;
let _e442 = difference;
let _e443 = difference;
chebyshev = (_e440 / (_e441 + (_e442 * _e443)));
let _e447 = chebyshev;
let _e448 = chebyshev;
let _e450 = chebyshev;
chebyshev = ((_e447 * _e448) * _e450);
}
let _e452 = probeWeight;
let _e453 = chebyshev;
probeWeight = max((_e452 * max(_e453, 0.05f)), 0.000001f);
let _e457 = probeWeight;
if (_e457 < 0.2f) {
let _e459 = probeWeight;
let _e460 = probeWeight;
let _e463 = probeWeight;
probeWeight = (_e463 * ((_e459 * _e460) * 25f));
}
let _e465 = probeWeight;
let _e466 = weight_3;
weight_3 = (_e466 * _e465);
}
let _e468 = unit;
param_134 = _e468;
let _e469 = ProbeOctahedral_u0028_vf3_u003b((¶m_134));
let _e470 = irradianceCorner;
param_135 = _e470;
let _e471 = irradianceTile;
param_136 = _e471;
param_137 = _e469;
let _e472 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((¶m_135), (¶m_136), (¶m_137));
let _e474 = weight_3;
let _e476 = total_2;
total_2 = (_e476 + (_e472.xyz * _e474));
let _e478 = weight_3;
let _e479 = weights;
weights = (_e479 + _e478);
continue;
} else {
break;
}
continuing {
let _e481 = corner_1;
corner_1 = (_e481 + 1i);
}
}
let _e483 = weights;
if (_e483 > 0f) {
let _e485 = total_2;
let _e486 = weights;
local_36 = (_e485 / vec3(_e486));
} else {
local_36 = vec3<f32>(0f, 0f, 0f);
}
let _e489 = local_36;
return _e489;
}
fn IrradianceEnabled_u0028_() -> bool {
let _e212 = irradiance_info.origin[3u];
return (_e212 > 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_10: ptr<function, Surface>) {
var param_138: vec3<f32>;
var param_139: vec3<f32>;
var param_140: vec3<f32>;
var param_141: Surface;
var param_142: Surface;
var param_143: Surface;
let _e217 = IrradianceEnabled_u0028_();
if _e217 {
let _e218 = v_world_position_1;
param_138 = _e218;
let _e220 = (*s_10).n;
param_139 = _e220;
let _e222 = (*s_10).v;
param_140 = _e222;
let _e223 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_138), (¶m_139), (¶m_140));
let _e226 = frag_info.material[2u];
(*s_10).ambient = (_e223 * _e226);
}
let _e229 = (*s_10);
param_141 = _e229;
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_141));
let _e230 = param_141;
(*s_10) = _e230;
let _e231 = (*s_10);
param_142 = _e231;
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_142));
let _e232 = param_142;
(*s_10) = _e232;
let _e233 = (*s_10);
param_143 = _e233;
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_143));
let _e234 = param_143;
(*s_10) = _e234;
return;
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e211 = Orthographic_u0028_();
if _e211 {
let _e213 = fog_info.forward;
local_37 = -(_e213.xyz);
} else {
let _e217 = fog_info.eye;
let _e219 = v_world_position_1;
local_37 = normalize((_e217.xyz - _e219));
}
let _e222 = local_37;
return _e222;
}
fn ReadSurface_u0028_() -> Surface {
var texel_6: vec4<f32>;
var s_11: Surface;
var param_144: vec3<f32>;
var param_145: vec3<f32>;
var cutoff: f32;
var edge: f32;
let _e216 = v_texcoord_1;
let _e217 = MaterialLodBias_u0028_();
let _e218 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e216, _e217);
texel_6 = _e218;
let _e219 = texel_6;
param_144 = _e219.xyz;
let _e221 = SrgbToLinear_u0028_vf3_u003b((¶m_144));
let _e223 = frag_info.base_color;
param_145 = _e223.xyz;
let _e225 = SrgbToLinear_u0028_vf3_u003b((¶m_145));
let _e227 = v_color_1;
s_11.albedo = ((_e221 * _e225) * _e227.xyz);
let _e232 = texel_6[3u];
let _e235 = frag_info.base_color[3u];
let _e238 = v_color_1[3u];
s_11.alpha = ((_e232 * _e235) * _e238);
let _e242 = s_11.albedo;
g_albedo = _e242;
let _e245 = frag_info.material2_[0u];
cutoff = _e245;
let _e246 = cutoff;
if (_e246 > 1f) {
let _e248 = cutoff;
edge = (_e248 - 1f);
let _e251 = s_11.alpha;
let _e252 = edge;
let _e255 = s_11.alpha;
let _e256 = fwidth(_e255);
s_11.alpha = clamp((((_e251 - _e252) / max(_e256, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e262 = cutoff;
if (_e262 >= 0f) {
s_11.alpha = 1f;
}
}
let _e265 = cutoff;
let _e267 = cutoff;
g_premultiply = ((_e265 < 0f) && (_e267 > -0.75f));
let _e270 = v_normal_1;
s_11.n = normalize(_e270);
let _e273 = gl_FrontFacing_1;
if !(_e273) {
let _e276 = s_11.n;
s_11.n = -(_e276);
}
let _e279 = TowardsEye_u0028_();
s_11.v = _e279;
let _e282 = s_11.n;
let _e284 = s_11.v;
s_11.n_dot_v = max(dot(_e282, _e284), 0.0001f);
let _e290 = frag_info.material[0u];
s_11.metallic = clamp(_e290, 0f, 1f);
let _e295 = frag_info.material[1u];
s_11.roughness = clamp(_e295, 0.02f, 1f);
let _e299 = frag_info.ambient_ground;
let _e302 = frag_info.ambient_sky;
let _e306 = s_11.n[1u];
let _e313 = frag_info.material[2u];
s_11.ambient = (mix(_e299.xyz, _e302.xyz, vec3(((_e306 * 0.5f) + 0.5f))) * _e313);
let _e318 = frag_info.frame_params[0u];
s_11.exposure = max(_e318, 0f);
s_11.occlusion = 1f;
s_11.emissive = vec3<f32>(0f, 0f, 0f);
let _e323 = s_11;
return _e323;
}
fn main_1() {
var s_12: Surface;
var param_146: Surface;
var param_147: Surface;
var rim: f32;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_148: Surface;
var param_149: Surface;
var param_150: vec3<f32>;
var param_151: vec3<f32>;
var param_152: f32;
var param_153: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e222 = ReadSurface_u0028_();
s_12 = _e222;
let _e223 = s_12;
param_146 = _e223;
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_146));
let _e224 = param_146;
s_12 = _e224;
let _e225 = s_12;
param_147 = _e225;
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_147));
let _e226 = param_147;
s_12 = _e226;
let _e228 = s_12.n_dot_v;
let _e233 = frag_info.material[3u];
rim = (pow((1f - _e228), 3f) * _e233);
let _e236 = s_12.albedo;
let _e238 = s_12.ambient;
let _e239 = SampleLightmap_u0028_();
let _e243 = s_12.occlusion;
ambient = ((_e236 * (_e238 + _e239)) * _e243);
let _e245 = s_12;
param_148 = _e245;
let _e246 = 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_148));
let _e248 = s_12.occlusion;
let _e250 = ambient;
let _e252 = rim;
let _e257 = s_12.emissive;
lit_3 = ((((_e246 * _e248) + _e250) + vec3((_e252 * 0.35f))) + _e257);
let _e259 = s_12;
param_149 = _e259;
let _e260 = lit_3;
param_150 = _e260;
let _e261 = WriteDebugView_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_vf3_u003b((¶m_149), (¶m_150));
if _e261 {
return;
}
let _e262 = lit_3;
param_151 = _e262;
let _e264 = s_12.alpha;
param_152 = _e264;
let _e266 = s_12.roughness;
param_153 = _e266;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_151), (¶m_152), (¶m_153));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
'DepthPredraw': WebGpuStage(
wgsl: r'''
struct PredrawInfo {
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;
var<private> g_pass_through: f32;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> predraw_info: PredrawInfo;
@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> 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_lightmap_uv_1: vec2<f32>;
fn FadePattern_u0028_() -> f32 {
let _e38 = gl_FragCoord_1;
return fract((52.982918f * fract(dot(_e38.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key: f32;
var origin: vec3<f32>;
var cell: vec3<f32>;
var p3_: vec3<f32>;
let _e44 = (*cutoff);
key = (-2f - _e44);
let _e46 = key;
let _e49 = key;
let _e51 = floor((_e49 / 128f));
let _e56 = key;
origin = vec3<f32>(floor((_e46 / 16384f)), (_e51 - (floor((_e51 / 128f)) * 128f)), (_e56 - (floor((_e56 / 128f)) * 128f)));
let _e62 = (*scenePosition);
let _e65 = origin;
let _e66 = (floor((_e62 * 16f)) + _e65);
let _e67 = vec3(128f);
cell = (_e66 - (floor((_e66 / _e67)) * _e67));
let _e72 = cell;
p3_ = fract((_e72 * 0.1031f));
let _e75 = p3_;
let _e76 = p3_;
let _e81 = p3_;
p3_ = (_e81 + vec3(dot(_e75, (_e76.zyx + vec3(31.32f)))));
let _e85 = p3_[0u];
let _e87 = p3_[1u];
let _e90 = p3_[2u];
return fract(((_e85 + _e87) * _e90));
}
fn main_1() {
var cutoff_1: f32;
var alpha: f32;
var alpha_1: f32;
var param: vec3<f32>;
var param_1: f32;
var share: f32;
var pattern: f32;
var kept: bool;
var local: bool;
g_albedo = vec3<f32>(0f, 0f, 0f);
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
g_premultiply = false;
g_pass_through = 0f;
let _e49 = predraw_info.mask[0u];
cutoff_1 = _e49;
let _e50 = cutoff_1;
let _e52 = cutoff_1;
if ((_e50 >= 0f) && (_e52 <= 1f)) {
let _e55 = v_texcoord_1;
let _e58 = predraw_info.mask[3u];
let _e59 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e55, _e58);
let _e63 = predraw_info.mask[1u];
let _e66 = v_color_1[3u];
alpha = ((_e59.w * _e63) * _e66);
let _e68 = alpha;
let _e69 = cutoff_1;
if (_e68 < _e69) {
discard;
}
} else {
let _e71 = cutoff_1;
if (_e71 < -1.5f) {
let _e73 = v_texcoord_1;
let _e76 = predraw_info.mask[3u];
let _e77 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e73, _e76);
let _e81 = predraw_info.mask[1u];
let _e84 = v_color_1[3u];
alpha_1 = ((_e77.w * _e81) * _e84);
let _e86 = alpha_1;
let _e87 = v_world_position_1;
param = _e87;
let _e88 = cutoff_1;
param_1 = _e88;
let _e89 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m), (¶m_1));
if (_e86 < _e89) {
discard;
}
}
}
let _e93 = predraw_info.mask[2u];
share = _e93;
let _e94 = share;
if (_e94 < 1f) {
let _e96 = FadePattern_u0028_();
pattern = _e96;
let _e97 = share;
if (_e97 >= 0f) {
let _e99 = pattern;
let _e100 = share;
local = (_e99 < _e100);
} else {
let _e102 = pattern;
let _e103 = share;
local = (_e102 >= (1f + _e103));
}
let _e106 = local;
kept = _e106;
let _e107 = kept;
if !(_e107) {
discard;
}
}
frag_color = vec4<f32>(0f, 0f, 0f, 0f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
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 _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'PredrawInfo',
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,
),
],
),
'Normals': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: 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_pass_through: 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> 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 _e45 = (*n)[0u];
let _e48 = (*n)[1u];
let _e52 = (*n)[2u];
let _e55 = (*n);
(*n) = (_e55 / vec3(((abs(_e45) + abs(_e48)) + abs(_e52))));
let _e58 = (*n);
e = _e58.xy;
let _e61 = (*n)[2u];
if (_e61 < 0f) {
let _e63 = (*n);
let _e69 = (*n)[0u];
let _e73 = (*n)[1u];
e = ((vec2(1f) - abs(_e63.yx)) * vec2<f32>(select(-1f, 1f, (_e69 >= 0f)), select(-1f, 1f, (_e73 >= 0f))));
}
let _e78 = e;
return ((_e78 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e42 = v_world_position_1;
let _e44 = fog_info.eye;
let _e48 = fog_info.forward;
return dot((_e42 - _e44.xyz), _e48.xyz);
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e43 = (*linear);
let _e45 = (*linear);
let _e49 = (*linear);
return mix((_e43 * 12.92f), ((pow(_e45, 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), _e49));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
var geometric: vec3<f32>;
var param_1: vec3<f32>;
let _e46 = g_albedo;
param = clamp(_e46, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e48 = LinearToSrgb_u0028_vf3_u003b((¶m));
frag_albedo = vec4<f32>(_e48.x, _e48.y, _e48.z, 1f);
let _e53 = g_debug_surface_on;
if _e53 {
let _e54 = g_debug_surface;
let _e55 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e54.x, _e54.y, _e54.z, _e55);
return;
}
let _e60 = v_normal_1;
geometric = normalize(_e60);
let _e62 = gl_FrontFacing_1;
if !(_e62) {
let _e64 = geometric;
geometric = -(_e64);
}
let _e66 = geometric;
param_1 = _e66;
let _e67 = EncodeOctahedral_u0028_vf3_u003b((¶m_1));
let _e68 = (*roughness);
let _e70 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e67.x, _e67.y, clamp(_e68, 0f, 1f), _e70);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e43 = (*srgb);
let _e46 = (*srgb);
let _e51 = (*srgb);
return mix((_e43 / vec3(12.92f)), pow(((_e46 + 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), _e51));
}
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 _e46 = (*displayColor);
param_2 = _e46;
let _e47 = SrgbToLinear_u0028_vf3_u003b((¶m_2));
let _e48 = (*alpha);
frag_color = vec4<f32>(_e47.x, _e47.y, _e47.z, _e48);
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;
g_pass_through = 0f;
let _e45 = v_normal_1;
n_1 = normalize(_e45);
let _e47 = n_1;
param_4 = ((_e47 * 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(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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(6) 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(6) 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(6) 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>,
lens: 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> composite_info: CompositeInfo;
@group(1) @binding(12)
var lut_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var lut_texture_smp: sampler;
@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 _e151 = (*at)[0u];
x = i32((_e151 - (floor((_e151 / 4f)) * 4f)));
let _e158 = (*at)[1u];
y = i32((_e158 - (floor((_e158 / 4f)) * 4f)));
let _e164 = y;
let _e166 = x;
index = ((_e164 * 4i) + _e166);
value = 0f;
let _e168 = index;
if (_e168 == 0i) {
value = 0f;
} else {
let _e170 = index;
if (_e170 == 1i) {
value = 8f;
} else {
let _e172 = index;
if (_e172 == 2i) {
value = 2f;
} else {
let _e174 = index;
if (_e174 == 3i) {
value = 10f;
} else {
let _e176 = index;
if (_e176 == 4i) {
value = 12f;
} else {
let _e178 = index;
if (_e178 == 5i) {
value = 4f;
} else {
let _e180 = index;
if (_e180 == 6i) {
value = 14f;
} else {
let _e182 = index;
if (_e182 == 7i) {
value = 6f;
} else {
let _e184 = index;
if (_e184 == 8i) {
value = 3f;
} else {
let _e186 = index;
if (_e186 == 9i) {
value = 11f;
} else {
let _e188 = index;
if (_e188 == 10i) {
value = 1f;
} else {
let _e190 = index;
if (_e190 == 11i) {
value = 9f;
} else {
let _e192 = index;
if (_e192 == 12i) {
value = 15f;
} else {
let _e194 = index;
if (_e194 == 13i) {
value = 7f;
} else {
let _e196 = index;
if (_e196 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e198 = value;
return ((_e198 / 16f) - 0.5f);
}
fn Hash_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
let _e146 = (*at_1);
return fract((sin(dot(_e146, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e147 = (*rows);
if (_e147 > 0f) {
let _e150 = gl_FragCoord_1[0u];
let _e151 = (*rows);
let _e153 = gl_FragCoord_1[1u];
local = vec2<f32>(_e150, (_e151 - _e153));
} else {
let _e156 = gl_FragCoord_1;
local = _e156.xy;
}
let _e158 = local;
return _e158;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param: f32;
let _e148 = frag_coord_info.origin[0u];
param = _e148;
let _e149 = FragCoordFromTop_u0028_f1_u003b((¶m));
return _e149;
}
fn SrgbToLinear_u0028_vf3_u003b(encoded: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e146 = (*encoded);
let _e149 = (*encoded);
let _e155 = (*encoded);
return mix((_e146 / vec3(12.92f)), pow(((max(_e149, 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), _e155));
}
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 _e158 = (*color);
c = clamp(_e158, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e160 = (*size);
sliceWidth = (1f / _e160);
let _e162 = (*size);
let _e163 = (*size);
texel = (1f / (_e162 * _e163));
let _e166 = texel;
let _e167 = (*size);
innerWidth = (_e166 * (_e167 - 1f));
let _e170 = texel;
let _e173 = c[0u];
let _e174 = innerWidth;
u = ((_e170 * 0.5f) + (_e173 * _e174));
let _e177 = (*size);
let _e180 = c[1u];
let _e181 = (*size);
let _e183 = (*size);
v = ((0.5f / _e177) + (_e180 * ((_e181 - 1f) / _e183)));
let _e188 = c[2u];
let _e189 = (*size);
slice = (_e188 * (_e189 - 1f));
let _e192 = slice;
lower = floor(_e192);
let _e194 = lower;
let _e196 = (*size);
upper = min((_e194 + 1f), (_e196 - 1f));
let _e199 = lower;
let _e200 = sliceWidth;
let _e202 = u;
let _e204 = v;
let _e206 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e199 * _e200) + _e202), _e204));
a = _e206.xyz;
let _e208 = upper;
let _e209 = sliceWidth;
let _e211 = u;
let _e213 = v;
let _e215 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e208 * _e209) + _e211), _e213));
b = _e215.xyz;
let _e217 = a;
let _e218 = b;
let _e219 = slice;
let _e220 = lower;
return mix(_e217, _e218, vec3((_e219 - _e220)));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e146 = (*linear);
let _e148 = (*linear);
let _e153 = (*linear);
return mix((_e146 * 12.92f), ((pow(max(_e148, 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), _e153));
}
fn Luma_u0028_vf3_u003b(color_1: ptr<function, vec3<f32>>) -> f32 {
let _e146 = (*color_1);
return dot(_e146, 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 _e149 = (*color_2);
v_1 = clamp(log2(max(_e149, 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 _e153 = v_1;
v_1 = ((_e153 - vec3<f32>(-12.47393f, -12.47393f, -12.47393f)) / vec3(16.499998f));
let _e157 = v_1;
let _e158 = v_1;
v2_ = (_e157 * _e158);
let _e160 = v2_;
let _e161 = v2_;
v4_ = (_e160 * _e161);
let _e163 = v4_;
let _e165 = v2_;
let _e167 = v4_;
let _e169 = v_1;
let _e172 = v4_;
let _e175 = v2_;
let _e177 = v_1;
let _e180 = v2_;
let _e183 = v_1;
v_1 = ((((((((_e163 * 15.5f) * _e165) - ((_e167 * 40.14f) * _e169)) + (_e172 * 31.96f)) - ((_e175 * 6.868f) * _e177)) + (_e180 * 0.4298f)) + (_e183 * 0.1191f)) - vec3(0.00232f));
let _e188 = v_1;
return clamp(_e188, 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 _e148 = (*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(_e148, vec3<f32>(0f, 0f, 0f)));
let _e151 = AgxSigmoid_u0028_vf3_u003b((¶m_1));
v_2 = _e151;
let _e152 = 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)) * _e152);
let _e154 = v_2;
return clamp(pow(max(_e154, 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 _e147 = (*color_4);
param_2 = _e147;
let _e148 = TonemapAgx_u0028_vf3_u003b((¶m_2));
return _e148;
}
fn TonemapReinhard_u0028_vf3_u003b(color_5: ptr<function, vec3<f32>>) -> vec3<f32> {
var numerator: vec3<f32>;
let _e147 = (*color_5);
let _e148 = (*color_5);
numerator = (_e147 * (vec3<f32>(1f, 1f, 1f) + (_e148 / vec3<f32>(16f, 16f, 16f))));
let _e152 = numerator;
let _e153 = (*color_5);
return clamp((_e152 / (vec3<f32>(1f, 1f, 1f) + _e153)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAces_u0028_vf3_u003b(color_6: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e146 = (*color_6);
let _e147 = (*color_6);
let _e152 = (*color_6);
let _e153 = (*color_6);
return clamp(((_e146 * ((_e147 * 2.51f) + vec3(0.03f))) / ((_e152 * ((_e153 * 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 _e153 = (*color_7)[0u];
let _e155 = (*color_7)[1u];
let _e157 = (*color_7)[2u];
minChannel = min(_e153, min(_e155, _e157));
let _e160 = minChannel;
if (_e160 < 0.08f) {
let _e162 = minChannel;
let _e163 = minChannel;
let _e165 = minChannel;
local_1 = (_e162 - ((6.25f * _e163) * _e165));
} else {
local_1 = 0.04f;
}
let _e168 = local_1;
offset = _e168;
let _e169 = offset;
let _e170 = (*color_7);
(*color_7) = (_e170 - vec3(_e169));
let _e174 = (*color_7)[0u];
let _e176 = (*color_7)[1u];
let _e178 = (*color_7)[2u];
peak = max(_e174, max(_e176, _e178));
let _e181 = peak;
if (_e181 < 0.76f) {
let _e183 = (*color_7);
return _e183;
}
let _e184 = peak;
newPeak = (1f - (0.0576f / ((_e184 + 0.24f) - 0.76f)));
let _e189 = newPeak;
let _e190 = peak;
let _e192 = (*color_7);
(*color_7) = (_e192 * (_e189 / _e190));
let _e194 = peak;
let _e195 = newPeak;
desaturate = (1f - (1f / ((0.15f * (_e194 - _e195)) + 1f)));
let _e201 = (*color_7);
let _e202 = newPeak;
let _e204 = desaturate;
return mix(_e201, vec3(_e202), vec3(_e204));
}
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 _e160 = composite_info.contact[1u];
size_1 = max(_e160, 2f);
let _e162 = (*color_8);
c_1 = clamp(((log2((max(_e162, 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 _e172 = size_1;
sliceWidth_1 = (1f / _e172);
let _e174 = size_1;
let _e175 = size_1;
texel_1 = (1f / (_e174 * _e175));
let _e178 = texel_1;
let _e179 = size_1;
innerWidth_1 = (_e178 * (_e179 - 1f));
let _e182 = texel_1;
let _e185 = c_1[0u];
let _e186 = innerWidth_1;
u_1 = ((_e182 * 0.5f) + (_e185 * _e186));
let _e189 = size_1;
let _e192 = c_1[1u];
let _e193 = size_1;
let _e195 = size_1;
v_3 = ((0.5f / _e189) + (_e192 * ((_e193 - 1f) / _e195)));
let _e200 = c_1[2u];
let _e201 = size_1;
slice_1 = (_e200 * (_e201 - 1f));
let _e204 = slice_1;
lower_1 = floor(_e204);
let _e206 = lower_1;
let _e208 = size_1;
upper_1 = min((_e206 + 1f), (_e208 - 1f));
let _e211 = lower_1;
let _e212 = sliceWidth_1;
let _e214 = u_1;
let _e216 = v_3;
let _e218 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e211 * _e212) + _e214), _e216));
a_1 = _e218.xyz;
let _e220 = upper_1;
let _e221 = sliceWidth_1;
let _e223 = u_1;
let _e225 = v_3;
let _e227 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e220 * _e221) + _e223), _e225));
b_1 = _e227.xyz;
let _e229 = a_1;
let _e230 = b_1;
let _e231 = slice_1;
let _e232 = lower_1;
return mix(_e229, _e230, vec3((_e231 - _e232)));
}
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 _e153 = (*curve);
if (_e153 == 6i) {
let _e155 = (*color_9);
param_3 = _e155;
let _e156 = SampleDisplay_u0028_vf3_u003b((¶m_3));
return _e156;
}
let _e157 = (*curve);
if (_e157 == 1i) {
let _e159 = (*color_9);
param_4 = _e159;
let _e160 = TonemapNeutral_u0028_vf3_u003b((¶m_4));
return _e160;
}
let _e161 = (*curve);
if (_e161 == 2i) {
let _e163 = (*color_9);
param_5 = _e163;
let _e164 = TonemapAces_u0028_vf3_u003b((¶m_5));
return _e164;
}
let _e165 = (*curve);
if (_e165 == 3i) {
let _e167 = (*color_9);
param_6 = _e167;
let _e168 = TonemapAgx_u0028_vf3_u003b((¶m_6));
return _e168;
}
let _e169 = (*curve);
if (_e169 == 4i) {
let _e171 = (*color_9);
param_7 = _e171;
let _e172 = TonemapReinhard_u0028_vf3_u003b((¶m_7));
return _e172;
}
let _e173 = (*curve);
if (_e173 == 5i) {
let _e175 = (*color_9);
param_8 = _e175;
let _e176 = TonemapAgxFull_u0028_vf3_u003b((¶m_8));
return _e176;
}
let _e177 = (*color_9);
return _e177;
}
fn Distort_u0028_vf2_u003b_f1_u003b(at_2: ptr<function, vec2<f32>>, k: ptr<function, f32>) -> vec2<f32> {
var aspect: f32;
var fromCentre: vec2<f32>;
var onFrame: vec2<f32>;
var r2_: f32;
var border: f32;
var local_2: f32;
let _e155 = composite_info.look_more[3u];
aspect = max(_e155, 0.0001f);
let _e157 = (*at_2);
fromCentre = (_e157 - vec2<f32>(0.5f, 0.5f));
let _e159 = fromCentre;
let _e160 = aspect;
onFrame = (_e159 * vec2<f32>(_e160, 1f));
let _e163 = onFrame;
let _e164 = onFrame;
r2_ = dot(_e163, _e164);
let _e166 = (*k);
if (_e166 > 0f) {
let _e168 = aspect;
let _e169 = aspect;
local_2 = (0.25f * ((_e168 * _e169) + 1f));
} else {
let _e173 = aspect;
let _e174 = aspect;
local_2 = (0.25f * min((_e173 * _e174), 1f));
}
let _e178 = local_2;
border = _e178;
let _e179 = fromCentre;
let _e180 = (*k);
let _e181 = r2_;
let _e185 = (*k);
let _e186 = border;
return (vec2<f32>(0.5f, 0.5f) + ((_e179 * (1f + (_e180 * _e181))) / vec2((1f + (_e185 * _e186)))));
}
fn main_1() {
var distortion: f32;
var uv: vec2<f32>;
var local_3: vec2<f32>;
var param_9: vec2<f32>;
var param_10: f32;
var dispersion: f32;
var fromCentre_1: 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_11: vec3<f32>;
var param_12: i32;
var contrast: f32;
var saturation: f32;
var temperature: f32;
var param_13: 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_14: vec3<f32>;
var graded: vec3<f32>;
var param_15: vec3<f32>;
var param_16: f32;
var param_17: vec3<f32>;
var vignette: f32;
var fromCentre_2: vec2<f32>;
var aspect_1: f32;
var radius: f32;
var encoded_1: vec3<f32>;
var param_18: vec3<f32>;
var grain: f32;
var param_19: vec2<f32>;
var dither: f32;
var param_20: vec2<f32>;
var sides: f32;
var right_of_wipe: bool;
var shows_channel: bool;
var raw: vec4<f32>;
var param_21: vec3<f32>;
var phi_1289_: bool;
var phi_1300_: bool;
let _e197 = composite_info.lens[0u];
distortion = _e197;
let _e198 = distortion;
if (_e198 != 0f) {
let _e200 = v_uv_1;
param_9 = _e200;
let _e201 = distortion;
param_10 = _e201;
let _e202 = Distort_u0028_vf2_u003b_f1_u003b((¶m_9), (¶m_10));
local_3 = _e202;
} else {
let _e203 = v_uv_1;
local_3 = _e203;
}
let _e204 = local_3;
uv = _e204;
let _e207 = composite_info.look[3u];
dispersion = _e207;
let _e208 = dispersion;
if (_e208 > 0f) {
let _e210 = uv;
fromCentre_1 = (_e210 - vec2<f32>(0.5f, 0.5f));
let _e212 = fromCentre_1;
let _e213 = dispersion;
step_uv = (_e212 * _e213);
let _e215 = uv;
let _e216 = textureSample(scene_texture_tex, scene_texture_smp, _e215);
scene = _e216;
let _e217 = uv;
let _e218 = step_uv;
let _e220 = textureSample(scene_texture_tex, scene_texture_smp, (_e217 + _e218));
scene[0u] = _e220.x;
let _e223 = uv;
let _e224 = step_uv;
let _e226 = textureSample(scene_texture_tex, scene_texture_smp, (_e223 - _e224));
scene[2u] = _e226.z;
} else {
let _e229 = uv;
let _e230 = textureSample(scene_texture_tex, scene_texture_smp, _e229);
scene = _e230;
}
let _e233 = composite_info.lens[3u];
if (_e233 > 0.5f) {
let _e235 = scene;
let _e236 = _e235.xxx;
scene = vec4<f32>(_e236.x, _e236.y, _e236.z, 1f);
}
let _e241 = uv;
let _e242 = textureSample(bloom_texture_tex, bloom_texture_smp, _e241);
bloom = _e242.xyz;
let _e245 = composite_info.ao_texel;
half_texel = (_e245.xy * 0.5f);
let _e248 = uv;
let _e250 = half_texel[0u];
let _e252 = half_texel[1u];
let _e255 = textureSample(ao_texture_tex, ao_texture_smp, (_e248 + vec2<f32>(_e250, _e252)));
let _e256 = uv;
let _e258 = half_texel[0u];
let _e261 = half_texel[1u];
let _e264 = textureSample(ao_texture_tex, ao_texture_smp, (_e256 + vec2<f32>(-(_e258), _e261)));
let _e266 = uv;
let _e268 = half_texel[0u];
let _e270 = half_texel[1u];
let _e274 = textureSample(ao_texture_tex, ao_texture_smp, (_e266 + vec2<f32>(_e268, -(_e270))));
let _e276 = uv;
let _e278 = half_texel[0u];
let _e281 = half_texel[1u];
let _e285 = textureSample(ao_texture_tex, ao_texture_smp, (_e276 + vec2<f32>(-(_e278), -(_e281))));
occlusion = ((((_e255 + _e264) + _e274) + _e285) * 0.25f);
let _e289 = occlusion[3u];
ao = _e289;
let _e290 = ao;
let _e293 = composite_info.params[3u];
ao = mix(1f, _e290, clamp(_e293, 0f, 1f));
let _e296 = uv;
let _e297 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e296);
contact = _e297.x;
let _e299 = contact;
let _e302 = composite_info.contact[0u];
let _e305 = ao;
ao = (_e305 * mix(1f, _e299, clamp(_e302, 0f, 1f)));
let _e307 = uv;
let _e308 = textureSample(local_exposure_texture_tex, local_exposure_texture_smp, _e307);
localStops = _e308.x;
let _e310 = scene;
let _e312 = localStops;
let _e315 = composite_info.contact[3u];
exposed = (_e310.xyz * exp2((_e312 * _e315)));
let _e319 = exposed;
let _e320 = ao;
let _e322 = bloom;
let _e325 = composite_info.params[1u];
color_10 = ((_e319 * _e320) + (_e322 * _e325));
let _e328 = occlusion;
let _e332 = composite_info.contact[2u];
let _e336 = composite_info.params[3u];
let _e339 = color_10;
color_10 = (_e339 + ((_e328.xyz * _e332) * clamp(_e336, 0f, 1f)));
let _e343 = composite_info.params[0u];
let _e345 = color_10;
color_10 = (_e345 * max(_e343, 0f));
let _e349 = composite_info.params[2u];
let _e352 = color_10;
param_11 = _e352;
param_12 = i32((_e349 + 0.5f));
let _e353 = TonemapBy_u0028_vf3_u003b_i1_u003b((¶m_11), (¶m_12));
color_10 = _e353;
let _e356 = composite_info.look[0u];
contrast = _e356;
let _e359 = composite_info.look[1u];
saturation = _e359;
let _e362 = composite_info.look[2u];
temperature = _e362;
let _e363 = contrast;
if (_e363 != 1f) {
let _e365 = color_10;
let _e369 = contrast;
color_10 = (vec3<f32>(0.18f, 0.18f, 0.18f) * pow((max(_e365, vec3<f32>(0f, 0f, 0f)) / vec3(0.18f)), vec3(_e369)));
}
let _e373 = color_10;
param_13 = _e373;
let _e374 = Luma_u0028_vf3_u003b((¶m_13));
let _e376 = color_10;
let _e377 = saturation;
color_10 = mix(vec3(_e374), _e376, vec3(_e377));
let _e380 = temperature;
let _e383 = temperature;
let _e387 = color_10;
color_10 = (_e387 * vec3<f32>((1f + (_e380 * 0.1f)), 1f, (1f - (_e383 * 0.1f))));
let _e390 = composite_info.lift;
lift = _e390.xyz;
let _e393 = composite_info.gamma;
gammaCurve = _e393.xyz;
let _e396 = composite_info.gain;
gain = _e396.xyz;
let _e398 = color_10;
let _e399 = lift;
let _e402 = lift;
color_10 = ((_e398 * (vec3<f32>(1f, 1f, 1f) - _e399)) + _e402);
let _e404 = color_10;
color_10 = max(_e404, vec3<f32>(0f, 0f, 0f));
let _e406 = gammaCurve;
if any((_e406 != vec3<f32>(1f, 1f, 1f))) {
let _e409 = color_10;
let _e410 = gammaCurve;
color_10 = pow(_e409, (vec3<f32>(1f, 1f, 1f) / _e410));
}
let _e413 = gain;
let _e414 = color_10;
color_10 = (_e414 * _e413);
let _e418 = composite_info.output_encode[1u];
balance = _e418;
let _e421 = composite_info.output_encode[2u];
tint = _e421;
let _e422 = balance;
let _e424 = tint;
if ((_e422 != 0f) || (_e424 != 0f)) {
let _e427 = balance;
let _e430 = tint;
let _e433 = balance;
let _e437 = color_10;
color_10 = (_e437 * vec3<f32>((1f + (_e427 * 0.2f)), (1f + (_e430 * 0.15f)), (1f - (_e433 * 0.2f))));
let _e439 = tint;
let _e442 = color_10[0u];
color_10[0u] = (_e442 - (_e439 * 0.075f));
let _e445 = tint;
let _e448 = color_10[2u];
color_10[2u] = (_e448 - (_e445 * 0.075f));
}
let _e453 = composite_info.ao_texel[2u];
lutStrength = _e453;
let _e454 = lutStrength;
if (_e454 > 0f) {
let _e456 = color_10;
param_14 = clamp(_e456, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e458 = LinearToSrgb_u0028_vf3_u003b((¶m_14));
encodedIn = _e458;
let _e461 = composite_info.ao_texel[3u];
let _e463 = encodedIn;
param_15 = _e463;
param_16 = max(_e461, 2f);
let _e464 = SampleLut_u0028_vf3_u003b_f1_u003b((¶m_15), (¶m_16));
param_17 = _e464;
let _e465 = SrgbToLinear_u0028_vf3_u003b((¶m_17));
graded = _e465;
let _e466 = color_10;
let _e467 = graded;
let _e468 = lutStrength;
color_10 = mix(_e466, _e467, vec3(clamp(_e468, 0f, 1f)));
}
let _e474 = composite_info.look_more[0u];
vignette = _e474;
let _e475 = vignette;
if (_e475 > 0f) {
let _e477 = v_uv_1;
fromCentre_2 = (_e477 - vec2<f32>(0.5f, 0.5f));
let _e481 = composite_info.look_more[3u];
aspect_1 = max(_e481, 0.0001f);
let _e483 = aspect_1;
let _e486 = composite_info.look_more[1u];
let _e489 = fromCentre_2[0u];
fromCentre_2[0u] = (_e489 * mix(1f, _e483, _e486));
let _e492 = fromCentre_2;
radius = (length(_e492) * 1.4142135f);
let _e495 = vignette;
let _e497 = radius;
let _e500 = color_10;
color_10 = (_e500 * mix(1f, (1f - _e495), clamp(_e497, 0f, 1f)));
}
let _e502 = color_10;
param_18 = max(_e502, vec3<f32>(0f, 0f, 0f));
let _e504 = LinearToSrgb_u0028_vf3_u003b((¶m_18));
encoded_1 = _e504;
let _e507 = composite_info.look_more[2u];
grain = _e507;
let _e508 = grain;
if (_e508 > 0f) {
let _e510 = TargetFragCoord_u0028_();
param_19 = _e510;
let _e511 = Hash_u0028_vf2_u003b((¶m_19));
let _e513 = grain;
let _e516 = encoded_1;
encoded_1 = (_e516 + vec3(((_e511 - 0.5f) * _e513)));
}
let _e520 = composite_info.output_encode[0u];
dither = _e520;
let _e521 = dither;
if (_e521 > 0f) {
let _e523 = TargetFragCoord_u0028_();
param_20 = _e523;
let _e524 = BayerCell_u0028_vf2_u003b((¶m_20));
let _e526 = dither;
let _e529 = encoded_1;
encoded_1 = (_e529 + vec3(((_e524 + 0.03125f) * _e526)));
}
let _e531 = encoded_1;
let _e533 = scene[3u];
frag_color = vec4<f32>(_e531.x, _e531.y, _e531.z, _e533);
let _e540 = composite_info.lens[1u];
sides = _e540;
let _e542 = v_uv_1[0u];
let _e545 = composite_info.lens[2u];
right_of_wipe = (_e542 >= _e545);
let _e547 = sides;
let _e548 = (_e547 > 2.5f);
phi_1289_ = _e548;
if !(_e548) {
let _e550 = sides;
let _e552 = sides;
let _e555 = right_of_wipe;
phi_1289_ = (((_e550 > 1.5f) && (_e552 < 2.5f)) && !(_e555));
}
let _e559 = phi_1289_;
phi_1300_ = _e559;
if !(_e559) {
let _e561 = sides;
let _e563 = sides;
let _e566 = right_of_wipe;
phi_1300_ = (((_e561 > 0.5f) && (_e563 < 1.5f)) && _e566);
}
let _e569 = phi_1300_;
shows_channel = _e569;
let _e570 = shows_channel;
if _e570 {
let _e571 = v_uv_1;
let _e572 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e571, 0f);
raw = _e572;
let _e573 = raw;
param_21 = clamp(_e573.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e576 = LinearToSrgb_u0028_vf3_u003b((¶m_21));
let _e578 = raw[3u];
frag_color = vec4<f32>(_e576.x, _e576.y, _e576.z, _e578);
}
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) 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: 160,
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,
),
WebGpuBlockMember(
name: 'lens',
offsetInBytes: 144,
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(6) 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(6) 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(6) 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(6) 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,
),
],
),
'SmaaEdges': WebGpuStage(
wgsl: r'''
struct SmaaInfo {
params: vec4<f32>,
}
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luma_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var c: vec3<f32>;
let _e19 = (*at);
let _e20 = textureSampleLevel(source_texture_tex, source_texture_smp, _e19, 0f);
c = _e20.xyz;
let _e22 = c;
return dot(_e22, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var texel: vec2<f32>;
var middle: f32;
var param: vec2<f32>;
var left: f32;
var param_1: vec2<f32>;
var top: f32;
var param_2: vec2<f32>;
var delta: vec2<f32>;
var edges: vec2<f32>;
var right: f32;
var param_3: vec2<f32>;
var bottom: f32;
var param_4: vec2<f32>;
var leftLeft: f32;
var param_5: vec2<f32>;
var topTop: f32;
var param_6: vec2<f32>;
var largest: f32;
let _e36 = smaa_info.params;
texel = _e36.xy;
let _e38 = v_uv_1;
param = _e38;
let _e39 = Luma_u0028_vf2_u003b((¶m));
middle = _e39;
let _e40 = v_uv_1;
let _e42 = texel[0u];
param_1 = (_e40 + vec2<f32>(-(_e42), 0f));
let _e46 = Luma_u0028_vf2_u003b((¶m_1));
left = _e46;
let _e47 = v_uv_1;
let _e49 = texel[1u];
param_2 = (_e47 + vec2<f32>(0f, -(_e49)));
let _e53 = Luma_u0028_vf2_u003b((¶m_2));
top = _e53;
let _e54 = middle;
let _e55 = left;
let _e57 = middle;
let _e58 = top;
delta = abs(vec2<f32>((_e54 - _e55), (_e57 - _e58)));
let _e64 = smaa_info.params[2u];
let _e66 = delta;
edges = step(vec2(_e64), _e66);
let _e69 = edges[0u];
let _e71 = edges[1u];
if ((_e69 + _e71) == 0f) {
frag_color = vec4<f32>(0f, 0f, 0f, 0f);
return;
}
let _e74 = middle;
let _e75 = v_uv_1;
let _e77 = texel[0u];
param_3 = (_e75 + vec2<f32>(_e77, 0f));
let _e80 = Luma_u0028_vf2_u003b((¶m_3));
right = abs((_e74 - _e80));
let _e83 = middle;
let _e84 = v_uv_1;
let _e86 = texel[1u];
param_4 = (_e84 + vec2<f32>(0f, _e86));
let _e89 = Luma_u0028_vf2_u003b((¶m_4));
bottom = abs((_e83 - _e89));
let _e92 = left;
let _e93 = v_uv_1;
let _e95 = texel[0u];
param_5 = (_e93 + vec2<f32>((-2f * _e95), 0f));
let _e99 = Luma_u0028_vf2_u003b((¶m_5));
leftLeft = abs((_e92 - _e99));
let _e102 = top;
let _e103 = v_uv_1;
let _e105 = texel[1u];
param_6 = (_e103 + vec2<f32>(0f, (-2f * _e105)));
let _e109 = Luma_u0028_vf2_u003b((¶m_6));
topTop = abs((_e102 - _e109));
let _e113 = delta[0u];
let _e115 = delta[1u];
let _e117 = right;
let _e118 = bottom;
let _e121 = leftLeft;
let _e122 = topTop;
largest = max(max(max(_e113, _e115), max(_e117, _e118)), max(_e121, _e122));
let _e125 = largest;
let _e129 = smaa_info.params[3u];
let _e130 = delta;
let _e133 = edges;
edges = (_e133 * step(vec2(_e125), (_e130 * _e129)));
let _e135 = edges;
frag_color = vec4<f32>(_e135.x, _e135.y, 0f, 0f);
return;
}
@fragment
fn main(@location(6) 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: 'SmaaInfo',
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,
),
],
),
'SmaaWeights': WebGpuStage(
wgsl: r'''
struct SmaaInfo {
params: vec4<f32>,
}
@group(1) @binding(3)
var edges_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var edges_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
@group(1) @binding(1)
var area_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var area_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b(first: ptr<function, f32>, last: ptr<function, f32>, codeFirst: ptr<function, f32>, codeLast: ptr<function, f32>) -> vec2<f32> {
var at: vec2<f32>;
let _e28 = (*codeFirst);
let _e29 = (*codeLast);
let _e32 = (*first);
let _e33 = (*last);
at = ((((vec2<f32>(_e28, _e29) * 16f) + sqrt(vec2<f32>(_e32, _e33))) + vec2(0.5f)) / vec2(80f));
let _e41 = at;
let _e42 = textureSampleLevel(area_texture_tex, area_texture_smp, _e41, 0f);
return _e42.xy;
}
fn Edges_u0028_vf2_u003b(offset: ptr<function, vec2<f32>>) -> vec4<f32> {
let _e24 = v_uv_1;
let _e25 = (*offset);
let _e27 = smaa_info.params;
let _e31 = textureSampleLevel(edges_texture_tex, edges_texture_smp, (_e24 + (_e25 * _e27.xy)), 0f);
return _e31;
}
fn main_1() {
var here: vec4<f32>;
var param: vec2<f32>;
var weights: vec4<f32>;
var first_1: i32;
var i: i32;
var param_1: vec2<f32>;
var param_2: vec2<f32>;
var last_1: i32;
var i_1: i32;
var next: vec4<f32>;
var param_3: vec2<f32>;
var f: f32;
var l: f32;
var codeFirst_1: f32;
var local: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var codeLast_1: f32;
var local_1: f32;
var param_6: vec2<f32>;
var param_7: vec2<f32>;
var param_8: f32;
var param_9: f32;
var param_10: f32;
var param_11: f32;
var first_2: i32;
var i_2: i32;
var param_12: vec2<f32>;
var param_13: vec2<f32>;
var last_2: i32;
var i_3: i32;
var next_1: vec4<f32>;
var param_14: vec2<f32>;
var f_1: f32;
var l_1: f32;
var codeFirst_2: f32;
var local_2: f32;
var param_15: vec2<f32>;
var param_16: vec2<f32>;
var codeLast_2: f32;
var local_3: f32;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var param_20: f32;
var param_21: f32;
var param_22: f32;
var phi_126_: bool;
var phi_159_: bool;
var phi_265_: bool;
var phi_297_: bool;
param = vec2<f32>(0f, 0f);
let _e70 = Edges_u0028_vf2_u003b((¶m));
here = _e70;
weights = vec4<f32>(0f, 0f, 0f, 0f);
let _e72 = here[1u];
if (_e72 > 0.5f) {
first_1 = 32i;
i = 0i;
loop {
let _e74 = i;
if (_e74 < 32i) {
let _e76 = i;
param_1 = vec2<f32>(-(f32(_e76)), 0f);
let _e80 = Edges_u0028_vf2_u003b((¶m_1));
let _e82 = (_e80.x > 0.5f);
phi_126_ = _e82;
if !(_e82) {
let _e84 = i;
param_2 = vec2<f32>((-(f32(_e84)) - 1f), 0f);
let _e89 = Edges_u0028_vf2_u003b((¶m_2));
phi_126_ = (_e89.y < 0.5f);
}
let _e93 = phi_126_;
if _e93 {
let _e94 = i;
first_1 = _e94;
break;
}
continue;
} else {
break;
}
continuing {
let _e95 = i;
i = (_e95 + 1i);
}
}
last_1 = 32i;
i_1 = 0i;
loop {
let _e97 = i_1;
if (_e97 < 32i) {
let _e99 = i_1;
param_3 = vec2<f32>((f32(_e99) + 1f), 0f);
let _e103 = Edges_u0028_vf2_u003b((¶m_3));
next = _e103;
let _e105 = next[0u];
let _e106 = (_e105 > 0.5f);
phi_159_ = _e106;
if !(_e106) {
let _e109 = next[1u];
phi_159_ = (_e109 < 0.5f);
}
let _e112 = phi_159_;
if _e112 {
let _e113 = i_1;
last_1 = _e113;
break;
}
continue;
} else {
break;
}
continuing {
let _e114 = i_1;
i_1 = (_e114 + 1i);
}
}
let _e116 = first_1;
f = f32(_e116);
let _e118 = last_1;
l = f32(_e118);
let _e120 = first_1;
if (_e120 == 32i) {
local = 0f;
} else {
let _e122 = f;
param_4 = vec2<f32>(-(_e122), 0f);
let _e125 = Edges_u0028_vf2_u003b((¶m_4));
let _e128 = f;
param_5 = vec2<f32>(-(_e128), -1f);
let _e131 = Edges_u0028_vf2_u003b((¶m_5));
local = ((3f * _e125.x) + _e131.x);
}
let _e134 = local;
codeFirst_1 = _e134;
let _e135 = last_1;
if (_e135 == 32i) {
local_1 = 0f;
} else {
let _e137 = l;
param_6 = vec2<f32>((_e137 + 1f), 0f);
let _e140 = Edges_u0028_vf2_u003b((¶m_6));
let _e143 = l;
param_7 = vec2<f32>((_e143 + 1f), -1f);
let _e146 = Edges_u0028_vf2_u003b((¶m_7));
local_1 = ((3f * _e140.x) + _e146.x);
}
let _e149 = local_1;
codeLast_1 = _e149;
let _e150 = f;
param_8 = _e150;
let _e151 = l;
param_9 = _e151;
let _e152 = codeFirst_1;
param_10 = _e152;
let _e153 = codeLast_1;
param_11 = _e153;
let _e154 = Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
weights[0u] = _e154.x;
weights[1u] = _e154.y;
}
let _e160 = here[0u];
if (_e160 > 0.5f) {
first_2 = 32i;
i_2 = 0i;
loop {
let _e162 = i_2;
if (_e162 < 32i) {
let _e164 = i_2;
param_12 = vec2<f32>(0f, -(f32(_e164)));
let _e168 = Edges_u0028_vf2_u003b((¶m_12));
let _e170 = (_e168.y > 0.5f);
phi_265_ = _e170;
if !(_e170) {
let _e172 = i_2;
param_13 = vec2<f32>(0f, (-(f32(_e172)) - 1f));
let _e177 = Edges_u0028_vf2_u003b((¶m_13));
phi_265_ = (_e177.x < 0.5f);
}
let _e181 = phi_265_;
if _e181 {
let _e182 = i_2;
first_2 = _e182;
break;
}
continue;
} else {
break;
}
continuing {
let _e183 = i_2;
i_2 = (_e183 + 1i);
}
}
last_2 = 32i;
i_3 = 0i;
loop {
let _e185 = i_3;
if (_e185 < 32i) {
let _e187 = i_3;
param_14 = vec2<f32>(0f, (f32(_e187) + 1f));
let _e191 = Edges_u0028_vf2_u003b((¶m_14));
next_1 = _e191;
let _e193 = next_1[1u];
let _e194 = (_e193 > 0.5f);
phi_297_ = _e194;
if !(_e194) {
let _e197 = next_1[0u];
phi_297_ = (_e197 < 0.5f);
}
let _e200 = phi_297_;
if _e200 {
let _e201 = i_3;
last_2 = _e201;
break;
}
continue;
} else {
break;
}
continuing {
let _e202 = i_3;
i_3 = (_e202 + 1i);
}
}
let _e204 = first_2;
f_1 = f32(_e204);
let _e206 = last_2;
l_1 = f32(_e206);
let _e208 = first_2;
if (_e208 == 32i) {
local_2 = 0f;
} else {
let _e210 = f_1;
param_15 = vec2<f32>(0f, -(_e210));
let _e213 = Edges_u0028_vf2_u003b((¶m_15));
let _e216 = f_1;
param_16 = vec2<f32>(-1f, -(_e216));
let _e219 = Edges_u0028_vf2_u003b((¶m_16));
local_2 = ((3f * _e213.y) + _e219.y);
}
let _e222 = local_2;
codeFirst_2 = _e222;
let _e223 = last_2;
if (_e223 == 32i) {
local_3 = 0f;
} else {
let _e225 = l_1;
param_17 = vec2<f32>(0f, (_e225 + 1f));
let _e228 = Edges_u0028_vf2_u003b((¶m_17));
let _e231 = l_1;
param_18 = vec2<f32>(-1f, (_e231 + 1f));
let _e234 = Edges_u0028_vf2_u003b((¶m_18));
local_3 = ((3f * _e228.y) + _e234.y);
}
let _e237 = local_3;
codeLast_2 = _e237;
let _e238 = f_1;
param_19 = _e238;
let _e239 = l_1;
param_20 = _e239;
let _e240 = codeFirst_2;
param_21 = _e240;
let _e241 = codeLast_2;
param_22 = _e241;
let _e242 = Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
weights[2u] = _e242.x;
weights[3u] = _e242.y;
}
let _e247 = weights;
frag_color = _e247;
return;
}
@fragment
fn main(@location(6) 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: 'SmaaInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'area_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'edges_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'SmaaBlend': WebGpuStage(
wgsl: r'''
struct SmaaInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
@group(1) @binding(1)
var blend_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var blend_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var source_texture_smp: sampler;
fn main_1() {
var texel: vec2<f32>;
var right: f32;
var bottom: f32;
var mine: vec4<f32>;
var top: f32;
var left: f32;
var across: bool;
var toward: f32;
var away: f32;
var axis: vec2<f32>;
var local: vec2<f32>;
var first: vec4<f32>;
var second: vec4<f32>;
var total: f32;
let _e29 = smaa_info.params;
texel = _e29.xy;
let _e31 = v_uv_1;
let _e33 = texel[0u];
let _e36 = textureSampleLevel(blend_texture_tex, blend_texture_smp, (_e31 + vec2<f32>(_e33, 0f)), 0f);
right = _e36.w;
let _e38 = v_uv_1;
let _e40 = texel[1u];
let _e43 = textureSampleLevel(blend_texture_tex, blend_texture_smp, (_e38 + vec2<f32>(0f, _e40)), 0f);
bottom = _e43.y;
let _e45 = v_uv_1;
let _e46 = textureSampleLevel(blend_texture_tex, blend_texture_smp, _e45, 0f);
mine = _e46;
let _e48 = mine[0u];
top = _e48;
let _e50 = mine[2u];
left = _e50;
let _e51 = right;
let _e52 = bottom;
let _e54 = top;
let _e56 = left;
if ((((_e51 + _e52) + _e54) + _e56) < 0.00001f) {
let _e59 = v_uv_1;
let _e60 = textureSampleLevel(source_texture_tex, source_texture_smp, _e59, 0f);
frag_color = _e60;
return;
}
let _e61 = right;
let _e62 = left;
let _e64 = bottom;
let _e65 = top;
across = (max(_e61, _e62) > max(_e64, _e65));
let _e68 = across;
let _e69 = right;
let _e70 = bottom;
toward = select(_e70, _e69, _e68);
let _e72 = across;
let _e73 = left;
let _e74 = top;
away = select(_e74, _e73, _e72);
let _e76 = across;
if _e76 {
let _e78 = texel[0u];
local = vec2<f32>(_e78, 0f);
} else {
let _e81 = texel[1u];
local = vec2<f32>(0f, _e81);
}
let _e83 = local;
axis = _e83;
let _e84 = v_uv_1;
let _e85 = toward;
let _e86 = axis;
let _e89 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e84 + (_e86 * _e85)), 0f);
first = _e89;
let _e90 = v_uv_1;
let _e91 = away;
let _e92 = axis;
let _e95 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e90 - (_e92 * _e91)), 0f);
second = _e95;
let _e96 = toward;
let _e97 = away;
total = (_e96 + _e97);
let _e99 = first;
let _e100 = toward;
let _e101 = total;
let _e104 = second;
let _e105 = away;
let _e106 = total;
frag_color = ((_e99 * (_e100 / _e101)) + (_e104 * (_e105 / _e106)));
return;
}
@fragment
fn main(@location(6) 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: 'SmaaInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'blend_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LensFlare': WebGpuStage(
wgsl: r'''
struct LensFlareInfo {
params: vec4<f32>,
more: vec4<f32>,
}
@group(1) @binding(1)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var bloom_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> lens_flare_info: LensFlareInfo;
var<private> frag_color: vec4<f32>;
fn Falloff_u0028_vf2_u003b_f1_u003b(at: ptr<function, vec2<f32>>, power: ptr<function, f32>) -> f32 {
var d: f32;
let _e27 = (*at);
d = (length((vec2<f32>(0.5f, 0.5f) - _e27)) / 0.70710677f);
let _e31 = d;
let _e34 = (*power);
return pow(max((1f - _e31), 0f), _e34);
}
fn Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b(at_1: ptr<function, vec2<f32>>, along: ptr<function, vec2<f32>>, spread: ptr<function, f32>) -> vec3<f32> {
let _e27 = (*at_1);
let _e28 = (*along);
let _e29 = (*spread);
let _e32 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, (_e27 + (_e28 * _e29)), 0f);
let _e34 = (*at_1);
let _e35 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, _e34, 0f);
let _e37 = (*at_1);
let _e38 = (*along);
let _e39 = (*spread);
let _e42 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, (_e37 - (_e38 * _e39)), 0f);
return vec3<f32>(_e32.x, _e35.y, _e42.z);
}
fn main_1() {
var glow: vec3<f32>;
var intensity: f32;
var flipped: vec2<f32>;
var towardMiddle: vec2<f32>;
var reach: f32;
var along_1: vec2<f32>;
var local: vec2<f32>;
var spread_1: f32;
var flare: vec3<f32>;
var ghosts: i32;
var i: i32;
var at_2: vec2<f32>;
var param: vec2<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var param_3: vec2<f32>;
var param_4: f32;
var aspect: f32;
var halo: vec2<f32>;
var haloAt: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
var param_8: vec2<f32>;
var param_9: f32;
let _e49 = v_uv_1;
let _e50 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, _e49, 0f);
glow = _e50.xyz;
let _e54 = lens_flare_info.params[0u];
intensity = _e54;
let _e55 = v_uv_1;
flipped = (vec2<f32>(1f, 1f) - _e55);
let _e57 = flipped;
let _e61 = lens_flare_info.params[2u];
towardMiddle = ((vec2<f32>(0.5f, 0.5f) - _e57) * _e61);
let _e63 = towardMiddle;
reach = length(_e63);
let _e65 = reach;
if (_e65 > 0.000001f) {
let _e67 = towardMiddle;
let _e68 = reach;
local = (_e67 / vec2(_e68));
} else {
local = vec2<f32>(0f, 0f);
}
let _e71 = local;
along_1 = _e71;
let _e74 = lens_flare_info.more[0u];
spread_1 = _e74;
flare = vec3<f32>(0f, 0f, 0f);
let _e77 = lens_flare_info.params[1u];
ghosts = i32((_e77 + 0.5f));
i = 0i;
loop {
let _e80 = i;
if (_e80 < 8i) {
let _e82 = i;
let _e83 = ghosts;
if (_e82 >= _e83) {
break;
}
let _e85 = flipped;
let _e86 = towardMiddle;
let _e87 = i;
at_2 = (_e85 + (_e86 * f32(_e87)));
let _e91 = at_2;
param = _e91;
let _e92 = along_1;
param_1 = _e92;
let _e93 = spread_1;
param_2 = _e93;
let _e94 = Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b((¶m), (¶m_1), (¶m_2));
let _e95 = at_2;
param_3 = _e95;
param_4 = 10f;
let _e96 = Falloff_u0028_vf2_u003b_f1_u003b((¶m_3), (¶m_4));
let _e98 = flare;
flare = (_e98 + (_e94 * _e96));
continue;
} else {
break;
}
continuing {
let _e100 = i;
i = (_e100 + 1i);
}
}
let _e104 = lens_flare_info.more[2u];
aspect = max(_e104, 0.0001f);
let _e106 = along_1;
let _e107 = aspect;
let _e113 = lens_flare_info.params[3u];
halo = ((_e106 * vec2<f32>((1f / _e107), 1f)) * _e113);
let _e115 = flipped;
let _e116 = halo;
haloAt = (_e115 + _e116);
let _e118 = haloAt;
param_5 = _e118;
let _e119 = along_1;
param_6 = _e119;
let _e120 = spread_1;
param_7 = _e120;
let _e121 = Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
let _e122 = haloAt;
param_8 = _e122;
param_9 = 5f;
let _e123 = Falloff_u0028_vf2_u003b_f1_u003b((¶m_8), (¶m_9));
let _e127 = lens_flare_info.more[1u];
let _e129 = flare;
flare = (_e129 + ((_e121 * _e123) * _e127));
let _e131 = glow;
let _e132 = flare;
let _e133 = intensity;
let _e135 = (_e131 + (_e132 * _e133));
frag_color = vec4<f32>(_e135.x, _e135.y, _e135.z, 1f);
return;
}
@fragment
fn main(@location(6) 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: 'LensFlareInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'more', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'bloom_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(6) 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> g_pass_through: f32;
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;
g_pass_through = 0f;
let _e20 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e20, 0f, 0f, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) 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>,
forward: vec4<f32>,
projection: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e19 = fog_info.projection[0u];
if (_e19 > 0.5f) {
let _e21 = (*world);
let _e23 = fog_info.eye;
let _e27 = fog_info.forward;
local = max(dot((_e21 - _e23.xyz), _e27.xyz), 0f);
} else {
let _e31 = (*world);
let _e33 = fog_info.eye;
local = distance(_e31, _e33.xyz);
}
let _e36 = local;
return _e36;
}
fn main_1() {
var centred: vec2<f32>;
var radius: f32;
var falloff: f32;
var intensity: f32;
var fogged: f32;
var param: vec3<f32>;
let _e21 = v_uv_1;
centred = ((_e21 * 2f) - vec2(1f));
let _e25 = centred;
radius = length(_e25);
let _e27 = radius;
falloff = (1f - smoothstep(0f, 1f, _e27));
let _e30 = falloff;
let _e31 = falloff;
intensity = (_e30 * _e31);
fogged = 1f;
let _e35 = fog_info.fog[3u];
if (_e35 > 0f) {
let _e39 = fog_info.fog[3u];
let _e41 = v_world_position_1;
param = _e41;
let _e42 = FogDistance_u0028_vf3_u003b((¶m));
fogged = clamp(exp((-(_e39) * _e42)), 0f, 1f);
}
let _e46 = v_color_1;
let _e49 = v_color_1[3u];
let _e51 = intensity;
let _e53 = fogged;
let _e54 = (((_e46.xyz * _e49) * _e51) * _e53);
frag_color = vec4<f32>(_e54.x, _e54.y, _e54.z, 1f);
return;
}
@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleTextured': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
@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>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e20 = fog_info.projection[0u];
if (_e20 > 0.5f) {
let _e22 = (*world);
let _e24 = fog_info.eye;
let _e28 = fog_info.forward;
local = max(dot((_e22 - _e24.xyz), _e28.xyz), 0f);
} else {
let _e32 = (*world);
let _e34 = fog_info.eye;
local = distance(_e32, _e34.xyz);
}
let _e37 = local;
return _e37;
}
fn main_1() {
var texel: vec4<f32>;
var fogged: f32;
var param: vec3<f32>;
var scale: f32;
let _e20 = v_uv_1;
let _e21 = textureSample(particle_texture_tex, particle_texture_smp, _e20);
texel = _e21;
fogged = 1f;
let _e24 = fog_info.fog[3u];
if (_e24 > 0f) {
let _e28 = fog_info.fog[3u];
let _e30 = v_world_position_1;
param = _e30;
let _e31 = FogDistance_u0028_vf3_u003b((¶m));
fogged = clamp(exp((-(_e28) * _e31)), 0f, 1f);
}
let _e36 = v_color_1[3u];
let _e38 = texel[3u];
let _e40 = fogged;
scale = ((_e36 * _e38) * _e40);
let _e42 = v_color_1;
let _e44 = texel;
let _e47 = scale;
let _e48 = ((_e42.xyz * _e44.xyz) * _e47);
frag_color = vec4<f32>(_e48.x, _e48.y, _e48.z, 1f);
return;
}
@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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 FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: vec4<f32>,
}
struct SixWayInfo {
right: vec4<f32>,
up: vec4<f32>,
forward: vec4<f32>,
emission: vec4<f32>,
ambient: 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(1)
var<uniform> fog_info: FogInfo;
@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>;
var<private> frag_color: vec4<f32>;
fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e49 = fog_info.projection[0u];
if (_e49 > 0.5f) {
let _e51 = (*world);
let _e53 = fog_info.eye;
let _e57 = fog_info.forward;
local = max(dot((_e51 - _e53.xyz), _e57.xyz), 0f);
} else {
let _e61 = (*world);
let _e63 = fog_info.eye;
local = distance(_e61, _e63.xyz);
}
let _e66 = local;
return _e66;
}
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 _e54 = (*l);
let _e56 = six_way_info.right;
x = dot(_e54, _e56.xyz);
let _e59 = (*l);
let _e61 = six_way_info.up;
y = dot(_e59, _e61.xyz);
let _e64 = (*l);
let _e66 = six_way_info.forward;
z = dot(_e64, _e66.xyz);
let _e69 = x;
let _e70 = x;
let _e72 = x;
if (_e72 > 0f) {
let _e75 = (*positive)[0u];
local_1 = _e75;
} else {
let _e77 = (*negative)[0u];
local_1 = _e77;
}
let _e78 = local_1;
let _e80 = y;
let _e81 = y;
let _e83 = y;
if (_e83 > 0f) {
let _e86 = (*positive)[1u];
local_2 = _e86;
} else {
let _e88 = (*negative)[1u];
local_2 = _e88;
}
let _e89 = local_2;
let _e92 = z;
let _e93 = z;
let _e95 = z;
if (_e95 > 0f) {
let _e98 = (*positive)[2u];
local_3 = _e98;
} else {
let _e100 = (*negative)[2u];
local_3 = _e100;
}
let _e101 = local_3;
return ((((_e69 * _e70) * _e78) + ((_e80 * _e81) * _e89)) + ((_e92 * _e93) * _e101));
}
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 _e51 = (*slot);
let _e52 = (*slot);
lane = (_e51 - ((_e52 / 4i) * 4i));
let _e56 = lane;
if (_e56 == 0i) {
let _e59 = (*four)[0u];
local_4 = _e59;
} else {
let _e60 = lane;
if (_e60 == 1i) {
let _e63 = (*four)[1u];
local_5 = _e63;
} else {
let _e64 = lane;
if (_e64 == 2i) {
let _e67 = (*four)[2u];
local_6 = _e67;
} else {
let _e69 = (*four)[3u];
local_6 = _e69;
}
let _e70 = local_6;
local_5 = _e70;
}
let _e71 = local_5;
local_4 = _e71;
}
let _e72 = local_4;
return _e72;
}
fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
var param: vec4<f32>;
var param_1: i32;
let _e48 = (*slot_1);
let _e52 = light_list_info.scales[(_e48 / 4i)];
param = _e52;
let _e53 = (*slot_1);
param_1 = _e53;
let _e54 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m), (¶m_1));
return _e54;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a: vec4<f32>;
var b: vec4<f32>;
let _e50 = light_list_info.slot_rows[0i];
let _e51 = (*row);
a = abs((_e50 - vec4(_e51)));
let _e57 = light_list_info.slot_rows[1i];
let _e58 = (*row);
b = abs((_e57 - vec4(_e58)));
let _e63 = a[0u];
let _e65 = a[1u];
let _e68 = a[2u];
let _e70 = a[3u];
let _e74 = b[0u];
let _e76 = b[1u];
let _e79 = b[2u];
let _e81 = b[3u];
return (min(min(min(_e63, _e65), min(_e68, _e70)), min(min(_e74, _e76), min(_e79, _e81))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_2: vec4<f32>;
var param_3: i32;
let _e48 = (*slot_2);
let _e52 = light_list_info.indices[(_e48 / 4i)];
param_2 = _e52;
let _e53 = (*slot_2);
param_3 = _e53;
let _e54 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_2), (¶m_3));
return _e54;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e47 = (*texel);
let _e51 = light_list_info.list[1u];
let _e53 = (*row_1);
let _e57 = light_list_info.list[2u];
let _e60 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e47 + 0.5f) * _e51), ((_e53 + 0.5f) * _e57)), 0f);
return _e60;
}
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 _e55 = g_cluster_offset;
let _e56 = (*slot_3);
entry = (_e55 + f32(_e56));
let _e59 = entry;
row_2 = floor((_e59 / 16f));
let _e62 = entry;
let _e63 = row_2;
within = (_e62 - (_e63 * 16f));
let _e66 = within;
texel_1 = floor((_e66 / 4f));
let _e71 = light_list_info.cluster_depth[3u];
let _e72 = row_2;
let _e74 = texel_1;
param_4 = _e74;
param_5 = (_e71 + _e72);
let _e75 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_4), (¶m_5));
four_1 = _e75;
let _e76 = within;
let _e77 = texel_1;
let _e82 = four_1;
param_6 = _e82;
param_7 = i32(((_e76 - (_e77 * 4f)) + 0.5f));
let _e83 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_6), (¶m_7));
return _e83;
}
fn Clustered_u0028_() -> bool {
let _e47 = light_list_info.cluster_grid[3u];
return (_e47 > 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_8: i32;
var param_9: i32;
var v: f32;
var u: f32;
var local_8: 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_9: vec3<f32>;
var ratio: f32;
var local_10: f32;
var window: f32;
var falloff: f32;
var spot: bool;
var linearRamp: f32;
var local_11: f32;
var ramp: f32;
var attenuation: f32;
var local_12: f32;
var local_13: f32;
var local_14: f32;
let _e83 = (*index);
if (_e83 < 8i) {
let _e85 = (*index);
let _e88 = contributor_light_info.light_position[_e85];
position = _e88;
let _e89 = (*index);
let _e92 = contributor_light_info.light_color[_e89];
color = _e92;
let _e93 = (*index);
let _e96 = contributor_light_info.light_direction[_e93];
direction = _e96;
let _e97 = (*index);
let _e100 = contributor_light_info.light_cone[_e97];
cone = _e100;
} else {
let _e101 = (*index);
slot_4 = (_e101 - 8i);
let _e103 = Clustered_u0028_();
clustered = _e103;
let _e104 = clustered;
if _e104 {
let _e105 = slot_4;
param_8 = _e105;
let _e106 = ClusterRow_u0028_i1_u003b((¶m_8));
local_7 = _e106;
} else {
let _e107 = slot_4;
param_9 = _e107;
let _e108 = LightListRow_u0028_i1_u003b((¶m_9));
local_7 = _e108;
}
let _e109 = local_7;
listRow = _e109;
let _e110 = listRow;
let _e114 = light_list_info.list[2u];
v = ((_e110 + 0.5f) * _e114);
let _e118 = light_list_info.list[1u];
u = _e118;
let _e119 = u;
let _e121 = v;
let _e123 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e119), _e121), 0f);
position = _e123;
let _e124 = u;
let _e126 = v;
let _e128 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e124), _e126), 0f);
color = _e128;
let _e129 = u;
let _e131 = v;
let _e133 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e129), _e131), 0f);
direction = _e133;
let _e134 = u;
let _e136 = v;
let _e138 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e134), _e136), 0f);
cone = _e138;
let _e139 = clustered;
if _e139 {
let _e140 = listRow;
param_10 = _e140;
let _e141 = InSlots_u0028_f1_u003b((¶m_10));
local_8 = select(1f, 0f, _e141);
} else {
let _e143 = slot_4;
param_11 = _e143;
let _e144 = LightListScale_u0028_i1_u003b((¶m_11));
local_8 = _e144;
}
let _e145 = local_8;
let _e147 = color[3u];
color[3u] = (_e147 * _e145);
}
let _e151 = position[3u];
type_30 = _e151;
let _e152 = type_30;
directional = (_e152 < 0.5f);
let _e154 = position;
let _e156 = (*world_1);
offset = (_e154.xyz - _e156);
let _e158 = offset;
distance_ = length(_e158);
let _e160 = direction;
aim = normalize(_e160.xyz);
let _e163 = directional;
let _e165 = distance_;
degenerate = (!(_e163) && (_e165 < 0.000001f));
let _e168 = directional;
if _e168 {
let _e169 = aim;
local_9 = -(_e169);
} else {
let _e171 = offset;
let _e172 = distance_;
local_9 = (_e171 / vec3(max(_e172, 0.000001f)));
}
let _e176 = local_9;
(*toLight) = _e176;
let _e178 = direction[3u];
if (_e178 > 0f) {
let _e180 = distance_;
let _e182 = direction[3u];
local_10 = (_e180 / _e182);
} else {
local_10 = 0f;
}
let _e184 = local_10;
ratio = _e184;
let _e185 = ratio;
let _e186 = ratio;
let _e188 = ratio;
let _e190 = ratio;
window = clamp((1f - (((_e185 * _e186) * _e188) * _e190)), 0f, 1f);
let _e194 = window;
let _e195 = window;
let _e197 = distance_;
let _e198 = distance_;
falloff = ((_e194 * _e195) / max((_e197 * _e198), 0.0001f));
let _e202 = type_30;
let _e204 = type_30;
spot = ((_e202 > 1.5f) && (_e204 < 2.5f));
let _e207 = spot;
if _e207 {
let _e208 = aim;
let _e209 = (*toLight);
let _e213 = cone[1u];
let _e216 = cone[0u];
let _e218 = cone[1u];
local_11 = clamp(((dot(_e208, -(_e209)) - _e213) / max((_e216 - _e218), 0.0001f)), 0f, 1f);
} else {
local_11 = 1f;
}
let _e223 = local_11;
linearRamp = _e223;
let _e224 = linearRamp;
let _e225 = linearRamp;
ramp = (_e224 * _e225);
let _e227 = type_30;
if (_e227 > 15.5f) {
local_12 = 0f;
} else {
let _e229 = directional;
if _e229 {
local_13 = 1f;
} else {
let _e230 = degenerate;
if _e230 {
local_14 = 0f;
} else {
let _e231 = falloff;
let _e232 = ramp;
local_14 = (_e231 * _e232);
}
let _e234 = local_14;
local_13 = _e234;
}
let _e235 = local_13;
local_12 = _e235;
}
let _e236 = local_12;
attenuation = _e236;
let _e237 = color;
let _e240 = color[3u];
let _e242 = attenuation;
(*radiance) = ((_e237.xyz * _e240) * _e242);
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_15: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_12: f32;
var param_13: f32;
let _e60 = light_list_info.cluster_view_projection;
let _e61 = (*world_2);
clip = (_e60 * vec4<f32>(_e61.x, _e61.y, _e61.z, 1f));
let _e67 = clip;
let _e70 = clip[3u];
ndc = (_e67.xy / vec2(max(_e70, 0.000001f)));
let _e75 = light_list_info.cluster_grid;
grid = _e75.xyz;
let _e79 = light_list_info.cluster_depth[0u];
near = _e79;
let _e81 = ndc[0u];
let _e85 = grid[0u];
let _e89 = grid[0u];
tx = clamp(floor((((_e81 * 0.5f) + 0.5f) * _e85)), 0f, (_e89 - 1f));
let _e93 = ndc[1u];
let _e97 = grid[1u];
let _e101 = grid[1u];
ty = clamp(floor((((_e93 * 0.5f) + 0.5f) * _e97)), 0f, (_e101 - 1f));
let _e105 = clip[3u];
let _e106 = near;
if (_e105 <= _e106) {
local_15 = 0f;
} else {
let _e109 = clip[3u];
let _e110 = near;
let _e115 = light_list_info.cluster_depth[1u];
let _e119 = grid[2u];
local_15 = clamp(floor((log((_e109 / _e110)) * _e115)), 0f, (_e119 - 1f));
}
let _e122 = local_15;
tz = _e122;
let _e123 = tx;
let _e124 = ty;
let _e126 = grid[0u];
let _e129 = tz;
let _e131 = grid[0u];
let _e134 = grid[1u];
cell = ((_e123 + (_e124 * _e126)) + ((_e129 * _e131) * _e134));
let _e137 = cell;
row_3 = floor((_e137 / 4f));
let _e140 = cell;
let _e141 = row_3;
let _e146 = light_list_info.cluster_depth[2u];
let _e147 = row_3;
param_12 = (_e140 - (_e141 * 4f));
param_13 = (_e146 + _e147);
let _e149 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_12), (¶m_13));
header = _e149;
let _e151 = header[0u];
g_cluster_offset = _e151;
let _e153 = header[1u];
g_cluster_count = _e153;
return;
}
fn ContributorLightCount_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) -> i32 {
var tail: f32;
var param_14: vec3<f32>;
let _e50 = light_list_info.list[0u];
tail = _e50;
let _e51 = Clustered_u0028_();
if _e51 {
let _e52 = (*world_3);
param_14 = _e52;
FindCluster_u0028_vf3_u003b((¶m_14));
let _e53 = g_cluster_count;
tail = _e53;
}
let _e56 = contributor_light_info.slots[0u];
let _e60 = tail;
return (clamp(i32((_e56 + 0.5f)), 0i, 8i) + clamp(i32((_e60 + 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 param_23: vec3<f32>;
var coverage: f32;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e65 = v_uv_1;
let _e66 = textureSample(six_way_positive_tex, six_way_positive_smp, _e65);
positive_1 = _e66;
let _e67 = v_uv_1;
let _e68 = textureSample(six_way_negative_tex, six_way_negative_smp, _e67);
negative_1 = _e68;
lit = vec3<f32>(0f, 0f, 0f);
let _e69 = v_world_position_1;
param_15 = _e69;
let _e70 = ContributorLightCount_u0028_vf3_u003b((¶m_15));
count = _e70;
i = 0i;
loop {
let _e71 = i;
if (_e71 < 32i) {
let _e73 = i;
let _e74 = count;
if (_e73 >= _e74) {
break;
}
let _e76 = i;
param_16 = _e76;
let _e77 = v_world_position_1;
param_17 = _e77;
ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
let _e78 = param_18;
l_1 = _e78;
let _e79 = param_19;
radiance_1 = _e79;
let _e80 = radiance_1;
let _e81 = l_1;
param_20 = _e81;
let _e82 = positive_1;
param_21 = _e82.xyz;
let _e84 = negative_1;
param_22 = _e84.xyz;
let _e86 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_20), (¶m_21), (¶m_22));
let _e88 = lit;
lit = (_e88 + (_e80 * _e86));
continue;
} else {
break;
}
continuing {
let _e90 = i;
i = (_e90 + 1i);
}
}
let _e93 = positive_1[0u];
let _e95 = positive_1[1u];
let _e98 = positive_1[2u];
let _e101 = negative_1[0u];
let _e104 = negative_1[1u];
let _e107 = negative_1[2u];
mean = ((((((_e93 + _e95) + _e98) + _e101) + _e104) + _e107) / 6f);
let _e110 = v_color_1;
let _e112 = lit;
let _e114 = six_way_info.ambient;
let _e116 = mean;
let _e121 = six_way_info.emission;
let _e124 = negative_1[3u];
color_1 = ((_e110.xyz * (_e112 + (_e114.xyz * _e116))) + (_e121.xyz * _e124));
fogged = 1f;
let _e129 = fog_info.fog[3u];
if (_e129 > 0f) {
let _e133 = fog_info.fog[3u];
let _e135 = v_world_position_1;
param_23 = _e135;
let _e136 = FogDistance_u0028_vf3_u003b((¶m_23));
fogged = clamp(exp((-(_e133) * _e136)), 0f, 1f);
}
let _e141 = fog_info.fog;
let _e143 = color_1;
let _e144 = fogged;
color_1 = mix(_e141.xyz, _e143, vec3(_e144));
let _e148 = v_color_1[3u];
let _e150 = positive_1[3u];
coverage = clamp((_e148 * _e150), 0f, 1f);
let _e153 = color_1;
let _e154 = coverage;
let _e155 = (_e153 * _e154);
let _e156 = coverage;
frag_color = vec4<f32>(_e155.x, _e155.y, _e155.z, _e156);
return;
}
@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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>,
forward: vec4<f32>,
projection: 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;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
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 _e23 = (*rows);
if (_e23 > 0f) {
let _e26 = gl_FragCoord_1[0u];
let _e27 = (*rows);
let _e29 = gl_FragCoord_1[1u];
local = vec2<f32>(_e26, (_e27 - _e29));
} else {
let _e32 = gl_FragCoord_1;
local = _e32.xy;
}
let _e34 = local;
return _e34;
}
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 _e29 = soft_particle_info.target_[2u];
param = _e29;
let _e30 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e32 = soft_particle_info.target_;
uv = (_e30 * _e32.xy);
let _e35 = uv;
let _e36 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e35, 0f);
stored = _e36.w;
let _e38 = (*world);
let _e40 = soft_particle_info.eye;
let _e44 = soft_particle_info.forward;
depth = dot((_e38 - _e40.xyz), _e44.xyz);
let _e47 = stored;
let _e48 = depth;
let _e52 = soft_particle_info.target_[3u];
fade = clamp(((_e47 - _e48) * _e52), 0f, 1f);
let _e55 = stored;
let _e57 = fade;
return select(1f, _e57, (_e55 > 0f));
}
fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
var local_1: f32;
let _e25 = fog_info.projection[0u];
if (_e25 > 0.5f) {
let _e27 = (*world_1);
let _e29 = fog_info.eye;
let _e33 = fog_info.forward;
local_1 = max(dot((_e27 - _e29.xyz), _e33.xyz), 0f);
} else {
let _e37 = (*world_1);
let _e39 = fog_info.eye;
local_1 = distance(_e37, _e39.xyz);
}
let _e42 = local_1;
return _e42;
}
fn main_1() {
var centred: vec2<f32>;
var radius: f32;
var falloff: f32;
var intensity: f32;
var fogged: f32;
var param_1: vec3<f32>;
var param_2: vec3<f32>;
let _e28 = v_uv_1;
centred = ((_e28 * 2f) - vec2(1f));
let _e32 = centred;
radius = length(_e32);
let _e34 = radius;
falloff = (1f - smoothstep(0f, 1f, _e34));
let _e37 = falloff;
let _e38 = falloff;
intensity = (_e37 * _e38);
fogged = 1f;
let _e42 = fog_info.fog[3u];
if (_e42 > 0f) {
let _e46 = fog_info.fog[3u];
let _e48 = v_world_position_1;
param_1 = _e48;
let _e49 = FogDistance_u0028_vf3_u003b((¶m_1));
fogged = clamp(exp((-(_e46) * _e49)), 0f, 1f);
}
let _e53 = v_world_position_1;
param_2 = _e53;
let _e54 = SoftParticleFade_u0028_vf3_u003b((¶m_2));
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(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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>,
forward: vec4<f32>,
projection: 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(0)
var<uniform> fog_info: FogInfo;
@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>;
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 _e24 = (*rows);
if (_e24 > 0f) {
let _e27 = gl_FragCoord_1[0u];
let _e28 = (*rows);
let _e30 = gl_FragCoord_1[1u];
local = vec2<f32>(_e27, (_e28 - _e30));
} else {
let _e33 = gl_FragCoord_1;
local = _e33.xy;
}
let _e35 = local;
return _e35;
}
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 _e30 = soft_particle_info.target_[2u];
param = _e30;
let _e31 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e33 = soft_particle_info.target_;
uv = (_e31 * _e33.xy);
let _e36 = uv;
let _e37 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e36, 0f);
stored = _e37.w;
let _e39 = (*world);
let _e41 = soft_particle_info.eye;
let _e45 = soft_particle_info.forward;
depth = dot((_e39 - _e41.xyz), _e45.xyz);
let _e48 = stored;
let _e49 = depth;
let _e53 = soft_particle_info.target_[3u];
fade = clamp(((_e48 - _e49) * _e53), 0f, 1f);
let _e56 = stored;
let _e58 = fade;
return select(1f, _e58, (_e56 > 0f));
}
fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
var local_1: f32;
let _e26 = fog_info.projection[0u];
if (_e26 > 0.5f) {
let _e28 = (*world_1);
let _e30 = fog_info.eye;
let _e34 = fog_info.forward;
local_1 = max(dot((_e28 - _e30.xyz), _e34.xyz), 0f);
} else {
let _e38 = (*world_1);
let _e40 = fog_info.eye;
local_1 = distance(_e38, _e40.xyz);
}
let _e43 = local_1;
return _e43;
}
fn main_1() {
var texel: vec4<f32>;
var fogged: f32;
var param_1: vec3<f32>;
var scale: f32;
var param_2: vec3<f32>;
let _e27 = v_uv_1;
let _e28 = textureSample(particle_texture_tex, particle_texture_smp, _e27);
texel = _e28;
fogged = 1f;
let _e31 = fog_info.fog[3u];
if (_e31 > 0f) {
let _e35 = fog_info.fog[3u];
let _e37 = v_world_position_1;
param_1 = _e37;
let _e38 = FogDistance_u0028_vf3_u003b((¶m_1));
fogged = clamp(exp((-(_e35) * _e38)), 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_2 = _e49;
let _e50 = SoftParticleFade_u0028_vf3_u003b((¶m_2));
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(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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 FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: vec4<f32>,
}
struct SixWayInfo {
right: vec4<f32>,
up: vec4<f32>,
forward: vec4<f32>,
emission: vec4<f32>,
ambient: 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(1)
var<uniform> fog_info: FogInfo;
@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>;
var<private> frag_color: vec4<f32>;
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local: vec2<f32>;
let _e51 = (*rows);
if (_e51 > 0f) {
let _e54 = gl_FragCoord_1[0u];
let _e55 = (*rows);
let _e57 = gl_FragCoord_1[1u];
local = vec2<f32>(_e54, (_e55 - _e57));
} else {
let _e60 = gl_FragCoord_1;
local = _e60.xy;
}
let _e62 = local;
return _e62;
}
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 _e57 = soft_particle_info.target_[2u];
param = _e57;
let _e58 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e60 = soft_particle_info.target_;
uv = (_e58 * _e60.xy);
let _e63 = uv;
let _e64 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e63, 0f);
stored = _e64.w;
let _e66 = (*world);
let _e68 = soft_particle_info.eye;
let _e72 = soft_particle_info.forward;
depth = dot((_e66 - _e68.xyz), _e72.xyz);
let _e75 = stored;
let _e76 = depth;
let _e80 = soft_particle_info.target_[3u];
fade = clamp(((_e75 - _e76) * _e80), 0f, 1f);
let _e83 = stored;
let _e85 = fade;
return select(1f, _e85, (_e83 > 0f));
}
fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
var local_1: f32;
let _e53 = fog_info.projection[0u];
if (_e53 > 0.5f) {
let _e55 = (*world_1);
let _e57 = fog_info.eye;
let _e61 = fog_info.forward;
local_1 = max(dot((_e55 - _e57.xyz), _e61.xyz), 0f);
} else {
let _e65 = (*world_1);
let _e67 = fog_info.eye;
local_1 = distance(_e65, _e67.xyz);
}
let _e70 = local_1;
return _e70;
}
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_2: f32;
var local_3: f32;
var local_4: f32;
let _e58 = (*l);
let _e60 = six_way_info.right;
x = dot(_e58, _e60.xyz);
let _e63 = (*l);
let _e65 = six_way_info.up;
y = dot(_e63, _e65.xyz);
let _e68 = (*l);
let _e70 = six_way_info.forward;
z = dot(_e68, _e70.xyz);
let _e73 = x;
let _e74 = x;
let _e76 = x;
if (_e76 > 0f) {
let _e79 = (*positive)[0u];
local_2 = _e79;
} else {
let _e81 = (*negative)[0u];
local_2 = _e81;
}
let _e82 = local_2;
let _e84 = y;
let _e85 = y;
let _e87 = y;
if (_e87 > 0f) {
let _e90 = (*positive)[1u];
local_3 = _e90;
} else {
let _e92 = (*negative)[1u];
local_3 = _e92;
}
let _e93 = local_3;
let _e96 = z;
let _e97 = z;
let _e99 = z;
if (_e99 > 0f) {
let _e102 = (*positive)[2u];
local_4 = _e102;
} else {
let _e104 = (*negative)[2u];
local_4 = _e104;
}
let _e105 = local_4;
return ((((_e73 * _e74) * _e82) + ((_e84 * _e85) * _e93)) + ((_e96 * _e97) * _e105));
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e55 = (*slot);
let _e56 = (*slot);
lane = (_e55 - ((_e56 / 4i) * 4i));
let _e60 = lane;
if (_e60 == 0i) {
let _e63 = (*four)[0u];
local_5 = _e63;
} else {
let _e64 = lane;
if (_e64 == 1i) {
let _e67 = (*four)[1u];
local_6 = _e67;
} else {
let _e68 = lane;
if (_e68 == 2i) {
let _e71 = (*four)[2u];
local_7 = _e71;
} else {
let _e73 = (*four)[3u];
local_7 = _e73;
}
let _e74 = local_7;
local_6 = _e74;
}
let _e75 = local_6;
local_5 = _e75;
}
let _e76 = local_5;
return _e76;
}
fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
var param_1: vec4<f32>;
var param_2: i32;
let _e52 = (*slot_1);
let _e56 = light_list_info.scales[(_e52 / 4i)];
param_1 = _e56;
let _e57 = (*slot_1);
param_2 = _e57;
let _e58 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_1), (¶m_2));
return _e58;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a: vec4<f32>;
var b: vec4<f32>;
let _e54 = light_list_info.slot_rows[0i];
let _e55 = (*row);
a = abs((_e54 - vec4(_e55)));
let _e61 = light_list_info.slot_rows[1i];
let _e62 = (*row);
b = abs((_e61 - vec4(_e62)));
let _e67 = a[0u];
let _e69 = a[1u];
let _e72 = a[2u];
let _e74 = a[3u];
let _e78 = b[0u];
let _e80 = b[1u];
let _e83 = b[2u];
let _e85 = b[3u];
return (min(min(min(_e67, _e69), min(_e72, _e74)), min(min(_e78, _e80), min(_e83, _e85))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_3: vec4<f32>;
var param_4: i32;
let _e52 = (*slot_2);
let _e56 = light_list_info.indices[(_e52 / 4i)];
param_3 = _e56;
let _e57 = (*slot_2);
param_4 = _e57;
let _e58 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_3), (¶m_4));
return _e58;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e51 = (*texel);
let _e55 = light_list_info.list[1u];
let _e57 = (*row_1);
let _e61 = light_list_info.list[2u];
let _e64 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e51 + 0.5f) * _e55), ((_e57 + 0.5f) * _e61)), 0f);
return _e64;
}
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 _e59 = g_cluster_offset;
let _e60 = (*slot_3);
entry = (_e59 + f32(_e60));
let _e63 = entry;
row_2 = floor((_e63 / 16f));
let _e66 = entry;
let _e67 = row_2;
within = (_e66 - (_e67 * 16f));
let _e70 = within;
texel_1 = floor((_e70 / 4f));
let _e75 = light_list_info.cluster_depth[3u];
let _e76 = row_2;
let _e78 = texel_1;
param_5 = _e78;
param_6 = (_e75 + _e76);
let _e79 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_5), (¶m_6));
four_1 = _e79;
let _e80 = within;
let _e81 = texel_1;
let _e86 = four_1;
param_7 = _e86;
param_8 = i32(((_e80 - (_e81 * 4f)) + 0.5f));
let _e87 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_7), (¶m_8));
return _e87;
}
fn Clustered_u0028_() -> bool {
let _e51 = light_list_info.cluster_grid[3u];
return (_e51 > 0.5f);
}
fn ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b(index: ptr<function, i32>, world_2: 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_8: f32;
var param_9: i32;
var param_10: i32;
var v: f32;
var u: f32;
var local_9: 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_10: vec3<f32>;
var ratio: f32;
var local_11: f32;
var window: f32;
var falloff: f32;
var spot: bool;
var linearRamp: f32;
var local_12: f32;
var ramp: f32;
var attenuation: f32;
var local_13: f32;
var local_14: f32;
var local_15: f32;
let _e87 = (*index);
if (_e87 < 8i) {
let _e89 = (*index);
let _e92 = contributor_light_info.light_position[_e89];
position = _e92;
let _e93 = (*index);
let _e96 = contributor_light_info.light_color[_e93];
color = _e96;
let _e97 = (*index);
let _e100 = contributor_light_info.light_direction[_e97];
direction = _e100;
let _e101 = (*index);
let _e104 = contributor_light_info.light_cone[_e101];
cone = _e104;
} else {
let _e105 = (*index);
slot_4 = (_e105 - 8i);
let _e107 = Clustered_u0028_();
clustered = _e107;
let _e108 = clustered;
if _e108 {
let _e109 = slot_4;
param_9 = _e109;
let _e110 = ClusterRow_u0028_i1_u003b((¶m_9));
local_8 = _e110;
} else {
let _e111 = slot_4;
param_10 = _e111;
let _e112 = LightListRow_u0028_i1_u003b((¶m_10));
local_8 = _e112;
}
let _e113 = local_8;
listRow = _e113;
let _e114 = listRow;
let _e118 = light_list_info.list[2u];
v = ((_e114 + 0.5f) * _e118);
let _e122 = light_list_info.list[1u];
u = _e122;
let _e123 = u;
let _e125 = v;
let _e127 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e123), _e125), 0f);
position = _e127;
let _e128 = u;
let _e130 = v;
let _e132 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e128), _e130), 0f);
color = _e132;
let _e133 = u;
let _e135 = v;
let _e137 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e133), _e135), 0f);
direction = _e137;
let _e138 = u;
let _e140 = v;
let _e142 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e138), _e140), 0f);
cone = _e142;
let _e143 = clustered;
if _e143 {
let _e144 = listRow;
param_11 = _e144;
let _e145 = InSlots_u0028_f1_u003b((¶m_11));
local_9 = select(1f, 0f, _e145);
} else {
let _e147 = slot_4;
param_12 = _e147;
let _e148 = LightListScale_u0028_i1_u003b((¶m_12));
local_9 = _e148;
}
let _e149 = local_9;
let _e151 = color[3u];
color[3u] = (_e151 * _e149);
}
let _e155 = position[3u];
type_31 = _e155;
let _e156 = type_31;
directional = (_e156 < 0.5f);
let _e158 = position;
let _e160 = (*world_2);
offset = (_e158.xyz - _e160);
let _e162 = offset;
distance_ = length(_e162);
let _e164 = direction;
aim = normalize(_e164.xyz);
let _e167 = directional;
let _e169 = distance_;
degenerate = (!(_e167) && (_e169 < 0.000001f));
let _e172 = directional;
if _e172 {
let _e173 = aim;
local_10 = -(_e173);
} else {
let _e175 = offset;
let _e176 = distance_;
local_10 = (_e175 / vec3(max(_e176, 0.000001f)));
}
let _e180 = local_10;
(*toLight) = _e180;
let _e182 = direction[3u];
if (_e182 > 0f) {
let _e184 = distance_;
let _e186 = direction[3u];
local_11 = (_e184 / _e186);
} else {
local_11 = 0f;
}
let _e188 = local_11;
ratio = _e188;
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 = distance_;
let _e202 = distance_;
falloff = ((_e198 * _e199) / max((_e201 * _e202), 0.0001f));
let _e206 = type_31;
let _e208 = type_31;
spot = ((_e206 > 1.5f) && (_e208 < 2.5f));
let _e211 = spot;
if _e211 {
let _e212 = aim;
let _e213 = (*toLight);
let _e217 = cone[1u];
let _e220 = cone[0u];
let _e222 = cone[1u];
local_12 = clamp(((dot(_e212, -(_e213)) - _e217) / max((_e220 - _e222), 0.0001f)), 0f, 1f);
} else {
local_12 = 1f;
}
let _e227 = local_12;
linearRamp = _e227;
let _e228 = linearRamp;
let _e229 = linearRamp;
ramp = (_e228 * _e229);
let _e231 = type_31;
if (_e231 > 15.5f) {
local_13 = 0f;
} else {
let _e233 = directional;
if _e233 {
local_14 = 1f;
} else {
let _e234 = degenerate;
if _e234 {
local_15 = 0f;
} else {
let _e235 = falloff;
let _e236 = ramp;
local_15 = (_e235 * _e236);
}
let _e238 = local_15;
local_14 = _e238;
}
let _e239 = local_14;
local_13 = _e239;
}
let _e240 = local_13;
attenuation = _e240;
let _e241 = color;
let _e244 = color[3u];
let _e246 = attenuation;
(*radiance) = ((_e241.xyz * _e244) * _e246);
return;
}
fn FindCluster_u0028_vf3_u003b(world_3: 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_16: f32;
var cell: f32;
var row_3: f32;
var header: vec4<f32>;
var param_13: f32;
var param_14: f32;
let _e64 = light_list_info.cluster_view_projection;
let _e65 = (*world_3);
clip = (_e64 * vec4<f32>(_e65.x, _e65.y, _e65.z, 1f));
let _e71 = clip;
let _e74 = clip[3u];
ndc = (_e71.xy / vec2(max(_e74, 0.000001f)));
let _e79 = light_list_info.cluster_grid;
grid = _e79.xyz;
let _e83 = light_list_info.cluster_depth[0u];
near = _e83;
let _e85 = ndc[0u];
let _e89 = grid[0u];
let _e93 = grid[0u];
tx = clamp(floor((((_e85 * 0.5f) + 0.5f) * _e89)), 0f, (_e93 - 1f));
let _e97 = ndc[1u];
let _e101 = grid[1u];
let _e105 = grid[1u];
ty = clamp(floor((((_e97 * 0.5f) + 0.5f) * _e101)), 0f, (_e105 - 1f));
let _e109 = clip[3u];
let _e110 = near;
if (_e109 <= _e110) {
local_16 = 0f;
} else {
let _e113 = clip[3u];
let _e114 = near;
let _e119 = light_list_info.cluster_depth[1u];
let _e123 = grid[2u];
local_16 = clamp(floor((log((_e113 / _e114)) * _e119)), 0f, (_e123 - 1f));
}
let _e126 = local_16;
tz = _e126;
let _e127 = tx;
let _e128 = ty;
let _e130 = grid[0u];
let _e133 = tz;
let _e135 = grid[0u];
let _e138 = grid[1u];
cell = ((_e127 + (_e128 * _e130)) + ((_e133 * _e135) * _e138));
let _e141 = cell;
row_3 = floor((_e141 / 4f));
let _e144 = cell;
let _e145 = row_3;
let _e150 = light_list_info.cluster_depth[2u];
let _e151 = row_3;
param_13 = (_e144 - (_e145 * 4f));
param_14 = (_e150 + _e151);
let _e153 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_13), (¶m_14));
header = _e153;
let _e155 = header[0u];
g_cluster_offset = _e155;
let _e157 = header[1u];
g_cluster_count = _e157;
return;
}
fn ContributorLightCount_u0028_vf3_u003b(world_4: ptr<function, vec3<f32>>) -> i32 {
var tail: f32;
var param_15: vec3<f32>;
let _e54 = light_list_info.list[0u];
tail = _e54;
let _e55 = Clustered_u0028_();
if _e55 {
let _e56 = (*world_4);
param_15 = _e56;
FindCluster_u0028_vf3_u003b((¶m_15));
let _e57 = g_cluster_count;
tail = _e57;
}
let _e60 = contributor_light_info.slots[0u];
let _e64 = tail;
return (clamp(i32((_e60 + 0.5f)), 0i, 8i) + clamp(i32((_e64 + 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 param_24: vec3<f32>;
var coverage: f32;
var param_25: vec3<f32>;
g_cluster_offset = 0f;
g_cluster_count = 0f;
let _e70 = v_uv_1;
let _e71 = textureSample(six_way_positive_tex, six_way_positive_smp, _e70);
positive_1 = _e71;
let _e72 = v_uv_1;
let _e73 = textureSample(six_way_negative_tex, six_way_negative_smp, _e72);
negative_1 = _e73;
lit = vec3<f32>(0f, 0f, 0f);
let _e74 = v_world_position_1;
param_16 = _e74;
let _e75 = ContributorLightCount_u0028_vf3_u003b((¶m_16));
count = _e75;
i = 0i;
loop {
let _e76 = i;
if (_e76 < 32i) {
let _e78 = i;
let _e79 = count;
if (_e78 >= _e79) {
break;
}
let _e81 = i;
param_17 = _e81;
let _e82 = v_world_position_1;
param_18 = _e82;
ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e83 = param_19;
l_1 = _e83;
let _e84 = param_20;
radiance_1 = _e84;
let _e85 = radiance_1;
let _e86 = l_1;
param_21 = _e86;
let _e87 = positive_1;
param_22 = _e87.xyz;
let _e89 = negative_1;
param_23 = _e89.xyz;
let _e91 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_21), (¶m_22), (¶m_23));
let _e93 = lit;
lit = (_e93 + (_e85 * _e91));
continue;
} else {
break;
}
continuing {
let _e95 = i;
i = (_e95 + 1i);
}
}
let _e98 = positive_1[0u];
let _e100 = positive_1[1u];
let _e103 = positive_1[2u];
let _e106 = negative_1[0u];
let _e109 = negative_1[1u];
let _e112 = negative_1[2u];
mean = ((((((_e98 + _e100) + _e103) + _e106) + _e109) + _e112) / 6f);
let _e115 = v_color_1;
let _e117 = lit;
let _e119 = six_way_info.ambient;
let _e121 = mean;
let _e126 = six_way_info.emission;
let _e129 = negative_1[3u];
color_1 = ((_e115.xyz * (_e117 + (_e119.xyz * _e121))) + (_e126.xyz * _e129));
fogged = 1f;
let _e134 = fog_info.fog[3u];
if (_e134 > 0f) {
let _e138 = fog_info.fog[3u];
let _e140 = v_world_position_1;
param_24 = _e140;
let _e141 = FogDistance_u0028_vf3_u003b((¶m_24));
fogged = clamp(exp((-(_e138) * _e141)), 0f, 1f);
}
let _e146 = fog_info.fog;
let _e148 = color_1;
let _e149 = fogged;
color_1 = mix(_e146.xyz, _e148, vec3(_e149));
let _e153 = v_color_1[3u];
let _e155 = positive_1[3u];
coverage = clamp((_e153 * _e155), 0f, 1f);
let _e158 = v_world_position_1;
param_25 = _e158;
let _e159 = SoftParticleFade_u0028_vf3_u003b((¶m_25));
let _e160 = coverage;
coverage = (_e160 * _e159);
let _e162 = color_1;
let _e163 = coverage;
let _e164 = (_e162 * _e163);
let _e165 = coverage;
frag_color = vec4<f32>(_e164.x, _e164.y, _e164.z, _e165);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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>,
forward: vec4<f32>,
projection: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e21 = fog_info.projection[0u];
if (_e21 > 0.5f) {
let _e23 = (*world);
let _e25 = fog_info.eye;
let _e29 = fog_info.forward;
local = max(dot((_e23 - _e25.xyz), _e29.xyz), 0f);
} else {
let _e33 = (*world);
let _e35 = fog_info.eye;
local = distance(_e33, _e35.xyz);
}
let _e38 = local;
return _e38;
}
fn main_1() {
var power: f32;
var alpha: f32;
var colour: vec3<f32>;
var visibility: f32;
var param: vec3<f32>;
let _e22 = v_uv_1;
let _e23 = v_uv_1;
power = (-0.5f * dot(_e22, _e23));
let _e26 = power;
if (_e26 < -4.5f) {
discard;
}
let _e29 = v_color_1[3u];
let _e30 = power;
alpha = (_e29 * exp(_e30));
let _e33 = alpha;
if (_e33 < 0.003921569f) {
discard;
}
let _e35 = v_color_1;
colour = _e35.xyz;
let _e39 = fog_info.fog[3u];
if (_e39 > 0f) {
let _e43 = fog_info.fog[3u];
let _e45 = v_world_position_1;
param = _e45;
let _e46 = FogDistance_u0028_vf3_u003b((¶m));
visibility = clamp(exp((-(_e43) * _e46)), 0f, 1f);
let _e51 = fog_info.fog;
let _e53 = colour;
let _e54 = visibility;
colour = mix(_e51.xyz, _e53, vec3(_e54));
}
let _e57 = colour;
let _e58 = alpha;
let _e59 = (_e57 * _e58);
let _e60 = alpha;
frag_color = vec4<f32>(_e59.x, _e59.y, _e59.z, _e60);
return;
}
@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'SplatHashed': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
projection: vec4<f32>,
}
struct SplatHashInfo {
frame: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
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;
var<private> frag_color: vec4<f32>;
fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e43 = fog_info.projection[0u];
if (_e43 > 0.5f) {
let _e45 = (*world);
let _e47 = fog_info.eye;
let _e51 = fog_info.forward;
local = max(dot((_e45 - _e47.xyz), _e51.xyz), 0f);
} else {
let _e55 = (*world);
let _e57 = fog_info.eye;
local = distance(_e55, _e57.xyz);
}
let _e60 = local;
return _e60;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_1: vec2<f32>;
let _e41 = (*rows);
if (_e41 > 0f) {
let _e44 = gl_FragCoord_1[0u];
let _e45 = (*rows);
let _e47 = gl_FragCoord_1[1u];
local_1 = vec2<f32>(_e44, (_e45 - _e47));
} else {
let _e50 = gl_FragCoord_1;
local_1 = _e50.xy;
}
let _e52 = local_1;
return _e52;
}
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;
var param_1: vec3<f32>;
let _e54 = v_uv_1;
let _e55 = v_uv_1;
power = (-0.5f * dot(_e54, _e55));
let _e58 = power;
if (_e58 < -4.5f) {
discard;
}
let _e61 = v_color_1[3u];
let _e62 = power;
alpha = (_e61 * exp(_e62));
let _e65 = alpha;
if (_e65 < 0.003921569f) {
discard;
}
let _e67 = v_world_position_1;
let _e69 = splat_hash_info.eye;
let _e73 = splat_hash_info.forward;
along = dot((_e67 - _e69.xyz), _e73.xyz);
let _e76 = along;
let _e79 = v_color_1;
identity = (floor((_e76 * 1000f)) + floor(dot(_e79, vec4<f32>(255f, 1785f, 7905f, 32385f))));
let _e83 = identity;
identity = (_e83 - (floor((_e83 / 4096f)) * 4096f));
let _e88 = identity;
let _e90 = ((_e88 * 1597f) + 2531f);
mixed = (_e90 - (floor((_e90 / 4096f)) * 4096f));
let _e95 = mixed;
let _e96 = mixed;
let _e98 = ((2f * _e96) + 1f);
let _e103 = (_e95 * (_e98 - (floor((_e98 / 4096f)) * 4096f)));
mixed = (_e103 - (floor((_e103 / 4096f)) * 4096f));
let _e108 = mixed;
row = floor((_e108 / 64f));
let _e111 = mixed;
let _e112 = row;
let _e114 = (_e111 + (_e112 * 37f));
let _e119 = row;
offset = vec2<f32>((_e114 - (floor((_e114 / 64f)) * 64f)), _e119);
let _e123 = splat_hash_info.frame[0u];
slice = _e123;
let _e126 = splat_hash_info.frame[1u];
param = _e126;
let _e127 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e129 = offset;
let _e130 = (floor(_e127) + _e129);
let _e131 = vec2(64f);
cell = (_e130 - (floor((_e130 / _e131)) * _e131));
let _e136 = slice;
let _e141 = slice;
corner = (vec2<f32>((_e136 - (floor((_e136 / 8f)) * 8f)), floor((_e141 / 8f))) * 64f);
let _e146 = corner;
let _e147 = cell;
let _e152 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, (((_e146 + _e147) + vec2(0.5f)) / vec2<f32>(512f, 256f)), 0f);
threshold = (_e152.x * 0.99609375f);
let _e155 = alpha;
let _e156 = threshold;
if (_e155 <= _e156) {
discard;
}
let _e158 = v_color_1;
colour = _e158.xyz;
let _e162 = fog_info.fog[3u];
if (_e162 > 0f) {
let _e166 = fog_info.fog[3u];
let _e168 = v_world_position_1;
param_1 = _e168;
let _e169 = FogDistance_u0028_vf3_u003b((¶m_1));
visibility = clamp(exp((-(_e166) * _e169)), 0f, 1f);
let _e174 = fog_info.fog;
let _e176 = colour;
let _e177 = visibility;
colour = mix(_e174.xyz, _e176, vec3(_e177));
}
let _e180 = colour;
frag_color = vec4<f32>(_e180.x, _e180.y, _e180.z, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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>,
forward: vec4<f32>,
projection: 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 FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
var local: f32;
let _e20 = fog_info.projection[0u];
if (_e20 > 0.5f) {
let _e22 = (*world);
let _e24 = fog_info.eye;
let _e28 = fog_info.forward;
local = max(dot((_e22 - _e24.xyz), _e28.xyz), 0f);
} else {
let _e32 = (*world);
let _e34 = fog_info.eye;
local = distance(_e32, _e34.xyz);
}
let _e37 = local;
return _e37;
}
fn TowardsEyeFrom_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> vec3<f32> {
var to_eye: vec3<f32>;
var length_to_eye: f32;
var local_1: vec3<f32>;
let _e22 = fog_info.projection[0u];
if (_e22 > 0.5f) {
let _e25 = fog_info.forward;
return -(_e25.xyz);
}
let _e29 = fog_info.eye;
let _e31 = (*world_1);
to_eye = (_e29.xyz - _e31);
let _e33 = to_eye;
length_to_eye = length(_e33);
let _e35 = length_to_eye;
if (_e35 > 0f) {
let _e37 = to_eye;
let _e38 = length_to_eye;
local_1 = (_e37 / vec3(_e38));
} else {
local_1 = vec3<f32>(0f, 0f, 0f);
}
let _e41 = local_1;
return _e41;
}
fn main_1() {
var towards_eye: vec3<f32>;
var param: vec3<f32>;
var n: vec3<f32>;
var facing: f32;
var local_2: f32;
var intensity: f32;
var fogged: f32;
var param_1: vec3<f32>;
let _e24 = v_world_position_1;
param = _e24;
let _e25 = TowardsEyeFrom_u0028_vf3_u003b((¶m));
towards_eye = _e25;
let _e26 = v_normal_1;
n = normalize(_e26);
let _e28 = towards_eye;
let _e29 = towards_eye;
if (dot(_e28, _e29) > 0f) {
let _e32 = n;
let _e33 = towards_eye;
local_2 = abs(dot(_e32, _e33));
} else {
local_2 = 1f;
}
let _e36 = local_2;
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 = v_world_position_1;
param_1 = _e47;
let _e48 = FogDistance_u0028_vf3_u003b((¶m_1));
fogged = clamp(exp((-(_e45) * _e48)), 0f, 1f);
}
let _e52 = v_color_1;
let _e55 = v_color_1[3u];
let _e57 = intensity;
let _e59 = fogged;
let _e60 = (((_e52.xyz * _e55) * _e57) * _e59);
frag_color = vec4<f32>(_e60.x, _e60.y, _e60.z, 1f);
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
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(6) 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(6) 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(6) 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(6) 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,
),
],
),
'ContactShadowResolve': WebGpuStage(
wgsl: r'''
struct ContactShadowResolveInfo {
params: vec4<f32>,
}
@group(1) @binding(1)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var contact_shadow_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(0)
var<uniform> resolve_info: ContactShadowResolveInfo;
fn main_1() {
var centre: vec4<f32>;
var centreDepth: f32;
var falloff: f32;
var total: vec4<f32>;
var weightSum: f32;
var y: i32;
var x: i32;
var at: vec2<f32>;
var depth: f32;
var weight: f32;
let _e26 = v_uv_1;
let _e27 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e26);
centre = _e27;
let _e28 = v_uv_1;
let _e29 = textureSample(surface_texture_tex, surface_texture_smp, _e28);
centreDepth = _e29.w;
let _e31 = centreDepth;
if (_e31 <= 0f) {
let _e33 = centre;
frag_color = _e33;
return;
}
let _e36 = resolve_info.params[2u];
let _e38 = centreDepth;
falloff = (max(_e36, 0.0001f) * max(_e38, 0.001f));
total = vec4<f32>(0f, 0f, 0f, 0f);
weightSum = 0f;
y = -2i;
loop {
let _e41 = y;
if (_e41 <= 1i) {
x = -2i;
loop {
let _e43 = x;
if (_e43 <= 1i) {
let _e45 = v_uv_1;
let _e46 = x;
let _e48 = y;
let _e52 = resolve_info.params;
at = (_e45 + (vec2<f32>(f32(_e46), f32(_e48)) * _e52.xy));
let _e56 = at;
let _e57 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e56, 0f);
depth = _e57.w;
let _e59 = depth;
if (_e59 <= 0f) {
continue;
}
let _e61 = depth;
let _e62 = centreDepth;
let _e66 = falloff;
weight = exp((-(abs((_e61 - _e62))) / _e66));
let _e69 = at;
let _e70 = textureSampleLevel(contact_shadow_texture_tex, contact_shadow_texture_smp, _e69, 0f);
let _e71 = weight;
let _e73 = total;
total = (_e73 + (_e70 * _e71));
let _e75 = weight;
let _e76 = weightSum;
weightSum = (_e76 + _e75);
continue;
} else {
break;
}
continuing {
let _e78 = x;
x = (_e78 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e80 = y;
y = (_e80 + 1i);
}
}
let _e82 = total;
let _e83 = weightSum;
frag_color = (_e82 / vec4(max(_e83, 0.0001f)));
return;
}
@fragment
fn main(@location(6) 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: 'ContactShadowResolveInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'contact_shadow_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
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(6) 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(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) 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(6) 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(6) 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 ShadowStored_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
var local: f32;
let _e63 = (*mode);
if (_e63 > 0.5f) {
let _e65 = (*stored);
local = (1f - _e65);
} else {
let _e67 = (*stored);
local = _e67;
}
let _e68 = local;
return _e68;
}
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_1: mat4x4<f32>;
var local_2: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var uv: vec2<f32>;
var stored_1: f32;
var param: f32;
var param_1: f32;
var bias: f32;
var local_3: f32;
var local_4: f32;
var phi_328_: bool;
var phi_339_: bool;
var phi_425_: bool;
var phi_432_: bool;
var phi_439_: bool;
let _e81 = shaft_info.cascades[2u];
cascadeCount = i32((_e81 + 0.5f));
cascade = 0i;
let _e84 = cascadeCount;
let _e85 = (_e84 > 1i);
phi_328_ = _e85;
if _e85 {
let _e86 = (*viewDistance);
let _e89 = shaft_info.cascades[0u];
phi_328_ = (_e86 > _e89);
}
let _e92 = phi_328_;
if _e92 {
cascade = 1i;
}
let _e93 = cascadeCount;
let _e94 = (_e93 > 2i);
phi_339_ = _e94;
if _e94 {
let _e95 = (*viewDistance);
let _e98 = shaft_info.cascades[1u];
phi_339_ = (_e95 > _e98);
}
let _e101 = phi_339_;
if _e101 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e102 = attempt;
if (_e102 < 3i) {
let _e104 = cascade;
let _e105 = attempt;
which = (_e104 + _e105);
let _e107 = which;
let _e108 = cascadeCount;
if (_e107 >= _e108) {
break;
}
let _e110 = which;
if (_e110 == 0i) {
let _e113 = shaft_info.shadow_matrix;
local_1 = _e113;
} else {
let _e114 = which;
if (_e114 == 1i) {
let _e117 = shaft_info.shadow_matrix_far;
local_2 = _e117;
} else {
let _e119 = shaft_info.shadow_matrix_farthest;
local_2 = _e119;
}
let _e120 = local_2;
local_1 = _e120;
}
let _e121 = local_1;
matrix = _e121;
let _e122 = matrix;
let _e123 = (*world);
lightSpace = (_e122 * vec4<f32>(_e123.x, _e123.y, _e123.z, 1f));
let _e130 = lightSpace[3u];
if (_e130 <= 0f) {
continue;
}
let _e132 = lightSpace;
let _e135 = lightSpace[3u];
candidate = (_e132.xyz / vec3(_e135));
let _e139 = candidate[0u];
let _e143 = candidate[1u];
inTile = vec2<f32>(((_e139 * 0.5f) + 0.5f), (0.5f - (_e143 * 0.5f)));
let _e148 = inTile[0u];
let _e149 = (_e148 < 0f);
phi_425_ = _e149;
if !(_e149) {
let _e152 = inTile[0u];
phi_425_ = (_e152 > 1f);
}
let _e155 = phi_425_;
phi_432_ = _e155;
if !(_e155) {
let _e158 = inTile[1u];
phi_432_ = (_e158 < 0f);
}
let _e161 = phi_432_;
phi_439_ = _e161;
if !(_e161) {
let _e164 = inTile[1u];
phi_439_ = (_e164 > 1f);
}
let _e167 = phi_439_;
if _e167 {
continue;
}
let _e169 = candidate[2u];
if (_e169 > 1f) {
let _e171 = which;
let _e172 = cascadeCount;
if (_e171 < (_e172 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e177 = inTile[0u];
let _e178 = which;
let _e181 = cascadeCount;
let _e185 = inTile[1u];
uv = vec2<f32>(((_e177 + f32(_e178)) / f32(_e181)), _e185);
let _e187 = uv;
let _e188 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e187, 0f);
param = _e188.x;
let _e192 = shaft_info.bias[3u];
param_1 = _e192;
let _e193 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m), (¶m_1));
stored_1 = _e193;
let _e194 = which;
if (_e194 == 0i) {
let _e198 = shaft_info.bias[0u];
local_3 = _e198;
} else {
let _e199 = which;
if (_e199 == 1i) {
let _e203 = shaft_info.bias[1u];
local_4 = _e203;
} else {
let _e206 = shaft_info.bias[2u];
local_4 = _e206;
}
let _e207 = local_4;
local_3 = _e207;
}
let _e208 = local_3;
bias = _e208;
let _e210 = candidate[2u];
let _e211 = bias;
let _e213 = stored_1;
return select(1f, 0f, ((_e210 - _e211) > _e213));
} else {
break;
}
continuing {
let _e216 = attempt;
attempt = (_e216 + 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_5: f32;
var param_2: vec2<f32>;
var param_3: vec2<f32>;
let _e66 = noise_info.noise[0u];
if (_e66 > 0.5f) {
let _e68 = (*at_2);
param_2 = _e68;
let _e69 = BlueNoise_u0028_vf2_u003b((¶m_2));
local_5 = _e69;
} else {
let _e70 = (*at_2);
param_3 = _e70;
let _e71 = BayerCell_u0028_vf2_u003b((¶m_3));
local_5 = _e71;
}
let _e72 = local_5;
return _e72;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_6: vec2<f32>;
let _e62 = (*rows);
if (_e62 > 0f) {
let _e65 = gl_FragCoord_1[0u];
let _e66 = (*rows);
let _e68 = gl_FragCoord_1[1u];
local_6 = vec2<f32>(_e65, (_e66 - _e68));
} else {
let _e71 = gl_FragCoord_1;
local_6 = _e71.xy;
}
let _e73 = local_6;
return _e73;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_4: f32;
let _e63 = frag_coord_info.origin[0u];
param_4 = _e63;
let _e64 = FragCoordFromTop_u0028_f1_u003b((¶m_4));
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 nearPoint: vec3<f32>;
var along: vec3<f32>;
var cosine_1: f32;
var origin: vec3<f32>;
var surfaceDepth: f32;
var toSurface: f32;
var local_7: f32;
var distance_: f32;
var stride: f32;
var offset: f32;
var param_5: 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_6: vec3<f32>;
var param_7: f32;
var phase: f32;
var param_8: f32;
var param_9: f32;
var shaft: vec3<f32>;
let _e91 = v_uv_1;
let _e92 = textureSample(scene_texture_tex, scene_texture_smp, _e91);
scene = _e92;
let _e95 = shaft_info.forward[3u];
steps = i32((_e95 + 0.5f));
let _e98 = steps;
if (_e98 < 1i) {
let _e100 = scene;
frag_color = _e100;
return;
}
let _e102 = v_uv_1[0u];
let _e106 = v_uv_1[1u];
xy = vec2<f32>(((_e102 * 2f) - 1f), (1f - (_e106 * 2f)));
let _e111 = shaft_info.inverse_view_projection;
let _e112 = xy;
nearH = (_e111 * vec4<f32>(_e112.x, _e112.y, 0f, 1f));
let _e118 = shaft_info.inverse_view_projection;
let _e119 = xy;
farH = (_e118 * vec4<f32>(_e119.x, _e119.y, 1f, 1f));
let _e124 = nearH;
let _e127 = nearH[3u];
nearPoint = (_e124.xyz / vec3(_e127));
let _e130 = farH;
let _e133 = farH[3u];
let _e136 = nearPoint;
along = normalize(((_e130.xyz / vec3(_e133)) - _e136));
let _e139 = along;
let _e141 = shaft_info.forward;
cosine_1 = max(dot(_e139, _e141.xyz), 0.0001f);
let _e145 = nearPoint;
let _e146 = along;
let _e147 = nearPoint;
let _e149 = shaft_info.camera;
let _e153 = shaft_info.forward;
let _e156 = cosine_1;
origin = (_e145 - (_e146 * (dot((_e147 - _e149.xyz), _e153.xyz) / _e156)));
let _e160 = v_uv_1;
let _e161 = textureSample(surface_texture_tex, surface_texture_smp, _e160);
surfaceDepth = _e161.w;
let _e163 = surfaceDepth;
if (_e163 > 0f) {
let _e165 = surfaceDepth;
let _e166 = cosine_1;
local_7 = (_e165 / _e166);
} else {
local_7 = 1000000000f;
}
let _e168 = local_7;
toSurface = _e168;
let _e171 = shaft_info.camera[3u];
let _e172 = toSurface;
distance_ = min(_e171, _e172);
let _e174 = distance_;
if (_e174 <= 0f) {
let _e176 = scene;
frag_color = _e176;
return;
}
let _e177 = distance_;
let _e178 = steps;
stride = (_e177 / f32(_e178));
let _e181 = TargetFragCoord_u0028_();
param_5 = _e181;
let _e182 = PixelNoise_u0028_vf2_u003b((¶m_5));
let _e183 = stride;
offset = (_e182 * _e183);
let _e187 = shaft_info.scatter[3u];
sigma = max(_e187, 0f);
let _e189 = sigma;
let _e191 = stride;
stepTransmittance = exp((-(_e189) * _e191));
let _e194 = sigma;
let _e196 = offset;
transmittance = exp((-(_e194) * _e196));
let _e200 = shaft_info.camera;
eye = _e200.xyz;
inscatter = 0f;
i = 0i;
loop {
let _e202 = i;
if (_e202 < 64i) {
let _e204 = i;
let _e205 = steps;
if (_e204 >= _e205) {
break;
}
let _e207 = offset;
let _e208 = i;
let _e210 = stride;
travelled = (_e207 + (f32(_e208) * _e210));
let _e213 = origin;
let _e214 = along;
let _e215 = travelled;
at_3 = (_e213 + (_e214 * _e215));
let _e218 = at_3;
let _e219 = eye;
let _e222 = at_3;
param_6 = _e222;
param_7 = length((_e218 - _e219));
let _e223 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_6), (¶m_7));
lit = _e223;
let _e224 = transmittance;
let _e225 = stepTransmittance;
let _e228 = lit;
let _e230 = inscatter;
inscatter = (_e230 + ((_e224 * (1f - _e225)) * _e228));
let _e232 = stepTransmittance;
let _e233 = transmittance;
transmittance = (_e233 * _e232);
continue;
} else {
break;
}
continuing {
let _e235 = i;
i = (_e235 + 1i);
}
}
let _e237 = along;
let _e239 = shaft_info.sun;
param_8 = dot(_e237, _e239.xyz);
let _e244 = shaft_info.sun[3u];
param_9 = _e244;
let _e245 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_8), (¶m_9));
phase = _e245;
let _e247 = shaft_info.scatter;
let _e249 = phase;
let _e250 = inscatter;
shaft = (_e247.xyz * (_e249 * _e250));
let _e253 = scene;
let _e255 = shaft;
let _e256 = (_e253.xyz + _e255);
let _e258 = scene[3u];
frag_color = vec4<f32>(_e256.x, _e256.y, _e256.z, _e258);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) 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_629_: bool;
var phi_690_: 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_629_ = _e138;
if _e138 {
let _e140 = a[0u];
let _e142 = a[2u];
phi_629_ = (_e140 >= _e142);
}
let _e145 = phi_629_;
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_690_ = _e188;
if !(_e188) {
let _e191 = ndc[1u];
phi_690_ = (abs(_e191) > 1f);
}
let _e195 = phi_690_;
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 ramp: 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 _e139 = fog_info.cluster_view_projection;
let _e140 = (*world_1);
clip_1 = (_e139 * vec4<f32>(_e140.x, _e140.y, _e140.z, 1f));
let _e146 = clip_1;
let _e149 = clip_1[3u];
ndc_1 = (_e146.xy / vec2(max(_e149, 0.000001f)));
let _e154 = fog_info.cluster_grid;
grid = _e154.xyz;
let _e158 = fog_info.cluster_depth[0u];
near = _e158;
let _e160 = ndc_1[0u];
let _e164 = grid[0u];
let _e168 = grid[0u];
tx = clamp(floor((((_e160 * 0.5f) + 0.5f) * _e164)), 0f, (_e168 - 1f));
let _e172 = ndc_1[1u];
let _e176 = grid[1u];
let _e180 = grid[1u];
ty = clamp(floor((((_e172 * 0.5f) + 0.5f) * _e176)), 0f, (_e180 - 1f));
let _e184 = clip_1[3u];
let _e185 = near;
if (_e184 <= _e185) {
local_4 = 0f;
} else {
let _e188 = clip_1[3u];
let _e189 = near;
let _e194 = fog_info.cluster_depth[1u];
let _e198 = grid[2u];
local_4 = clamp(floor((log((_e188 / _e189)) * _e194)), 0f, (_e198 - 1f));
}
let _e201 = local_4;
tz = _e201;
let _e202 = tx;
let _e203 = ty;
let _e205 = grid[0u];
let _e208 = tz;
let _e210 = grid[0u];
let _e213 = grid[1u];
cell = ((_e202 + (_e203 * _e205)) + ((_e208 * _e210) * _e213));
let _e216 = cell;
headerRow = floor((_e216 / 4f));
let _e219 = cell;
let _e220 = headerRow;
let _e225 = fog_info.cluster_depth[2u];
let _e226 = headerRow;
param = (_e219 - (_e220 * 4f));
param_1 = (_e225 + _e226);
let _e228 = ListTexel_u0028_f1_u003b_f1_u003b((¶m), (¶m_1));
header = _e228;
let _e230 = header[1u];
count = i32((_e230 + 0.5f));
total = vec3<f32>(0f, 0f, 0f);
i = 0i;
loop {
let _e233 = i;
if (_e233 < 16i) {
let _e235 = i;
let _e236 = count;
if (_e235 >= _e236) {
break;
}
let _e239 = header[0u];
let _e240 = i;
entry = (_e239 + f32(_e240));
let _e243 = entry;
entryRow = floor((_e243 / 16f));
let _e246 = entry;
let _e247 = entryRow;
within = (_e246 - (_e247 * 16f));
let _e250 = within;
texel_1 = floor((_e250 / 4f));
let _e255 = fog_info.cluster_depth[3u];
let _e256 = entryRow;
let _e258 = texel_1;
param_2 = _e258;
param_3 = (_e255 + _e256);
let _e259 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_2), (¶m_3));
four_1 = _e259;
let _e260 = within;
let _e261 = texel_1;
let _e264 = four_1;
param_4 = _e264;
param_5 = (_e260 - (_e261 * 4f));
let _e265 = Lane_u0028_vf4_u003b_f1_u003b((¶m_4), (¶m_5));
row_1 = _e265;
param_6 = 0f;
let _e266 = row_1;
param_7 = _e266;
let _e267 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_6), (¶m_7));
position = _e267;
param_8 = 1f;
let _e268 = row_1;
param_9 = _e268;
let _e269 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_8), (¶m_9));
color = _e269;
param_10 = 2f;
let _e270 = row_1;
param_11 = _e270;
let _e271 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_10), (¶m_11));
direction = _e271;
param_12 = 3f;
let _e272 = row_1;
param_13 = _e272;
let _e273 = ListTexel_u0028_f1_u003b_f1_u003b((¶m_12), (¶m_13));
cone_1 = _e273;
let _e275 = position[3u];
type_30 = _e275;
let _e276 = position;
let _e278 = (*world_1);
toLight = (_e276.xyz - _e278);
let _e280 = toLight;
distance_1 = length(_e280);
let _e282 = type_30;
let _e284 = type_30;
let _e287 = distance_1;
usable = select(0f, 1f, (((_e282 > 0.5f) && (_e284 < 2.5f)) && (_e287 > 0.0001f)));
let _e291 = toLight;
let _e292 = distance_1;
l = (_e291 / vec3(max(_e292, 0.0001f)));
let _e296 = distance_1;
let _e297 = distance_1;
attenuation = (1f / max((_e296 * _e297), 0.0001f));
let _e302 = direction[3u];
if (_e302 > 0f) {
let _e304 = distance_1;
let _e306 = direction[3u];
ratio = (_e304 / _e306);
let _e308 = ratio;
let _e309 = ratio;
let _e311 = ratio;
let _e313 = ratio;
window = clamp((1f - (((_e308 * _e309) * _e311) * _e313)), 0f, 1f);
let _e317 = window;
let _e318 = window;
let _e320 = attenuation;
attenuation = (_e320 * (_e317 * _e318));
}
let _e322 = type_30;
let _e324 = type_30;
if ((_e322 > 1.5f) && (_e324 < 2.5f)) {
let _e327 = direction;
let _e330 = l;
cosAngle = dot(normalize(_e327.xyz), -(_e330));
let _e333 = cosAngle;
let _e335 = cone_1[1u];
let _e338 = cone_1[0u];
let _e340 = cone_1[1u];
ramp = clamp(((_e333 - _e335) / (_e338 - _e340)), 0f, 1f);
let _e344 = ramp;
let _e345 = ramp;
let _e347 = attenuation;
attenuation = (_e347 * (_e344 * _e345));
}
let _e349 = attenuation;
let _e350 = usable;
if ((_e349 * _e350) > 0f) {
let _e353 = (*world_1);
param_14 = _e353;
let _e354 = cone_1;
param_15 = _e354;
let _e355 = LocalLitAt_u0028_vf3_u003b_vf4_u003b((¶m_14), (¶m_15));
local_5 = _e355;
} else {
local_5 = 1f;
}
let _e356 = local_5;
visibility = _e356;
let _e357 = color;
let _e360 = color[3u];
let _e361 = attenuation;
let _e363 = usable;
let _e365 = visibility;
let _e367 = (*along);
let _e368 = l;
param_16 = dot(_e367, _e368);
let _e370 = (*g_1);
param_17 = _e370;
let _e371 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_16), (¶m_17));
let _e374 = total;
total = (_e374 + (_e357.xyz * ((((_e360 * _e361) * _e363) * _e365) * _e371)));
continue;
} else {
break;
}
continuing {
let _e376 = i;
i = (_e376 + 1i);
}
}
let _e378 = total;
return _e378;
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_1: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
var local_6: f32;
let _e84 = (*mode);
if (_e84 > 0.5f) {
let _e86 = (*stored_1);
local_6 = (1f - _e86);
} else {
let _e88 = (*stored_1);
local_6 = _e88;
}
let _e89 = local_6;
return _e89;
}
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_7: mat4x4<f32>;
var local_8: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var uv_1: vec2<f32>;
var stored_2: f32;
var param_18: f32;
var param_19: f32;
var bias: f32;
var local_9: f32;
var local_10: f32;
var phi_374_: bool;
var phi_385_: bool;
var phi_470_: bool;
var phi_477_: bool;
var phi_484_: bool;
let _e102 = fog_info.cascades[2u];
cascadeCount = i32((_e102 + 0.5f));
cascade = 0i;
let _e105 = cascadeCount;
let _e106 = (_e105 > 1i);
phi_374_ = _e106;
if _e106 {
let _e107 = (*viewDistance);
let _e110 = fog_info.cascades[0u];
phi_374_ = (_e107 > _e110);
}
let _e113 = phi_374_;
if _e113 {
cascade = 1i;
}
let _e114 = cascadeCount;
let _e115 = (_e114 > 2i);
phi_385_ = _e115;
if _e115 {
let _e116 = (*viewDistance);
let _e119 = fog_info.cascades[1u];
phi_385_ = (_e116 > _e119);
}
let _e122 = phi_385_;
if _e122 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e123 = attempt;
if (_e123 < 3i) {
let _e125 = cascade;
let _e126 = attempt;
which = (_e125 + _e126);
let _e128 = which;
let _e129 = cascadeCount;
if (_e128 >= _e129) {
break;
}
let _e131 = which;
if (_e131 == 0i) {
let _e134 = fog_info.shadow_matrix;
local_7 = _e134;
} else {
let _e135 = which;
if (_e135 == 1i) {
let _e138 = fog_info.shadow_matrix_far;
local_8 = _e138;
} else {
let _e140 = fog_info.shadow_matrix_farthest;
local_8 = _e140;
}
let _e141 = local_8;
local_7 = _e141;
}
let _e142 = local_7;
matrix = _e142;
let _e143 = matrix;
let _e144 = (*world_2);
lightSpace = (_e143 * vec4<f32>(_e144.x, _e144.y, _e144.z, 1f));
let _e151 = lightSpace[3u];
if (_e151 <= 0f) {
continue;
}
let _e153 = lightSpace;
let _e156 = lightSpace[3u];
candidate = (_e153.xyz / vec3(_e156));
let _e160 = candidate[0u];
let _e164 = candidate[1u];
inTile = vec2<f32>(((_e160 * 0.5f) + 0.5f), (0.5f - (_e164 * 0.5f)));
let _e169 = inTile[0u];
let _e170 = (_e169 < 0f);
phi_470_ = _e170;
if !(_e170) {
let _e173 = inTile[0u];
phi_470_ = (_e173 > 1f);
}
let _e176 = phi_470_;
phi_477_ = _e176;
if !(_e176) {
let _e179 = inTile[1u];
phi_477_ = (_e179 < 0f);
}
let _e182 = phi_477_;
phi_484_ = _e182;
if !(_e182) {
let _e185 = inTile[1u];
phi_484_ = (_e185 > 1f);
}
let _e188 = phi_484_;
if _e188 {
continue;
}
let _e190 = candidate[2u];
if (_e190 > 1f) {
let _e192 = which;
let _e193 = cascadeCount;
if (_e192 < (_e193 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e198 = inTile[0u];
let _e199 = which;
let _e202 = cascadeCount;
let _e206 = inTile[1u];
uv_1 = vec2<f32>(((_e198 + f32(_e199)) / f32(_e202)), _e206);
let _e208 = uv_1;
let _e209 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e208, 0f);
param_18 = _e209.x;
let _e213 = fog_info.bias[3u];
param_19 = _e213;
let _e214 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_18), (¶m_19));
stored_2 = _e214;
let _e215 = which;
if (_e215 == 0i) {
let _e219 = fog_info.bias[0u];
local_9 = _e219;
} else {
let _e220 = which;
if (_e220 == 1i) {
let _e224 = fog_info.bias[1u];
local_10 = _e224;
} else {
let _e227 = fog_info.bias[2u];
local_10 = _e227;
}
let _e228 = local_10;
local_9 = _e228;
}
let _e229 = local_9;
bias = _e229;
let _e231 = candidate[2u];
let _e232 = bias;
let _e234 = stored_2;
return select(1f, 0f, ((_e231 - _e232) > _e234));
} else {
break;
}
continuing {
let _e237 = attempt;
attempt = (_e237 + 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_11: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
let _e87 = noise_info.noise[0u];
if (_e87 > 0.5f) {
let _e89 = (*at_2);
param_20 = _e89;
let _e90 = BlueNoise_u0028_vf2_u003b((¶m_20));
local_11 = _e90;
} else {
let _e91 = (*at_2);
param_21 = _e91;
let _e92 = BayerCell_u0028_vf2_u003b((¶m_21));
local_11 = _e92;
}
let _e93 = local_11;
return _e93;
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_12: vec2<f32>;
let _e83 = (*rows);
if (_e83 > 0f) {
let _e86 = gl_FragCoord_1[0u];
let _e87 = (*rows);
let _e89 = gl_FragCoord_1[1u];
local_12 = vec2<f32>(_e86, (_e87 - _e89));
} else {
let _e92 = gl_FragCoord_1;
local_12 = _e92.xy;
}
let _e94 = local_12;
return _e94;
}
fn TargetFragCoord_u0028_() -> vec2<f32> {
var param_22: f32;
let _e84 = frag_coord_info.origin[0u];
param_22 = _e84;
let _e85 = FragCoordFromTop_u0028_f1_u003b((¶m_22));
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_13: f32;
var distance_2: f32;
var stride: f32;
var offset: f32;
var param_23: vec2<f32>;
var g_2: f32;
var sunPhase: f32;
var param_24: f32;
var param_25: 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_26: f32;
var light: vec3<f32>;
var param_27: vec3<f32>;
var param_28: f32;
var param_29: vec3<f32>;
var param_30: vec3<f32>;
var param_31: 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_13 = (_e184 / _e185);
} else {
local_13 = 1000000000f;
}
let _e187 = local_13;
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_23 = _e202;
let _e203 = PixelNoise_u0028_vf2_u003b((¶m_23));
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_24 = dot(_e209, _e211.xyz);
let _e214 = g_2;
param_25 = _e214;
let _e215 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_24), (¶m_25));
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_26 = _e240;
let _e241 = Density_u0028_f1_u003b((¶m_26));
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_27 = _e254;
param_28 = length((_e250 - _e251));
let _e255 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_27), (¶m_28));
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_29 = _e267;
let _e268 = along_1;
param_30 = _e268;
let _e269 = g_2;
param_31 = _e269;
let _e270 = ClusterLight_u0028_vf3_u003b_vf3_u003b_f1_u003b((¶m_29), (¶m_30), (¶m_31));
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(6) 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(6) 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(6) 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(6) 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(6) 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(6) 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(6) 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(6) 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,
),
],
),
'OutlineMask': WebGpuStage(
wgsl: r'''
struct OutlineMaskInfo {
target_: vec4<f32>,
color: vec4<f32>,
}
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> mask_info: OutlineMaskInfo;
@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 phi_90_: bool;
let _e23 = mask_info.target_[2u];
param = _e23;
let _e24 = FragCoordFromTop_u0028_f1_u003b((¶m));
let _e26 = mask_info.target_;
uv = (_e24 * _e26.xy);
let _e29 = uv;
let _e30 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e29, 0f);
stored = _e30.w;
let _e32 = stored;
let _e33 = (_e32 > 0f);
phi_90_ = _e33;
if _e33 {
let _e34 = v_depth_1;
let _e35 = stored;
let _e38 = mask_info.target_[3u];
phi_90_ = (_e34 > ((_e35 * (1f + _e38)) + 0.001f));
}
let _e44 = phi_90_;
hidden = _e44;
let _e45 = hidden;
if _e45 {
discard;
}
let _e47 = mask_info.color;
let _e48 = _e47.xyz;
frag_color = vec4<f32>(_e48.x, _e48.y, _e48.z, 1f);
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: 'OutlineMaskInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'target',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'color',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'HighContrast': WebGpuStage(
wgsl: r'''
struct HighContrastInfo {
look: vec4<f32>,
edges: vec4<f32>,
line: vec4<f32>,
screen: vec4<f32>,
}
@group(1) @binding(3)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> contrast_info: HighContrastInfo;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
@group(1) @binding(1)
var mask_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var mask_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b(a: ptr<function, f32>, centre: ptr<function, f32>, b: ptr<function, f32>) -> f32 {
let _e48 = (*a);
let _e50 = (*b);
if ((_e48 <= 0f) || (_e50 <= 0f)) {
return 1000000f;
}
let _e53 = (*a);
let _e54 = (*b);
let _e56 = (*centre);
let _e60 = (*centre);
return (abs(((_e53 + _e54) - (2f * _e56))) / _e60);
}
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 _e50 = (*e);
(*e) = ((_e50 * 2f) - vec2(1f));
let _e54 = (*e);
let _e56 = (*e)[0u];
let _e60 = (*e)[1u];
n = vec3<f32>(_e54.x, _e54.y, ((1f - abs(_e56)) - abs(_e60)));
let _e67 = n[2u];
t = max(-(_e67), 0f);
let _e71 = n[0u];
if (_e71 >= 0f) {
let _e73 = t;
local = -(_e73);
} else {
let _e75 = t;
local = _e75;
}
let _e76 = local;
let _e78 = n[0u];
n[0u] = (_e78 + _e76);
let _e82 = n[1u];
if (_e82 >= 0f) {
let _e84 = t;
local_1 = -(_e84);
} else {
let _e86 = t;
local_1 = _e86;
}
let _e87 = local_1;
let _e89 = n[1u];
n[1u] = (_e89 + _e87);
let _e92 = n;
return normalize(_e92);
}
fn main_1() {
var scene: vec4<f32>;
var colour: vec3<f32>;
var texel: vec2<f32>;
var hasSurface: bool;
var hasMask: bool;
var surface: vec4<f32>;
var depth: f32;
var normal: vec3<f32>;
var local_2: vec3<f32>;
var param: vec2<f32>;
var bend: f32;
var turn: f32;
var flatten: f32;
var spacing: vec2<f32>;
var sum: vec3<f32>;
var count: f32;
var y: i32;
var x: i32;
var uv: vec2<f32>;
var tap: vec4<f32>;
var ring: f32;
var same: bool;
var param_1: vec2<f32>;
var luma: f32;
var reach: f32;
var dx: vec2<f32>;
var dy: vec2<f32>;
var left: vec4<f32>;
var right: vec4<f32>;
var up: vec4<f32>;
var down: vec4<f32>;
var across: bool;
var along: bool;
var bent: f32;
var local_3: f32;
var param_2: f32;
var param_3: f32;
var param_4: f32;
var local_4: f32;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var turned: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: vec2<f32>;
var ringWidth: f32;
var own: vec4<f32>;
var directions: array<vec2<f32>, 8>;
var found: vec4<f32>;
var i: i32;
var d: i32;
var tap_1: vec4<f32>;
var phi_267_: bool;
var phi_279_: bool;
var phi_405_: bool;
var phi_421_: bool;
var phi_588_: bool;
var phi_623_: bool;
let _e99 = v_uv_1;
let _e100 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e99, 0f);
scene = _e100;
let _e101 = scene;
colour = _e101.xyz;
let _e104 = contrast_info.screen;
texel = _e104.xy;
let _e108 = contrast_info.screen[2u];
hasSurface = (_e108 > 0.5f);
let _e112 = contrast_info.screen[3u];
hasMask = (_e112 > 0.5f);
surface = vec4<f32>(0f, 0f, 0f, 0f);
let _e114 = hasSurface;
if _e114 {
let _e115 = v_uv_1;
let _e116 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e115, 0f);
surface = _e116;
}
let _e118 = surface[3u];
depth = _e118;
let _e119 = depth;
if (_e119 > 0f) {
let _e121 = surface;
param = _e121.xy;
let _e123 = DecodeOctahedral_u0028_vf2_u003b((¶m));
local_2 = _e123;
} else {
local_2 = vec3<f32>(0f, 0f, 1f);
}
let _e124 = local_2;
normal = _e124;
let _e127 = contrast_info.edges[0u];
bend = max(_e127, 0.0001f);
let _e131 = contrast_info.edges[1u];
turn = max(_e131, 0.0001f);
let _e135 = contrast_info.look[0u];
flatten = clamp(_e135, 0f, 1f);
let _e137 = depth;
let _e139 = flatten;
if ((_e137 > 0f) && (_e139 > 0f)) {
let _e142 = texel;
let _e145 = contrast_info.edges[3u];
spacing = (_e142 * max(_e145, 1f));
sum = vec3<f32>(0f, 0f, 0f);
count = 0f;
y = -2i;
loop {
let _e148 = y;
if (_e148 <= 2i) {
x = -2i;
loop {
let _e150 = x;
if (_e150 <= 2i) {
let _e152 = v_uv_1;
let _e153 = x;
let _e155 = y;
let _e158 = spacing;
uv = (_e152 + (vec2<f32>(f32(_e153), f32(_e155)) * _e158));
let _e161 = uv;
let _e162 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e161, 0f);
tap = _e162;
let _e163 = x;
let _e165 = y;
ring = f32(max(abs(_e163), abs(_e165)));
let _e170 = tap[3u];
let _e171 = (_e170 > 0f);
phi_267_ = _e171;
if _e171 {
let _e173 = tap[3u];
let _e174 = depth;
let _e177 = bend;
let _e178 = depth;
let _e180 = ring;
phi_267_ = (abs((_e173 - _e174)) <= ((_e177 * _e178) * max(_e180, 1f)));
}
let _e185 = phi_267_;
phi_279_ = _e185;
if _e185 {
let _e186 = tap;
param_1 = _e186.xy;
let _e188 = DecodeOctahedral_u0028_vf2_u003b((¶m_1));
let _e189 = normal;
let _e192 = turn;
phi_279_ = ((1f - dot(_e188, _e189)) < _e192);
}
let _e195 = phi_279_;
same = _e195;
let _e196 = same;
if _e196 {
let _e197 = uv;
let _e198 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e197, 0f);
let _e200 = sum;
sum = (_e200 + _e198.xyz);
let _e202 = count;
count = (_e202 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e204 = x;
x = (_e204 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e206 = y;
y = (_e206 + 1i);
}
}
let _e208 = count;
if (_e208 > 0f) {
let _e210 = colour;
let _e211 = sum;
let _e212 = count;
let _e215 = flatten;
colour = mix(_e210, (_e211 / vec3(_e212)), vec3(_e215));
}
}
let _e218 = colour;
luma = dot(_e218, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e220 = luma;
let _e222 = colour;
let _e225 = contrast_info.look[2u];
colour = mix(vec3(_e220), _e222, vec3(clamp(_e225, 0f, 1f)));
let _e229 = colour;
let _e234 = contrast_info.look[1u];
colour = clamp((((_e229 - vec3(0.5f)) * max(_e234, 0f)) + vec3(0.5f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e242 = contrast_info.edges[2u];
reach = _e242;
let _e243 = depth;
let _e245 = reach;
if ((_e243 > 0f) && (_e245 > 0f)) {
let _e249 = texel[0u];
let _e250 = reach;
dx = vec2<f32>((_e249 * _e250), 0f);
let _e254 = texel[1u];
let _e255 = reach;
dy = vec2<f32>(0f, (_e254 * _e255));
let _e258 = v_uv_1;
let _e259 = dx;
let _e261 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e258 - _e259), 0f);
left = _e261;
let _e262 = v_uv_1;
let _e263 = dx;
let _e265 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e262 + _e263), 0f);
right = _e265;
let _e266 = v_uv_1;
let _e267 = dy;
let _e269 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e266 - _e267), 0f);
up = _e269;
let _e270 = v_uv_1;
let _e271 = dy;
let _e273 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e270 + _e271), 0f);
down = _e273;
let _e275 = v_uv_1[0u];
let _e277 = dx[0u];
let _e279 = ((_e275 - _e277) >= 0f);
phi_405_ = _e279;
if _e279 {
let _e281 = v_uv_1[0u];
let _e283 = dx[0u];
phi_405_ = ((_e281 + _e283) <= 1f);
}
let _e287 = phi_405_;
across = _e287;
let _e289 = v_uv_1[1u];
let _e291 = dy[1u];
let _e293 = ((_e289 - _e291) >= 0f);
phi_421_ = _e293;
if _e293 {
let _e295 = v_uv_1[1u];
let _e297 = dy[1u];
phi_421_ = ((_e295 + _e297) <= 1f);
}
let _e301 = phi_421_;
along = _e301;
let _e302 = across;
if _e302 {
let _e304 = left[3u];
param_2 = _e304;
let _e305 = depth;
param_3 = _e305;
let _e307 = right[3u];
param_4 = _e307;
let _e308 = DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_2), (¶m_3), (¶m_4));
local_3 = _e308;
} else {
local_3 = 0f;
}
let _e309 = local_3;
let _e310 = along;
if _e310 {
let _e312 = up[3u];
param_5 = _e312;
let _e313 = depth;
param_6 = _e313;
let _e315 = down[3u];
param_7 = _e315;
let _e316 = DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
local_4 = _e316;
} else {
local_4 = 0f;
}
let _e317 = local_4;
bent = max(_e309, _e317);
turned = 0f;
let _e320 = left[3u];
if (_e320 > 0f) {
let _e322 = turned;
let _e323 = left;
param_8 = _e323.xy;
let _e325 = DecodeOctahedral_u0028_vf2_u003b((¶m_8));
let _e326 = normal;
turned = max(_e322, (1f - dot(_e325, _e326)));
}
let _e331 = right[3u];
if (_e331 > 0f) {
let _e333 = turned;
let _e334 = right;
param_9 = _e334.xy;
let _e336 = DecodeOctahedral_u0028_vf2_u003b((¶m_9));
let _e337 = normal;
turned = max(_e333, (1f - dot(_e336, _e337)));
}
let _e342 = up[3u];
if (_e342 > 0f) {
let _e344 = turned;
let _e345 = up;
param_10 = _e345.xy;
let _e347 = DecodeOctahedral_u0028_vf2_u003b((¶m_10));
let _e348 = normal;
turned = max(_e344, (1f - dot(_e347, _e348)));
}
let _e353 = down[3u];
if (_e353 > 0f) {
let _e355 = turned;
let _e356 = down;
param_11 = _e356.xy;
let _e358 = DecodeOctahedral_u0028_vf2_u003b((¶m_11));
let _e359 = normal;
turned = max(_e355, (1f - dot(_e358, _e359)));
}
let _e363 = bent;
let _e364 = bend;
let _e366 = turned;
let _e367 = turn;
if ((_e363 >= _e364) || (_e366 >= _e367)) {
let _e371 = contrast_info.line;
colour = _e371.xyz;
}
}
let _e375 = contrast_info.line[3u];
ringWidth = _e375;
let _e376 = hasMask;
if _e376 {
let _e377 = v_uv_1;
let _e378 = textureSampleLevel(mask_texture_tex, mask_texture_smp, _e377, 0f);
own = _e378;
let _e380 = own[3u];
if (_e380 > 0.5f) {
let _e382 = colour;
let _e383 = own;
let _e387 = contrast_info.look[3u];
colour = mix(_e382, _e383.xyz, vec3(clamp(_e387, 0f, 1f)));
} else {
let _e391 = ringWidth;
if (_e391 > 0f) {
directions = array<vec2<f32>, 8>(vec2<f32>(1f, 0f), vec2<f32>(-1f, 0f), vec2<f32>(0f, 1f), vec2<f32>(0f, -1f), vec2<f32>(1f, 1f), vec2<f32>(-1f, 1f), vec2<f32>(1f, -1f), vec2<f32>(-1f, -1f));
found = vec4<f32>(0f, 0f, 0f, 0f);
i = 1i;
loop {
let _e393 = i;
if (_e393 <= 4i) {
let _e395 = i;
let _e397 = ringWidth;
let _e398 = (f32(_e395) <= _e397);
phi_588_ = _e398;
if _e398 {
let _e400 = found[3u];
phi_588_ = (_e400 < 0.5f);
}
let _e403 = phi_588_;
if _e403 {
d = 0i;
loop {
let _e404 = d;
if (_e404 < 8i) {
let _e406 = v_uv_1;
let _e407 = d;
let _e409 = directions[_e407];
let _e410 = texel;
let _e412 = i;
let _e416 = textureSampleLevel(mask_texture_tex, mask_texture_smp, (_e406 + ((_e409 * _e410) * f32(_e412))), 0f);
tap_1 = _e416;
let _e418 = found[3u];
let _e419 = (_e418 < 0.5f);
phi_623_ = _e419;
if _e419 {
let _e421 = tap_1[3u];
phi_623_ = (_e421 > 0.5f);
}
let _e424 = phi_623_;
if _e424 {
let _e425 = tap_1;
found = _e425;
}
continue;
} else {
break;
}
continuing {
let _e426 = d;
d = (_e426 + 1i);
}
}
}
continue;
} else {
break;
}
continuing {
let _e428 = i;
i = (_e428 + 1i);
}
}
let _e431 = found[3u];
if (_e431 > 0.5f) {
let _e433 = found;
colour = _e433.xyz;
}
}
}
}
let _e435 = colour;
let _e437 = scene[3u];
frag_color = vec4<f32>(_e435.x, _e435.y, _e435.z, _e437);
return;
}
@fragment
fn main(@location(6) 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: 'HighContrastInfo',
group: 1,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'look', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'edges',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'line', offsetInBytes: 32, sizeInBytes: 16),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'mask_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,
),
],
),
'Decal': WebGpuStage(
wgsl: r'''
struct DecalInfo {
inverse_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
view: vec4<f32>,
slots: array<vec4<f32>, 4>,
axis_x: array<vec4<f32>, 16>,
axis_y: array<vec4<f32>, 16>,
axis_z: array<vec4<f32>, 16>,
region: array<vec4<f32>, 16>,
color: array<vec4<f32>, 16>,
fade: array<vec4<f32>, 16>,
emissive: array<vec4<f32>, 16>,
}
@group(1) @binding(0)
var<uniform> decal_info: DecalInfo;
@group(1) @binding(11)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var decal_texture_3_tex: texture_2d<f32>;
@group(1) @binding(10)
var decal_texture_3_smp: sampler;
@group(1) @binding(7)
var decal_texture_2_tex: texture_2d<f32>;
@group(1) @binding(8)
var decal_texture_2_smp: sampler;
@group(1) @binding(5)
var decal_texture_1_tex: texture_2d<f32>;
@group(1) @binding(6)
var decal_texture_1_smp: sampler;
@group(1) @binding(3)
var decal_texture_0_tex: texture_2d<f32>;
@group(1) @binding(4)
var decal_texture_0_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var albedo_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var albedo_texture_smp: sampler;
fn SampleSlot_u0028_f1_u003b_vf2_u003b_f1_u003b(slot: ptr<function, f32>, uv: ptr<function, vec2<f32>>, lod: ptr<function, f32>) -> vec4<f32> {
var picture: vec4<f32>;
picture = vec4<f32>(1f, 1f, 1f, 1f);
let _e64 = (*slot);
if (_e64 > 2.5f) {
let _e66 = (*uv);
let _e67 = (*lod);
let _e68 = textureSampleLevel(decal_texture_3_tex, decal_texture_3_smp, _e66, _e67);
picture = _e68;
} else {
let _e69 = (*slot);
if (_e69 > 1.5f) {
let _e71 = (*uv);
let _e72 = (*lod);
let _e73 = textureSampleLevel(decal_texture_2_tex, decal_texture_2_smp, _e71, _e72);
picture = _e73;
} else {
let _e74 = (*slot);
if (_e74 > 0.5f) {
let _e76 = (*uv);
let _e77 = (*lod);
let _e78 = textureSampleLevel(decal_texture_1_tex, decal_texture_1_smp, _e76, _e77);
picture = _e78;
} else {
let _e79 = (*slot);
if (_e79 > -0.5f) {
let _e81 = (*uv);
let _e82 = (*lod);
let _e83 = textureSampleLevel(decal_texture_0_tex, decal_texture_0_smp, _e81, _e82);
picture = _e83;
}
}
}
}
let _e84 = picture;
return _e84;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e61 = (*srgb);
let _e64 = (*srgb);
let _e69 = (*srgb);
return mix((_e61 / vec3(12.92f)), pow(((_e64 + 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), _e69));
}
fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var inView: vec2<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 _e69 = (*uv_1);
let _e71 = decal_info.view;
let _e75 = decal_info.view;
inView = ((_e69 - _e71.xy) / _e75.zw);
let _e79 = inView[0u];
let _e83 = inView[1u];
xy = vec2<f32>(((_e79 * 2f) - 1f), (1f - (_e83 * 2f)));
let _e88 = decal_info.inverse_view_projection;
let _e89 = xy;
nearH = (_e88 * vec4<f32>(_e89.x, _e89.y, 0f, 1f));
let _e95 = decal_info.inverse_view_projection;
let _e96 = xy;
farH = (_e95 * vec4<f32>(_e96.x, _e96.y, 1f, 1f));
let _e101 = nearH;
let _e104 = nearH[3u];
origin = (_e101.xyz / vec3(_e104));
let _e107 = farH;
let _e110 = farH[3u];
let _e113 = origin;
along = normalize(((_e107.xyz / vec3(_e110)) - _e113));
let _e117 = decal_info.forward;
axis = _e117.xyz;
let _e119 = origin;
let _e120 = along;
let _e121 = (*depth);
let _e122 = origin;
let _e124 = decal_info.camera;
let _e127 = axis;
let _e130 = along;
let _e131 = axis;
return (_e119 + (_e120 * ((_e121 - dot((_e122 - _e124.xyz), _e127)) / dot(_e130, _e131))));
}
fn WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b(step_: ptr<function, vec2<f32>>, depth_1: ptr<function, f32>, at: ptr<function, vec3<f32>>) -> vec3<f32> {
var ahead: vec4<f32>;
var behind: vec4<f32>;
var aheadGap: f32;
var local: f32;
var behindGap: f32;
var local_1: f32;
var forward: vec3<f32>;
var param: vec2<f32>;
var param_1: f32;
var backward: vec3<f32>;
var param_2: vec2<f32>;
var param_3: f32;
var chosen: vec3<f32>;
let _e76 = v_uv_1;
let _e77 = (*step_);
let _e79 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e76 + _e77), 0f);
ahead = _e79;
let _e80 = v_uv_1;
let _e81 = (*step_);
let _e83 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e80 - _e81), 0f);
behind = _e83;
let _e85 = ahead[3u];
if (_e85 > 0f) {
let _e88 = ahead[3u];
let _e89 = (*depth_1);
local = abs((_e88 - _e89));
} else {
local = 1000000000000000000000000000000f;
}
let _e92 = local;
aheadGap = _e92;
let _e94 = behind[3u];
if (_e94 > 0f) {
let _e97 = behind[3u];
let _e98 = (*depth_1);
local_1 = abs((_e97 - _e98));
} else {
local_1 = 1000000000000000000000000000000f;
}
let _e101 = local_1;
behindGap = _e101;
let _e102 = v_uv_1;
let _e103 = (*step_);
param = (_e102 + _e103);
let _e106 = ahead[3u];
param_1 = _e106;
let _e107 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m), (¶m_1));
let _e108 = (*at);
forward = (_e107 - _e108);
let _e110 = (*at);
let _e111 = v_uv_1;
let _e112 = (*step_);
param_2 = (_e111 - _e112);
let _e115 = behind[3u];
param_3 = _e115;
let _e116 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_2), (¶m_3));
backward = (_e110 - _e116);
let _e118 = aheadGap;
let _e119 = behindGap;
let _e121 = forward;
let _e122 = backward;
chosen = select(_e122, _e121, vec3((_e118 <= _e119)));
let _e125 = aheadGap;
let _e126 = behindGap;
let _e129 = chosen;
return select(vec3<f32>(0f, 0f, 0f), _e129, vec3((min(_e125, _e126) < 100000000000000000000000000000f)));
}
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 _e65 = (*e);
(*e) = ((_e65 * 2f) - vec2(1f));
let _e69 = (*e);
let _e71 = (*e)[0u];
let _e75 = (*e)[1u];
n = vec3<f32>(_e69.x, _e69.y, ((1f - abs(_e71)) - abs(_e75)));
let _e82 = n[2u];
t = max(-(_e82), 0f);
let _e86 = n[0u];
if (_e86 >= 0f) {
let _e88 = t;
local_2 = -(_e88);
} else {
let _e90 = t;
local_2 = _e90;
}
let _e91 = local_2;
let _e93 = n[0u];
n[0u] = (_e93 + _e91);
let _e97 = n[1u];
if (_e97 >= 0f) {
let _e99 = t;
local_3 = -(_e99);
} else {
let _e101 = t;
local_3 = _e101;
}
let _e102 = local_3;
let _e104 = n[1u];
n[1u] = (_e104 + _e102);
let _e107 = n;
return normalize(_e107);
}
fn main_1() {
var factor: bool;
var surface: vec4<f32>;
var keepFactor: vec3<f32>;
var keepTerm: vec3<f32>;
var depth_2: f32;
var at_1: vec3<f32>;
var param_4: vec2<f32>;
var param_5: f32;
var normal: vec3<f32>;
var param_6: vec2<f32>;
var dx: vec3<f32>;
var param_7: vec2<f32>;
var param_8: f32;
var param_9: vec3<f32>;
var dy: vec3<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var param_12: vec3<f32>;
var albedo: vec3<f32>;
var param_13: vec3<f32>;
var painted: vec3<f32>;
var kept: f32;
var laid: vec3<f32>;
var emitted: vec3<f32>;
var count: i32;
var i: i32;
var rowX: vec4<f32>;
var rowY: vec4<f32>;
var rowZ: vec4<f32>;
var local_4: vec3<f32>;
var fade: vec4<f32>;
var facing: f32;
var byAngle: f32;
var byDepth: f32;
var local_5: f32;
var region: vec4<f32>;
var uv_2: vec2<f32>;
var slot_1: f32;
var size: vec2<f32>;
var alongX: vec2<f32>;
var alongY: vec2<f32>;
var footprint: f32;
var lod_1: f32;
var local_6: f32;
var picture_1: vec4<f32>;
var param_14: f32;
var param_15: vec2<f32>;
var param_16: f32;
var tint: vec4<f32>;
var colour: vec3<f32>;
var param_17: vec3<f32>;
var alpha: f32;
var named: f32;
var swap: vec3<f32>;
var multiply: vec3<f32>;
var add: vec3<f32>;
let _e118 = decal_info.params[3u];
factor = (_e118 < 0.5f);
let _e120 = v_uv_1;
let _e121 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e120, 0f);
surface = _e121;
keepFactor = vec3<f32>(1f, 1f, 1f);
keepTerm = vec3<f32>(0f, 0f, 0f);
let _e123 = surface[3u];
if (_e123 <= 0f) {
let _e125 = factor;
let _e126 = keepFactor;
let _e127 = keepTerm;
let _e129 = select(_e127, _e126, vec3(_e125));
frag_color = vec4<f32>(_e129.x, _e129.y, _e129.z, 1f);
return;
}
let _e135 = surface[3u];
depth_2 = _e135;
let _e136 = v_uv_1;
param_4 = _e136;
let _e137 = depth_2;
param_5 = _e137;
let _e138 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_4), (¶m_5));
at_1 = _e138;
let _e139 = surface;
param_6 = _e139.xy;
let _e141 = DecodeOctahedral_u0028_vf2_u003b((¶m_6));
normal = _e141;
let _e144 = decal_info.params[1u];
param_7 = vec2<f32>(_e144, 0f);
let _e146 = depth_2;
param_8 = _e146;
let _e147 = at_1;
param_9 = _e147;
let _e148 = WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b((¶m_7), (¶m_8), (¶m_9));
dx = _e148;
let _e151 = decal_info.params[2u];
param_10 = vec2<f32>(0f, _e151);
let _e153 = depth_2;
param_11 = _e153;
let _e154 = at_1;
param_12 = _e154;
let _e155 = WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b((¶m_10), (¶m_11), (¶m_12));
dy = _e155;
let _e156 = v_uv_1;
let _e157 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e156, 0f);
param_13 = _e157.xyz;
let _e159 = SrgbToLinear_u0028_vf3_u003b((¶m_13));
albedo = _e159;
let _e160 = albedo;
painted = _e160;
kept = 1f;
laid = vec3<f32>(0f, 0f, 0f);
emitted = vec3<f32>(0f, 0f, 0f);
let _e163 = decal_info.params[0u];
count = i32((_e163 + 0.5f));
i = 0i;
loop {
let _e166 = i;
if (_e166 < 16i) {
let _e168 = i;
let _e169 = count;
if (_e168 >= _e169) {
break;
}
let _e171 = i;
let _e174 = decal_info.axis_x[_e171];
rowX = _e174;
let _e175 = i;
let _e178 = decal_info.axis_y[_e175];
rowY = _e178;
let _e179 = i;
let _e182 = decal_info.axis_z[_e179];
rowZ = _e182;
let _e183 = rowX;
let _e185 = at_1;
let _e188 = rowX[3u];
let _e190 = rowY;
let _e192 = at_1;
let _e195 = rowY[3u];
let _e197 = rowZ;
let _e199 = at_1;
let _e202 = rowZ[3u];
local_4 = vec3<f32>((dot(_e183.xyz, _e185) + _e188), (dot(_e190.xyz, _e192) + _e195), (dot(_e197.xyz, _e199) + _e202));
let _e205 = local_4;
if any((abs(_e205) > vec3<f32>(0.5f, 0.5f, 0.5f))) {
continue;
}
let _e209 = i;
let _e212 = decal_info.fade[_e209];
fade = _e212;
let _e213 = normal;
let _e214 = rowY;
facing = dot(_e213, normalize(_e214.xyz));
let _e218 = facing;
let _e220 = fade[1u];
let _e223 = fade[2u];
byAngle = clamp(((_e218 - _e220) / max(_e223, 0.0001f)), 0f, 1f);
let _e228 = fade[3u];
if (_e228 > 0f) {
let _e231 = local_4[1u];
let _e235 = fade[3u];
local_5 = clamp(((0.5f - abs(_e231)) / (_e235 * 0.5f)), 0f, 1f);
} else {
local_5 = 1f;
}
let _e239 = local_5;
byDepth = _e239;
let _e240 = i;
let _e243 = decal_info.region[_e240];
region = _e243;
let _e244 = region;
let _e246 = local_4;
let _e250 = region;
uv_2 = (_e244.xy + ((_e246.xz + vec2(0.5f)) * _e250.zw));
let _e255 = fade[0u];
slot_1 = _e255;
let _e256 = slot_1;
let _e261 = decal_info.slots[i32(clamp(_e256, 0f, 3f))];
size = _e261.xy;
let _e263 = rowX;
let _e265 = dx;
let _e267 = rowZ;
let _e269 = dx;
let _e272 = region;
alongX = (vec2<f32>(dot(_e263.xyz, _e265), dot(_e267.xyz, _e269)) * _e272.zw);
let _e275 = rowX;
let _e277 = dy;
let _e279 = rowZ;
let _e281 = dy;
let _e284 = region;
alongY = (vec2<f32>(dot(_e275.xyz, _e277), dot(_e279.xyz, _e281)) * _e284.zw);
let _e288 = alongX[0u];
let _e291 = alongY[0u];
let _e295 = size[0u];
let _e298 = alongX[1u];
let _e301 = alongY[1u];
let _e305 = size[1u];
footprint = max((max(abs(_e288), abs(_e291)) * _e295), (max(abs(_e298), abs(_e301)) * _e305));
let _e308 = footprint;
if (_e308 > 1f) {
let _e310 = footprint;
local_6 = log2(_e310);
} else {
local_6 = 0f;
}
let _e312 = local_6;
lod_1 = _e312;
let _e313 = slot_1;
param_14 = _e313;
let _e314 = uv_2;
param_15 = _e314;
let _e315 = lod_1;
param_16 = _e315;
let _e316 = SampleSlot_u0028_f1_u003b_vf2_u003b_f1_u003b((¶m_14), (¶m_15), (¶m_16));
picture_1 = _e316;
let _e317 = i;
let _e320 = decal_info.color[_e317];
tint = _e320;
let _e321 = picture_1;
param_17 = _e321.xyz;
let _e323 = SrgbToLinear_u0028_vf3_u003b((¶m_17));
let _e324 = tint;
colour = (_e323 * _e324.xyz);
let _e328 = picture_1[3u];
let _e330 = tint[3u];
let _e332 = byAngle;
let _e334 = byDepth;
alpha = clamp((((_e328 * _e330) * _e332) * _e334), 0f, 1f);
let _e337 = painted;
let _e338 = colour;
let _e339 = alpha;
painted = mix(_e337, _e338, vec3(_e339));
let _e342 = alpha;
let _e344 = kept;
kept = (_e344 * (1f - _e342));
let _e346 = laid;
let _e347 = colour;
let _e348 = alpha;
laid = mix(_e346, _e347, vec3(_e348));
let _e351 = emitted;
let _e352 = colour;
let _e353 = i;
let _e356 = decal_info.emissive[_e353];
let _e359 = alpha;
emitted = mix(_e351, (_e352 * _e356.xyz), vec3(_e359));
continue;
} else {
break;
}
continuing {
let _e362 = i;
i = (_e362 + 1i);
}
}
let _e365 = albedo[0u];
let _e367 = albedo[1u];
let _e369 = albedo[2u];
named = clamp((max(_e365, max(_e367, _e369)) / 0.08f), 0f, 1f);
let _e374 = painted;
let _e375 = albedo;
let _e377 = albedo;
swap = (vec3<f32>(1f, 1f, 1f) + ((_e374 - _e375) / max(_e377, vec3<f32>(0.08f, 0.08f, 0.08f))));
let _e381 = swap;
let _e382 = named;
let _e384 = kept;
let _e385 = named;
multiply = ((_e381 * _e382) + vec3((_e384 * (1f - _e385))));
let _e390 = laid;
let _e391 = named;
let _e394 = emitted;
add = ((_e390 * (1f - _e391)) + _e394);
let _e396 = factor;
let _e397 = multiply;
let _e398 = add;
let _e400 = select(_e398, _e397, vec3(_e396));
frag_color = vec4<f32>(_e400.x, _e400.y, _e400.z, 1f);
return;
}
@fragment
fn main(@location(6) 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: 'DecalInfo',
group: 1,
binding: 0,
sizeInBytes: 1984,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 64,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 80,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 96,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'view',
offsetInBytes: 112,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 128,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'axis_x',
offsetInBytes: 192,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'axis_y',
offsetInBytes: 448,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'axis_z',
offsetInBytes: 704,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'region',
offsetInBytes: 960,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'color',
offsetInBytes: 1216,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'fade',
offsetInBytes: 1472,
sizeInBytes: 256,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 1728,
sizeInBytes: 256,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'albedo_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'decal_texture_0',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'decal_texture_1',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'decal_texture_2',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'decal_texture_3',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
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(6) 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,
),
],
),
'RenderTextureEncode': WebGpuStage(
wgsl: r'''
struct RenderTextureInfo {
params: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> encode_info: RenderTextureInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e22 = (*linear);
let _e24 = (*linear);
let _e29 = (*linear);
return mix((_e22 * 12.92f), ((pow(max(_e24, 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), _e29));
}
fn main_1() {
var uv: vec2<f32>;
var light: vec3<f32>;
var param: vec3<f32>;
let _e24 = v_uv_1;
uv = _e24;
let _e27 = encode_info.params[1u];
if (_e27 > 0.5f) {
let _e30 = uv[1u];
uv[1u] = (1f - _e30);
}
let _e33 = uv;
let _e34 = textureSampleLevel(source_texture_tex, source_texture_smp, _e33, 0f);
let _e38 = encode_info.params[0u];
light = (_e34.xyz * _e38);
let _e40 = light;
param = clamp(_e40, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e42 = LinearToSrgb_u0028_vf3_u003b((¶m));
frag_color = vec4<f32>(_e42.x, _e42.y, _e42.z, 1f);
return;
}
@fragment
fn main(@location(6) 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: 'RenderTextureInfo',
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,
),
],
),
'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;
var<private> g_pass_through: f32;
@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;
g_pass_through = 0f;
let _e25 = shadow_light.light[3u];
range = max(_e25, 0.0001f);
let _e27 = v_world_position_1;
let _e29 = shadow_light.light;
distance_ = length((_e27 - _e29.xyz));
let _e33 = distance_;
let _e34 = range;
frag_color = vec4<f32>(clamp((_e33 / _e34), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) 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;
var<private> g_pass_through: f32;
@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;
g_pass_through = 0f;
let _e27 = v_texcoord_1;
let _e28 = textureSample(base_color_texture_tex, base_color_texture_smp, _e27);
let _e32 = mask_info.mask[1u];
alpha = (_e28.w * _e32);
let _e34 = alpha;
let _e37 = mask_info.mask[0u];
if (_e34 < _e37) {
discard;
}
let _e40 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e40, 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) 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;
var<private> g_pass_through: f32;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(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;
g_pass_through = 0f;
let _e29 = v_texcoord_1;
let _e30 = textureSample(base_color_texture_tex, base_color_texture_smp, _e29);
let _e34 = mask_info.mask[1u];
alpha = (_e30.w * _e34);
let _e36 = alpha;
let _e39 = mask_info.mask[0u];
if (_e36 < _e39) {
discard;
}
let _e43 = shadow_light.light[3u];
range = max(_e43, 0.0001f);
let _e45 = v_world_position_1;
let _e47 = shadow_light.light;
distance_ = length((_e45 - _e47.xyz));
let _e51 = distance_;
let _e52 = range;
frag_color = vec4<f32>(clamp((_e51 / _e52), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) 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,
),
],
),
'CausticSurface': 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> g_pass_through: f32;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_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;
g_pass_through = 0f;
let _e18 = v_normal_1;
let _e19 = normalize(_e18);
let _e21 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e19.x, _e19.y, _e19.z, _e21);
return;
}
@fragment
fn main(@location(3) v_normal: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_normal_1 = v_normal;
gl_FragCoord_1 = gl_FragCoord;
v_world_position_1 = v_world_position;
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>[],
),
'CausticPhoton': WebGpuStage(
wgsl: r'''
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var r2_: f32;
var k: f32;
var e: vec3<f32>;
let _e11 = v_uv_1;
let _e12 = v_uv_1;
r2_ = dot(_e11, _e12);
let _e14 = r2_;
if (_e14 >= 1f) {
discard;
}
let _e16 = r2_;
let _e18 = r2_;
k = ((1f - _e16) * (1f - _e18));
let _e21 = v_color_1;
let _e23 = k;
e = (_e21.xyz * _e23);
let _e26 = e[0u];
let _e28 = e[1u];
let _e30 = e[2u];
frag_color = vec4<f32>(0f, _e26, _e28, _e30);
return;
}
@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_color_1 = v_color;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'ShadowTransmittance': WebGpuStage(
wgsl: r'''
struct TransmittanceInfo {
color: vec4<f32>,
light: vec4<f32>,
params: 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_pass_through: f32;
@group(1) @binding(0)
var<uniform> transmittance_info: TransmittanceInfo;
@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_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_world_position_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 opacity: f32;
var transmission: f32;
var tint: vec3<f32>;
var body: vec3<f32>;
var facing: f32;
var f0_: f32;
var fresnel: f32;
var lost: f32;
var through: vec3<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_pass_through = 0f;
let _e41 = transmittance_info.color[3u];
opacity = clamp(_e41, 0f, 1f);
let _e45 = transmittance_info.params[0u];
transmission = clamp(_e45, 0f, 1f);
let _e48 = transmittance_info.color;
let _e51 = v_texcoord_1;
let _e52 = textureSample(base_color_texture_tex, base_color_texture_smp, _e51);
tint = (max(_e48.xyz, vec3<f32>(0f, 0f, 0f)) * _e52.xyz);
let _e55 = opacity;
let _e58 = opacity;
let _e59 = transmission;
let _e61 = tint;
body = (vec3((1f - _e55)) + (_e61 * (_e58 * _e59)));
let _e64 = v_normal_1;
let _e67 = transmittance_info.light;
facing = clamp(abs(dot(normalize(_e64), _e67.xyz)), 0f, 1f);
let _e74 = transmittance_info.params[1u];
f0_ = clamp(_e74, 0f, 1f);
let _e76 = f0_;
let _e77 = f0_;
let _e79 = facing;
fresnel = (_e76 + ((1f - _e77) * pow((1f - _e79), 5f)));
let _e84 = fresnel;
let _e85 = facing;
let _e87 = facing;
lost = (_e84 * min(((2f * _e85) * _e87), 1f));
let _e91 = body;
let _e94 = lost;
through = (sqrt(max(_e91, vec3<f32>(0f, 0f, 0f))) * (1f - _e94));
let _e99 = transmittance_info.params[2u];
if (_e99 > 0.5f) {
through = vec3<f32>(0f, 0f, 0f);
}
let _e102 = through[0u];
let _e105 = through[1u];
let _e108 = through[2u];
frag_color = vec4<f32>(0f, (1f - _e102), (1f - _e105), _e108);
return;
}
@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(3) v_normal: vec3<f32>, @location(7) v_world_position: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
v_normal_1 = v_normal;
v_world_position_1 = v_world_position;
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: 'TransmittanceInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'color', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'light',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
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 mode: f32;
var nothing: f32;
var depth: f32;
var local: f32;
var phi_40_: bool;
let _e24 = v_uv_1;
let _e26 = copy_info.shift;
from_ = (_e24 - _e26.xy);
let _e29 = from_;
let _e31 = all((_e29 >= vec2<f32>(0f, 0f)));
phi_40_ = _e31;
if _e31 {
let _e32 = from_;
phi_40_ = all((_e32 <= vec2<f32>(1f, 1f)));
}
let _e36 = phi_40_;
inside = _e36;
let _e38 = copy_info.tile;
let _e40 = from_;
let _e45 = copy_info.tile;
let _e49 = textureSampleLevel(static_shadow_texture_tex, static_shadow_texture_smp, (_e38.xy + (clamp(_e40, vec2(0f), vec2(1f)) * _e45.zw)), 0f);
stored = _e49.x;
let _e53 = copy_info.shift[3u];
mode = _e53;
let _e54 = mode;
nothing = select(1f, 0f, (_e54 > 0.5f));
let _e57 = inside;
let _e58 = stored;
let _e59 = nothing;
if (_e57 && (_e58 != _e59)) {
let _e62 = stored;
let _e65 = copy_info.shift[2u];
local = clamp((_e62 + _e65), 0f, 1f);
} else {
let _e68 = nothing;
local = _e68;
}
let _e69 = local;
depth = _e69;
let _e70 = mode;
if (_e70 > 1.5f) {
let _e72 = depth;
depth = (1f - _e72);
}
let _e74 = depth;
frag_color = vec4<f32>(_e74, 0f, 0f, 1f);
let _e76 = depth;
gl_FragDepth = _e76;
return;
}
@fragment
fn main(@location(6) 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 ShadowStored_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
var local: f32;
let _e25 = (*mode);
if (_e25 > 0.5f) {
let _e27 = (*stored);
local = (1f - _e27);
} else {
let _e29 = (*stored);
local = _e29;
}
let _e30 = local;
return _e30;
}
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_1: vec4<f32>;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var weight: f32;
let _e43 = evsm_info.tile[0u];
count = max(_e43, 1f);
let _e46 = v_uv_1[0u];
let _e47 = count;
let _e50 = count;
which = min(floor((_e46 * _e47)), (_e50 - 1f));
let _e53 = which;
let _e54 = count;
let _e58 = evsm_info.tile[1u];
let _e62 = evsm_info.tile[2u];
lo = vec2<f32>(((_e53 / _e54) + _e58), _e62);
let _e64 = which;
let _e66 = count;
let _e70 = evsm_info.tile[1u];
let _e74 = evsm_info.tile[2u];
hi = vec2<f32>((((_e64 + 1f) / _e66) - _e70), (1f - _e74));
let _e79 = evsm_info.axis[2u];
taps = clamp(_e79, 0f, 8f);
let _e81 = taps;
sigma = max((_e81 * 0.5f), 0.5f);
let _e86 = evsm_info.axis[3u];
warp = (_e86 > 0.5f);
total = vec4<f32>(0f, 0f, 0f, 0f);
weightSum = 0f;
i = -8i;
loop {
let _e88 = i;
if (_e88 <= 8i) {
let _e90 = i;
offset = f32(_e90);
let _e92 = offset;
let _e94 = taps;
if (abs(_e92) > _e94) {
continue;
}
let _e96 = v_uv_1;
let _e98 = evsm_info.axis;
let _e100 = offset;
let _e103 = lo;
let _e104 = hi;
at = clamp((_e96 + (_e98.xy * _e100)), _e103, _e104);
let _e106 = at;
let _e107 = textureSampleLevel(evsm_source_tex, evsm_source_smp, _e106, 0f);
texel = _e107;
let _e108 = warp;
if _e108 {
let _e110 = texel[0u];
param_1 = _e110;
let _e113 = evsm_info.tile[3u];
param_2 = _e113;
let _e114 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_1), (¶m_2));
param_3 = _e114;
let _e115 = EvsmMoments_u0028_f1_u003b((¶m_3));
local_1 = _e115;
} else {
let _e116 = texel;
local_1 = _e116;
}
let _e117 = local_1;
value = _e117;
let _e118 = offset;
let _e119 = offset;
let _e122 = sigma;
let _e124 = sigma;
weight = exp((-((_e118 * _e119)) / ((2f * _e122) * _e124)));
let _e128 = value;
let _e129 = weight;
let _e131 = total;
total = (_e131 + (_e128 * _e129));
let _e133 = weight;
let _e134 = weightSum;
weightSum = (_e134 + _e133);
continue;
} else {
break;
}
continuing {
let _e136 = i;
i = (_e136 + 1i);
}
}
let _e138 = total;
let _e139 = weightSum;
frag_color = (_e138 / vec4(_e139));
return;
}
@fragment
fn main(@location(6) 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(6) 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(6) v_ray: vec3<f32>, @location(11) v_zenith: vec4<f32>, @location(4) v_nadir: vec4<f32>, @location(2) v_horizon: vec4<f32>, @location(9) 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(6) v_ray: vec3<f32>, @location(10) 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,
),
],
),
'SkyPhysical': WebGpuStage(
wgsl: r'''
var<private> v_rayleigh_1: vec4<f32>;
var<private> v_mie_1: vec4<f32>;
var<private> v_planet_1: vec4<f32>;
var<private> v_stars_1: vec4<f32>;
var<private> v_ray_1: vec3<f32>;
var<private> v_sun_1: vec4<f32>;
var<private> v_disc_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn Hash_u0028_vf3_u003b(p: ptr<function, vec3<f32>>) -> f32 {
let _e53 = (*p);
(*p) = fract((_e53 * 0.1031f));
let _e56 = (*p);
let _e57 = (*p);
let _e62 = (*p);
(*p) = (_e62 + vec3(dot(_e56, (_e57.zyx + vec3(31.32f)))));
let _e66 = (*p)[0u];
let _e68 = (*p)[1u];
let _e71 = (*p)[2u];
return fract(((_e66 + _e68) * _e71));
}
fn StarField_u0028_vf3_u003b(d: ptr<function, vec3<f32>>) -> f32 {
var a: vec3<f32>;
var face: f32;
var uv: vec2<f32>;
var grid: vec2<f32>;
var cell: vec2<f32>;
var key: vec3<f32>;
var param: vec3<f32>;
var centre: vec2<f32>;
var param_1: vec3<f32>;
var param_2: vec3<f32>;
var off: f32;
var magnitude: f32;
var param_3: vec3<f32>;
var phi_279_: bool;
let _e66 = (*d);
a = abs(_e66);
let _e69 = a[0u];
let _e71 = a[1u];
let _e72 = (_e69 >= _e71);
phi_279_ = _e72;
if _e72 {
let _e74 = a[0u];
let _e76 = a[2u];
phi_279_ = (_e74 >= _e76);
}
let _e79 = phi_279_;
if _e79 {
let _e81 = (*d)[0u];
face = select(1f, 0f, (_e81 > 0f));
let _e84 = (*d);
let _e87 = a[0u];
uv = (_e84.zy / vec2(_e87));
} else {
let _e91 = a[1u];
let _e93 = a[2u];
if (_e91 >= _e93) {
let _e96 = (*d)[1u];
face = select(3f, 2f, (_e96 > 0f));
let _e99 = (*d);
let _e102 = a[1u];
uv = (_e99.xz / vec2(_e102));
} else {
let _e106 = (*d)[2u];
face = select(5f, 4f, (_e106 > 0f));
let _e109 = (*d);
let _e112 = a[2u];
uv = (_e109.xy / vec2(_e112));
}
}
let _e115 = uv;
let _e120 = v_stars_1[2u];
grid = (((_e115 * 0.5f) + vec2(0.5f)) * _e120);
let _e122 = grid;
cell = floor(_e122);
let _e124 = cell;
let _e125 = face;
key = vec3<f32>(_e124.x, _e124.y, _e125);
let _e129 = key;
param = _e129;
let _e130 = Hash_u0028_vf3_u003b((¶m));
let _e132 = v_stars_1[1u];
if (_e130 >= _e132) {
return 0f;
}
let _e134 = key;
param_1 = (_e134 + vec3<f32>(17f, 0f, 0f));
let _e136 = Hash_u0028_vf3_u003b((¶m_1));
let _e137 = key;
param_2 = (_e137 + vec3<f32>(0f, 29f, 0f));
let _e139 = Hash_u0028_vf3_u003b((¶m_2));
centre = ((vec2<f32>(_e136, _e139) * 0.6f) + vec2(0.2f));
let _e144 = grid;
let _e145 = cell;
let _e147 = centre;
off = length(((_e144 - _e145) - _e147));
let _e150 = key;
param_3 = (_e150 + vec3<f32>(0f, 0f, 13f));
let _e152 = Hash_u0028_vf3_u003b((¶m_3));
magnitude = _e152;
let _e153 = off;
let _e156 = magnitude;
let _e158 = magnitude;
let _e160 = magnitude;
return ((1f - smoothstep(0f, 0.35f, _e153)) * (0.15f + (((0.85f * _e156) * _e158) * _e160)));
}
fn Through_u0028_vf3_u003b(air: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e53 = v_rayleigh_1;
let _e56 = (*air)[0u];
let _e59 = v_mie_1[1u];
let _e61 = (*air)[1u];
let _e66 = v_stars_1[3u];
let _e68 = (*air)[2u];
return exp(-((((_e53.xyz * _e56) + vec3((_e59 * _e61))) + (vec3<f32>(0.00065f, 0.001881f, 0.000085f) * (_e66 * _e68)))));
}
fn OzoneDensity_u0028_f1_u003b(h: ptr<function, f32>) -> f32 {
let _e53 = (*h);
return max(0f, (1f - (abs((_e53 - 25f)) / 15f)));
}
fn AirAt_u0028_f1_u003b(h_1: ptr<function, f32>) -> vec3<f32> {
var param_4: f32;
let _e54 = (*h_1);
let _e57 = v_rayleigh_1[3u];
let _e59 = v_mie_1[2u];
let _e63 = exp((vec2(-(_e54)) / vec2<f32>(_e57, _e59)));
let _e64 = (*h_1);
param_4 = _e64;
let _e65 = OzoneDensity_u0028_f1_u003b((¶m_4));
return vec3<f32>(_e63.x, _e63.y, _e65);
}
fn Leave_u0028_f1_u003b_f1_u003b_f1_u003b(r: ptr<function, f32>, mu: ptr<function, f32>, radius: ptr<function, f32>) -> f32 {
var b: f32;
var d_1: f32;
var local: f32;
let _e58 = (*r);
let _e59 = (*mu);
b = (_e58 * _e59);
let _e61 = b;
let _e62 = b;
let _e64 = (*r);
let _e65 = (*radius);
let _e67 = (*r);
let _e68 = (*radius);
d_1 = ((_e61 * _e62) - ((_e64 - _e65) * (_e67 + _e68)));
let _e72 = d_1;
if (_e72 < 0f) {
local = -1f;
} else {
let _e74 = b;
let _e76 = d_1;
local = (-(_e74) + sqrt(_e76));
}
let _e79 = local;
return _e79;
}
fn SunwardAir_u0028_vf3_u003b_vf3_u003b(p_1: ptr<function, vec3<f32>>, s: ptr<function, vec3<f32>>) -> vec3<f32> {
var r_1: f32;
var span: f32;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var stride: f32;
var air_1: vec3<f32>;
var j: i32;
var q: vec3<f32>;
var param_8: f32;
let _e64 = (*p_1);
r_1 = length(_e64);
let _e66 = (*p_1);
let _e67 = (*s);
let _e69 = r_1;
let _e71 = r_1;
param_5 = _e71;
param_6 = (dot(_e66, _e67) / _e69);
let _e73 = v_planet_1[1u];
param_7 = _e73;
let _e74 = Leave_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
span = _e74;
let _e75 = span;
stride = (_e75 / 8f);
air_1 = vec3<f32>(0f, 0f, 0f);
j = 0i;
loop {
let _e77 = j;
if (_e77 < 8i) {
let _e79 = (*p_1);
let _e80 = (*s);
let _e81 = j;
let _e84 = stride;
q = (_e79 + (_e80 * ((f32(_e81) + 0.5f) * _e84)));
let _e88 = q;
let _e91 = v_planet_1[0u];
param_8 = (length(_e88) - _e91);
let _e93 = AirAt_u0028_f1_u003b((¶m_8));
let _e94 = stride;
let _e96 = air_1;
air_1 = (_e96 + (_e93 * _e94));
continue;
} else {
break;
}
continuing {
let _e98 = j;
j = (_e98 + 1i);
}
}
let _e100 = air_1;
return _e100;
}
fn Meet_u0028_f1_u003b_f1_u003b_f1_u003b(r_2: ptr<function, f32>, mu_1: ptr<function, f32>, radius_1: ptr<function, f32>) -> f32 {
var b_1: f32;
var d_2: f32;
var local_1: f32;
let _e58 = (*r_2);
let _e59 = (*mu_1);
b_1 = (_e58 * _e59);
let _e61 = b_1;
let _e62 = b_1;
let _e64 = (*r_2);
let _e65 = (*radius_1);
let _e67 = (*r_2);
let _e68 = (*radius_1);
d_2 = ((_e61 * _e62) - ((_e64 - _e65) * (_e67 + _e68)));
let _e72 = d_2;
if (_e72 < 0f) {
local_1 = -1f;
} else {
let _e74 = b_1;
let _e76 = d_2;
local_1 = (-(_e74) - sqrt(_e76));
}
let _e79 = local_1;
return _e79;
}
fn main_1() {
var d_3: vec3<f32>;
var s_1: vec3<f32>;
var eye: vec3<f32>;
var ground: f32;
var param_9: f32;
var param_10: f32;
var param_11: f32;
var grounded: bool;
var span_1: f32;
var local_2: f32;
var param_12: f32;
var param_13: f32;
var param_14: f32;
var seenAir: vec3<f32>;
var molecules: vec3<f32>;
var haze: vec3<f32>;
var i: i32;
var a0_: f32;
var a1_: f32;
var t: f32;
var stride_1: f32;
var p_2: vec3<f32>;
var r_3: f32;
var air_2: vec3<f32>;
var param_15: f32;
var param_16: f32;
var param_17: f32;
var param_18: f32;
var through: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec3<f32>;
var param_21: vec3<f32>;
var mu_2: f32;
var g: f32;
var gg: f32;
var rayleighPhase: f32;
var miePhase: f32;
var colour: vec3<f32>;
var seen: vec3<f32>;
var param_22: vec3<f32>;
var p_3: vec3<f32>;
var lit: f32;
var param_23: vec3<f32>;
var param_24: vec3<f32>;
var param_25: vec3<f32>;
var disc: f32;
var local_3: f32;
var night: f32;
var param_26: vec3<f32>;
let _e101 = v_ray_1;
d_3 = normalize(_e101);
let _e103 = v_sun_1;
s_1 = _e103.xyz;
let _e106 = v_planet_1[2u];
eye = vec3<f32>(0f, _e106, 0f);
let _e109 = v_planet_1[2u];
param_9 = _e109;
let _e111 = d_3[1u];
param_10 = _e111;
let _e113 = v_planet_1[0u];
param_11 = _e113;
let _e114 = Meet_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_9), (¶m_10), (¶m_11));
ground = _e114;
let _e115 = ground;
grounded = (_e115 > 0f);
let _e117 = grounded;
if _e117 {
let _e118 = ground;
local_2 = _e118;
} else {
let _e120 = v_planet_1[2u];
param_12 = _e120;
let _e122 = d_3[1u];
param_13 = _e122;
let _e124 = v_planet_1[1u];
param_14 = _e124;
let _e125 = Leave_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14));
local_2 = _e125;
}
let _e126 = local_2;
span_1 = _e126;
seenAir = vec3<f32>(0f, 0f, 0f);
molecules = vec3<f32>(0f, 0f, 0f);
haze = vec3<f32>(0f, 0f, 0f);
i = 0i;
loop {
let _e127 = i;
if (_e127 < 16i) {
let _e129 = i;
a0_ = (f32(_e129) / 16f);
let _e132 = i;
a1_ = (f32((_e132 + 1i)) / 16f);
let _e136 = span_1;
let _e138 = a0_;
let _e139 = a0_;
let _e141 = a1_;
let _e142 = a1_;
t = ((_e136 * 0.5f) * ((_e138 * _e139) + (_e141 * _e142)));
let _e146 = span_1;
let _e147 = a1_;
let _e148 = a1_;
let _e150 = a0_;
let _e151 = a0_;
stride_1 = (_e146 * ((_e147 * _e148) - (_e150 * _e151)));
let _e155 = eye;
let _e156 = d_3;
let _e157 = t;
p_2 = (_e155 + (_e156 * _e157));
let _e160 = p_2;
r_3 = length(_e160);
let _e162 = r_3;
let _e164 = v_planet_1[0u];
param_15 = (_e162 - _e164);
let _e166 = AirAt_u0028_f1_u003b((¶m_15));
let _e167 = stride_1;
air_2 = (_e166 * _e167);
let _e169 = air_2;
let _e170 = seenAir;
seenAir = (_e170 + _e169);
let _e172 = p_2;
let _e173 = s_1;
let _e175 = r_3;
let _e177 = r_3;
param_16 = _e177;
param_17 = (dot(_e172, _e173) / _e175);
let _e179 = v_planet_1[0u];
param_18 = _e179;
let _e180 = Meet_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18));
if (_e180 > 0f) {
continue;
}
let _e182 = seenAir;
let _e183 = air_2;
let _e186 = p_2;
param_19 = _e186;
let _e187 = s_1;
param_20 = _e187;
let _e188 = SunwardAir_u0028_vf3_u003b_vf3_u003b((¶m_19), (¶m_20));
param_21 = ((_e182 - (_e183 * 0.5f)) + _e188);
let _e190 = Through_u0028_vf3_u003b((¶m_21));
through = _e190;
let _e192 = air_2[0u];
let _e193 = through;
let _e195 = molecules;
molecules = (_e195 + (_e193 * _e192));
let _e198 = air_2[1u];
let _e199 = through;
let _e201 = haze;
haze = (_e201 + (_e199 * _e198));
continue;
} else {
break;
}
continuing {
let _e203 = i;
i = (_e203 + 1i);
}
}
let _e205 = d_3;
let _e206 = s_1;
mu_2 = dot(_e205, _e206);
let _e209 = v_mie_1[3u];
g = _e209;
let _e210 = g;
let _e211 = g;
gg = (_e210 * _e211);
let _e213 = mu_2;
let _e214 = mu_2;
rayleighPhase = (0.059683103f * (1f + (_e213 * _e214)));
let _e218 = gg;
let _e220 = mu_2;
let _e221 = mu_2;
let _e226 = gg;
let _e228 = gg;
let _e230 = g;
let _e232 = mu_2;
miePhase = ((0.119366206f * ((1f - _e218) * (1f + (_e220 * _e221)))) / ((2f + _e226) * pow(((1f + _e228) - ((2f * _e230) * _e232)), 1.5f)));
let _e239 = v_sun_1[3u];
let _e240 = molecules;
let _e241 = v_rayleigh_1;
let _e244 = rayleighPhase;
let _e246 = haze;
let _e248 = v_mie_1[0u];
let _e249 = miePhase;
colour = ((((_e240 * _e241.xyz) * _e244) + (_e246 * (_e248 * _e249))) * _e239);
let _e254 = seenAir;
param_22 = _e254;
let _e255 = Through_u0028_vf3_u003b((¶m_22));
seen = _e255;
let _e256 = grounded;
if _e256 {
let _e257 = eye;
let _e258 = d_3;
let _e259 = span_1;
p_3 = (_e257 + (_e258 * _e259));
let _e262 = p_3;
let _e264 = s_1;
lit = dot(normalize(_e262), _e264);
let _e266 = lit;
if (_e266 > 0f) {
let _e268 = seen;
let _e269 = p_3;
param_23 = _e269;
let _e270 = s_1;
param_24 = _e270;
let _e271 = SunwardAir_u0028_vf3_u003b_vf3_u003b((¶m_23), (¶m_24));
param_25 = _e271;
let _e272 = Through_u0028_vf3_u003b((¶m_25));
let _e275 = v_planet_1[3u];
let _e277 = lit;
let _e280 = v_sun_1[3u];
let _e283 = colour;
colour = (_e283 + ((_e268 * _e272) * (((_e275 / 3.1415927f) * _e277) * _e280)));
}
} else {
let _e286 = v_disc_1[1u];
if (_e286 > 0f) {
let _e289 = v_disc_1[0u];
let _e291 = v_disc_1[1u];
let _e294 = v_disc_1[0u];
let _e295 = mu_2;
local_3 = smoothstep((_e289 - _e291), _e294, _e295);
} else {
let _e298 = v_disc_1[0u];
let _e299 = mu_2;
local_3 = step(_e298, _e299);
}
let _e301 = local_3;
disc = _e301;
let _e302 = seen;
let _e303 = disc;
let _e305 = v_disc_1[2u];
let _e308 = colour;
colour = (_e308 + (_e302 * (_e303 * _e305)));
let _e311 = s_1[1u];
night = (1f - smoothstep(-0.2f, 0.1f, _e311));
let _e315 = v_stars_1[0u];
let _e317 = night;
if ((_e315 > 0f) && (_e317 > 0f)) {
let _e320 = seen;
let _e322 = v_stars_1[0u];
let _e323 = night;
let _e325 = d_3;
param_26 = _e325;
let _e326 = StarField_u0028_vf3_u003b((¶m_26));
let _e329 = colour;
colour = (_e329 + (_e320 * ((_e322 * _e323) * _e326)));
}
}
let _e331 = colour;
frag_color = vec4<f32>(_e331.x, _e331.y, _e331.z, 1f);
return;
}
@fragment
fn main(@location(7) v_rayleigh: vec4<f32>, @location(3) v_mie: vec4<f32>, @location(5) v_planet: vec4<f32>, @location(8) v_stars: vec4<f32>, @location(6) v_ray: vec3<f32>, @location(9) v_sun: vec4<f32>, @location(0) v_disc: vec4<f32>) -> @location(0) vec4<f32> {
v_rayleigh_1 = v_rayleigh;
v_mie_1 = v_mie;
v_planet_1 = v_planet;
v_stars_1 = v_stars;
v_ray_1 = v_ray;
v_sun_1 = v_sun;
v_disc_1 = v_disc;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'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(6) 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(6) 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;
var<private> g_pass_through: f32;
@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;
g_pass_through = 0f;
let _e29 = id_info.mask[0u];
cutoff = _e29;
let _e30 = cutoff;
if (_e30 >= 0f) {
let _e32 = v_texcoord_1;
let _e33 = textureSample(base_color_texture_tex, base_color_texture_smp, _e32);
let _e37 = id_info.mask[1u];
let _e40 = v_color_1[3u];
alpha = ((_e33.w * _e37) * _e40);
let _e42 = alpha;
let _e43 = cutoff;
if (_e42 < _e43) {
discard;
}
}
let _e46 = id_info.id;
let _e47 = _e46.xyz;
frag_color = vec4<f32>(_e47.x, _e47.y, _e47.z, 1f);
return;
}
@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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(6) 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(6) 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(6) 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(6) 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>,
projection: 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>,
debug_view: 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_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
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;
var<private> v_tangent_1: vec4<f32>;
@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_lightmap_uv_1: vec2<f32>;
fn ViewDepth_u0028_() -> f32 {
let _e209 = v_world_position_1;
let _e211 = fog_info.eye;
let _e215 = fog_info.forward;
return dot((_e209 - _e211.xyz), _e215.xyz);
}
fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
var z: f32;
var near: f32;
var far: f32;
var far3_: f32;
let _e214 = ViewDepth_u0028_();
z = abs(_e214);
let _e216 = z;
near = (_e216 / 5f);
let _e218 = z;
far = (_e218 / 200f);
let _e220 = far;
let _e221 = far;
let _e223 = far;
far3_ = ((_e220 * _e221) * _e223);
let _e225 = (*alpha);
let _e226 = near;
let _e227 = near;
let _e230 = far3_;
let _e231 = far3_;
return (_e225 * clamp((10f / ((0.00001f + (_e226 * _e227)) + (_e230 * _e231))), 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 _e218 = fog_info.forward[3u];
mode = _e218;
let _e219 = mode;
if (_e219 > 0.5f) {
let _e222 = frag_color[3u];
alpha_1 = _e222;
let _e223 = alpha_1;
param = _e223;
let _e224 = WeightedBlendedWeight_u0028_f1_u003b((¶m));
weight = _e224;
let _e225 = frag_color;
let _e227 = weight;
let _e228 = (_e225.xyz * _e227);
let _e229 = alpha_1;
let _e230 = weight;
accumulate = vec4<f32>(_e228.x, _e228.y, _e228.z, (_e229 * _e230));
let _e236 = mode;
let _e238 = mode;
revealage = ((_e236 > 1.5f) && (_e238 < 2.5f));
let _e241 = revealage;
if _e241 {
let _e242 = alpha_1;
local = vec4(_e242);
} else {
let _e244 = accumulate;
local = _e244;
}
let _e245 = local;
frag_color = _e245;
let _e246 = mode;
if (_e246 > 2.5f) {
let _e248 = alpha_1;
frag_surface = vec4(_e248);
}
}
return;
}
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e212 = (*n)[0u];
let _e215 = (*n)[1u];
let _e219 = (*n)[2u];
let _e222 = (*n);
(*n) = (_e222 / vec3(((abs(_e212) + abs(_e215)) + abs(_e219))));
let _e225 = (*n);
e = _e225.xy;
let _e228 = (*n)[2u];
if (_e228 < 0f) {
let _e230 = (*n);
let _e236 = (*n)[0u];
let _e240 = (*n)[1u];
e = ((vec2(1f) - abs(_e230.yx)) * vec2<f32>(select(-1f, 1f, (_e236 >= 0f)), select(-1f, 1f, (_e240 >= 0f))));
}
let _e245 = e;
return ((_e245 * 0.5f) + vec2(0.5f));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e210 = (*linear);
let _e212 = (*linear);
let _e216 = (*linear);
return mix((_e210 * 12.92f), ((pow(_e212, 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), _e216));
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param_1: vec3<f32>;
var geometric: vec3<f32>;
var param_2: vec3<f32>;
let _e213 = g_albedo;
param_1 = clamp(_e213, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e215 = LinearToSrgb_u0028_vf3_u003b((¶m_1));
frag_albedo = vec4<f32>(_e215.x, _e215.y, _e215.z, 1f);
let _e220 = g_debug_surface_on;
if _e220 {
let _e221 = g_debug_surface;
let _e222 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e221.x, _e221.y, _e221.z, _e222);
return;
}
let _e227 = v_normal_1;
geometric = normalize(_e227);
let _e229 = gl_FrontFacing_1;
if !(_e229) {
let _e231 = geometric;
geometric = -(_e231);
}
let _e233 = geometric;
param_2 = _e233;
let _e234 = EncodeOctahedral_u0028_vf3_u003b((¶m_2));
let _e235 = (*roughness);
let _e237 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e234.x, _e234.y, clamp(_e235, 0f, 1f), _e237);
return;
}
fn Orthographic_u0028_() -> bool {
let _e211 = fog_info.projection[0u];
return (_e211 > 0.5f);
}
fn EyeDistance_u0028_() -> f32 {
var local_1: f32;
let _e210 = Orthographic_u0028_();
if _e210 {
let _e211 = ViewDepth_u0028_();
local_1 = max(_e211, 0f);
} else {
let _e213 = v_world_position_1;
let _e215 = fog_info.eye;
local_1 = distance(_e213, _e215.xyz);
}
let _e218 = local_1;
return _e218;
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
var falloff: f32;
var k: f32;
var local_2: f32;
let _e217 = fog_info.fog[3u];
density = _e217;
let _e218 = density;
if (_e218 <= 0f) {
let _e220 = (*color);
return _e220;
}
let _e221 = EyeDistance_u0028_();
d = _e221;
let _e224 = fog_info.eye[3u];
falloff = _e224;
let _e225 = falloff;
if (_e225 > 0f) {
let _e227 = falloff;
let _e229 = v_world_position_1[1u];
let _e232 = fog_info.eye[1u];
k = (_e227 * (_e229 - _e232));
let _e235 = k;
if (abs(_e235) > 0.001f) {
let _e238 = k;
let _e242 = k;
local_2 = ((1f - exp(-(_e238))) / _e242);
} else {
let _e244 = k;
local_2 = (1f - (0.5f * _e244));
}
let _e247 = local_2;
let _e248 = density;
density = (_e248 * _e247);
}
let _e251 = fog_info.fog;
let _e253 = (*color);
let _e254 = density;
let _e256 = d;
return mix(_e251.xyz, _e253, vec3(clamp(exp((-(_e254) * _e256)), 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 _e215 = g_premultiply;
let _e216 = (*alpha_2);
weight_1 = select(1f, _e216, _e215);
let _e218 = (*linearColor);
param_3 = _e218;
let _e219 = ApplyFog_u0028_vf3_u003b((¶m_3));
let _e220 = weight_1;
let _e221 = (_e219 * _e220);
let _e222 = (*alpha_2);
let _e223 = g_pass_through;
frag_color = vec4<f32>(_e221.x, _e221.y, _e221.z, (_e222 * (1f - _e223)));
let _e230 = (*roughness_1);
param_4 = _e230;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_4));
WriteWeightedBlended_u0028_();
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e210 = (*srgb);
let _e213 = (*srgb);
let _e218 = (*srgb);
return mix((_e210 / vec3(12.92f)), pow(((_e213 + 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), _e218));
}
fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
var hue: f32;
var k_1: vec3<f32>;
let _e212 = (*key);
hue = fract(((_e212 * 0.618034f) + 0.13f));
let _e216 = hue;
k_1 = clamp((abs(((fract((vec3(_e216) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
let _e229 = k_1;
return (mix(vec3<f32>(1f, 1f, 1f), _e229, vec3(0.7f)) * 0.95f);
}
fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
var phi_2854_: bool;
let _e210 = (*c);
let _e211 = (*c);
let _e213 = any((_e210 != _e211));
phi_2854_ = _e213;
if !(_e213) {
let _e215 = (*c);
phi_2854_ = any((abs(_e215) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
}
let _e220 = phi_2854_;
return _e220;
}
fn WriteDebugView_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_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
var view: f32;
var local_3: f32;
var code: i32;
var shown: vec3<f32>;
var geometric_n: vec3<f32>;
var tangent: vec3<f32>;
var tangent_usable: bool;
var identity: f32;
var identity_object: f32;
var identity_rest: f32;
var identity_material: f32;
var normal_mapped: bool;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var grey: f32;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var uv: vec2<f32>;
var cell: vec2<f32>;
var odd: f32;
var within: vec2<f32>;
var param_9: vec3<f32>;
var key_1: f32;
var param_10: f32;
var srgb_1: vec3<f32>;
var param_11: vec3<f32>;
var luma: f32;
var metal: bool;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: vec3<f32>;
var m: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var weight_2: f32;
var local_11: f32;
var param_12: vec3<f32>;
var param_13: f32;
var phi_2944_: bool;
var phi_3212_: bool;
let _e252 = gl_FragCoord_1[0u];
let _e255 = frag_info.debug_view[1u];
if (_e252 < _e255) {
let _e259 = frag_info.debug_view[2u];
local_3 = _e259;
} else {
let _e262 = frag_info.debug_view[0u];
local_3 = _e262;
}
let _e263 = local_3;
view = _e263;
let _e264 = view;
if (_e264 < 0.5f) {
return false;
}
let _e266 = view;
code = i32((_e266 + 0.5f));
shown = vec3<f32>(0f, 0f, 0f);
let _e269 = v_normal_1;
geometric_n = normalize(_e269);
let _e271 = v_tangent_1;
let _e273 = geometric_n;
let _e274 = geometric_n;
let _e275 = v_tangent_1;
tangent = (_e271.xyz - (_e273 * dot(_e274, _e275.xyz)));
let _e280 = tangent;
let _e281 = tangent;
let _e283 = (dot(_e280, _e281) > 0.000000000001f);
phi_2944_ = _e283;
if _e283 {
let _e285 = v_tangent_1[3u];
phi_2944_ = (abs((abs(_e285) - 1f)) < 0.01f);
}
let _e291 = phi_2944_;
tangent_usable = _e291;
let _e294 = frag_info.debug_view[3u];
identity = _e294;
let _e295 = identity;
identity_object = floor((_e295 / 8192f));
let _e298 = identity;
let _e299 = identity_object;
identity_rest = (_e298 - (_e299 * 8192f));
let _e302 = identity_rest;
identity_material = floor((_e302 / 2f));
let _e305 = identity_rest;
let _e306 = identity_material;
normal_mapped = ((_e305 - (_e306 * 2f)) > 0.5f);
let _e310 = code;
if (_e310 == 1i) {
let _e313 = (*s).albedo;
param_5 = clamp(_e313, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e315 = LinearToSrgb_u0028_vf3_u003b((¶m_5));
shown = _e315;
} else {
let _e316 = code;
if (_e316 == 2i) {
let _e319 = (*s).n;
shown = ((_e319 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
let _e322 = code;
if (_e322 == 3i) {
let _e325 = (*s).roughness;
shown = vec3(clamp(_e325, 0f, 1f));
} else {
let _e328 = code;
if (_e328 == 4i) {
let _e331 = (*s).metallic;
shown = vec3(clamp(_e331, 0f, 1f));
} else {
let _e334 = code;
if (_e334 == 5i) {
let _e337 = (*s).occlusion;
shown = vec3(clamp(_e337, 0f, 1f));
} else {
let _e340 = code;
if (_e340 == 6i) {
let _e343 = (*s).emissive;
param_6 = clamp(_e343, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e345 = LinearToSrgb_u0028_vf3_u003b((¶m_6));
shown = _e345;
} else {
let _e346 = code;
if (_e346 == 7i) {
let _e348 = v_texcoord_1;
let _e349 = fract(_e348);
shown = vec3<f32>(_e349.x, _e349.y, 0f);
} else {
let _e353 = code;
if (_e353 == 8i) {
let _e355 = (*lit);
param_7 = clamp(_e355, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e357 = LinearToSrgb_u0028_vf3_u003b((¶m_7));
grey = dot(_e357, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e359 = (*lit);
param_8 = _e359;
let _e360 = NonFinite_u0028_vf3_u003b((¶m_8));
if _e360 {
local_4 = vec3<f32>(1f, 0f, 1f);
} else {
let _e361 = grey;
local_4 = vec3((_e361 * 0.5f));
}
let _e364 = local_4;
shown = _e364;
} else {
let _e365 = code;
if (_e365 == 9i) {
let _e367 = tangent_usable;
if _e367 {
let _e368 = tangent;
local_5 = ((normalize(_e368) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
} else {
local_5 = vec3<f32>(0f, 0f, 0f);
}
let _e372 = local_5;
shown = _e372;
} else {
let _e373 = code;
if (_e373 == 10i) {
let _e375 = v_texcoord_1;
uv = _e375;
let _e376 = uv;
cell = floor((_e376 * 8f));
let _e380 = cell[0u];
let _e382 = cell[1u];
odd = (fract(((_e380 + _e382) * 0.5f)) * 2f);
let _e387 = uv;
within = fract(_e387);
let _e389 = odd;
let _e393 = within[0u];
let _e397 = within[1u];
shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e389)) * vec3<f32>((0.55f + (0.45f * _e393)), (0.55f + (0.45f * _e397)), 0.85f));
} else {
let _e402 = code;
if (_e402 == 11i) {
let _e404 = gl_FrontFacing_1;
shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e404));
} else {
let _e407 = code;
if (_e407 == 12i) {
let _e409 = v_color_1;
param_9 = clamp(_e409.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e412 = LinearToSrgb_u0028_vf3_u003b((¶m_9));
shown = _e412;
} else {
let _e413 = code;
let _e415 = code;
if ((_e413 == 13i) || (_e415 == 14i)) {
let _e418 = code;
let _e420 = identity_object;
let _e421 = identity_material;
key_1 = select(_e421, _e420, (_e418 == 13i));
let _e423 = key_1;
param_10 = _e423;
let _e424 = DebugIdentityColour_u0028_f1_u003b((¶m_10));
let _e426 = (*s).n_dot_v;
shown = (_e424 * (0.55f + (0.45f * _e426)));
} else {
let _e430 = code;
if (_e430 == 15i) {
let _e433 = (*s).albedo;
param_11 = clamp(_e433, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e435 = LinearToSrgb_u0028_vf3_u003b((¶m_11));
srgb_1 = _e435;
let _e436 = srgb_1;
luma = dot(_e436, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
let _e439 = (*s).metallic;
metal = (_e439 > 0.5f);
let _e441 = metal;
let _e443 = luma;
if (!(_e441) && (_e443 < 0.11764706f)) {
local_6 = vec3<f32>(0.1f, 0.3f, 1f);
} else {
let _e446 = metal;
let _e447 = !(_e446);
phi_3212_ = _e447;
if _e447 {
let _e449 = srgb_1[0u];
let _e451 = srgb_1[1u];
let _e453 = srgb_1[2u];
phi_3212_ = (max(_e449, max(_e451, _e453)) > 0.9411765f);
}
let _e458 = phi_3212_;
if _e458 {
local_7 = vec3<f32>(1f, 0.1f, 0.1f);
} else {
let _e459 = metal;
let _e460 = luma;
if (_e459 && (_e460 < 0.7058824f)) {
local_8 = vec3<f32>(1f, 0.85f, 0.1f);
} else {
let _e463 = luma;
local_8 = vec3(_e463);
}
let _e465 = local_8;
local_7 = _e465;
}
let _e466 = local_7;
local_6 = _e466;
}
let _e467 = local_6;
shown = _e467;
} else {
let _e468 = code;
if (_e468 == 16i) {
let _e471 = (*s).metallic;
m = _e471;
let _e472 = m;
let _e474 = m;
if ((_e472 > 0.05f) && (_e474 < 0.95f)) {
local_9 = vec3<f32>(1f, 0.5f, 0f);
} else {
let _e477 = m;
local_9 = vec3(select(0.15f, 1f, (_e477 > 0.5f)));
}
let _e481 = local_9;
shown = _e481;
} else {
let _e482 = code;
if (_e482 == 17i) {
let _e484 = normal_mapped;
if !(_e484) {
local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
} else {
let _e486 = tangent_usable;
local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e486));
}
let _e489 = local_10;
shown = _e489;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e490 = g_premultiply;
if _e490 {
let _e492 = (*s).alpha;
local_11 = _e492;
} else {
local_11 = 1f;
}
let _e493 = local_11;
weight_2 = _e493;
let _e494 = shown;
param_12 = _e494;
let _e495 = SrgbToLinear_u0028_vf3_u003b((¶m_12));
let _e496 = weight_2;
let _e497 = (_e495 * _e496);
let _e499 = (*s).alpha;
frag_color = vec4<f32>(_e497.x, _e497.y, _e497.z, _e499);
let _e505 = (*s).roughness;
param_13 = _e505;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_13));
WriteWeightedBlended_u0028_();
return true;
}
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_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e212 = (*s_1).albedo;
return _e212;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e210 = (*i);
if (_e210 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e212 = (*i);
if (_e212 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e214 = (*i);
if (_e214 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e216 = (*i);
if (_e216 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e218 = (*i);
if (_e218 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e220 = (*i);
if (_e220 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e222 = (*i);
if (_e222 == 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_14: i32;
let _e215 = (*i_1);
param_14 = _e215;
let _e216 = PointShadowDiskTap_u0028_i1_u003b((¶m_14));
p = _e216;
let _e218 = p[0u];
let _e219 = (*ca);
let _e222 = p[1u];
let _e223 = (*sa);
let _e227 = p[0u];
let _e228 = (*sa);
let _e231 = p[1u];
let _e232 = (*ca);
let _e236 = (*radius);
return (vec2<f32>(((_e218 * _e219) - (_e222 * _e223)), ((_e227 * _e228) + (_e231 * _e232))) * _e236);
}
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_12: vec2<f32>;
var atlas: vec2<f32>;
let _e218 = point_shadow.params[0u];
inset = _e218;
let _e219 = (*uv_1);
let _e220 = (*offset);
let _e222 = inset;
let _e223 = inset;
local_12 = clamp((_e219 + _e220), vec2(_e222), vec2((1f - _e223)));
let _e228 = local_12;
let _e229 = (*tile);
atlas = ((_e228 + _e229) * vec2<f32>(0.16666667f, 0.16666667f));
let _e234 = point_shadow.params3_[0u];
if (_e234 > 0.5f) {
let _e237 = atlas[1u];
atlas[1u] = (1f - _e237);
}
let _e240 = atlas;
let _e241 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e240, 0f);
let _e243 = atlas;
let _e244 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e243, 0f);
let _e247 = (*range);
return (min(_e241.x, _e244.x) * _e247);
}
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_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
let _e219 = (*uv_2);
param_15 = _e219;
let _e220 = (*offset_1);
param_16 = _e220;
let _e221 = (*tile_1);
param_17 = _e221;
let _e222 = (*range_1);
param_18 = _e222;
let _e223 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
stored = _e223;
let _e224 = stored;
let _e225 = (*range_1);
if (_e224 >= (_e225 * 0.999f)) {
return 1f;
}
let _e228 = (*receiver);
let _e229 = stored;
return select(1f, 0f, (_e228 > _e229));
}
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_19: vec2<f32>;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_23: i32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e240 = point_shadow.params2_[1u];
lightRadius = _e240;
let _e243 = point_shadow.params2_[0u];
minRadius = _e243;
let _e246 = point_shadow.params2_[2u];
maxRadius = _e246;
let _e247 = lightRadius;
if (_e247 <= 0f) {
let _e249 = (*uv_3);
param_19 = _e249;
param_20 = vec2<f32>(0f, 0f);
let _e250 = (*tile_2);
param_21 = _e250;
let _e251 = (*range_2);
param_22 = _e251;
let _e252 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
(*blockerOut) = _e252;
let _e253 = minRadius;
return _e253;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e254 = i_2;
if (_e254 < 8i) {
let _e256 = i_2;
param_23 = _e256;
let _e257 = (*ca_1);
param_24 = _e257;
let _e258 = (*sa_1);
param_25 = _e258;
let _e259 = maxRadius;
param_26 = _e259;
let _e260 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
let _e261 = (*uv_3);
param_27 = _e261;
param_28 = _e260;
let _e262 = (*tile_2);
param_29 = _e262;
let _e263 = (*range_2);
param_30 = _e263;
let _e264 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30));
stored_1 = _e264;
let _e265 = stored_1;
let _e266 = (*range_2);
if (_e265 >= (_e266 * 0.999f)) {
continue;
}
let _e269 = stored_1;
let _e270 = (*receiver_1);
if (_e269 >= _e270) {
continue;
}
let _e272 = stored_1;
let _e273 = sum;
sum = (_e273 + _e272);
let _e275 = count;
count = (_e275 + 1f);
continue;
} else {
break;
}
continuing {
let _e277 = i_2;
i_2 = (_e277 + 1i);
}
}
let _e279 = count;
if (_e279 < 0.5f) {
return -1f;
}
let _e281 = sum;
let _e282 = count;
blocker = max((_e281 / _e282), 0.0001f);
let _e285 = blocker;
(*blockerOut) = _e285;
let _e286 = lightRadius;
let _e287 = (*receiver_1);
let _e288 = blocker;
let _e292 = blocker;
world = ((_e286 * max((_e287 - _e288), 0f)) / _e292);
let _e294 = world;
let _e295 = (*receiver_1);
let _e297 = (*tanHalf);
let _e300 = minRadius;
let _e301 = maxRadius;
return clamp((_e294 / ((2f * _e295) * _e297)), _e300, _e301);
}
fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
var local_13: vec2<f32>;
let _e211 = (*rows);
if (_e211 > 0f) {
let _e214 = gl_FragCoord_1[0u];
let _e215 = (*rows);
let _e217 = gl_FragCoord_1[1u];
local_13 = vec2<f32>(_e214, (_e215 - _e217));
} else {
let _e220 = gl_FragCoord_1;
local_13 = _e220.xy;
}
let _e222 = local_13;
return _e222;
}
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_4: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var param_31: 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_32: vec2<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 local_14: vec3<f32>;
var lit_1: 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 i_3: i32;
var param_45: i32;
var param_46: f32;
var param_47: f32;
var param_48: f32;
var param_49: vec2<f32>;
var param_50: vec2<f32>;
var param_51: vec2<f32>;
var param_52: f32;
var param_53: f32;
var phi_2541_: bool;
var phi_2602_: bool;
let _e263 = (*lightIndex);
let _e267 = point_shadow.slots[_e263][0u];
slot = i32((_e267 + 0.5f));
let _e270 = (*lightIndex);
let _e274 = point_shadow.slots[_e270][0u];
if (_e274 < 0f) {
return 1f;
}
let _e278 = point_shadow.params[2u];
strength = _e278;
let _e279 = strength;
if (_e279 <= 0f) {
return 1f;
}
let _e281 = slot;
let _e284 = point_shadow.lights[_e281];
let _e286 = (*world_1);
toLight = (_e284.xyz - _e286);
let _e288 = toLight;
toLightLength = max(length(_e288), 0.000001f);
let _e291 = (*normal);
let _e292 = toLight;
let _e293 = toLightLength;
nDotL = max(dot(_e291, (_e292 / vec3(_e293))), 0.15f);
let _e298 = nDotL;
let _e299 = nDotL;
let _e304 = nDotL;
let _e305 = nDotL;
slope = min((sqrt(max((1f - (_e298 * _e299)), 0f)) / (_e304 * _e305)), 8f);
let _e309 = toLightLength;
let _e311 = (*lightIndex);
let _e315 = point_shadow.slots[_e311][2u];
let _e320 = point_shadow.params3_[1u];
texel = (((2f * _e309) * max(_e315, 0.0001f)) * _e320);
let _e322 = (*world_1);
let _e323 = (*normal);
let _e324 = texel;
let _e328 = point_shadow.params[3u];
let _e330 = slope;
origin = (_e322 + (((_e323 * _e324) * _e328) * (1f + _e330)));
let _e334 = origin;
let _e335 = slot;
let _e338 = point_shadow.lights[_e335];
toFragment = (_e334 - _e338.xyz);
let _e341 = toFragment;
distance_ = length(_e341);
let _e343 = slot;
let _e347 = point_shadow.lights[_e343][3u];
range_3 = max(_e347, 0.0001f);
let _e349 = distance_;
let _e350 = range_3;
if (_e349 >= _e350) {
return 1f;
}
face = 0i;
let _e352 = (*lightIndex);
let _e356 = point_shadow.slots[_e352][1u];
if (_e356 < 0.5f) {
let _e358 = toFragment;
a = abs(_e358);
let _e361 = a[0u];
let _e363 = a[1u];
let _e364 = (_e361 >= _e363);
phi_2541_ = _e364;
if _e364 {
let _e366 = a[0u];
let _e368 = a[2u];
phi_2541_ = (_e366 >= _e368);
}
let _e371 = phi_2541_;
if _e371 {
let _e373 = toFragment[0u];
face = select(1i, 0i, (_e373 > 0f));
} else {
let _e377 = a[1u];
let _e379 = a[2u];
if (_e377 >= _e379) {
let _e382 = toFragment[1u];
face = select(3i, 2i, (_e382 > 0f));
} else {
let _e386 = toFragment[2u];
face = select(5i, 4i, (_e386 > 0f));
}
}
}
let _e389 = slot;
let _e391 = face;
let _e395 = point_shadow.faces[((_e389 * 6i) + _e391)];
let _e396 = origin;
clip = (_e395 * vec4<f32>(_e396.x, _e396.y, _e396.z, 1f));
let _e403 = clip[3u];
if (_e403 <= 0f) {
return 1f;
}
let _e405 = clip;
let _e408 = clip[3u];
ndc = (_e405.xy / vec2(_e408));
let _e412 = ndc[0u];
let _e414 = (abs(_e412) > 1f);
phi_2602_ = _e414;
if !(_e414) {
let _e417 = ndc[1u];
phi_2602_ = (abs(_e417) > 1f);
}
let _e421 = phi_2602_;
if _e421 {
return 1f;
}
let _e423 = ndc[0u];
let _e427 = ndc[1u];
uv_4 = vec2<f32>(((_e423 * 0.5f) + 0.5f), (0.5f - (_e427 * 0.5f)));
let _e431 = face;
let _e433 = slot;
tile_3 = vec2<f32>(f32(_e431), f32(_e433));
let _e436 = distance_;
let _e439 = point_shadow.params[1u];
receiver_2 = (_e436 - _e439);
let _e443 = frag_info.target_origin[0u];
param_31 = _e443;
let _e444 = FragCoordFromTop_u0028_f1_u003b((¶m_31));
noise = fract((52.982918f * fract(dot(_e444, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e449 = noise;
angle = (_e449 * 6.2831855f);
let _e451 = angle;
ca_2 = cos(_e451);
let _e453 = angle;
sa_2 = sin(_e453);
let _e455 = (*lightIndex);
let _e459 = point_shadow.slots[_e455][2u];
tanHalf_1 = max(_e459, 0.0001f);
blocker_1 = -1f;
let _e461 = uv_4;
param_32 = _e461;
let _e462 = tile_3;
param_33 = _e462;
let _e463 = range_3;
param_34 = _e463;
let _e464 = receiver_2;
param_35 = _e464;
let _e465 = ca_2;
param_36 = _e465;
let _e466 = sa_2;
param_37 = _e466;
let _e467 = tanHalf_1;
param_38 = _e467;
let _e468 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_32), (¶m_33), (¶m_34), (¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
let _e469 = param_39;
blocker_1 = _e469;
radius_1 = _e468;
let _e472 = point_shadow.params2_[3u];
if (_e472 > 0.5f) {
g_debug_surface_on = true;
let _e474 = radius_1;
if (_e474 < 0f) {
local_14 = vec3<f32>(0f, 0f, 1f);
} else {
let _e476 = radius_1;
let _e479 = point_shadow.params2_[2u];
let _e483 = blocker_1;
let _e484 = range_3;
local_14 = vec3<f32>(clamp((_e476 / max(_e479, 0.000001f)), 0f, 1f), clamp((_e483 / _e484), 0f, 1f), 0f);
}
let _e488 = local_14;
g_debug_surface = _e488;
}
let _e489 = radius_1;
if (_e489 < 0f) {
return 1f;
}
let _e491 = uv_4;
param_40 = _e491;
param_41 = vec2<f32>(0f, 0f);
let _e492 = tile_3;
param_42 = _e492;
let _e493 = range_3;
param_43 = _e493;
let _e494 = receiver_2;
param_44 = _e494;
let _e495 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43), (¶m_44));
lit_1 = _e495;
let _e496 = radius_1;
if (_e496 > 0f) {
i_3 = 0i;
loop {
let _e498 = i_3;
if (_e498 < 8i) {
let _e500 = i_3;
param_45 = _e500;
let _e501 = ca_2;
param_46 = _e501;
let _e502 = sa_2;
param_47 = _e502;
let _e503 = radius_1;
param_48 = _e503;
let _e504 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e505 = uv_4;
param_49 = _e505;
param_50 = _e504;
let _e506 = tile_3;
param_51 = _e506;
let _e507 = range_3;
param_52 = _e507;
let _e508 = receiver_2;
param_53 = _e508;
let _e509 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_49), (¶m_50), (¶m_51), (¶m_52), (¶m_53));
let _e510 = lit_1;
lit_1 = (_e510 + _e509);
continue;
} else {
break;
}
continuing {
let _e512 = i_3;
i_3 = (_e512 + 1i);
}
}
let _e514 = lit_1;
lit_1 = (_e514 * 0.11111111f);
}
let _e516 = lit_1;
let _e517 = strength;
return mix(1f, _e516, clamp(_e517, 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 _e214 = (*i_4);
let _e217 = (*n_1);
r = sqrt(((f32(_e214) + 0.5f) / f32(_e217)));
let _e221 = (*i_4);
let _e224 = (*turn);
theta = ((f32(_e221) * 2.3999631f) + _e224);
let _e226 = r;
let _e227 = theta;
let _e229 = theta;
return (vec2<f32>(cos(_e227), sin(_e229)) * _e226);
}
fn ShadowNoise_u0028_() -> f32 {
var at: vec2<f32>;
var param_54: f32;
let _e213 = frag_info.target_origin[0u];
param_54 = _e213;
let _e214 = FragCoordFromTop_u0028_f1_u003b((¶m_54));
let _e217 = frag_info.target_origin[3u];
at = (_e214 + vec2((5.588238f * max(_e217, 0f))));
let _e222 = at;
return fract((52.982918f * fract(dot(_e222, vec2<f32>(0.06711056f, 0.00583715f)))));
}
fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
var local_15: f32;
let _e212 = (*mode_1);
if (_e212 > 0.5f) {
let _e214 = (*stored_2);
local_15 = (1f - _e214);
} else {
let _e216 = (*stored_2);
local_15 = _e216;
}
let _e217 = local_15;
return _e217;
}
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 _e218 = (*moments)[1u];
let _e220 = (*moments)[0u];
let _e222 = (*moments)[0u];
let _e225 = (*minVariance);
variance = max((_e218 - (_e220 * _e222)), _e225);
let _e227 = (*t);
let _e229 = (*moments)[0u];
d_1 = (_e227 - _e229);
let _e231 = variance;
let _e232 = variance;
let _e233 = d_1;
let _e234 = d_1;
pMax = (_e231 / (_e232 + (_e233 * _e234)));
let _e238 = pMax;
let _e239 = (*bleed);
let _e241 = (*bleed);
reduced = clamp(((_e238 - _e239) / max((1f - _e241), 0.0001f)), 0f, 1f);
let _e246 = (*t);
let _e248 = (*moments)[0u];
let _e250 = reduced;
return select(_e250, 1f, (_e246 <= _e248));
}
fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
var d_2: f32;
let _e211 = (*depth);
d_2 = ((2f * clamp(_e211, 0f, 1f)) - 1f);
let _e215 = d_2;
let _e218 = d_2;
return vec2<f32>(exp((40f * _e215)), -(exp((-5f * _e218))));
}
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_55: f32;
var scale: vec2<f32>;
var positive: f32;
var param_56: vec2<f32>;
var param_57: f32;
var param_58: f32;
var param_59: f32;
var negative: f32;
var param_60: vec2<f32>;
var param_61: f32;
var param_62: f32;
var param_63: f32;
let _e225 = (*depth_1);
param_55 = _e225;
let _e226 = EvsmWarp_u0028_f1_u003b((¶m_55));
warped = _e226;
let _e227 = warped;
scale = (vec2<f32>(0.004f, 0.0005f) * _e227);
let _e230 = scale[0u];
let _e232 = scale[0u];
let _e234 = (*moments_1);
param_56 = _e234.xy;
let _e237 = warped[0u];
param_57 = _e237;
param_58 = (_e230 * _e232);
let _e238 = (*bleed_1);
param_59 = _e238;
let _e239 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_56), (¶m_57), (¶m_58), (¶m_59));
positive = _e239;
let _e241 = scale[1u];
let _e243 = scale[1u];
let _e245 = (*moments_1);
param_60 = _e245.zw;
let _e248 = warped[1u];
param_61 = _e248;
param_62 = (_e241 * _e243);
let _e249 = (*bleed_1);
param_63 = _e249;
let _e250 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63));
negative = _e250;
let _e251 = positive;
let _e252 = negative;
return min(_e251, _e252);
}
fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
var stored_3: f32;
let _e211 = (*depth_2);
stored_3 = max((1f - _e211), 0.000061035156f);
let _e214 = stored_3;
return exp2((floor(log2(_e214)) - 10f));
}
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_2: 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 local_16: f32;
var cascade: i32;
var uv_5: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var cascadeTexel: f32;
var cascadeDepth: f32;
var receiverSlope: f32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_17: mat4x4<f32>;
var local_18: mat4x4<f32>;
var axisX: vec3<f32>;
var axisY: vec3<f32>;
var rowX: f32;
var rowY: f32;
var texelMetres: f32;
var reach: f32;
var flatOffset: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var cosSlope: f32;
var bias: f32;
var local_19: f32;
var local_20: f32;
var storage_: f32;
var param_64: f32;
var texel_1: vec2<f32>;
var tileLo: vec2<f32>;
var tileHi: vec2<f32>;
var stored_4: vec4<f32>;
var through: vec3<f32>;
var softness: f32;
var lit_2: f32;
var moments_2: vec4<f32>;
var param_65: vec4<f32>;
var param_66: f32;
var param_67: f32;
var y: i32;
var x: i32;
var occluder: f32;
var param_68: f32;
var param_69: f32;
var spread: f32;
var turn_1: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_5: i32;
var disc: vec2<f32>;
var param_70: i32;
var param_71: i32;
var param_72: f32;
var tapBias: f32;
var occluder_1: f32;
var param_73: f32;
var param_74: f32;
var gap: f32;
var radius_2: f32;
var i_6: i32;
var disc_1: vec2<f32>;
var param_75: i32;
var param_76: i32;
var param_77: f32;
var tapBias_1: f32;
var occluder_2: f32;
var param_78: f32;
var param_79: f32;
var phi_3391_: bool;
var phi_3402_: bool;
var phi_3559_: bool;
var phi_3566_: bool;
var phi_3573_: bool;
let _e288 = frag_info.shadow_params[3u];
strength_1 = _e288;
let _e289 = strength_1;
if (_e289 <= 0f) {
return 1f;
}
let _e291 = (*lightIndex_1);
let _e294 = frag_info.frame_params[2u];
if (_e291 != i32(floor((_e294 + 0.5f)))) {
return 1f;
}
let _e301 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e301 + 0.5f));
let _e304 = Orthographic_u0028_();
if _e304 {
let _e305 = ViewDepth_u0028_();
local_16 = _e305;
} else {
let _e306 = v_world_position_1;
let _e308 = frag_info.camera_position;
local_16 = length((_e306 - _e308.xyz));
}
let _e312 = local_16;
viewDistance = _e312;
cascade = 0i;
let _e313 = cascadeCount;
let _e314 = (_e313 > 1i);
phi_3391_ = _e314;
if _e314 {
let _e315 = viewDistance;
let _e318 = frag_info.shadow_cascades[0u];
phi_3391_ = (_e315 > _e318);
}
let _e321 = phi_3391_;
if _e321 {
cascade = 1i;
}
let _e322 = cascadeCount;
let _e323 = (_e322 > 2i);
phi_3402_ = _e323;
if _e323 {
let _e324 = viewDistance;
let _e327 = frag_info.shadow_cascades[1u];
phi_3402_ = (_e324 > _e327);
}
let _e330 = phi_3402_;
if _e330 {
cascade = 2i;
}
uv_5 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
cascadeTexel = 1f;
cascadeDepth = 1f;
receiverSlope = 0f;
attempt = 0i;
loop {
let _e331 = attempt;
if (_e331 < 3i) {
let _e333 = cascade;
let _e334 = attempt;
which = (_e333 + _e334);
let _e336 = which;
let _e337 = cascadeCount;
if (_e336 >= _e337) {
break;
}
let _e339 = which;
if (_e339 == 0i) {
let _e342 = frag_info.shadow_matrix;
local_17 = _e342;
} else {
let _e343 = which;
if (_e343 == 1i) {
let _e346 = frag_info.shadow_matrix_far;
local_18 = _e346;
} else {
let _e348 = frag_info.shadow_matrix_farthest;
local_18 = _e348;
}
let _e349 = local_18;
local_17 = _e349;
}
let _e350 = local_17;
matrix = _e350;
let _e353 = matrix[0][0u];
let _e356 = matrix[1][0u];
let _e359 = matrix[2][0u];
axisX = vec3<f32>(_e353, _e356, _e359);
let _e363 = matrix[0][1u];
let _e366 = matrix[1][1u];
let _e369 = matrix[2][1u];
axisY = vec3<f32>(_e363, _e366, _e369);
let _e371 = axisX;
rowX = max(length(_e371), 0.000001f);
let _e374 = axisY;
rowY = max(length(_e374), 0.000001f);
let _e379 = frag_info.shadow_cascades[3u];
let _e381 = rowX;
texelMetres = ((2f * _e379) / _e381);
let _e385 = frag_info.shadow_cascades[3u];
let _e388 = (*s_2).n;
let _e389 = axisX;
let _e392 = rowX;
let _e393 = rowX;
let _e397 = (*s_2).n;
let _e398 = axisY;
let _e401 = rowY;
let _e402 = rowY;
reach = ((3f * _e385) * ((abs(dot(_e388, _e389)) / (_e392 * _e393)) + (abs(dot(_e397, _e398)) / (_e401 * _e402))));
let _e409 = frag_info.shadow_params[2u];
let _e410 = texelMetres;
flatOffset = min(_e409, _e410);
let _e412 = v_world_position_1;
let _e414 = (*s_2).n;
let _e415 = flatOffset;
let _e416 = reach;
origin_1 = (_e412 + (_e414 * (_e415 + _e416)));
let _e420 = matrix;
let _e421 = origin_1;
lightSpace = (_e420 * vec4<f32>(_e421.x, _e421.y, _e421.z, 1f));
let _e428 = lightSpace[3u];
if (_e428 <= 0f) {
continue;
}
let _e430 = lightSpace;
let _e433 = lightSpace[3u];
candidate = (_e430.xyz / vec3(_e433));
let _e437 = candidate[0u];
let _e441 = candidate[1u];
inTile = vec2<f32>(((_e437 * 0.5f) + 0.5f), (0.5f - (_e441 * 0.5f)));
let _e446 = inTile[0u];
let _e447 = (_e446 < 0f);
phi_3559_ = _e447;
if !(_e447) {
let _e450 = inTile[0u];
phi_3559_ = (_e450 > 1f);
}
let _e453 = phi_3559_;
phi_3566_ = _e453;
if !(_e453) {
let _e456 = inTile[1u];
phi_3566_ = (_e456 < 0f);
}
let _e459 = phi_3566_;
phi_3573_ = _e459;
if !(_e459) {
let _e462 = inTile[1u];
phi_3573_ = (_e462 > 1f);
}
let _e465 = phi_3573_;
if _e465 {
continue;
}
let _e467 = candidate[2u];
if (_e467 > 1f) {
let _e469 = which;
let _e470 = cascadeCount;
if (_e469 < (_e470 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e475 = inTile[0u];
let _e476 = which;
let _e479 = cascadeCount;
let _e483 = inTile[1u];
uv_5 = vec2<f32>(((_e475 + f32(_e476)) / f32(_e479)), _e483);
let _e485 = candidate;
projected = _e485;
let _e486 = which;
cascade = _e486;
let _e487 = texelMetres;
cascadeTexel = _e487;
let _e490 = matrix[0][2u];
let _e493 = matrix[1][2u];
let _e496 = matrix[2][2u];
cascadeDepth = (1f / max(length(vec3<f32>(_e490, _e493, _e496)), 0.000001f));
let _e502 = (*s_2).n;
let _e505 = matrix[0][2u];
let _e508 = matrix[1][2u];
let _e511 = matrix[2][2u];
let _e515 = cascadeDepth;
cosSlope = clamp((abs(dot(_e502, vec3<f32>(_e505, _e508, _e511))) * _e515), 0.1f, 1f);
let _e518 = texelMetres;
let _e519 = cosSlope;
let _e520 = cosSlope;
let _e526 = cosSlope;
let _e528 = cascadeDepth;
receiverSlope = (((_e518 * sqrt(max((1f - (_e519 * _e520)), 0f))) / _e526) / _e528);
found = true;
break;
} else {
break;
}
continuing {
let _e530 = attempt;
attempt = (_e530 + 1i);
}
}
let _e532 = found;
if !(_e532) {
return 1f;
}
let _e534 = cascade;
if (_e534 == 0i) {
let _e538 = frag_info.shadow_bias[0u];
local_19 = _e538;
} else {
let _e539 = cascade;
if (_e539 == 1i) {
let _e543 = frag_info.shadow_bias[1u];
local_20 = _e543;
} else {
let _e546 = frag_info.shadow_bias[2u];
local_20 = _e546;
}
let _e547 = local_20;
local_19 = _e547;
}
let _e548 = local_19;
bias = _e548;
let _e551 = frag_info.shadow_params[1u];
storage_ = _e551;
let _e552 = storage_;
let _e554 = storage_;
if ((_e552 > 0.5f) && (_e554 < 1.5f)) {
let _e557 = bias;
let _e559 = projected[2u];
param_64 = _e559;
let _e560 = ShadowStoredStep_u0028_f1_u003b((¶m_64));
bias = max(_e557, _e560);
}
let _e564 = frag_info.shadow_params[0u];
let _e567 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e564, _e567);
let _e569 = cascade;
let _e571 = cascadeCount;
let _e575 = texel_1;
tileLo = (vec2<f32>((f32(_e569) / f32(_e571)), 0f) + (_e575 * 0.5f));
let _e578 = cascade;
let _e581 = cascadeCount;
let _e585 = texel_1;
tileHi = (vec2<f32>((f32((_e578 + 1i)) / f32(_e581)), 1f) - (_e585 * 0.5f));
let _e590 = frag_info.shadow_bias[3u];
if (_e590 > 0.5f) {
let _e592 = uv_5;
let _e593 = tileLo;
let _e594 = tileHi;
let _e596 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e592, _e593, _e594), 0f);
stored_4 = _e596;
let _e598 = stored_4[1u];
let _e601 = stored_4[2u];
let _e604 = stored_4[3u];
through = clamp(vec3<f32>((1f - _e598), (1f - _e601), _e604), vec3(0f), vec3(4f));
let _e609 = through;
let _e610 = strength_1;
light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e609, vec3(clamp(_e610, 0f, 1f)));
}
let _e616 = frag_info.ambient_ground[3u];
softness = _e616;
lit_2 = 0f;
let _e617 = softness;
if (_e617 < 0f) {
let _e619 = uv_5;
let _e620 = tileLo;
let _e621 = tileHi;
let _e623 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e619, _e620, _e621), 0f);
moments_2 = _e623;
let _e625 = projected[2u];
let _e626 = bias;
let _e628 = softness;
let _e632 = moments_2;
param_65 = _e632;
param_66 = (_e625 - _e626);
param_67 = clamp((-(_e628) - 1f), 0f, 0.95f);
let _e633 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
lit_2 = _e633;
} else {
let _e634 = softness;
if (_e634 <= 0f) {
y = -1i;
loop {
let _e636 = y;
if (_e636 <= 1i) {
x = -1i;
loop {
let _e638 = x;
if (_e638 <= 1i) {
let _e640 = uv_5;
let _e641 = x;
let _e643 = y;
let _e646 = texel_1;
let _e649 = tileLo;
let _e650 = tileHi;
let _e652 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e640 + (vec2<f32>(f32(_e641), f32(_e643)) * _e646)), _e649, _e650), 0f);
param_68 = _e652.x;
let _e654 = storage_;
param_69 = _e654;
let _e655 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_68), (¶m_69));
occluder = _e655;
let _e657 = projected[2u];
let _e658 = bias;
let _e660 = occluder;
let _e663 = lit_2;
lit_2 = (_e663 + select(1f, 0f, ((_e657 - _e658) > _e660)));
continue;
} else {
break;
}
continuing {
let _e665 = x;
x = (_e665 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e667 = y;
y = (_e667 + 1i);
}
}
let _e669 = lit_2;
lit_2 = (_e669 * 0.11111111f);
} else {
let _e671 = softness;
spread = tan(min(_e671, 0.5f));
let _e674 = ShadowNoise_u0028_();
turn_1 = (_e674 * 6.2831855f);
let _e676 = spread;
let _e678 = projected[2u];
let _e680 = cascadeDepth;
let _e682 = cascadeTexel;
searchRadius = clamp((((_e676 * _e678) * _e680) / _e682), 1f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_5 = 0i;
loop {
let _e685 = i_5;
if (_e685 < 16i) {
let _e687 = i_5;
param_70 = _e687;
param_71 = 16i;
let _e688 = turn_1;
param_72 = _e688;
let _e689 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_70), (¶m_71), (¶m_72));
disc = _e689;
let _e690 = bias;
let _e691 = disc;
let _e693 = searchRadius;
let _e697 = receiverSlope;
tapBias = (_e690 + (max(((length(_e691) * _e693) - 1.5f), 0f) * _e697));
let _e700 = uv_5;
let _e701 = disc;
let _e702 = texel_1;
let _e704 = searchRadius;
let _e707 = tileLo;
let _e708 = tileHi;
let _e710 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e700 + ((_e701 * _e702) * _e704)), _e707, _e708), 0f);
param_73 = _e710.x;
let _e712 = storage_;
param_74 = _e712;
let _e713 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_73), (¶m_74));
occluder_1 = _e713;
let _e715 = projected[2u];
let _e716 = tapBias;
let _e718 = occluder_1;
if ((_e715 - _e716) > _e718) {
let _e720 = occluder_1;
let _e721 = blockerSum;
blockerSum = (_e721 + _e720);
let _e723 = blockerCount;
blockerCount = (_e723 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e725 = i_5;
i_5 = (_e725 + 1i);
}
}
let _e727 = blockerCount;
if (_e727 <= 0f) {
return 1f;
}
let _e730 = projected[2u];
let _e731 = blockerSum;
let _e732 = blockerCount;
let _e736 = cascadeDepth;
gap = (max((_e730 - (_e731 / _e732)), 0f) * _e736);
let _e738 = spread;
let _e739 = gap;
let _e741 = cascadeTexel;
radius_2 = clamp(((_e738 * _e739) / _e741), 1f, 16f);
i_6 = 0i;
loop {
let _e744 = i_6;
if (_e744 < 16i) {
let _e746 = turn_1;
let _e748 = i_6;
param_75 = _e748;
param_76 = 16i;
param_77 = (_e746 + 1f);
let _e749 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
disc_1 = _e749;
let _e750 = bias;
let _e751 = disc_1;
let _e753 = radius_2;
let _e757 = receiverSlope;
tapBias_1 = (_e750 + (max(((length(_e751) * _e753) - 1.5f), 0f) * _e757));
let _e760 = uv_5;
let _e761 = disc_1;
let _e762 = texel_1;
let _e764 = radius_2;
let _e767 = tileLo;
let _e768 = tileHi;
let _e770 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e760 + ((_e761 * _e762) * _e764)), _e767, _e768), 0f);
param_78 = _e770.x;
let _e772 = storage_;
param_79 = _e772;
let _e773 = ShadowStored_u0028_f1_u003b_f1_u003b((¶m_78), (¶m_79));
occluder_2 = _e773;
let _e775 = projected[2u];
let _e776 = tapBias_1;
let _e778 = occluder_2;
let _e781 = lit_2;
lit_2 = (_e781 + select(1f, 0f, ((_e775 - _e776) > _e778)));
continue;
} else {
break;
}
continuing {
let _e783 = i_6;
i_6 = (_e783 + 1i);
}
}
let _e785 = lit_2;
lit_2 = (_e785 * 0.0625f);
}
}
let _e787 = lit_2;
let _e788 = strength_1;
return mix(1f, _e787, clamp(_e788, 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_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_80: Surface;
var param_81: LightSample;
var param_82: i32;
let _e215 = (*s_3);
param_80 = _e215;
let _e216 = (*light_2);
param_81 = _e216;
let _e217 = (*index);
param_82 = _e217;
let _e218 = 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_80), (¶m_81), (¶m_82));
return _e218;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e210 = (*index_1);
return (_e210 < 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 _e214 = (*distance_1);
let _e215 = (*distance_1);
attenuation = (1f / max((_e214 * _e215), 0.0001f));
let _e219 = (*range_4);
if (_e219 > 0f) {
let _e221 = (*distance_1);
let _e222 = (*range_4);
ratio = (_e221 / _e222);
let _e224 = ratio;
let _e225 = ratio;
let _e227 = ratio;
let _e229 = ratio;
window = clamp((1f - (((_e224 * _e225) * _e227) * _e229)), 0f, 1f);
let _e233 = window;
let _e234 = window;
let _e236 = attenuation;
attenuation = (_e236 * (_e233 * _e234));
}
let _e238 = attenuation;
return _e238;
}
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_21: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e226 = (*halfWidth);
let _e227 = (*halfHeight);
n_2 = cross(_e226, _e227);
let _e229 = n_2;
nLen = length(_e229);
let _e231 = nLen;
if (_e231 < 0.000000000001f) {
let _e233 = (*centre);
return _e233;
}
let _e234 = nLen;
let _e235 = n_2;
n_2 = (_e235 / vec3(_e234));
let _e238 = (*centre);
let _e239 = (*world_2);
toPlane = (_e238 - _e239);
let _e241 = (*mirror);
let _e242 = n_2;
denom = dot(_e241, _e242);
let _e244 = denom;
if (abs(_e244) < 0.00001f) {
let _e247 = toPlane;
let _e248 = n_2;
let _e249 = toPlane;
let _e250 = n_2;
onPlane = (_e247 - (_e248 * dot(_e249, _e250)));
} else {
let _e254 = toPlane;
let _e255 = n_2;
let _e257 = denom;
t_1 = (dot(_e254, _e255) / _e257);
let _e259 = t_1;
if (_e259 > 0f) {
let _e261 = (*mirror);
let _e262 = t_1;
local_21 = (_e261 * _e262);
} else {
let _e264 = toPlane;
let _e265 = n_2;
let _e266 = toPlane;
let _e267 = n_2;
local_21 = (_e264 - (_e265 * dot(_e266, _e267)));
}
let _e271 = local_21;
onPlane = _e271;
}
let _e272 = onPlane;
let _e273 = toPlane;
offset_2 = (_e272 - _e273);
let _e275 = (*halfWidth);
let _e276 = (*halfWidth);
wLen2_ = max(dot(_e275, _e276), 0.000000000001f);
let _e279 = (*halfHeight);
let _e280 = (*halfHeight);
hLen2_ = max(dot(_e279, _e280), 0.000000000001f);
let _e283 = offset_2;
let _e284 = (*halfWidth);
let _e286 = wLen2_;
u = clamp((dot(_e283, _e284) / _e286), -1f, 1f);
let _e289 = offset_2;
let _e290 = (*halfHeight);
let _e292 = hLen2_;
v = clamp((dot(_e289, _e290) / _e292), -1f, 1f);
let _e295 = (*centre);
let _e296 = (*halfWidth);
let _e297 = u;
let _e300 = (*halfHeight);
let _e301 = v;
return ((_e295 + (_e296 * _e297)) + (_e300 * _e301));
}
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_22: f32;
let _e218 = (*a_1);
let _e219 = (*a_1);
ua = (_e218 / vec3(max(length(_e219), 0.000000000001f)));
let _e224 = (*b);
let _e225 = (*b);
ub = (_e224 / vec3(max(length(_e225), 0.000000000001f)));
let _e230 = ua;
let _e231 = ub;
angle_1 = acos(clamp(dot(_e230, _e231), -1f, 1f));
let _e235 = ua;
let _e236 = ub;
axis = cross(_e235, _e236);
let _e238 = axis;
len = length(_e238);
let _e240 = len;
if (_e240 > 0.000001f) {
let _e242 = angle_1;
let _e243 = axis;
let _e244 = (*n_3);
let _e247 = len;
local_22 = ((_e242 * dot(_e243, _e244)) / _e247);
} else {
local_22 = 0f;
}
let _e249 = local_22;
return _e249;
}
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_23: i32;
var ha: f32;
var hb: f32;
var d_3: f32;
var q: vec3<f32>;
var local_24: f32;
var aAbove: bool;
var bAbove: bool;
var local_25: f32;
var param_83: vec3<f32>;
var param_84: vec3<f32>;
var param_85: vec3<f32>;
var param_86: vec3<f32>;
var param_87: vec3<f32>;
var param_88: vec3<f32>;
total = 0f;
exit = vec3<f32>(0f, 0f, 0f);
entry = vec3<f32>(0f, 0f, 0f);
i_7 = 0i;
loop {
let _e232 = i_7;
if (_e232 < 4i) {
let _e234 = i_7;
let _e236 = (*corners)[_e234];
a_2 = _e236;
let _e237 = i_7;
if (_e237 == 3i) {
local_23 = 0i;
} else {
let _e239 = i_7;
local_23 = (_e239 + 1i);
}
let _e241 = local_23;
let _e243 = (*corners)[_e241];
b_1 = _e243;
let _e244 = a_2;
let _e245 = (*n_4);
ha = dot(_e244, _e245);
let _e247 = b_1;
let _e248 = (*n_4);
hb = dot(_e247, _e248);
let _e250 = ha;
let _e251 = hb;
d_3 = (_e250 - _e251);
let _e253 = a_2;
let _e254 = b_1;
let _e255 = a_2;
let _e257 = d_3;
if (abs(_e257) > 0.000000000001f) {
let _e260 = ha;
let _e261 = d_3;
local_24 = (_e260 / _e261);
} else {
local_24 = 0f;
}
let _e263 = local_24;
q = (_e253 + ((_e254 - _e255) * _e263));
let _e266 = ha;
aAbove = (_e266 > 0f);
let _e268 = hb;
bAbove = (_e268 > 0f);
let _e270 = aAbove;
let _e271 = bAbove;
if (_e270 || _e271) {
let _e273 = aAbove;
let _e274 = a_2;
let _e275 = q;
let _e278 = bAbove;
let _e279 = b_1;
let _e280 = q;
param_83 = select(_e275, _e274, vec3(_e273));
param_84 = select(_e280, _e279, vec3(_e278));
let _e283 = (*n_4);
param_85 = _e283;
let _e284 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_83), (¶m_84), (¶m_85));
local_25 = _e284;
} else {
local_25 = 0f;
}
let _e285 = local_25;
let _e286 = total;
total = (_e286 + _e285);
let _e288 = aAbove;
let _e289 = bAbove;
let _e292 = q;
let _e293 = exit;
exit = select(_e293, _e292, vec3((_e288 && !(_e289))));
let _e296 = aAbove;
let _e298 = bAbove;
let _e300 = q;
let _e301 = entry;
entry = select(_e301, _e300, vec3((!(_e296) && _e298)));
continue;
} else {
break;
}
continuing {
let _e304 = i_7;
i_7 = (_e304 + 1i);
}
}
let _e306 = exit;
param_86 = _e306;
let _e307 = entry;
param_87 = _e307;
let _e308 = (*n_4);
param_88 = _e308;
let _e309 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((¶m_86), (¶m_87), (¶m_88));
let _e310 = total;
total = (_e310 + _e309);
let _e312 = total;
return max((-(_e312) * 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_26: f32;
var local_27: f32;
var local_28: f32;
let _e215 = (*slot_1);
let _e216 = (*slot_1);
lane = (_e215 - ((_e216 / 4i) * 4i));
let _e220 = lane;
if (_e220 == 0i) {
let _e223 = (*four)[0u];
local_26 = _e223;
} else {
let _e224 = lane;
if (_e224 == 1i) {
let _e227 = (*four)[1u];
local_27 = _e227;
} else {
let _e228 = lane;
if (_e228 == 2i) {
let _e231 = (*four)[2u];
local_28 = _e231;
} else {
let _e233 = (*four)[3u];
local_28 = _e233;
}
let _e234 = local_28;
local_27 = _e234;
}
let _e235 = local_27;
local_26 = _e235;
}
let _e236 = local_26;
return _e236;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_89: vec4<f32>;
var param_90: i32;
let _e212 = (*slot_2);
let _e216 = light_list_info.scales[(_e212 / 4i)];
param_89 = _e216;
let _e217 = (*slot_2);
param_90 = _e217;
let _e218 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_89), (¶m_90));
return _e218;
}
fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
var a_3: vec4<f32>;
var b_2: vec4<f32>;
let _e214 = light_list_info.slot_rows[0i];
let _e215 = (*row);
a_3 = abs((_e214 - vec4(_e215)));
let _e221 = light_list_info.slot_rows[1i];
let _e222 = (*row);
b_2 = abs((_e221 - vec4(_e222)));
let _e227 = a_3[0u];
let _e229 = a_3[1u];
let _e232 = a_3[2u];
let _e234 = a_3[3u];
let _e238 = b_2[0u];
let _e240 = b_2[1u];
let _e243 = b_2[2u];
let _e245 = b_2[3u];
return (min(min(min(_e227, _e229), min(_e232, _e234)), min(min(_e238, _e240), min(_e243, _e245))) < 0.5f);
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_91: vec4<f32>;
var param_92: i32;
let _e212 = (*slot_3);
let _e216 = light_list_info.indices[(_e212 / 4i)];
param_91 = _e216;
let _e217 = (*slot_3);
param_92 = _e217;
let _e218 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_91), (¶m_92));
return _e218;
}
fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
let _e211 = (*texel_2);
let _e215 = light_list_info.list[1u];
let _e217 = (*row_1);
let _e221 = light_list_info.list[2u];
let _e224 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e211 + 0.5f) * _e215), ((_e217 + 0.5f) * _e221)), 0f);
return _e224;
}
fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
var entry_1: f32;
var row_2: f32;
var within_1: f32;
var texel_3: f32;
var four_1: vec4<f32>;
var param_93: f32;
var param_94: f32;
var param_95: vec4<f32>;
var param_96: i32;
let _e219 = g_cluster_offset;
let _e220 = (*slot_4);
entry_1 = (_e219 + f32(_e220));
let _e223 = entry_1;
row_2 = floor((_e223 / 16f));
let _e226 = entry_1;
let _e227 = row_2;
within_1 = (_e226 - (_e227 * 16f));
let _e230 = within_1;
texel_3 = floor((_e230 / 4f));
let _e235 = light_list_info.cluster_depth[3u];
let _e236 = row_2;
let _e238 = texel_3;
param_93 = _e238;
param_94 = (_e235 + _e236);
let _e239 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_93), (¶m_94));
four_1 = _e239;
let _e240 = within_1;
let _e241 = texel_3;
let _e246 = four_1;
param_95 = _e246;
param_96 = i32(((_e240 - (_e241 * 4f)) + 0.5f));
let _e247 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_95), (¶m_96));
return _e247;
}
fn Clustered_u0028_() -> bool {
let _e211 = light_list_info.cluster_grid[3u];
return (_e211 > 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_4: 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_29: f32;
var param_97: i32;
var param_98: i32;
var v_1: f32;
var u_1: f32;
var local_30: f32;
var param_99: f32;
var param_100: 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_31: f32;
var param_101: array<vec3<f32>, 4>;
var param_102: vec3<f32>;
var area: f32;
var radiance: f32;
var local_32: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_103: vec3<f32>;
var param_104: vec3<f32>;
var param_105: vec3<f32>;
var param_106: vec3<f32>;
var param_107: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var local_33: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_108: f32;
var param_109: f32;
var cosAngle: f32;
var ramp: f32;
light_3.integrated = 0f;
light_3.ltc = vec3<f32>(0f, 0f, 0f);
let _e263 = (*index_2);
if (_e263 < 8i) {
let _e265 = (*index_2);
let _e268 = frag_info.light_position[_e265];
position = _e268;
let _e269 = (*index_2);
let _e272 = frag_info.light_color[_e269];
color_1 = _e272;
let _e273 = (*index_2);
let _e276 = frag_info.light_direction[_e273];
direction = _e276;
let _e277 = (*index_2);
let _e280 = frag_info.light_cone[_e277];
cone = _e280;
} else {
let _e281 = (*index_2);
slot_5 = (_e281 - 8i);
let _e283 = Clustered_u0028_();
clustered = _e283;
let _e284 = clustered;
if _e284 {
let _e285 = slot_5;
param_97 = _e285;
let _e286 = ClusterRow_u0028_i1_u003b((¶m_97));
local_29 = _e286;
} else {
let _e287 = slot_5;
param_98 = _e287;
let _e288 = LightListRow_u0028_i1_u003b((¶m_98));
local_29 = _e288;
}
let _e289 = local_29;
listRow = _e289;
let _e290 = listRow;
let _e294 = light_list_info.list[2u];
v_1 = ((_e290 + 0.5f) * _e294);
let _e298 = light_list_info.list[1u];
u_1 = _e298;
let _e299 = u_1;
let _e301 = v_1;
let _e303 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e299), _e301), 0f);
position = _e303;
let _e304 = u_1;
let _e306 = v_1;
let _e308 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e304), _e306), 0f);
color_1 = _e308;
let _e309 = u_1;
let _e311 = v_1;
let _e313 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e309), _e311), 0f);
direction = _e313;
let _e314 = u_1;
let _e316 = v_1;
let _e318 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e314), _e316), 0f);
cone = _e318;
let _e319 = clustered;
if _e319 {
let _e320 = listRow;
param_99 = _e320;
let _e321 = InSlots_u0028_f1_u003b((¶m_99));
local_30 = select(1f, 0f, _e321);
} else {
let _e323 = slot_5;
param_100 = _e323;
let _e324 = LightListScale_u0028_i1_u003b((¶m_100));
local_30 = _e324;
}
let _e325 = local_30;
let _e327 = color_1[3u];
color_1[3u] = (_e327 * _e325);
}
let _e331 = position[3u];
type_39 = _e331;
let _e332 = type_39;
if (_e332 > 15.5f) {
let _e335 = (*s_4).n;
light_3.l = _e335;
let _e338 = (*s_4).n;
light_3.h = _e338;
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 _e344 = light_3;
return _e344;
}
let _e345 = type_39;
if (_e345 > 2.5f) {
let _e347 = direction;
halfWidth_1 = _e347.xyz;
let _e349 = cone;
halfHeight_1 = _e349.xyz;
let _e351 = position;
let _e353 = v_world_position_1;
toCentre = (_e351.xyz - _e353);
let _e355 = toCentre;
let _e356 = halfWidth_1;
let _e358 = halfHeight_1;
corners_1[0i] = ((_e355 - _e356) - _e358);
let _e361 = toCentre;
let _e362 = halfWidth_1;
let _e364 = halfHeight_1;
corners_1[1i] = ((_e361 + _e362) - _e364);
let _e367 = toCentre;
let _e368 = halfWidth_1;
let _e370 = halfHeight_1;
corners_1[2i] = ((_e367 + _e368) + _e370);
let _e373 = toCentre;
let _e374 = halfWidth_1;
let _e376 = halfHeight_1;
corners_1[3i] = ((_e373 - _e374) + _e376);
let _e379 = toCentre;
let _e380 = halfWidth_1;
let _e381 = halfHeight_1;
behind = (dot(_e379, cross(_e380, _e381)) >= 0f);
let _e385 = behind;
if _e385 {
local_31 = 0f;
} else {
let _e386 = corners_1;
param_101 = _e386;
let _e388 = (*s_4).n;
param_102 = _e388;
let _e389 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_101), (¶m_102));
local_31 = _e389;
}
let _e390 = local_31;
formFactor = _e390;
let _e391 = halfWidth_1;
let _e392 = halfHeight_1;
area = (length(cross(_e391, _e392)) * 4f);
let _e396 = area;
if (_e396 > 0.000000001f) {
let _e398 = area;
local_32 = (1f / _e398);
} else {
local_32 = 0f;
}
let _e400 = local_32;
radiance = _e400;
let _e401 = toCentre;
distance_2 = length(_e401);
let _e404 = direction[3u];
if (_e404 > 0f) {
let _e406 = distance_2;
let _e408 = direction[3u];
ratio_1 = (_e406 / _e408);
let _e410 = ratio_1;
let _e411 = ratio_1;
let _e413 = ratio_1;
let _e415 = ratio_1;
window_1 = clamp((1f - (((_e410 * _e411) * _e413) * _e415)), 0f, 1f);
let _e419 = window_1;
let _e420 = window_1;
let _e422 = radiance;
radiance = (_e422 * (_e419 * _e420));
}
let _e425 = (*s_4).v;
let _e428 = (*s_4).n;
mirror_1 = reflect(-(_e425), _e428);
let _e430 = position;
param_103 = _e430.xyz;
let _e432 = halfWidth_1;
param_104 = _e432;
let _e433 = halfHeight_1;
param_105 = _e433;
let _e434 = v_world_position_1;
param_106 = _e434;
let _e435 = mirror_1;
param_107 = _e435;
let _e436 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_103), (¶m_104), (¶m_105), (¶m_106), (¶m_107));
representative = _e436;
let _e437 = representative;
let _e438 = v_world_position_1;
toPoint = (_e437 - _e438);
let _e440 = toPoint;
pointDistance = length(_e440);
let _e442 = pointDistance;
if (_e442 > 0.000001f) {
let _e444 = toPoint;
let _e445 = pointDistance;
local_33 = (_e444 / vec3(_e445));
} else {
let _e449 = (*s_4).n;
local_33 = _e449;
}
let _e450 = local_33;
light_3.l = _e450;
let _e453 = light_3.l;
let _e455 = (*s_4).v;
light_3.h = normalize((_e453 + _e455));
let _e459 = formFactor;
light_3.n_dot_l = _e459;
let _e462 = (*s_4).n;
let _e464 = light_3.h;
light_3.n_dot_h = max(dot(_e462, _e464), 0f);
let _e469 = (*s_4).v;
let _e471 = light_3.h;
light_3.v_dot_h = max(dot(_e469, _e471), 0f);
let _e475 = color_1;
let _e478 = color_1[3u];
let _e480 = radiance;
light_3.radiance = ((_e475.xyz * _e478) * _e480);
let _e483 = light_3;
return _e483;
}
let _e484 = direction;
aim = normalize(_e484.xyz);
attenuation_1 = 1f;
let _e487 = type_39;
if (_e487 < 0.5f) {
let _e489 = aim;
light_3.l = -(_e489);
} else {
let _e492 = position;
let _e494 = v_world_position_1;
toLight_1 = (_e492.xyz - _e494);
let _e496 = toLight_1;
distance_3 = length(_e496);
let _e498 = distance_3;
if (_e498 < 0.000001f) {
let _e501 = (*s_4).n;
light_3.l = _e501;
let _e504 = (*s_4).n;
light_3.h = _e504;
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 _e510 = light_3;
return _e510;
}
let _e511 = toLight_1;
let _e512 = distance_3;
light_3.l = (_e511 / vec3(_e512));
let _e516 = distance_3;
param_108 = _e516;
let _e518 = direction[3u];
param_109 = _e518;
let _e519 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_108), (¶m_109));
attenuation_1 = _e519;
let _e520 = type_39;
if (_e520 > 1.5f) {
let _e522 = aim;
let _e524 = light_3.l;
cosAngle = dot(_e522, -(_e524));
let _e527 = cosAngle;
let _e529 = cone[1u];
let _e532 = cone[0u];
let _e534 = cone[1u];
ramp = clamp(((_e527 - _e529) / (_e532 - _e534)), 0f, 1f);
let _e538 = ramp;
let _e539 = ramp;
let _e541 = attenuation_1;
attenuation_1 = (_e541 * (_e538 * _e539));
}
}
let _e544 = light_3.l;
let _e546 = (*s_4).v;
light_3.h = normalize((_e544 + _e546));
let _e551 = (*s_4).n;
let _e553 = light_3.l;
light_3.n_dot_l = max(dot(_e551, _e553), 0f);
let _e558 = (*s_4).n;
let _e560 = light_3.h;
light_3.n_dot_h = max(dot(_e558, _e560), 0f);
let _e565 = (*s_4).v;
let _e567 = light_3.h;
light_3.v_dot_h = max(dot(_e565, _e567), 0f);
let _e571 = color_1;
let _e574 = color_1[3u];
let _e576 = attenuation_1;
light_3.radiance = ((_e571.xyz * _e574) * _e576);
let _e579 = light_3;
return _e579;
}
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_34: f32;
var cell_1: f32;
var row_3: f32;
var header: vec4<f32>;
var param_110: f32;
var param_111: f32;
let _e224 = light_list_info.cluster_view_projection;
let _e225 = (*world_3);
clip_1 = (_e224 * vec4<f32>(_e225.x, _e225.y, _e225.z, 1f));
let _e231 = clip_1;
let _e234 = clip_1[3u];
ndc_1 = (_e231.xy / vec2(max(_e234, 0.000001f)));
let _e239 = light_list_info.cluster_grid;
grid = _e239.xyz;
let _e243 = light_list_info.cluster_depth[0u];
near_1 = _e243;
let _e245 = ndc_1[0u];
let _e249 = grid[0u];
let _e253 = grid[0u];
tx = clamp(floor((((_e245 * 0.5f) + 0.5f) * _e249)), 0f, (_e253 - 1f));
let _e257 = ndc_1[1u];
let _e261 = grid[1u];
let _e265 = grid[1u];
ty = clamp(floor((((_e257 * 0.5f) + 0.5f) * _e261)), 0f, (_e265 - 1f));
let _e269 = clip_1[3u];
let _e270 = near_1;
if (_e269 <= _e270) {
local_34 = 0f;
} else {
let _e273 = clip_1[3u];
let _e274 = near_1;
let _e279 = light_list_info.cluster_depth[1u];
let _e283 = grid[2u];
local_34 = clamp(floor((log((_e273 / _e274)) * _e279)), 0f, (_e283 - 1f));
}
let _e286 = local_34;
tz = _e286;
let _e287 = tx;
let _e288 = ty;
let _e290 = grid[0u];
let _e293 = tz;
let _e295 = grid[0u];
let _e298 = grid[1u];
cell_1 = ((_e287 + (_e288 * _e290)) + ((_e293 * _e295) * _e298));
let _e301 = cell_1;
row_3 = floor((_e301 / 4f));
let _e304 = cell_1;
let _e305 = row_3;
let _e310 = light_list_info.cluster_depth[2u];
let _e311 = row_3;
param_110 = (_e304 - (_e305 * 4f));
param_111 = (_e310 + _e311);
let _e313 = LightListTexel_u0028_f1_u003b_f1_u003b((¶m_110), (¶m_111));
header = _e313;
let _e315 = header[0u];
g_cluster_offset = _e315;
let _e317 = header[1u];
g_cluster_count = _e317;
return;
}
fn LightCount_u0028_() -> i32 {
var tail: f32;
var param_112: vec3<f32>;
let _e213 = light_list_info.list[0u];
tail = _e213;
let _e214 = Clustered_u0028_();
if _e214 {
let _e215 = v_world_position_1;
param_112 = _e215;
FindCluster_u0028_vf3_u003b((¶m_112));
let _e216 = g_cluster_count;
tail = _e216;
}
let _e219 = frag_info.frame_params[1u];
let _e223 = tail;
return (clamp(i32((_e219 + 0.5f)), 0i, 8i) + clamp(i32((_e223 + 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_5: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_8: i32;
var light_4: LightSample;
var param_113: i32;
var param_114: Surface;
var visibility: f32;
var param_115: i32;
var local_35: f32;
var param_116: Surface;
var param_117: LightSample;
var param_118: i32;
var param_119: vec3<f32>;
var param_120: vec3<f32>;
var param_121: i32;
var param_122: Surface;
var param_123: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e227 = LightCount_u0028_();
count_1 = _e227;
i_8 = 0i;
loop {
let _e228 = i_8;
if (_e228 < 32i) {
let _e230 = i_8;
let _e231 = count_1;
if (_e230 >= _e231) {
break;
}
let _e233 = i_8;
param_113 = _e233;
let _e234 = (*s_5);
param_114 = _e234;
let _e235 = 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_113), (¶m_114));
light_4 = _e235;
let _e237 = light_4.n_dot_l;
if (_e237 <= 0f) {
continue;
}
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e239 = i_8;
param_115 = _e239;
let _e240 = LightHasShadow_u0028_i1_u003b((¶m_115));
if _e240 {
let _e241 = (*s_5);
param_116 = _e241;
let _e242 = light_4;
param_117 = _e242;
let _e243 = i_8;
param_118 = _e243;
let _e244 = 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_116), (¶m_117), (¶m_118));
let _e245 = v_world_position_1;
param_119 = _e245;
let _e247 = (*s_5).n;
param_120 = _e247;
let _e248 = i_8;
param_121 = _e248;
let _e249 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_119), (¶m_120), (¶m_121));
local_35 = (_e244 * _e249);
} else {
local_35 = 1f;
}
let _e251 = local_35;
visibility = _e251;
let _e252 = visibility;
if (_e252 <= 0f) {
continue;
}
let _e254 = (*s_5);
param_122 = _e254;
let _e255 = light_4;
param_123 = _e255;
let _e256 = 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_122), (¶m_123));
let _e258 = light_4.radiance;
let _e261 = light_4.n_dot_l;
let _e263 = visibility;
let _e265 = light_transmittance;
let _e267 = total_1;
total_1 = (_e267 + ((((_e256 * _e258) * _e261) * _e263) * _e265));
continue;
} else {
break;
}
continuing {
let _e269 = i_8;
i_8 = (_e269 + 1i);
}
}
let _e271 = total_1;
return _e271;
}
fn ImpostorRight_u0028_vf3_u003b(d_4: ptr<function, vec3<f32>>) -> vec3<f32> {
var up: vec3<f32>;
let _e212 = (*d_4)[1u];
up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e212) > 0.999f)));
let _e217 = up;
let _e218 = (*d_4);
return normalize(cross(_e217, _e218));
}
fn ImpostorDecode_u0028_vf2_u003b(uv_6: ptr<function, vec2<f32>>) -> vec3<f32> {
var p_1: vec2<f32>;
var y_1: f32;
var s_6: vec2<f32>;
var folded: vec2<f32>;
var xz: vec2<f32>;
let _e215 = (*uv_6);
p_1 = ((_e215 * 2f) - vec2<f32>(1f, 1f));
let _e219 = p_1[0u];
let _e223 = p_1[1u];
y_1 = ((1f - abs(_e219)) - abs(_e223));
let _e227 = p_1[0u];
let _e231 = p_1[1u];
s_6 = vec2<f32>(select(-1f, 1f, (_e227 >= 0f)), select(-1f, 1f, (_e231 >= 0f)));
let _e235 = p_1;
let _e239 = s_6;
folded = ((vec2<f32>(1f, 1f) - abs(_e235.yx)) * _e239);
let _e241 = y_1;
let _e243 = p_1;
let _e244 = folded;
xz = select(_e244, _e243, vec2((_e241 >= 0f)));
let _e248 = xz[0u];
let _e249 = y_1;
let _e251 = xz[1u];
return normalize(vec3<f32>(_e248, _e249, _e251));
}
fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_2: ptr<function, vec2<f32>>, offset_3: ptr<function, vec3<f32>>) -> vec2<f32> {
var d_5: vec3<f32>;
var param_124: vec2<f32>;
var right: vec3<f32>;
var param_125: vec3<f32>;
var up_1: vec3<f32>;
var local_36: vec2<f32>;
let _e217 = (*cell_2);
param_124 = (_e217 / vec2(7f));
let _e220 = ImpostorDecode_u0028_vf2_u003b((¶m_124));
d_5 = _e220;
let _e221 = d_5;
param_125 = _e221;
let _e222 = ImpostorRight_u0028_vf3_u003b((¶m_125));
right = _e222;
let _e223 = d_5;
let _e224 = right;
up_1 = cross(_e223, _e224);
let _e226 = (*offset_3);
let _e227 = right;
let _e231 = (*offset_3);
let _e232 = up_1;
local_36 = vec2<f32>(((dot(_e226, _e227) * 0.5f) + 0.5f), (0.5f - (dot(_e231, _e232) * 0.5f)));
let _e237 = (*cell_2);
let _e238 = local_36;
return ((_e237 + clamp(_e238, 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_7: vec2<f32>;
var folded_1: vec2<f32>;
let _e214 = (*d_6);
a_4 = abs(_e214);
let _e216 = (*d_6);
let _e219 = a_4[0u];
let _e221 = a_4[1u];
let _e224 = a_4[2u];
p_2 = (_e216.xz / vec2(max(((_e219 + _e221) + _e224), 0.00000001f)));
let _e230 = p_2[0u];
let _e234 = p_2[1u];
s_7 = vec2<f32>(select(-1f, 1f, (_e230 >= 0f)), select(-1f, 1f, (_e234 >= 0f)));
let _e238 = p_2;
let _e242 = s_7;
folded_1 = ((vec2<f32>(1f, 1f) - abs(_e238.yx)) * _e242);
let _e245 = (*d_6)[1u];
let _e247 = p_2;
let _e248 = folded_1;
return ((select(_e248, _e247, vec2((_e245 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
}
fn TowardsEye_u0028_() -> vec3<f32> {
var local_37: vec3<f32>;
let _e210 = Orthographic_u0028_();
if _e210 {
let _e212 = fog_info.forward;
local_37 = -(_e212.xyz);
} else {
let _e216 = fog_info.eye;
let _e218 = v_world_position_1;
local_37 = normalize((_e216.xyz - _e218));
}
let _e221 = local_37;
return _e221;
}
fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
var key_2: f32;
var origin_2: vec3<f32>;
var cell_3: vec3<f32>;
var p3_: vec3<f32>;
let _e215 = (*cutoff);
key_2 = (-2f - _e215);
let _e217 = key_2;
let _e220 = key_2;
let _e222 = floor((_e220 / 128f));
let _e227 = key_2;
origin_2 = vec3<f32>(floor((_e217 / 16384f)), (_e222 - (floor((_e222 / 128f)) * 128f)), (_e227 - (floor((_e227 / 128f)) * 128f)));
let _e233 = (*scenePosition);
let _e236 = origin_2;
let _e237 = (floor((_e233 * 16f)) + _e236);
let _e238 = vec3(128f);
cell_3 = (_e237 - (floor((_e237 / _e238)) * _e238));
let _e243 = cell_3;
p3_ = fract((_e243 * 0.1031f));
let _e246 = p3_;
let _e247 = p3_;
let _e252 = p3_;
p3_ = (_e252 + vec3(dot(_e246, (_e247.zyx + vec3(31.32f)))));
let _e256 = p3_[0u];
let _e258 = p3_[1u];
let _e261 = p3_[2u];
return fract(((_e256 + _e258) * _e261));
}
fn MaterialLodBias_u0028_() -> f32 {
let _e211 = frag_info.target_origin[1u];
return _e211;
}
fn ReadSurface_u0028_() -> Surface {
var texel_4: vec4<f32>;
var s_8: Surface;
var param_126: vec3<f32>;
var param_127: vec3<f32>;
var cutoff_1: f32;
var edge: f32;
var param_128: vec3<f32>;
var param_129: f32;
let _e217 = v_texcoord_1;
let _e218 = MaterialLodBias_u0028_();
let _e219 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e217, _e218);
texel_4 = _e219;
let _e220 = texel_4;
param_126 = _e220.xyz;
let _e222 = SrgbToLinear_u0028_vf3_u003b((¶m_126));
let _e224 = frag_info.base_color;
param_127 = _e224.xyz;
let _e226 = SrgbToLinear_u0028_vf3_u003b((¶m_127));
let _e228 = v_color_1;
s_8.albedo = ((_e222 * _e226) * _e228.xyz);
let _e233 = texel_4[3u];
let _e236 = frag_info.base_color[3u];
let _e239 = v_color_1[3u];
s_8.alpha = ((_e233 * _e236) * _e239);
let _e243 = s_8.albedo;
g_albedo = _e243;
let _e246 = frag_info.material2_[0u];
cutoff_1 = _e246;
let _e247 = cutoff_1;
if (_e247 > 1f) {
let _e249 = cutoff_1;
edge = (_e249 - 1f);
let _e252 = s_8.alpha;
let _e253 = edge;
let _e256 = s_8.alpha;
let _e257 = fwidth(_e256);
s_8.alpha = clamp((((_e252 - _e253) / max(_e257, 0.0001f)) + 0.5f), 0f, 1f);
} else {
let _e263 = cutoff_1;
if (_e263 >= 0f) {
let _e266 = s_8.alpha;
let _e267 = cutoff_1;
if (_e266 < _e267) {
discard;
}
s_8.alpha = 1f;
} else {
let _e270 = cutoff_1;
if (_e270 < -1.5f) {
let _e273 = s_8.alpha;
let _e274 = v_world_position_1;
param_128 = _e274;
let _e275 = cutoff_1;
param_129 = _e275;
let _e276 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((¶m_128), (¶m_129));
if (_e273 < _e276) {
discard;
}
}
}
}
let _e278 = cutoff_1;
let _e280 = cutoff_1;
g_premultiply = ((_e278 < 0f) && (_e280 > -0.75f));
let _e283 = v_normal_1;
s_8.n = normalize(_e283);
let _e286 = gl_FrontFacing_1;
if !(_e286) {
let _e289 = s_8.n;
s_8.n = -(_e289);
}
let _e292 = TowardsEye_u0028_();
s_8.v = _e292;
let _e295 = s_8.n;
let _e297 = s_8.v;
s_8.n_dot_v = max(dot(_e295, _e297), 0.0001f);
let _e303 = frag_info.material[0u];
s_8.metallic = clamp(_e303, 0f, 1f);
let _e308 = frag_info.material[1u];
s_8.roughness = clamp(_e308, 0.02f, 1f);
let _e312 = frag_info.ambient_ground;
let _e315 = frag_info.ambient_sky;
let _e319 = s_8.n[1u];
let _e326 = frag_info.material[2u];
s_8.ambient = (mix(_e312.xyz, _e315.xyz, vec3(((_e319 * 0.5f) + 0.5f))) * _e326);
let _e331 = frag_info.frame_params[0u];
s_8.exposure = max(_e331, 0f);
s_8.occlusion = 1f;
s_8.emissive = vec3<f32>(0f, 0f, 0f);
let _e336 = s_8;
return _e336;
}
fn main_1() {
var s_9: Surface;
var d_7: vec3<f32>;
var right_1: vec3<f32>;
var param_130: vec3<f32>;
var up_2: vec3<f32>;
var offset_4: vec3<f32>;
var g: vec2<f32>;
var param_131: vec3<f32>;
var base: vec2<f32>;
var f: vec2<f32>;
var lower: bool;
var c0_: vec2<f32>;
var local_38: vec2<f32>;
var c1_: vec2<f32>;
var c2_: vec2<f32>;
var w: vec3<f32>;
var local_39: vec3<f32>;
var uv0_: vec2<f32>;
var param_132: vec2<f32>;
var param_133: vec3<f32>;
var uv1_: vec2<f32>;
var param_134: vec2<f32>;
var param_135: vec3<f32>;
var uv2_: vec2<f32>;
var param_136: vec2<f32>;
var param_137: 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_2: vec3<f32>;
var local_40: vec3<f32>;
var worldRight: vec3<f32>;
var worldFacing: vec3<f32>;
var worldUp: vec3<f32>;
var param_138: vec3<f32>;
var param_139: vec3<f32>;
var ambient: vec3<f32>;
var lit_3: vec3<f32>;
var param_140: Surface;
var param_141: Surface;
var param_142: vec3<f32>;
var param_143: vec3<f32>;
var param_144: f32;
var param_145: 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_pass_through = 0f;
g_cluster_offset = 0f;
g_cluster_count = 0f;
light_transmittance = vec3<f32>(1f, 1f, 1f);
let _e258 = ReadSurface_u0028_();
s_9 = _e258;
let _e259 = v_color_1;
d_7 = normalize(_e259.xyz);
let _e262 = d_7;
param_130 = _e262;
let _e263 = ImpostorRight_u0028_vf3_u003b((¶m_130));
right_1 = _e263;
let _e264 = d_7;
let _e265 = right_1;
up_2 = cross(_e264, _e265);
let _e267 = right_1;
let _e269 = v_texcoord_1[0u];
let _e273 = up_2;
let _e275 = v_texcoord_1[1u];
offset_4 = ((_e267 * ((_e269 * 2f) - 1f)) + (_e273 * (1f - (_e275 * 2f))));
let _e280 = d_7;
param_131 = _e280;
let _e281 = ImpostorEncode_u0028_vf3_u003b((¶m_131));
g = (_e281 * 7f);
let _e283 = g;
base = clamp(floor(_e283), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
let _e286 = g;
let _e287 = base;
f = (_e286 - _e287);
let _e290 = f[0u];
let _e292 = f[1u];
lower = ((_e290 + _e292) < 1f);
let _e295 = lower;
if _e295 {
let _e296 = base;
local_38 = _e296;
} else {
let _e297 = base;
local_38 = (_e297 + vec2<f32>(1f, 1f));
}
let _e299 = local_38;
c0_ = _e299;
let _e300 = base;
c1_ = (_e300 + vec2<f32>(1f, 0f));
let _e302 = base;
c2_ = (_e302 + vec2<f32>(0f, 1f));
let _e304 = lower;
if _e304 {
let _e306 = f[0u];
let _e309 = f[1u];
let _e312 = f[0u];
let _e314 = f[1u];
local_39 = vec3<f32>(((1f - _e306) - _e309), _e312, _e314);
} else {
let _e317 = f[0u];
let _e319 = f[1u];
let _e323 = f[1u];
let _e326 = f[0u];
local_39 = vec3<f32>(((_e317 + _e319) - 1f), (1f - _e323), (1f - _e326));
}
let _e329 = local_39;
w = _e329;
let _e330 = c0_;
param_132 = _e330;
let _e331 = offset_4;
param_133 = _e331;
let _e332 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_132), (¶m_133));
uv0_ = _e332;
let _e333 = c1_;
param_134 = _e333;
let _e334 = offset_4;
param_135 = _e334;
let _e335 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_134), (¶m_135));
uv1_ = _e335;
let _e336 = c2_;
param_136 = _e336;
let _e337 = offset_4;
param_137 = _e337;
let _e338 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((¶m_136), (¶m_137));
uv2_ = _e338;
let _e339 = uv0_;
let _e340 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e339, 0f);
a0_ = _e340;
let _e341 = uv1_;
let _e342 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e341, 0f);
a1_ = _e342;
let _e343 = uv2_;
let _e344 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e343, 0f);
a2_ = _e344;
let _e345 = uv0_;
let _e346 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e345, 0f);
n0_ = _e346;
let _e347 = uv1_;
let _e348 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e347, 0f);
n1_ = _e348;
let _e349 = uv2_;
let _e350 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e349, 0f);
n2_ = _e350;
let _e351 = w;
let _e353 = a0_[3u];
let _e355 = a1_[3u];
let _e357 = a2_[3u];
wa = (_e351 * vec3<f32>(_e353, _e355, _e357));
let _e361 = wa[0u];
let _e363 = wa[1u];
let _e366 = wa[2u];
alpha_3 = ((_e361 + _e363) + _e366);
let _e368 = alpha_3;
if (_e368 < 0.5f) {
discard;
}
let _e370 = a0_;
let _e373 = wa[0u];
let _e375 = a1_;
let _e378 = wa[1u];
let _e381 = a2_;
let _e384 = wa[2u];
let _e387 = alpha_3;
srgb_2 = ((((_e370.xyz * _e373) + (_e375.xyz * _e378)) + (_e381.xyz * _e384)) / vec3(_e387));
let _e390 = n0_;
let _e395 = wa[0u];
let _e397 = n1_;
let _e402 = wa[1u];
let _e405 = n2_;
let _e410 = wa[2u];
local_40 = (((((_e390.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e395) + (((_e397.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e402)) + (((_e405.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e410));
let _e413 = local_40;
let _e414 = local_40;
let _e417 = local_40;
let _e418 = d_7;
local_40 = normalize(select(_e418, _e417, vec3((dot(_e413, _e414) > 0.000000000001f))));
let _e422 = v_tangent_1;
worldRight = normalize(_e422.xyz);
let _e425 = v_normal_1;
worldFacing = normalize(_e425);
let _e427 = worldFacing;
let _e428 = worldRight;
worldUp = cross(_e427, _e428);
let _e430 = worldRight;
let _e431 = local_40;
let _e432 = right_1;
let _e435 = worldUp;
let _e436 = local_40;
let _e437 = up_2;
let _e441 = worldFacing;
let _e442 = local_40;
let _e443 = d_7;
s_9.n = normalize((((_e430 * dot(_e431, _e432)) + (_e435 * dot(_e436, _e437))) + (_e441 * dot(_e442, _e443))));
let _e450 = s_9.n;
let _e452 = s_9.v;
s_9.n_dot_v = max(dot(_e450, _e452), 0.0001f);
let _e456 = srgb_2;
param_138 = _e456;
let _e457 = SrgbToLinear_u0028_vf3_u003b((¶m_138));
let _e459 = frag_info.base_color;
param_139 = _e459.xyz;
let _e461 = SrgbToLinear_u0028_vf3_u003b((¶m_139));
s_9.albedo = (_e457 * _e461);
s_9.alpha = 1f;
let _e466 = s_9.albedo;
g_albedo = _e466;
let _e468 = frag_info.ambient_ground;
let _e471 = frag_info.ambient_sky;
let _e475 = s_9.n[1u];
let _e482 = frag_info.material[2u];
s_9.ambient = (mix(_e468.xyz, _e471.xyz, vec3(((_e475 * 0.5f) + 0.5f))) * _e482);
let _e486 = s_9.albedo;
let _e488 = s_9.ambient;
ambient = (_e486 * _e488);
let _e490 = s_9;
param_140 = _e490;
let _e491 = 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_140));
let _e492 = ambient;
lit_3 = (_e491 + _e492);
let _e494 = s_9;
param_141 = _e494;
let _e495 = lit_3;
param_142 = _e495;
let _e496 = WriteDebugView_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_vf3_u003b((¶m_141), (¶m_142));
if _e496 {
return;
}
let _e497 = lit_3;
param_143 = _e497;
param_144 = 1f;
param_145 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_143), (¶m_144), (¶m_145));
return;
}
@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) 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: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'projection',
offsetInBytes: 48,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 912,
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,
),
WebGpuBlockMember(
name: 'debug_view',
offsetInBytes: 896,
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,
),
],
),
},
);